Triangle alphabet

48

Vous devez imprimer ce texte exact:

A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

Spécifications

  • Les nouvelles lignes de fin sont autorisées à la fin de la sortie.
  • Des espaces de fin supplémentaires (U + 0020) sont autorisés à la fin de chaque ligne, y compris les nouvelles lignes de fin.
  • Vous pouvez utiliser toutes les minuscules au lieu de toutes les majuscules, mais vous ne pouvez pas imprimer partiellement minuscule, partiellement partiellement majuscule.
  • Vous pouvez renvoyer le texte sous forme de sortie de fonction au lieu de l'imprimer dans un programme complet.

Notation

Comme il s'agit d'un triangle et que celui-ci a 3 côtés et que 3 est un petit nombre, votre code doit être petit en termes de nombre d'octets.

Fuite Nun
la source
22
Tant d'alphabets récemment
downrep_nation
1
Ma synesthésie va porc sauvage, @downrep_nation
DoctorHeckle
5
"Comme un triangle a 3 côtés et que 3 est un petit nombre, votre code doit donc être petit en termes de nombre d'octets." semble légitime
Rohan Jhunjhunwala
1
Les carrés de nombres composés uniquement de 1 semblent liés: 1 * 1 = 1 ~ = A, 11 * 11 = 121 ~ = ABA, 111 * 111 = 12321 ~ = ABCBA ...
Caridorc
1
"Depuis un triangle a 3 côtés et ..." confirma Illuminati.
HyperNeutrino

Réponses:

38

Vim, 37 octets

:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ

entrez la description de l'image ici

Légende

↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape
Lynn
la source
2
C'est un GIF vraiment cool.
AdmBorkBork
13
Je ne cesserai jamais d'être surpris par les réponses de Vim.
DanTheMan
Voulez-vous expliquer comment cela fonctionne pour ceux qui ne parlent pas couramment Vim?
R. Kap
6
@ R.Kap Je vous recommande de télécharger Vim et d'essayer la solution vous-même - vous pouvez regarder la solution se déplier, coup par coup! Essentiellement, je vole l’alphabet dans un fichier d’aide ( :h<_↵↵↵YZZP), puis enregistre une macro ( qq…q) qui coupe de façon répétée une lettre de la ligne supérieure, en fait deux copies pour faire grandir le triangle verticalement, puis ajoute la lettre coupée à toutes les lignes. pour le développer horizontalement. Je répète cette macro 24 fois de plus pour tracer le triangle entier.
Lynn
31

Logo, 232 207 196 190 octets

Est-ce que quelqu'un a dit des triangles?

Sortez votre boussole et votre rapporteur et procédons de manière graphique. La géométrie utilise un triangle équilatéral pour aligner les résultats. J'avais précédemment un triangle isocèle, mais celui-ci impliquait trop de décimales. Cette modification a également compacté la sortie, réduisant ainsi le nombre de préparations d'écran et de modifications de polices que je devais faire.

J'ai utilisé l' interprète en ligne Calormen pour étoffer celui-ci. Si vous ne disposez pas de suffisamment d’écran, cela s’emballe, mais vous pouvez aussi manipuler des chiffres pour s’occuper de cela. J'ai utilisé le mode plein écran "F11" sur mon navigateur.

ht
pu
to r:n:b:l repeat:n[rt:b label char 90-:n lt:b fd:l] end
to t:s
fd 12 rt 120 bk 6
repeat 2[r:s 90 12]
repeat 2[rt 120 r:s 90-heading 24]
end
rt 90 label "Z lt 210
repeat 25[t repcount]

La rprocédure dessine une ligne de ncaractères. Le caractère est déterminé automatiquement en fonction du nombre de segments à utiliser. Le bparamètre indique la quantité de rotation temporaire à effectuer pour que les lettres soient orientées dans la bonne direction. Le lparamètre détermine la distance linéaire entre les lettres.

La tprocédure passe à la position suivante et appelle la rfonction quatre fois pour créer un triangle, en effectuant une rotation si nécessaire. Je l'ai appelé deux fois pour le côté vertical car cela prenait moins d'octets que si on l'appelait une fois avec un traitement spécial. La fin de la procédure positionne la tortue pour le début du prochain triangle, une étape plus haut.

Zest un cas spécial, nous l’imprimons donc directement et nous tournons comme si nous venions de terminer un triangle. Enfin, test appelé 25 fois.

En cours d'image annotéeRésultat fini

GuitarPicker
la source
3
Hors de la boîte. Bien fait.
CousinCocaine
19

Haskell, 58 octets

f x=init x++reverse x
t=unlines$f[f['A'..c]|c<-['A'..'Z']]

Définit une fonction tqui renvoie la sortie sous forme de chaîne.

f x=               define a helper function
init x             take the argument minus its last element
++                 and concatenate it with
reverse x          the argument reversed, producing ex. [a,b,c,b,a] from [a,b,c]

t=                                    define the main function
           [         |c<-['A'..'Z']]  for every char c from 'A' to 'Z'...
             ['A'..c]                 generate the range from 'A' to c
            f                         call the helper function to "reflect" it
          f                           call the helper function on the entire list
  unlines$                            join on newlines
Poignée de porte
la source
12

Gelée , 16 à 13 octets

Ṗ;Ṛ
ØAḣJÇ€Çj⁷

Merci à @ LeakyNun pour le golf de 3 octets!

Essayez-le en ligne!

Comment ça fonctionne

Ṗ;Ṛ        Helper link. Argument: A (array)

Ṗ          Pop; yield A without its last element.
  Ṛ        Reversed; yield A with inverted order.
 ;         Concatenate the results to both sides.


ØAḣJÇ€Çj⁷  Main link. No arguments.

ØA         Alphabet; set link argument and return value to "A...Z".
   J       Indices; yield [1, ..., 26].
  ḣ        Head; take the first, the first two, etc. elements of the alphabet.
           This yields ["A", AB", ..., "A...Z"].
    ǀ     Apply the helper link to each string.
      Ç    Apply the helper link to the array itself.
       j⁷  Join, separating by linefeeds.
Dennis
la source
3
3 octets off
Leaky Nun
@ LeakyNun Merci.
Dennis
4
Je serais curieux de savoir comment cela fonctionne dans le monde ...
Socratic Phoenix
peut-être que si vous utilisez le duplicateur de liens, vous pouvez économiser un octet
Leaky Nun
3
@MathieuRodic Jelly utilise une page de code personnalisée qui code tous les 256 caractères qu’elle comprend sous la forme d’un seul octet. Le lien d' octets dans l'en-tête pointe vers lui.
Dennis
10

Python, 74 octets

def f(x=66,s='A'):
 t=s+s[-2::-1];print t
 if x<91:f(x+1,s+chr(x));print t

Une fonction Python 2 qui imprime et ne prend aucun argument. L'idée principale est de générer le motif triangulaire aller-retour avec récursivité. Considérons d’abord cette fonction plus simple qui imprime les lettres «A» jusqu’à «Z» et de nouveau à «A»:

def f(x=65):
 t=chr(x);print t
 if x<90:f(x+1);print t 

La fonction commence par imprimer "A" (code 65), puis revient à imprimer "B" (66) et ainsi de suite sur "Z" (90). A partir de là, ça cesse de récurer. En redescendant la pile récursive, il imprime le caractère timprimé sur le même calque, de "Y" à "A".

Le code principal fait la même chose, à la différence qu’il s’accumule sjusqu’à présent dans la chaîne de lettres et imprime la chaîne en haut et en bas s+s[-2::-1].

Merci à xsot pour 2 octets.

En Python 3, la même chose est un octet plus court (73 octets) en mettant tout sur une seule ligne.

def f(x=66,s='A'):t=s+s[-2::-1];print(t);x>90or[f(x+1,s+chr(x)),print(t)]
Xnor
la source
Vous pouvez économiser 2 octets si vous décalez les variables, c.-à-d f(x=66,s='A'). Cela vous permet de mettre à jour sl'appel de fonction à la place du corps de la fonction.
xsot
Je pense que votre version de Python 3, à l'instar de son parent de Python 2, nécessite une valeur de 90 au lieu de 89 pour avoir la plus longue ligne allant jusqu'à Z et vice-versa.
Tebbe
@Tebbe Merci, corrige-les.
xnor
8

brainfuck, 1733 121 119 octets

----[---->+<]>++.<++++++++++.<+++++[<+++++>-]<+>>>.<[>>[>.]<[>+>+<<-]>+.>[<<+> >-]<[<.]<-]>>[>[>]<[-]<[<]>>[.>]<<[.<]>]

Version légèrement plus lisible:

----[---->+<]>++.<
++++++++++.<
+++++[<+++++>-]<+
>>
>.<
[
  >>[>.]<
  [>+>+<<-]
  >+.>
  [<<+>>-]
  <[<.]<
  -
]
>>
[
  >[>]<
  [-]
  <[<]>
  >[.>]<<[.<]>
]

Explication à venir éventuellement.

DanTheMan
la source
Essayez d’utiliser une boucle au lieu de construire chaque personnage manuellement.
Leaky Nun
@ LeakyNun Je n'ai aucune idée de la façon de s'y prendre. Aucune suggestion?
DanTheMan
4
Bien, alors tu n'as dormi que 4 heures.
Leaky Nun
1
Félicitations pour avoir le programme plus petit que la sortie!
GuitarPicker
1
Comment peut-on golf de 1612 octets?
FantaC
8

05AB1E , 20 13 12 6 octets

Sauvegardé 2 octets grâce à Adnan.
Sauvegardé 6 octets grâce à Magic Octopus Urn et à de nouvelles fonctionnalités linguistiques.

Aη€ûû»

Essayez-le en ligne!

Explication

Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines
Emigna
la source
Très agréable! Vous pouvez changer Œ26£en .p, qui est la commande prefix. En outre, vous pouvez changer D,à =, qui imprime sans popping.
Adnan
Wow, astuce avec le gF,!
Adnan
@Adnan: Merci! Je savais qu'il y avait quelque part une commande de préfixe quelque part :) Je vérifie rarement les commandes étendues.
Emigna
2
Cette commande bifurcate Âest très agréable et une fonctionnalité vraiment chouette.
miles
1
@carusocomputing: ûest malheureusement plus récent que le défi et rendrait cette réponse non concurrente.
Emigna
6

J, 26 23 22 octets

f(f=:,1}.|.)\u:65+i.26

Explication

,1}.|.  Monad f: Input: A
    |.  Reverse the items in A
 1}.    Drop the first item in the reversed A
,       Join A and the previous

f(f=:,1}.|.)\u:65+i.26
                  i.26  Create the range [0, 1, ..., 25]
               65+      Add 65 to each
             u:         Convert to characters to get 'A..Z'
  f=:,1}.|.             Define a verb f
 (         )\           Call f monadically on each prefix of 'A..Z'
f                       Call f again on that result
milles
la source
f=:,1}.|.essayez ceci
Leaky Nun
@ LeakyNun Merci, je ne sais pas pourquoi j'ai pensé qu'ils étaient différents.
miles
5

Python 3, 97 octets

s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
a=[s[:x]+s[x::-1]for x in range(26)]
print('\n'.join(a+a[24::-1]))

Ideone ça!

Fuite Nun
la source
1
Vous pouvez également faire'\n'.join(a+a[-2::-1])
Miguel
96 octets!
Artemis Fowl
5

Ruby, 71 octets

Essayez-le sur repl.it

s=*?A..?Y
s+=[?Z]+s.reverse
puts s.map{|e|k=[*?A...e]*'';k+e+k.reverse}
Valeur d'encre
la source
Cette solution s'appuie sur la vôtre et utilise l'arithmétique des valeurs absolues pour économiser 3 octets.
benj2240
5

C, 272 247 234 230 144 144 137 octets:

( Sauvegardé de nombreux octets ( 272 -> 230) dans ma méthode précédente grâce aux excellents conseils et astuces de sigalor concernant le golf ! )

( Sauvegardé près de 100 octets ( 230 -> 144) en passant à une meilleure méthode. )

main(q,i,e,x){for(q=0;q<51;q++){i=q>25 ? 25-(q-25):q;for(e=65;e<66+i;e++)printf("%c",e);for(x=64+i;x>64;x--)printf("%c",x);printf("\n");}}

Ma première réponse dans C. Je viens de commencer l'auto-apprentissage récemment, alors voyons comment ça se passe.

C it en action! (Idéone)

R. Kap
la source
1
Ahhh, je voulais juste ajouter une réponse en C aussi ... Peu importe, je vais vous aider ensuite;) Tout d'abord, c'est du code golf, vous n'avez pas besoin d'écrire du code parfait. Les avertissements du compilateur sont tout à fait corrects. C'est pourquoi vous pouvez supprimer main()le type de retour et même le #include <stdio.h>. GCC (et aussi des sites comme Ideone) est d'accord avec ça. Ensuite, vous pouvez «externaliser» les définitions de variable dans la liste de paramètres d'une fonction. Laisser for(int i=65;...devenir for(i=65...et changer main()en main(i). Faites la même chose pour toutes les autres variables int également (GCC utilise par défaut les types manquants int).
Sigalor
@ Sigalor Merci pour les conseils! :) Juste une question: pourquoi dois - je besoin de changer main()pour main(i)?
R. Kap
@ Sigalor En fait, maintenant, je reçois un tas d'erreurs de compilation.
R. Kap
Lorsque vous ne déclarez pas votre ivariable dans l'initialisation de la boucle for, vous devez la déclarer ailleurs. Et comme (au moins en C) les paramètres d’une fonction peuvent être utilisés comme des variables normales, il ne devrait y avoir aucun problème. Btw, quel compilateur utilisez-vous?
Sigalor
@sigalor Actuellement Cà Ideone. Je reçois plusieurs <variable> undeclarederreurs.
R. Kap
5

JavaScript (ES6), 81 octets

[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)
ASCII seulement
la source
5

Mathematica 59 octets

Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]
chyanog
la source
Je pense que retirer //Columnde la fin et préfixer votre code avec des Column@œuvres.
Yytsi
2
Vous semblez avoir compté et en octets simples. Je doute qu'il existe une page de codes à un octet qui est également prise en charge par Mathematica. Ils avaient trois octets en UTF-8, donc ils ne sauvegardent pas vraiment rien [[...]]. Je ne sais pas non plus à quel point la légitimité Columnest légitime, car elle s’affiche comme une liste de lignes dans un bloc-notes Mathematica. L'exécution de ce code à partir d'un fichier de script n'afficherait rien. Cependant, Print/@est le même nombre d'octets et fonctionne dans les deux cas.
Martin Ender
Si vous voulez faire un lien vers une page avec une adresse longue, vous pouvez faire ce qui suit: [what you see](actual link). Ex. [Example Link](https://www.example.com), qui montre comme exemple Link
Stan Strum
4

R, 63 61 59 octets

for(i in c(1:26,25:1))cat(LETTERS[c(1:i,i:1-1)],"
",sep="")

Utilement LETTTERS[0]ne renvoie aucun caractère.

Edit: perdu un grâce à @leakynun

Edit: deux autres grâce à @plannapus

utilisateur5957401
la source
1
Vous pouvez utiliser une nouvelle ligne littérale au lieu de\n
Leaky Nun
3

TSQL, 159 octets

DECLARE @ varchar(52)='ABCDEFGHIJKLMNOPQRSTUVWXY',@o varchar(max)SELECT @+='Z'+REVERSE(@)+'
',@o=@
WHILE''<@
SELECT @=STUFF(@,LEN(@)/2,2,''),@o=@+@o+@
PRINT @o

Violon

t-clausen.dk
la source
1
J'ai essayé de le faire, mais je me suis retrouvé avec plus de 250 octets, donc je n'ai jamais posté ça. Vous avez effectivement une meilleure solution que la mienne. Encore une fois :)
Anuj Tripathi
3

Javascript (en utilisant une bibliothèque externe-Enumerable), 135 octets

_.Range(1,51).WriteLine(x=>(g=_.Range(65,x>25?52-x:x)).Write("",y=>(w=String.fromCharCode)(y))+(g.Reverse().Skip(1).Write("",y=>w(y))))

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication de code: Créez une plage d’entités commençant à 1, pour un compte de 51. Pour chacune d’elles, écrivez une ligne en fonction de la variable pred. Faites de la magie JS avec des variables globales et la mise en cache ... et le tour est joué. Pour chaque int de WriteLine, nous créons la plage de gauche des entrées et les stockons dans un "g" global, ainsi que la jonction de chaînes (écriture) avec un ""délimiteur et mappons chaque int sur le mappage de chaîne sur le code de caractère int. Ensuite, nous concattrons le côté droit en prenant le renversement de cette séquence (et en sautant le premier élément car cela correspondra au dernier élément de la commande d'origine ...), en écrivant avec la même logique. EDIT: Mise à jour des composants internes de Write dans la bibliothèque. Une séquence vide écrira une chaîne vide au lieu de null maintenant. Cela a également rasé 15 octets de la réponse

entrez la description de l'image ici

applejacks01
la source
1
N'avez-vous pas besoin d'inclure les octets nécessaires pour importer la bibliothèque?
MatthewRock
1
Idk, j'ai posté plus de 20 réponses en utilisant une bibliothèque et vous seriez le premier à me le dire. Je ne pense pas que quiconque s'inquiète vraiment parce que mes réponses ne gagnent jamais de toute façon
applejacks01
1
@ applejacks01 Si vous ne l'importez pas, vous devez dire quelque chose comme "JS + Enumerable" en haut. Semblables à "Bash + Coreutils"
mbomb007
2
Il est courant de compter l'importation. Les réponses Python + SymPy ont toujours import sympyou from sympy import*au sommet. Les réponses de Bash + x sont différentes car il vous suffit d'installer x et non de l'activer.
Dennis
1
@ PatrickRoberts Tant que la bibliothèque existait avant la publication du défi, oui. Python répond à faire usage de sympy, numpy, scipy, etc. tout le temps.
Dennis
3

Powershell, 61 52 octets

Merci à TimmyD d’avoir économisé 9 octets!

65..90+89..65|%{-join[char[]]((65..$_-ne$_)+$_..65)}

Parcourt les valeurs ASCII pour les lettres majuscules en avant, puis en arrière. Pour chaque numéro, cela crée un tableau des X premiers chiffres, supprime le X-1er numéro, puis ajoute l'inverse des premiers X chiffres, qui sont tous ensuite convertis en caractères et réunis dans une chaîne.

Ben Owen
la source
Hé, c'est bon, merci! J'avais branché 65..90..65sur un caprice plus tôt sans succès. Je suppose que j'ai oublié de pouvoir additionner les gammes.
Ben Owen
3

Cheddar , 102 96 79 69 67 octets

17 octets grâce à Downgoat et source d’inspiration pour 10 autres.

"A"+(2@"27+@"(25|>1)).bytes.map(i->65@"(64+i)+@"((64+i)|>65)).vfuse

Le fait que les chaînes puissent concaténer mais pas les tableaux signifie que je devrais convertir les deux plages en chaînes, concaténer, puis reconvertir en tableaux.

De plus, le fait de vfuseproduire un newliens de premier plan signifie que j’aurais besoin de générer la première ligne manuellement puis de concaténer le reste.

@" en tant que dyade (fonction à deux arguments) peut convertir directement en chaîne, mais ne fonctionne pas pour la plage inversée (si le premier argument est plus grand que le second).

Gamme était demi-inclus. Après le correctif, il est devenu inclusif.

Usage

cheddar> "A"+(2@"27+@"(25|>1)).bytes.map(i->(65@"(64+i)+@"((64+i)|>65))).vfuse
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A"

Cheddar, 55 octets (non concurrents)

Dans la dernière version avec tous les correctifs, la réponse est:

(|>25+24|>0).map(i->65@"(65+i)+(i?(64+i)@"65:"")).vfuse

mais c'était fait après le challenge.

Fuite Nun
la source
@"(1|>26)peut être1@"26
Downgoat
String.letterspeut être(65@"91)
Downgoat
String.letters.slice(0,i)pourrait peut-être être65@"(66+i)
Downgoat
Aha, je vois que vous avez grille de votre bytecount.
Steenbergh
3

C, 93 octets

Appel f()sans arguments.

g(l,n){putchar(l);n?g(l+1,--n),putchar(l):0;}f(n){for(n=-26;++n<26;puts(""))g(65,25-abs(n));}

Essayez sur ideone .

owacoder
la source
3

VBA, 94 octets

Function T:For j=-25To 25:k=25-Abs(j):For i=-k To k:T=T &Chr(65+k-Abs(i)):Next:T=T &vbLf:Next

Appeler dans la fenêtre immédiate avec? T

Juste pour expliquer ce qui se passe: j’utilise deux fois la fonction Abs pour refléter à la fois le chemin de l’alphabet et la longueur de la ligne. Il est bien adapté à la tâche en raison de la valeur extrême unique dans les deux cas, qui correspond au passage par zéro de la variable pré-Abs.

En tant que simple jeu de commandes dans la fenêtre Immédiat de VBA, plutôt qu’un programme ou une fonction, les éléments suivants auraient besoin de 72 octets:

For j=-25To 25:k=25-Abs(j):For i=-k To k:?Chr(65+k-Abs(i));:Next:?:Next

(avec merci à @GuitarPicker)

Joffan
la source
1
J'ai utilisé une logique similaire dans l'une de mes soumissions de drapeau islandais. Ne pourriez-vous pas jouer encore plus loin en le lançant entièrement dans la fenêtre immédiate et en sautant la déclaration de fonction, ou est-ce que cela enfreint une règle que je ne connais pas bien?
GuitarPicker
@GuitarPicker; pas sûr si l'exécution dans la fenêtre immédiate compte comme un programme complet, mais si c'est le cas alors 8 octets de moins, efficacement; au lieu de commencer par Function T:terminer par :?T(bien que cela ne fonctionne qu'une seule fois, car après cela, vous devrez réinitialiser T sur "" - mais qui a besoin de plus d'un de ces triangles?)
Joffan
2
Vous n'avez même pas besoin de T si ?vous allez avec ;.
GuitarPicker
J'ai pu réduire ce nombre à 71 en utilisant cette méthode. Astuce: vous n’avez pas besoin de vbCrLf non plus.
GuitarPicker
1
oui, j'ai le même; notez que le retour est requis.
Joffan
3

Python, 73 71 octets

Merci à @xnor pour la récursion

f=lambda x=66,s='A',t='':x/92*t or t+f(x+1,s+chr(x),s+s[-2::-1]+"\n")+t

Explication

  • Paramètres :
    • x est la valeur ascii de la lettre suivante de l'alphabet
    • s est un accumulateur pour l'alphabet
    • test une ligne dans le triangle (ie s+ s backwards)
  • Retour : tsi l'alphabet est terminé (c'est-à-dire que nous sommes au centre)
  • Sinon : t+f(...)+tavec:
    • x incrémenté
    • s annexé à la lettre suivante
    • tréinitialiser à s+ s backwards+\n

Mise à jour

  • -2 [16-08-05] Supprimez les majuscules \n(+1) et les raccourcis conditionnels (-3), grâce à @xnor
Fruit non linéaire
la source
1
Quelle méthode intelligente, en tpassant à la boucle suivante. Il y a une nouvelle ligne menant supplémentaire cependant; x=66,s='A''s'en débarrasse. Le cas de base peut être raccourci à x/92*t or .
xnor
3

HTML + CSS, 884 caractères

(763 caractères HTML + 121 caractères CSS)

Juste expansion Leaky Nun 's commentaire sur MonkeyZeus ' s réponse . (Bien que je puisse mal interpréter le commentaire…)

p{margin:0}p:before{content:"ABCDEFGH"}p:after{content:"HGFEDCBA"}a:before{content:"IJKLMNOP"}a:after{content:"PONMLKJI"}
<pre>A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
<p>I</p><p>IJI</p><p>IJKJI</p><p>IJKLKJI</p><p>IJKLMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNOPONMLKJI</p><p><a>Q</p><p><a>QRQ</p><p><a>QRSRQ</p><p><a>QRSTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXYZYXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTSRQ</p><p><a>QRSRQ</p><p><a>QRQ</p><p><a>Q</a></p><p>IJKLMNOPONMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMLKJI</p><p>IJKLKJI</p><p>IJKJI</p><p>IJI</p><p>I</p>ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

4 tours
la source
3

Brachylog , 37 29 octets

Crédits à Fataliser pour son aide tout au long.

4 octets grâce à Fatalize et inspiration pour 4 autres octets.

@A:1&e:"a"yr:1&cw@Nw\
:Lc.r.!

Essayez-le en ligne!

Prédicat 0 (prédicat principal)

@A:1&e:"a"yr:1&cw@Nw\
@A:1&                  Apply predicate 1 to @A, which is
                       basically "abcdefghijklmnopqrstuvwxyz"
     e                 Choose one element from the result (choice point)
      :"a"yr               generate substring from element to "a"
            :1&            apply predicate 1
               c           concatenate
                w          write to STDOUT
                 @Nw       write "\n" to STDOUT
                    \  Backtrack to last choice point to choose
                       another element until there is no more
                       choice left, then halt.

Prédicat 1 (prédicat auxiliaire)

Cela construit essentiellement un palindrome à partir de la chaîne donnée.

:Lc.r.!
:Lc.     output is [input:L]
   .r.   output reversed is still output
      !  stop searching after the first output
Fuite Nun
la source
Vous pouvez remplacer ,Adans le prédicat 1 avec h, en enregistrant un octet.
Fataliser
Vous pouvez également enregistrer deux octets en remplaçant :1:2yt.par :2&.un !(points de choix coupés) et en ajoutant un à la fin du prédicat 2.
Fatalize
3

R, 127 125 octets

k=cat;L=LETTERS;for(i in 1:26)k(c(L[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

Pas complètement satisfait de cette solution, en particulier des deux forboucles, mais ne pourrait pas venir avec quelque chose de mieux!
LETTERScontient les lettres majuscules.

Ungolfed:

for(i in 1:26){
  cat(c(LETTERS[1:i],LETTERS[(i-1):0],"\n"))
               }

for(i in 1:26){
  cat(c(LETTERS[0:(26-i)],LETTERS[ifelse((25-i)>=0,25-i,0):0],"\n"))
               }

ifelseest un moyen plus simple de décompresser if... else...et fonctionne de la manière suivante:ifelse(condition,action if TRUE, action if FALSE)

Une autre solution de 125 octets:

for(i in 1:26)(k=cat)(c((L=LETTERS)[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))
Frédéric
la source
112 octets
Giuseppe
3

Java 131 octets

Sans utiliser String (131 octets)

public static void main(String[] args) {
    for(int i = 0 ,k=1; i>-1; i+=k){
        for(int c= 65, d = 1; c>64;){
            d = d>-1 & c < 65+i?1:-1;
            System.out.print((char)c+((c+=d)<65?"\n":""));
        }
        k = k>-1 & i < 25?1:-1;
    }
}

Codé

for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));

Avec chaîne (173 octets)

String a="abcdefghijklmnopqrstuvwxyz";
for(int i = 1 ,k=1; i>0; i+=k==1?1:-1){
    System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i));
    k = k>-1 & i < 26?1:-1;
}

Codé

String a="abcdefghijklmnopqrstuvwxyz";for(int i=1,k=1;i>0;k=k>-1&i<26?1:-1,System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i)),i+=k==1?1:-1);

Merci à manatwork et à Kevin Cruijssen

Syamesh K
la source
2
Bienvenue chez PPCG. Veuillez lire le “Comment devrais-je répondre à un code golf? Des astuces? ”Dans la page d'informations de la balise code-golf . Les réponses à ce type de défis devraient présenter des efforts pour réduire la taille du code. Vous y trouverez de l'aide dans Astuces pour le golf en Java et Astuces pour le golf dans <toutes les langues> .
manatwork
1
Là, vous utilisez 4 opérateurs ternaires et toutes les conditions sont entre parenthèses. Vous pouvez les supprimer pour sauvegarder 8 caractères.
manatwork
1
d et k ne peuvent pas descendre en dessous de -1, non? Ensuite, vous pouvez remplacer d!=-1par d>-1, idem pour k. (BTW, vous avez oublié de corriger la version
golfée
Instructions déplacées du corps de la boucle à la section d'incrémentation pour économiser 3 octets.
Syamesh K
1
Salut, je sais que ça fait un bon bout de temps, mais vous i+=k==1?1:-1pouvez jouer au golf deux choses: être i+=ket System.out.print((char)c+(c+d<65?"\n":"")),c+=d==1?1:-1);être System.out.print((char)c+((c+=d)<65?"\n":"")));. Donc, au total, cela devient ( 131 octets ):for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));
Kevin Cruijssen
3

brainfuck, 79 octets

+<++<<--------[>+++++>>[+++<+<]>]<+[[>+>+.<<-]>-[<+>>-.<-]>->.>[->]<<<[<<++>]<]

Formaté:

+<++<<
--------[>+++++>>[+++<+<]>]
<+
[
  [>+>+.<<-]
  >-[<+> >-.<-]
  >->.>[->]
  <<<[<<++>]
  <
]

Essayez-le en ligne

Mitch Schwartz
la source
2

Sesos , 27 octets

0000000: a85ab9 ac5daa f8b1c7 785f9b b961f7 665c1b 73ccfc  .Z..]....x_..a.f\.s..
0000015: c01ecb 987303                                     ....s.

Essayez-le en ligne! Cochez Debug pour voir le code SBIN généré.

Assemblage Sesos

Le fichier binaire ci-dessus a été généré en assemblant le code SASM suivant.

add 65, rwd 1, add 10, rwd 2, add 25
jmp
    fwd 3
    jmp
        put, fwd 1
    jnz
    rwd 1
    jmp
        fwd 1, add 1, fwd 1, add 1, rwd 2, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    rwd 1, add 1, rwd 2
    jmp
        put, rwd 1
    jnz
    rwd 1, sub 1
jnz
fwd 3
jmp
    jmp
        put, fwd 1
    jnz
    rwd 1, get, rwd 1
    jmp
        put, rwd 1
    jnz
    fwd 2
; jnz (implicit)
Dennis
la source
2

/// , 208 octets

/'/\/\///+/BA
AB'-/DC+CD'&/FE-EF')/HG&GH'=/JI)IJ'|/LK=KL'7/NM|MN'1/PO7OP'q/RQ1QR'p/TSqST'6/VUpUV'[/XW6WX/A
A+C+C-E-E&G&G)I)I=K=K|M|M7O7O1Q1QqSqSpUpU6W6W[Y[YZY[Y[W6W6UpUpSqSqQ1Q1O7O7M|M|K=K=I)I)G&G&E-E-C+C+A
A

Pas gagnant, bien sûr, mais le voilà, précédant Martin Ender ...

Erik le golfeur
la source