Dessinez un chapeau de fête alphabet

22

Votre tâche consiste à imprimer ce texte exact:

            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

L'affaire n'a pas d'importance.

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le plus petit nombre d'octets l'emporte.

code-golf  kolmogorov-complexity  alphabet 
— Oliver Ni
source
2
Pourquoi les downvotes?
— Oliver Ni du
19
Je soupçonne que certaines personnes sont simplement fatiguées de tous les défis de l'alphabet ascii-art KC.
— xnor
Pouvons-nous le faire en majuscules?
— Downgoat
7
Sérieusement, un autre défi de l'alphabet?
— Erik the Outgolfer
2
J'aime ces défis alphabétiques. Celui-ci pourrait facilement être rebaptisé arbre de Noël.
— Pete Arden

Réponses:

6

Cheddar, 50 45 42 37 octets

25|>0=>i->print" "*(i/2|0)+(65+i)@"90

Simple, mais utilise la syntaxe de classement du cheddar (à la fois numérique et alphabétique)

Essayez-le en ligne!

Explication

25 |> 0 =>    // Map range [0, 26) (i.e. [25, 0] reversed) over....
   i -> 
     print    // Prints in it's own line...
     " " * (i/2 |0) +     // Number of spaces is floor(n/2).
                          // `|0` for flooring is hack from JS
     (65 + i) @" 90       // Char code range is this

65est le code de caractère pour Aet 90pourA

— Downgoat
source
1
Zest 90, non A.
— Mego
5

05AB1E , 15 13 octets

A.svy12N;ï-ú,

Essayez-le en ligne! (légèrement différent de ci-dessus car il ún'est pas encore sur TIO)

Explication

  1. Push alphabet
  2. Calculer les suffixes de l'alphabet
  3. Ajouter 12 index / 2 espaces
  4. Impression
— Emigna
source
4

Python 2, 70 octets

Porté de la réponse d' Emigna , -2 octets pour le remplacer -i-1par~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]
— Karl Napf
source
Je suis assez sûr que l'utilisation de la carte peut produire un alphabet plus court, sauf peut-être des minuscules ayant des valeurs plus élevées
— Destructible Lemon
En fait, je ne suis plus sûr. Je pense que ça ne marcherait pas de toute façon :( soz
— Destructible Lemon
4

R, 67 66 59 octets

EDIT: économisé quelques octets grâce à @rturnbull

for(i in 25:0)cat(rep(" ",i/2),letters[i:25+1],"\n",sep="")

Exploiter le fait que tout nombre transmis à la repfonction est automatiquement arrondi à l'entier le plus proche (par exemple rep("*",1.99) => "*"), ce qui signifie que la séquence réelle transmise est floor(13-1:26/2):

12 12 11 11 10 10  9  9  8  8  7  7  6  6  5  5  4  4  3  3  2  2  1  1  0  0
— Billywob
source
1
Cela sort plus court que ma tentative de matrice. Remplacer 14...-1par 13?
— JDL
@JDL Ah oui bien sûr. Un vestige de tenter une autre approche
— Billywob
2
Si vous boucle à travers au 25:0lieu de 1:26, vous pouvez changer 13-i/2à i/2et simplifier (27-i):26pour i:25+1, sauver 6 octets.
— rturnbull
3

Pyth, 15 octets

j_m+*/d2\ >GdUG

Un programme qui imprime le résultat sur STDOUT.

Essayez-le en ligne

Comment ça marche

j_m+*/d2\ >GdUG  Program
             UG  Yield [1, 2, 3, 4, ..., 26]
  m              Map over the range with variable d:
          >Gd      Yield alphabet with first d-1 letters discarded
   +               Prepend
     /d2             d//2
    *   \            spaces
 _               Reverse
j                Join on newlines
                 Implicitly print
— TheBikingViking
source
Essayez ;au lieu de\
— isaacg
3

Python 2, 52 octets

n=26;s=''
while n:n-=1;s=chr(97+n)+s;print n/2*' '+s

Accumule la chaîne sà imprimer et met à jour le nombre d'espaces de tête n/2. Une whileboucle se terminant en 0est une boucle numérique rare qui bat une execboucle (53 octets):

n=26;s=''
exec"n-=1;s=chr(97+n)+s;print n/2*' '+s;"*n

Également une alternative à 53 octets:

s=''
exec"s=chr(122-len(s))+s;print s.center(26);"*26
— xnor
source
3

JavaScript (ES6), 85 75 69 68 octets

for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+`
`

-1 octet grâce à @ l4m2 .

— darrylyeo
source
2
N'est-ce pas un extrait plutôt qu'une fonction ou un programme?
— Neil
1
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#'1B plus court
— l4m2
@ l4m2 Brillant!
— darrylyeo
1
Belle idée en utilisant la base 36! +1
— Titus
2

Brain-Flak , 244 octets

((((((()()()()())){}{}){}){}()){})((((()()()){}){}()){}){(({}[()]<>)<({}<(<>({})<>)>){({}[()]<(({})[()])>)}({}({})<>[({})]<>(((()()()){}){}){}())((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{}){({}[()]<((((()()()()){}){}){})>)}((()()()()()){})><>)}<>

Essayez-le en ligne!

Cela devrait être suffisamment lisible tel quel. Si vous en avez besoin, j'ai une explication complète:

push 122 (z): ((((((()()()()())){}{}){}){}()){})
push 26:      ((((()()()){}){}()){})
loop 26 times (i = 25..0): {
 (
  i--, push to b stack:({}[()]<>)
  <
   put 122 from a stack under i: ({}<(<>({})<>)>)
   i times push letter-1: {({}[()]<(({})[()])>)}
   replace top 0 with 26-i: ({}({})<>[({})]<>(((()()()){}){}){}())
   devide by two: ((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{})
   add spaces: {({}[()]<((((()()()()){}){}){})>)}
   push 10 (\n): ((()()()()()){})
  >
  flip stack back: <>
 push i--: ) 
}
flip to results stack: <>
— MegaTom
source
4
This should be readable enough as is.Vous parlez de Brain-Flak , non?
— Erik the Outgolfer
2

Gelée , 15 13 octets

-2 octets grâce à @miles (a formé une chaîne niladique que je soupçonnais exister mais ne s'est pas formée)

ØaJ’H⁶ẋżṫJ$ṚY

TryItOnline!

Comment?

ØaJ’H⁶ẋżṫJ$ṚY - Main link
Øa            - alphabet yield -> ['a', 'b', 'c', ..., 'y', 'z']
  J           -    range(length)      -> [1, 2, 3, ..., 25, 26]
   ’          -    decrement          -> [0, 1, 2, ..., 24, 25]
    H         -    halve              -> [0,.5  1, ..., 12, 12.5]
     ⁶        -    literal [' ']
      ẋ       -    repeat list        -> [[], [], [' '], ..., 12x' ', 12x' ']
          $   - last two links as a monad
         J    -     range(length)     -> [1, 2, 3, ..., 25, 26]
        ṫ     -     tail (vectorises) -> [['a'-'z'], ['b'-'z'], ..., ['y','z'], ['z']]
       ż      - zip
              -> [[[],['a'-'z']], [[],['b'-'z']], ..., [12x' ',['y','z']], [12x' ',['z]]]
           Ṛ  - reverse whole array
            Y - join with line feeds (implicit print)
— Jonathan Allan
source
J'ai trouvé un moyen de former une chaîne niladique commençant par l'alphabet ØaJ’H⁶ẋżṫJ$ṚYqui enregistre 2 octets
— miles
Pensez-vous que l'explication est correcte?
— Jonathan Allan
1
Oui, pensez-y simplement comme une chaîne monadique avec un seul argument étant l'alphabet
— miles
2

C, 72 68 octets

m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}
— o79y
source
1

Turtlèd , 70 68 octets

noter l'espace de fuite

#abcdefghijklmnopqrstuvwxyz#' -{ -{ +.r_}' l[ l-]d,(*@!' r)(!@*)_}'

Essayez-le en ligne!

Comment ça marche:

#abcdefghijklmnopqrstuvwxyz#              Set string var to this value
                            ' -           write space on first grid cell, string pointer-=1
                               {                                    } While cell is space
                                 -                 decrement string pointer
                                  {     }    While cell is space
                                    +.       increment string pointer, write pointed char
                                      r      move right
                                       _     write non-space if pointed char is last char

                                         '[space]   write space on cell
                                           l        move left
                                            [ l-]   move left, pointer-- until cell's space
                                                 d, move down, write character var \
                                                                           (initially *)

                                                   (*     ) if cell is *
                                                     @!     set char var=!
                                                       ' r  write space over *, move right

                                                           (!    ) if cell is !
                                                             @*    set char var=*
                                                               '[space] write space over !

                                                                 _ (explanation below)
                                               write (*|!) if pointed char is last char

                                                                   '[space]    Write space

Explication lisible par l'homme (?):

Il utilise la chaîne var pour contenir l'alphabet. À chaque itération, il réduit l'index d'une unité jusqu'à ce qu'il s'enroule et s'arrête après être arrivé à la dernière ligne. Pour les retraits alternés, il utilise le char var. À chaque itération, il vérifie le var var et le retourne. si c'était * il se déplace vers la droite, donc le premier caractère s'aligne, sinon non, donc le dernier caractère s'aligne.

— Citron destructible
source
1

Perl, 44 octets

Ceci est un port de la réponse de @ xnor .

$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--

Doit -E(ou -M5.010) fonctionner:

perl -E '$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--';
— Dada
source
1

Java 7,128 127 octets

1 octet enregistré. Merci à Kevin.

String c(int n,String s,char v,String d){String c="";for(int j=0;j++<(n-1)/2;c+=" ");return n>0?c(--n,s=v+s,--v,d+c+s+"\n"):d;}

non golfé

  class A {

public static void main(String[] args) {
System.out.print(c(26, "", (char)122, ""));
}
static String c(int n, String s, char v, String d){

    String c = "";

    for (int j = 0; j++ < (n - 1)/2; c += " ");

    return n > 0 ? c(--n, s = v + s, --v, d + c + s + "\n" ) : d;
}
}

Sans passer 122 dans une fonction

132 octets

String c(String s,int n,String d){String c="";int v=96,j=0;for(;j++<(n-1)/2;c+=" ");return n>0?c(s=(char)(v+n--)+s,n,d+c+s+"\n"):d;}

non golfé

  class A{

public static void main(String[] args) {
System.out.print(c("",26,""));

}
static String c(String s, int n, String d) {
    String c = "";
    int v = 96,j=0;
    for (; j++ < (n - 1)/2; c += " ");
    return n > 0 ? c(s = ( char) (v + n--) + s, n, (d + c + s + "\n")) : d;
     }
  }
— Numberknot
source
1
Vous pouvez supprimer le =at d+=c+s+"\n". En outre, vous souhaiterez peut-être formater un peu votre code non golf avec des indentations. J'ai remarqué cela avec certaines de vos autres réponses également. :)
— Kevin Cruijssen
1
Oops! j'ai encore fait cette erreur, honte à moi. ...... ok @KevinCruijssen j'y suis.
— Numberknot
Vous ne pouvez pas remplacer le s=v+sdans la récursivité par s+=v?
— Roman Gräf
Non ... car le motif des lettres est à l'envers.
— Numberknot
1

Ruby, 64 octets

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
— Manny42
source
Quelques commentaires: Vous n'avez pas besoin de mettre les crochets après l' join appel eachau lieu de mapn'est pas nécessaire, car nous ne nous soucions pas de ce que nous retournons Vous pouvez appeler lastsur une plage
— Lee W
Au lieu de (0..26).map, essayez 27.times; au lieu de ('a'..'z').to_a, [*?a..?z]; et au lieu de .join, *"".
— Jordan
1

Japt , 16 octets

;C¬£SpY/2 +CsYÃw ·

Essayez-le en ligne!

Explication:

;C¬£SpY/2 +CsYÃw ·
;C                  // Alphabet shortcut
  ¬                 // Split into an array of chars
   £          Ã     // Map each item X and index Y by:
    SpY/2           //  " " repeated floor(Y/2) times
          +CsY      //  + alphabet.slice(Y)
               w    // Reverse the array of lines
                 ·  // Join with newlines
— Oliver
source
1

REXX, 52 octets

do i=1 to 26
  say centre(right(xrange(a,z),i),26)
  end

Sortie:

            Z             
            YZ            
           XYZ            
           WXYZ           
          VWXYZ           
          UVWXYZ          
         TUVWXYZ          
         STUVWXYZ         
        RSTUVWXYZ         
        QRSTUVWXYZ        
       PQRSTUVWXYZ        
       OPQRSTUVWXYZ       
      NOPQRSTUVWXYZ       
      MNOPQRSTUVWXYZ      
     LMNOPQRSTUVWXYZ      
     KLMNOPQRSTUVWXYZ     
    JKLMNOPQRSTUVWXYZ     
    IJKLMNOPQRSTUVWXYZ    
   HIJKLMNOPQRSTUVWXYZ    
   GHIJKLMNOPQRSTUVWXYZ   
  FGHIJKLMNOPQRSTUVWXYZ   
  EFGHIJKLMNOPQRSTUVWXYZ  
 DEFGHIJKLMNOPQRSTUVWXYZ  
 CDEFGHIJKLMNOPQRSTUVWXYZ 
BCDEFGHIJKLMNOPQRSTUVWXYZ 
ABCDEFGHIJKLMNOPQRSTUVWXYZ
— idrougge
source
1

Vim, 25 frappes

:h<_␍jjYZZPqqPxYPr Yq12@q

Où ␍ est la touche Entrée, également parfois notée comme <cr> .

Explication

:h<_␍jjYZZ                 " get a-z
          P                " initialize by pasting
           qq              " start record macro @q
             Px            " paste and remove the 1st char
               YPr␣        " yank and paste and replace 1st char with space
                   Y       " yank the whole line again
                    q      " end recording
                     12@q  " call macro 12 @q times

Je suis nouveau sur ViM cependant - j'ai commencé en novembre. Vous vous demandez s'il existe un moyen de fusionner l'initialisation Pavec celle de la macro.

Quelle est la façon "correcte" de tester une séquence ViM jouée au golf? J'ai testé avec \vi -u /dev/null. Cependant, dans une machine virtuelle :h<_␍ne fonctionne même pas. Je ne sais pas non plus pourquoi mon ViM se déplacera vers le premier caractère non spatial haha.

PS Avant de passer à OS X, je jouais en Hexagonie avec d'excellents outils ... Maintenant, sur OS XI, ne faites pas de vin et n'exécutez donc pas les excellents outils pour les explications et le débogage. C'est ainsi qu'a commencé mon voyage avec ViM!

— Sunny Pun
source
1

C # (.NET Core) , 112 octets

()=>string.Join("\n",new int[26].Select((_,i)=>"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".Substring(25-i)))

Essayez-le en ligne!

()=>string.Join("\n", // OP doesnt want to output a sequence of string...
    new int[26].Select((_,i)=> // yield range from 0 to 25
        "".PadLeft(12-i/2)+ // add spaces to center
            "abcdefghijklmnopqrstuvwxyz".Substring(25-i)))  // remove letters
— aloisdg dit Réintégrer Monica
source
1

Tcl , 92 octets

set a {}
time {set a [format %c [expr 123-[incr i]]]$a;puts [format %[expr 13+$i/2]s $a]} 26

Essayez-le en ligne!

tcl, 94

set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr 74-$i/2]s $a]} 26

démo

Au milieu du processus, j'ai accidentellement obtenu la version italique du chapeau:

tcl, 94

set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]} 26

démo

tcl, 101

set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr ($i-48)/2]s $a]}

démo

Au milieu du processus, j'ai accidentellement obtenu la version italique du chapeau:

tcl, 99

set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]}

démo

— sergiol
source
— ASCII uniquement le
@ Merci ASCII uniquement!
— sergiol
1

Lisp commun, SBCL, 83 82 octets

(dotimes(i 27)(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))

Explication

(dotimes(i 27) ; loop from i=0 to i=26
(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))
;print out part of alphabet starting from character number 26-i (counting from zero)
;using justification (~26:@<~a~>) to center with weight 26 characters

-1 en utilisant la suggestion par ASCII uniquement à utiliser <enter>au lieu de~%

— ASCII uniquement
source
1
82
— ASCII uniquement
1

T-SQL, 107 octets

DECLARE @t VARCHAR(99)=SPACE(13),@ INT=27a:SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))PRINT @t
SET @-=1IF @>1GOTO a

Modifie la chaîne pour chaque ligne en entassant la bonne lettre à la bonne position à l'aide de la fonction SQL STUFF(). Formaté:

DECLARE @t VARCHAR(99)=SPACE(13), @ INT=27
a:
    SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))
    PRINT @t
    SET @-=1
IF @>1 GOTO a

@/2utilise la division entière (pas de reste) pour déterminer la position d'insertion de la lettre. @%2est leMODULO fonction et bascule entre 0 (insérer la lettre) et 1 (écraser un espace).

Si vous préférez les lettres capitales, utilisez CHAR(@+63)plutôt (ne change pas notre nombre d'octets).

— BradC
source
0

Haskell (Lambdabot), 73 octets

unlines[([1..div(26-length x)2]>>" ")++x|x<-reverse.init$tails['a'..'z']]

même longueur:

do x<-reverse.init$tails['a'..'z'];([1..div(26-length x)2]>>" ")++x++"\n"

J'utilise init.tailsou tail.initsavec un revers possible devant à peu près tous les défis; J'aimerais qu'ils l'ajoutent déjà à Prelude.

— BlackCap
source
0

Python 2, 66 64 octets

i=91;exec'i-=1;print`map(chr,range(i,91))`[2::5].center(26);'*26
— Bleu
source
0

Groovy, 53 octets

('z'..'a').each{println((it..'z').join().center(26))}

Sortie:

            z             
            yz            
           xyz            
           wxyz           
          vwxyz           
          uvwxyz          
         tuvwxyz          
         stuvwxyz         
        rstuvwxyz         
        qrstuvwxyz        
       pqrstuvwxyz        
       opqrstuvwxyz       
      nopqrstuvwxyz       
      mnopqrstuvwxyz      
     lmnopqrstuvwxyz      
     klmnopqrstuvwxyz     
    jklmnopqrstuvwxyz     
    ijklmnopqrstuvwxyz    
   hijklmnopqrstuvwxyz    
   ghijklmnopqrstuvwxyz   
  fghijklmnopqrstuvwxyz   
  efghijklmnopqrstuvwxyz  
 defghijklmnopqrstuvwxyz  
 cdefghijklmnopqrstuvwxyz 
bcdefghijklmnopqrstuvwxyz 
abcdefghijklmnopqrstuvwxyz
— Urne de poulpe magique
source
0

QBIC , 57 octets

[25,0,-1|Y=Z[1,a/2|Y=Y+@ |]X=Z[a,25|X=X+$CHR$(65+|c)]?Y+X

Celui-ci fonctionne étonnamment bien avec les boucles QBIC 'FOR. Explication (de la version précédente - le même principe s'applique):

[26,1,-1|          Loops from 26 to 1, decrementing 'a'
                   'a' is used to determine the number of spaces per line and the last letter we want to print
Y=Z                Z is always an empty string in this program, 
                   Y will hold the spaces we need to center this line
[1,a/2|Y=Y+@ |]    Add a space to Y equal to half the value of 'a', giving us a center alignment
X=Z                X holds the characters we need on this line, reset it
[a,26|             FOR c = a to 26 --> loop over the last part of the alphabet
X=X+$CHR$(64+|c)]  Convert c+64 to ASCII and append
?Y+X               Print the spaces and the letters

<outer FOR loop is closed by QBIC>

Sortie: 

            Z
            YZ
           XYZ
           WXYZ
          VWXYZ
          UVWXYZ
         TUVWXYZ
         STUVWXYZ
        RSTUVWXYZ
        QRSTUVWXYZ
       PQRSTUVWXYZ
       OPQRSTUVWXYZ
      NOPQRSTUVWXYZ
      MNOPQRSTUVWXYZ
     LMNOPQRSTUVWXYZ
     KLMNOPQRSTUVWXYZ
    JKLMNOPQRSTUVWXYZ
    IJKLMNOPQRSTUVWXYZ
   HIJKLMNOPQRSTUVWXYZ
   GHIJKLMNOPQRSTUVWXYZ
  FGHIJKLMNOPQRSTUVWXYZ
  EFGHIJKLMNOPQRSTUVWXYZ
 DEFGHIJKLMNOPQRSTUVWXYZ
 CDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
— steenbergh
source
Ne correspond pas à l'OP.
— Urne de poulpe magique du
@carusocomputing le fait maintenant.
— steenbergh
0

Raquette 137 octets

(for((n(range 122 96 -1)))(for((i(floor(/(- n 97)2))))(display #\space))
(for((i(range n 123)))(display(integer->char i)))(displayln ""))

Non golfé: 

(define (f)
  (for ((n (range 122 96 -1)))
       (for ((i (floor(/(- n 97)2))))
         (display #\space))
       (for ((i (range n 123)))
         (display (integer->char i)))
    (displayln "")))

Essai: 

(f)

Sortie: 

            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
— rnso
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.