Disegna un cappello da festa con alfabeto

22

Il tuo compito è stampare questo testo esatto:

            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

Il caso non ha importanza.

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

code-golf  kolmogorov-complexity  alphabet 
— Oliver Ni
fonte
2
Perché i downvotes?
— Oliver Ni,
19
Ho il sospetto che alcune persone siano solo stanche di tutte le sfide KC di ASCII secondo il modello alfabetico.
— xnor
Possiamo farlo in maiuscolo?
— Downgoat,
7
Scherzi a parte, un'altra sfida alfabetica?
— Erik the Outgolfer,
2
Mi piacciono queste sfide dell'alfabeto. Questo potrebbe facilmente essere rinominato come un albero di Natale.
— Pete Arden,

Risposte:

6

Cheddar, 50 45 42 37 byte

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

Semplice, ma utilizza la sintassi del consise cheddar (sia numerica che alfabetica)

Provalo online!

Spiegazione

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

65è un codice char per Ae 90perA

— Downgoat
fonte
1
Zè 90, non è A.
— Mego,
5

05AB1E , 15 13 byte

A.svy12N;ï-ú,

Provalo online!(leggermente diverso da sopra perché únon è ancora su TIO)

Spiegazione

  1. Spingere alfabeto
  2. Calcola i suffissi dell'alfabeto
  3. Prepara 12 spazi / 2 spazi
  4. Stampare
— Emigna
fonte
4

Python 2, 70 byte

Portato dalla risposta di Emigna , -2 byte per la sostituzione -i-1con~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]
— Karl Napf
fonte
Sono abbastanza sicuro che l'uso della mappa può produrre un alfabeto più breve, tranne forse il minuscolo con valori più alti
— Limone distruttibile,
In realtà non ne sono più sicuro. Penso che non funzionerebbe comunque per questo :( soz
— Destructible Lemon il
4

R, 67 66 59 byte

EDIT: salvato un paio di byte grazie a @rturnbull

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

Sfruttando il fatto che qualsiasi numero passato alla repfunzione viene automaticamente arrotondato per difetto all'intero più vicino (ad esempio rep("*",1.99) => "*"), il che significa che la sequenza effettiva passata è 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
fonte
1
Questo risulta più breve del mio tentativo di matrice. Sostituisci 14...-1con 13?
— JDL,
@JDL Ah sì, certo. Un residuo del tentativo di un altro approccio
— Billywob,
2
Se si esegue un ciclo 25:0, invece di 1:26, è possibile modificare 13-i/2a i/2, e semplificare (27-i):26al i:25+1, risparmiando 6 byte.
— rturnbull,
3

Pyth, 15 byte

j_m+*/d2\ >GdUG

Un programma che stampa il risultato su STDOUT.

Provalo online

Come funziona

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
fonte
Prova ;invece di\
— isaacg,
3

Python 2, 52 byte

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

Accumula la stringa sper stampare e aggiorna il numero di spazi iniziali n/2. Un whileloop che termina in 0è un loop numerico raro che batte un execloop (53 byte):

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

Anche un'alternativa a 53 byte:

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

JavaScript (ES6), 85 75 69 68 byte

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

-1 byte grazie a @ l4m2 .

— darrylyeo
fonte
2
Non è uno snippet piuttosto che una funzione o un programma?
— Neil,
1
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#'1B più corto
— l4m2
@ l4m2 Brilliant!
— darrylyeo,
1
Bella idea usando la base 36! +1
— Tito
2

Brain-Flak , 244 byte

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

Provalo online!

Questo dovrebbe essere abbastanza leggibile così com'è. Se ne hai bisogno, ho una spiegazione completa:

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
fonte
4
This should be readable enough as is.Stai parlando di Brain-Flak , giusto?
— Erik the Outgolfer,
2

Gelatina , 15 13 byte

-2 byte grazie a @miles (formava una catena niladica che sospettavo esistesse ma non si è formata)

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

TryItOnline!

Come?

Ø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
fonte
Ho trovato un modo per formare una catena niladica che inizia con l'alfabeto ØaJ’H⁶ẋżṫJ$ṚYche salva 2 byte
— miglia
Pensi che la spiegazione sia corretta?
— Jonathan Allan,
1
Sì, pensalo come una catena monadica con un solo argomento: l'alfabeto
— miglia,
2

C, 72 68 byte

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

Turtlèd , 70 68 byte

notare lo spazio finale

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

Provalo online!

Come funziona:

#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

Spiegazione leggibile dall'uomo (?):

Usa la stringa var per contenere l'alfabeto. Ogni iterazione, riduce l'indice di uno, fino a quando non si avvolge e si ferma, dopo essere arrivato all'ultima riga. Per i rientri alternati, utilizza il carattere var. Ogni iterazione controlla il var di carattere e lo lancia. se era * si sposta a destra, quindi il primo carattere si allinea, altrimenti no, quindi l'ultimo carattere si allinea.

— Limone Distruttibile
fonte
1

Perl, 44 byte

Questa è una porta della risposta di @ xnor .

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

Deve -E(o -M5.010) funzionare:

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

Java 7,128 127 byte

Salvato 1 byte. Grazie a 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;}

ungolfed

  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;
}
}

Senza un passaggio 122 in una funzione

132 byte

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;}

ungolfed

  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
fonte
1
È possibile rimuovere l' =a d+=c+s+"\n". Inoltre, potresti voler formattare un po 'il tuo codice non golfato con rientri. L'ho notato anche con alcune delle tue altre risposte. :)
— Kevin Cruijssen,
1
oops! ho fatto di nuovo questo errore, peccato per me. ...... ok @KevinCruijssen ci sono.
— Numberknot,
Non è possibile sostituire il s=v+snella ricorsione con s+=v?
— Roman Gräf,
No ... perché il motivo delle lettere è in ordine inverso.
— Numberknot
1

Rubino, 64 byte

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
— Manny42
fonte
Alcuni commenti: non è necessario mettere le parentesi dopo la join chiamata eachinvece di mapnon è necessario, dal momento che non ci interessa ciò che stiamo tornando Puoi chiamare lastsu un intervallo
— Lee W
Invece di (0..26).map, prova 27.times; invece ('a'..'z').to_a, [*?a..?z]; e invece di .join, *"".
— Giordania,
1

Japt , 16 byte

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

Provalo online!

Spiegazione:

;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
fonte
1

REXX, 52 byte

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

Produzione:

            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
fonte
1

Vim, 25 sequenze di tasti

:h<_␍jjYZZPqqPxYPr Yq12@q

Dove ␍ è il tasto Invio, talvolta anche annotato come <cr>.

Spiegazione

: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

Sono nuovo di ViM, ho iniziato a novembre. Mi chiedo se c'è un modo per unire l'inizializzazione Pcon quello nella macro.

Qual è il modo "corretto" per testare una sequenza ViM golfizzata? Ho provato con \vi -u /dev/null. Tuttavia, in una VM :h<_␍non funziona nemmeno. Inoltre, non so perché il mio ViM si sposterà sul primo personaggio non spaziale ahah.

PS Prima di passare a utilizzare OS X, ho giocato a golf in Hexagony con ottimi strumenti ... Ora su OS X non faccio vino e quindi non eseguo i grandi strumenti per spiegazioni e debugging. Così è iniziato il mio viaggio con ViM!

— Sunny Pun
fonte
1

C # (.NET Core) , 112 byte

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

Provalo online!

()=>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 dice Reinstate Monica
fonte
1

Tcl , 92 byte

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

Provalo online!

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

dimostrazione

Nel mezzo del processo, ho accidentalmente ottenuto la versione in corsivo del cappello:

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

dimostrazione

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]}

dimostrazione

Nel mezzo del processo, ho accidentalmente ottenuto la versione in corsivo del cappello:

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]}

dimostrazione

— sergiol
fonte
— ASCII il
@ Solo ASCII grazie!
— sergiol,
1

Lisp comune, SBCL, 83 82 byte

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

Spiegazione

(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 usando la sugestion di ASCII-only da usare al <enter>posto di~%

— ASCII-only
fonte
1
82
— ASCII il
1

T-SQL, 107 byte

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

Modifica la stringa per ogni riga inserendo la lettera corretta nella posizione corretta utilizzando il comando SQL STUFF(). formattato:

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

@/2usa la divisione intera (nessun resto) per determinare la posizione in cui inserire la lettera. @%2è la MODULOfunzione e scorre tra 0 (inserire la lettera) e 1 (sovrascrivere uno spazio).

Se preferisci le lettere maiuscole, usa CHAR(@+63)invece (non cambia il nostro conteggio di byte).

— BradC
fonte
0

Haskell (Lambdabot), 73 byte

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

stessa lunghezza:

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

Uso init.tailso tail.initscon un possibile rovescio in avanti praticamente in ogni sfida; Vorrei che lo aggiungessero già a Prelude.

— Capinera
fonte
0

Python 2, 66 64 byte

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

Groovy, 53 byte

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

Produzione:

            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
— Urna di polpo magico
fonte
0

QBIC , 57 byte

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

Questo funziona sorprendentemente bene con i loop QBIC 'FOR. Spiegazione (della versione precedente - si applica lo stesso principio):

[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>

Produzione: 

            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
fonte
Non corrisponde all'OP.
— Magic Octopus Urn,
@carusocomputing lo fa ora.
— Steenbergh,
0

Racchetta 137 byte

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

Ungolfed: 

(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 "")))

test: 

(f)

Produzione: 

            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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.