Crea un riflettore alfabetico!

66

Ispirato da un bug in una soluzione a questa sfida , la tua sfida è quella di produrre questo testo esatto:

                         ZYXWVUTSRQPONMLKJIHGFEDCBA
                        YXWVUTSRQPONMLKJIHGFEDCBA
                       XWVUTSRQPONMLKJIHGFEDCBA
                      WVUTSRQPONMLKJIHGFEDCBA
                     VUTSRQPONMLKJIHGFEDCBA
                    UTSRQPONMLKJIHGFEDCBA
                   TSRQPONMLKJIHGFEDCBA
                  SRQPONMLKJIHGFEDCBA
                 RQPONMLKJIHGFEDCBA
                QPONMLKJIHGFEDCBA
               PONMLKJIHGFEDCBA
              ONMLKJIHGFEDCBA
             NMLKJIHGFEDCBA
            MLKJIHGFEDCBA
           LKJIHGFEDCBA
          KJIHGFEDCBA
         JIHGFEDCBA
        IHGFEDCBA
       HGFEDCBA
      GFEDCBA
     FEDCBA
    EDCBA
   DCBA
  CBA
 BA
A
  • La prima riga avrà 25 spazi, quindi l'alfabeto all'indietro a partire dalla 26a lettera ( ZYXWVUTSRQPONMLKJIHGFEDCBA), quindi una nuova riga.
  • La seconda riga avrà 24 spazi, quindi l'alfabeto all'indietro a partire dalla 25a lettera ( YXWVUTSRQPONMLKJIHGFEDCBA), quindi una nuova riga.
  • ...
  • L'ultima (26a) riga non avrà spazi, quindi l'alfabeto all'indietro a partire dalla 1a lettera ( A), quindi una nuova riga.

Regole aggiuntive:

  • Il programma può utilizzare qualsiasi metodo di output consentito.
  • È consentita una nuova riga finale e / o una nuova riga iniziale.
  • Ci deve essere una nuova riga tra le righe che contengono le lettere, non di più.
  • Le lettere devono essere tutte in maiuscolo.

Come per il code-golf , vince l'invio più breve. In bocca al lupo!

Classifica:

Mostra snippet di codice

code-golf  ascii-art  kolmogorov-complexity  alphabet 
— MD XF
fonte
3
A me sembra la luce
— emessa
4
— Mr. Xcoder,
Ogni linea può avere uno spazio extra davanti?
— HyperNeutrino,
3
Ogni riga potrebbe avere spazi finali dopo l'ultima lettera?
— miglia,
1
@miles sì, va bene.
— MD XF,

Risposte:

19

05AB1E , 7 byte

Codice:

₂žp.s1Λ

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

 žp.s      # Get the suffixes of ZYX...CBA
      Λ    # Using the canvas mode, print the
₂          # first 26 elements of the array
     1     # into the upper-right direction
— Adnan
fonte
2
@MDXF IMO, è una regola davvero stupida
— DJMcMayhem
3
Hmm ... Immagino che rimuoverò la regola, quindi. stato completato
— MD XF
2
Potrei proporre un PR che documenta quella caratteristica quando trovo il tempo. Sembra essere un buon modo per imparare un po 'di pitone da un codice ben scritto e di facile lettura
— scottinet,
6
Perché žpesiste quando Auè d'oro? BADUM tissss
— Magic Octopus Urn
5
Usando 05AB1E, crea un file che documenta tutte le sue caratteristiche, abbrevia il codice vince: P
— Christian
22

R , 67 55 byte

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

Provalo online!

— Giuseppe
fonte
4
R sta battendo Python in una sfida con le stringhe? Bello. +1 per LETTERE
— CriminallyVulgar
1
@CriminallyVulgar è una sfida molto strana; Haskell sta battendo il pareggio di PHP e R che stanno entrambi battendo Python ... almeno Perl è in testa a tutti loro come ci si potrebbe aspettare.
— CR Drost,
-2 byte se si cambia sepin s. Le funzioni
— completeranno
1
@Punintended che non funzionerà a causa ...dell'argomento; gli argomenti che precedono ...(in genere) ottengono una corrispondenza parziale e quelli che seguono non lo fanno. Credo che ci siano alcune eccezioni, ma catnon è una di queste
— Giuseppe,
@Giuseppe Non vedo un...
— MilkyWay90
15

V , 13 , 11 byte

¬ZAòY>HGpxl

Provalo online!

hexdump:

00000000: ac5a 41f2 593e 4847 7078 6c              .ZA.Y>HGpxl

Scritto dal mio telefono: P.

¬ZA         " Insert the alphabet backwards
   ò        " Recursively:
    Y       "   Yank this current line
     >H     "   Add one space to every line
       G    "   Move to the last line in the buffer
        p   "   Paste the line we yanked
         x  "   Delete one character
          l "   Move one character to the right, which will throw an error on 
            "   the last time through, breaking the loop
— DJMcMayhem
fonte
1
Faccio anche queste sul mio telefono, +1
— Stan Strum,
12

PowerShell , 42 byte

25..0|%{' '*$_+-join[char[]]((65+$_)..65)}

Provalo online!

Spiegazione:

25..0|%{                                 } # Loop from 25 to 0
                             (65+$_)..65   # Construct a range of the specific ASCII codes
                    [char[]](           )  # Cast that as a character array
               -join                       # that has been joined together into a string
        ' '*$_+                            # Prepended with the correct amount of spaces
— AdmBorkBork
fonte
10

/// , 105 97 byte

/:/\\\\*//#/:Z:Y:X:W:V:U:T:S:R:Q:P:O:N:M:L:K:J:I:H:G:F:E:D:C:B:A//\\*/\/\/_____#
\/ //_/     //*#

Provalo online!

Spiegazione

/// conosce solo un comando, /<pattern>/<substitution>/<text>sostituisce tutte le occorrenze di <pattern>in <text>con <substitution>. Inoltre \può essere usato per sfuggire ai personaggi.

Codice abbreviato per semplicità: 

/:/\\\\*//#/:E:D:C:B:A//\\*/\/\/__#
\/ //_/  //*#

Il primo comando /:/\\\\*/sostituisce :con \\*nel codice successivo. Questo da:

/#/\\*E\\*D\\*C\\*B\\*A//\\*/\/\/__#
\/ //_/  //*#

Quindi /#/\\*E\\*D\\*C\\*B\\*A/sostituisce #con \*E\*D\*C\*B\*A:

/\\*/\/\/__\*E\*D\*C\*B\*A
\/ //_/  //*\*E\*D\*C\*B\*A

Quindi /\\*/\/\/__\*E\*D\*C\*B\*A<newline>\/ /sostituisce \*con //__*E*D*C*B*A<newline>/:

/_/  //*//__*E*D*C*B*A
/ E//__*E*D*C*B*A
/ D//__*E*D*C*B*A
/ C//__*E*D*C*B*A
/ B//__*E*D*C*B*A
/ A

Avviso: ho dovuto usare \*per la sostituzione. Poiché *fa anche parte della sostituzione, genererebbe un ciclo infinito se lo sostituissi *.

Quindi il comando /_/ /sostituisce _con spazi ed /*//elimina tutto *:

EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/ A

Il comando successivo non /#//sostituisce #nulla. Dal momento che non è presente #nel codice, non fa nulla. Questo è qui solo per rimuovere le due derivazioni //dall'inizio del codice. Questo lascia

EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/

Quindi il comando / E//rimuove <space>E, quindi questo lascerà il codice

    EDCBA
   DCBA
/ D//   DCBA
/ C//   DCBA
/ B//   DCBA
/

Simile / D//rimuove <space>D:

    EDCBA
   DCBA
  CBA
/ C//  CBA
/ B//  CBA
/

/ C//:

    EDCBA
   DCBA
  CBA
 BA
/ B// BA
/

/ B//:

    EDCBA
   DCBA
  CBA
 BA
A
/

E l'ultimo comando è incompleto, quindi non fa nulla:

    EDCBA
   DCBA
  CBA
 BA
A
— Jakube
fonte
Stesse lunghezze di C # e risposte di brainfuck: D
— Conor O'Brien,
9

Haskell, 53 52 byte

f(a:b)=(b>>" ")++a:b++'\n':f b
f x=x
f['Z','Y'..'A']

Provalo online!

Come funziona

f['Z','Y'..'A']        -- call f with the full backwards alphabet

f(a:b)=                -- let `a` be the first char and `b` the rest. Return
   (b>>" ") ++         -- replace each char in b with a space, followed by
   a:b ++              -- the input string, followed by
   '\n' :              -- a newline, followed by
   f b                 -- a recursive call of `f` with `b`
f x=x                  -- stop on an empty input string
— Nome del modello
fonte
Perché non f['Z'..'A']funziona?
— Conor O'Brien,
1
@ ConorO'Brien: [a..b]inizia con ae raccoglie tutti i successori ( +1per i numeri interi, il successivo carattere ASCII per i caratteri, ecc.) Fino a b. Se a > bquesta è una lista vuota. Tuttavia, è possibile specificare anche il secondo valore (che può essere inferiore) da cui viene calcolato un incremento / decremento. [1,3..8]-> [1,3,5,7], [15,10..0]-> [15,10,5,0]o ['Z','Y'..'A']che è l'alfabeto maiuscolo all'indietro.
— nimi,
Ah, vedo adesso. Grazie!
— Conor O'Brien,
7

JavaScript (ES6), 83 77 76 byte

f=(n=0,p='')=>n<26?f(++n,p+' ')+p+`ZYXWVUTSRQPONMLKJIHGFEDCBA
`.slice(~n):''

o.innerText = f()
<pre id=o>
Espandi frammento

— Arnauld
fonte
Volevo suggerirti un miglioramento, ma poi ho capito che i nostri approcci sono molto diversi. Spero non ti dispiaccia.
@ThePirateBay Nessun problema!
— Arnauld,
7

Gelatina , 12 byte

ØAµ⁶ṁḊ;ṚµƤṚY

Provalo online!

ØAµ⁶ṁḊ;ṚµƤṚY  Main Link
ØA            "ABC...XYZ"
         Ƥ    For each prefix,
  µ⁶ṁḊ;Ṛµ     Monadic Link
   ⁶          ' '
    ṁ         (with automatic repetition) molded to the shape of
     Ḋ        All but the first letter of the input (repeat - 1)
      ;       With the input          appended to it
       Ṛ                     reversed
           Y  Join on newlines

-3 byte grazie alle miglia

— HyperNeutrino
fonte
— Leaky Nun,
@LeakyNun Oh bene grazie!
— HyperNeutrino,
Sì, un altro uso per il prefisso veloce. 12 byte poiché lo stampo rimodellerà qui usando implicitamente la lunghezza.
— miglia,
@LeakyNun In realtà, sfortunatamente ciò lo renderebbe non valido perché non ci possono essere spazi extra (ci vorranno 2 byte per risolvere)
— HyperNeutrino,
7

Brainfuck , 105 byte

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

Provalo online!

Minificato e formattato:

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

Versione leggibile:

[
  pre-initialize the tape with the values 10 90 32 >26<
  C_NEWLINE: 10
  V_ALPHA: 90
  C_SPACE: 32
  V_COUNTER: 26

AS:

  10 = 8 *  1 + 2
  90 = 8 * 11 + 2
  32 = 8 *  4 + 0
  26 = 8 *  3 + 2
]

8 ++++++++ [
  *  1 >+
  * 11 >+++++++++++
  *  4 >++++
  *  3 >+++
<<<<-]
PLUS 2 >++
PLUS 2 >++
PLUS 0 >
PLUS 2 >++

UNTIL V_COUNTER == 0 [
  COPY V_COUNTER to RIGHT and RIGHT_RIGHT
  [->+>+<<]
  TAPE: 10 V_ALPHA 32 >0< V_COUNTER_R V_COUNTER_RR
  V_COUNTER_R SUB 1 TIMES: >-[-
     PRINT C_SPACE <<.
  >>]
  TAPE: 10 V_ALPHA 32 0 >0< V_COUNTER_RR
  V_COUNTER_RR TIMES: >[-
    PRINT V_ALPHA <<<<.
    DECREMENT V_ALPHA -
    INCREMENT V_COUNTER_R >>>+
  >]
  TAPE: 10 V_ALPHA 32 0 V_COUNTER_R(26) >0<
  V_COUNTER_R SUB 1 TIMES: <-[-
    INCREMENT V_COUNTER <+
    INCREMENT V_ALPHA <<+
  >>>]
  PRINT C_NEWLINE <<<<.
>>>]
— Conor O'Brien
fonte
6

Poetico , 601 byte

one night i camped a bit
throughout all the forest now
the sweet sights
i saw giant things
i saw little small things
here i am
seated around all my trees i saw
i sleep
i sle-e-p
sleep in a cabin
i am sleep-y
i sleep a bit
i awaken in bed
i stand
i walk
i am ready
i saw a vision of a dragon
i am fooled
i know i am
should i f-ight
i f-light
i did f-light
i did a flight
go away,i do imply
i*m afraid
i run
i leave
i flee
i am timid
i*m just a person,not toughie-tough-guy
no,never
i*m waste
i am stupid
a quitter i was
i am stupid
i*m turning around
i do not appreciate camping
i cry
i am crying
no
no

Poetic è un esolang che ho creato nel 2018 per un progetto di classe ed è un derivato brainfuck in cui le lunghezze delle parole corrispondono ai comandi brainfuck (e i comandi +, -,> e <hanno ciascuno argomenti a 1 cifra).

Il fatto che solo la lunghezza delle parole imponga i comandi significa che tecnicamente avrei potuto creare un programma interamente composto da non parole (cioè la lettera X tutte le volte necessarie, con spazi tra le parole), ma volevo creare un interessante ne esce poesia in versi liberi senza aggiungere byte non necessari.

Se vuoi provarlo online (che è la metà del progetto di classe in primo luogo), dai un'occhiata al mio interprete online !

— JosiahRyanW
fonte
Perché questo non è in competizione?
— pppery
La lingua è stata creata dopo la sfida.
— JosiahRyanW,
1
— pppery
Hm, allora credo che ciò mi dia più motivazione per usare Poetic come linguaggio di programmazione! Eh.
— JosiahRyanW,
5

05AB1E , 10 byte

žpDvÐg<ú,¦

Provalo online!

spiegazioni:

žpDvÐg<ú,¦
žp           Push the uppercased alphabet, reversed
  D          Duplicate
   v         For each letter (we just want to loop 26 times, so we use the 
                already pushed alphabet for that purpose)
    Ð        Triplicate
     g<      Length of the string - 1
       ú     Add that number of spaces at the beginning of the string
        ,    Print with newline
         ¦   Remove the 1st element of the remaining copy of the string
— scottinet
fonte
5

Perl 6 , 37 byte

Salvataggio di 9 byte grazie a @Massa.

say " "x$_,chrs $_+65...65 for 25...0

Provalo online!

Spiegazione: 25...0 è un intervallo da 25 a 0 (come previsto). Esaminiamo quell'intervallo, dicendo (= stampa con newline) che molti spazi e la stringa di caratteri che hanno codici ASCII ( chrs) da 65 + quel numero ( $_+65...65).

— Ramillies
fonte
1
25...0 è il modo più breve :-)
— Massa,
prova say " "x$_,chrs $_+65...65 for 25...0:-)
— Massa,
Grazie molto! Non l'ho mai saputo! E anche il sottomodulo è migliore (peccato che l'ho realizzato dalla cima della mia testa). (Ecco perché mi piace usare Perl 6 per codegolf, scopro sempre qualcosa di nuovo.)
— Ramillies
4

Carbone , 19 11 byte

-8 byte grazie solo a ASCII.

Ｆ²⁶«Ｐ⮌…α⊕ι↗

Provalo online! Il collegamento è alla versione dettagliata.

— totallyhuman
fonte
— ASCII il
Aspetta noooooo c'è spazio in testa
— solo ASCII il
Figlio di un ... Devo controllare ogni singolo comando e operatore che ha Charcoal. > _> Grazie!
— totalmente umano il
Risolto tio.run/…
— ASCII il
1
@ Solo ASCII CycleChop... ma hai dimenticato Increment(o come si chiama)
— Erik the Outgolfer
4

Perl 5 , 36 byte

35 byte codice + 1 per -p.

$\=$"x$-++.($a=$_.$a).$/.$\for A..Z

Nota : TIO non supporta input vuoti , quindi viene fornita una nuova riga, ciò si traduce in una nuova riga estranea, ma quando si esegue alla riga di comando con input vuoto, questo non viene visualizzato.

Provalo online!

— Dom Hastings
fonte
4

Cubix , 43 46 byte

$/\;u:\s/':(!$u;:'@^!@Wu;oSU;o+<u(;;oN;(!|

Provalo online!

Cubified

      $ / \
      ; u :
      \ s /
'  : ( ! $ u ; : ' @ ^
! @ W u ; o S U ; o + <
u ( ; ; o N ; ( ! | . .
      . . .
      . . .
      . . .

Guarda correre

Sono riuscito a radere un po 'di più, ma è stato un po' più difficile di quanto pensassi. C'è un personaggio sostitutivo dopo la prima citazione per darmi 26.

  • '<sub> spingere 26 nello stack come numero di base
  • :(! base duplicata come contatore, decremento, test di verità
  • usu true salta il $comando e gira a destra
    • So;u premere 32, emettere come carattere, far apparire 32 e u-girare a destra sul decremento
  • $su false salta il ucomando successivo
  • ;:'@^ pop, duplicare il numero di base, spingere 64 in pila e reindirizzare in un percorso tortuoso
  • $\s/:\/u;$questo è l'ordine dei passaggi sulla faccia superiore. Si riduce a scambiare il contatore con il 64. Termina con un salto sul reindirizzamento che lo ha messo qui.
  • <+o;U reindirizzare per aggiungere, carattere di output, pop, u-turn a sinistra
  • (!decremento, test per verità. Se true inizia su un percorso che colpisce l'inversione di marcia e torna al reindirizzamento.
  • |(;No su falso, riflesso, test ridondante, decremento ridondante, pop, push 10 e carattere di output
  • ;;(u!@Wpassa al numero base, decrementa, u-gira a destra sul test di verità, fermati se falso altrimenti cambia corsia sul duplicato all'inizio. Risciacqua e ripeti.
— MickyT
fonte
4

Python, 83 byte

[print(' '*i+''.join([chr(64+i)for i in range(i+1,0,-1)]))for i in range(25,-1,-1)]

La mia prima risposta su codegolf :)

— Jacob Garby
fonte
1
Un benvenuto in ritardo a PPCG! bella risposta!
— Conor O'Brien,
3

JavaScript, 75 74 byte

1 byte salvato grazie a Rick Hitchcock

f=(a=65,b='',c)=>a>90?'':f(a+1,b+' ',c=String.fromCharCode(a)+[c])+`
`+b+c

Provalo online!

Salvare un byte inizializzando b( b=''), quindi estraendo ble parentesi quadre.
— Rick Hitchcock,
@RickHitchcock. Grazie.
3

Perl 5 , 49 byte

$_=$"x26 .join'',reverse A..Z,Z;say while s/ \S//

Provalo online!

— Xcali
fonte
Sembra che ti manchi il primo A, ma sembra che possa essere risolto cambiando $"x25in $"x26!
— Dom Hastings,
Quando ho aggiunto un extra Z, mi sono dimenticato di renderlo conto.
— Xcali,
3

Pyke , 8 byte

G_.<XFo}h-

Provalo qui!

           -  o = 0
G_         -    reversed(alphabet)
  .<       -   suffixes(^)
    XF     -  for i in ^:
      o    -      o++
       }   -     ^ * 2
        h  -    ^ + 1
         - -   i.lpad(" ", ^)
           - for i in reversed(^):
           -  print i

Riesco a vedere la lingua giusta farlo in 6 byte se avevano un built- prepend n spaces to stringin oltre a quello che fa Pyke

— Blu
fonte
3

PHP ( 63 58 55 byte)

Questo è forse il mio strano angolo preferito di PHP, un angolo che eredita da Perl:

for($c=A;$c!=AA;$q="$s$z 
$q",$s.=" ")$z=$c++.$z;echo$q;

Ciò genera la nuova riga finale, come esplicitamente consentito. Questo può essere eseguito php -rper salvare l'apertura <?phpnecessaria per inserirlo in un file.

Spiegazione: quando una variabile contenente la stringa 'A'viene incrementata in PHP, diventa 'B'e quindi 'C'e così via fino a 'Z'diventare 'AA'. Non c'è una cifra prima 'A'di iniziare con questa algebra pazza, e l'operatore di decremento non lo annulla, quindi salviamo l'alfabeto invertito in modo incrementale $z(che per impostazione predefinita NULLquando viene concatenato con una stringa si comporta come la stringa vuota - il lo stesso succede con $se $q). Lo spazio bianco viene accumulato in $se l'intera stringa viene accumulata all'indietro in variabile, il $qche significa che dobbiamo riecheggiarlo alla fine.

Grazie a Titus per il golf delle mie parentesi graffe e per avermi detto che non ho bisogno di pagare una penalità per bandiere di valutazione in linea come -r.

— CR Drost
fonte
1
Sono 57 byte, se usi un'interruzione di linea di Linux. -rè libero. Due byte più brevi:for($c=A;$c!=AA;$q="$s$z\n$q",$s.=" ")$z=$c++.$z;echo$q;
— Tito
@Titus grazie, ti ho dato un complimento nella risposta.
— CR Drost,
nm. Basta notare che -Re -Fsono non liberi. Vedi codegolf.meta.stackexchange.com/questions/2424/…
— Titus
Credo che puoi salvare un byte se lo usi $c<AA.
— Ismael Miguel,
1
@IsmaelMiguel scusa, ero troppo conciso. Stavo pensando quando ho scritto che "forse c'è un modo per mescolare le cose senza guadagnare byte in modo che il caso A si verifichi per primo e quindi possiamo rilevare AA vs. B ma non penso di essere abbastanza intelligente da vederlo ". Non intendevo essere irriverente e cercherò di fare attenzione in futuro.
— CR Drost,
3

SOGL V0.12 , 10 8 byte

Z±{Xf}⁰¼

Provalo qui!

— dzaima
fonte
Solo curioso, quanto dura la versione compressa?
— caird coinheringaahing
@cairdcoinheringaahing TL; DR troppo a lungo. La compressione SOGL fa schifo a (e non è specificamente fatta per) cose ripetitive. Sarebbe molto difficile dirlo poiché la compressione non è automatizzata (l'automazione richiederebbe 701 choose xtentativi per qualsiasi numero intero x) ma un tentativo approssimativo era di 450 byte: P
— dzaima,
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.