¡Haz un reflector alfabético!

66

Inspirado por un error en una solución a este desafío , su desafío es producir este texto exacto:

                         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 primera línea tendrá 25 espacios, luego el alfabeto hacia atrás a partir de la letra 26 ( ZYXWVUTSRQPONMLKJIHGFEDCBA), luego una nueva línea.
  • La segunda línea tendrá 24 espacios, luego el alfabeto hacia atrás a partir de la letra 25 ( YXWVUTSRQPONMLKJIHGFEDCBA), luego una nueva línea.
  • ...
  • La última línea (26) no tendrá espacios, luego el alfabeto hacia atrás a partir de la primera letra ( A), luego una nueva línea.

Reglas adicionales:

  • Su programa puede usar cualquier método de salida permitido.
  • Se permite una nueva línea y / o una nueva línea inicial.
  • Debe haber una nueva línea entre las líneas que contienen las letras, no más.
  • Las letras deben ser todas mayúsculas.

Al igual que con code-golf , gana la presentación más corta. ¡Buena suerte!

Tabla de clasificación:

Mostrar fragmento de código

code-golf  ascii-art  kolmogorov-complexity  alphabet 
— MD XF
fuente
3
Para mí, parece la luz emitida por la señal del murciélago
— scottinet
44
— Sr. Xcoder
¿Puede cada línea tener un espacio adicional delante?
— HyperNeutrino
3
¿Podría cada línea tener espacios finales después de la última letra?
— millas
1
@ millas sí, está bien.
— MD XF

Respuestas:

19

05AB1E , 7 bytes

Código:

₂žp.s1Λ

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación

 ž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
fuente
2
@MDXF IMO, esa es una regla realmente tonta
— DJMcMayhem
3
Hmm ... supongo que eliminaré la regla, entonces. estado completado
— MD XF
2
Podría proponer un RP que documente esa función cuando encuentre el momento. Parece ser una buena manera de aprender un poco de pitón de un bien escrito, fácil de leer el código
— scottinet
66
¿Por qué žpexiste cuando Aues dorado? BADUM tissss
— Magic Octopus Urn
55
Usando 05AB1E, cree un archivo que documente todas sus características, abreviaciones de código: P
— Christian
22

R , 67 55 bytes

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

Pruébalo en línea!

— Giuseppe
fuente
44
¿R está venciendo a Python en un desafío de cuerdas? Agradable. +1 para CARTAS
— CriminallyVulgar
1
@CriminallyVulgar es un desafío muy extraño; Haskell está superando el vínculo de PHP y R, que están superando a Python ... al menos Perl está por delante de todos ellos, como es de esperar.
— CR Drost
-2 bytes si cambias sepa s. Las funciones autocompletarán argumentos con nombre si no hay colisiones
— Punintended
1
@Punintended que no funcionará debido al ...argumento; Los argumentos que vienen antes ...(típicamente) se hacen coincidir parcialmente, y los que siguen no. Creo que hay algunas excepciones, pero catno es una de ellas
— Giuseppe
@Giuseppe No veo un...
— MilkyWay90
15

V , 13 , 11 bytes

¬ZAòY>HGpxl

Pruébalo en línea!

Hexdump:

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

Escrito desde mi teléfono: 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
fuente
1
También hago esto en mi teléfono, +1
— Stan Strum
12

PowerShell , 42 bytes

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

Pruébalo en línea!

Explicación:

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
fuente
10

/// , 105 97 bytes

/:/\\\\*//#/: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//\\*/\/\/_____#
\/ //_/     //*#

Pruébalo en línea!

Explicación

/// solo conoce un comando, /<pattern>/<substitution>/<text>reemplaza todas las apariciones de <pattern>in <text>con <substitution>. Además \se puede usar para escapar de los personajes.

Código acortado por simplicidad: 

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

El primer comando /:/\\\\*/reemplaza :con \\*en el código posterior. Esto da:

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

Luego /#/\\*E\\*D\\*C\\*B\\*A/reemplaza #con \*E\*D\*C\*B\*A:

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

Luego /\\*/\/\/__\*E\*D\*C\*B\*A<newline>\/ /reemplaza \*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

Aviso: tuve que usar \*para el reemplazo. Como *también es parte de la sustitución, generaría un bucle infinito si solo reemplazara *.

Luego, el comando /_/ /reemplaza _con espacios y /*//elimina todo *:

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

El siguiente comando /#//reemplaza #por nada. Como no hay #un código, no hace nada. Esto es solo para eliminar los dos encabezados //desde el comienzo del código. Esto deja

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

Luego, el comando se / E//elimina <space>E, por lo que esto dejará el código

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

/ D//Elimina similares <space>D:

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

/ C//:

    EDCBA
   DCBA
  CBA
 BA
/ B// BA
/

/ B//:

    EDCBA
   DCBA
  CBA
 BA
A
/

Y el último comando está incompleto, por lo que no hace nada:

    EDCBA
   DCBA
  CBA
 BA
A
— Jakube
fuente
Misma duración que las respuestas de C # y brainfuck: D
— Conor O'Brien
9

Haskell, 53 52 bytes

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

Pruébalo en línea!

Cómo funciona

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
— nimi
fuente
¿Por qué no f['Z'..'A']funciona?
— Conor O'Brien
1
@ ConorO'Brien: [a..b]comienza con ay recopila todos los sucesores ( +1para enteros, el siguiente ascii-char para personajes, etc.) hasta b. Si a > besta es una lista vacía. Sin embargo, también puede especificar el segundo valor (que puede ser más pequeño) a partir del cual se calcula un incremento / decremento. [1,3..8]-> [1,3,5,7], [15,10..0]-> [15,10,5,0], o ['Z','Y'..'A']que es el alfabeto en mayúsculas hacia atrás.
— nimi
Ah, ya veo ahora. ¡Gracias!
— Conor O'Brien
7

JavaScript (ES6), 83 77 76 bytes

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

o.innerText = f()
<pre id=o>
Expandir fragmento

— Arnauld
fuente
Quería sugerirle una mejora, pero luego me di cuenta de que nuestros enfoques son muy diferentes. Espero que no te importe.
@ThePirateBay ¡No hay problema!
— Arnauld
7

Jalea , 12 bytes

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

Pruébalo en línea!

Ø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 bytes gracias a millas

— Hiperneutrino
fuente
— Leaky Nun
@LeakyNun Oh, claro, gracias.
— HyperNeutrino
Yay, otro uso para el prefijo rápido. 12 bytes ya que el molde se reformará aquí usando la longitud implícitamente.
— millas
@LeakyNun En realidad, desafortunadamente eso lo haría inválido porque no puede haber espacios adicionales (tomaría 2 bytes para solucionarlo)
— HyperNeutrino
7

brainfuck , 105 bytes

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

Pruébalo en línea!

Minificado y formateado:

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

Versión legible:

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

Poético , 601 bytes

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 es un esolang que creé en 2018 para un proyecto de clase, y es un derivado de brainfuck en el que las longitudes de las palabras corresponden a comandos de brainfuck (y los comandos +, -,> y <tienen argumentos de 1 dígito).

El hecho de que solo la longitud de la palabra dicta los comandos significa que técnicamente podría haber creado un programa completamente compuesto de no palabras (es decir, la letra X tantas veces como sea necesario, con espacios entre las palabras), pero quería hacer un interesante poema de verso libre sin agregar bytes innecesarios.

Si quieres probarlo en línea (que es la mitad del proyecto de clase en primer lugar), ¡mira mi intérprete en línea !

— JosiahRyanW
fuente
¿Por qué esto no es competitivo?
— pppery
El lenguaje fue creado después del desafío.
— JosiahRyanW
1
— pppery
¡Hm, entonces supongo que eso me da más motivación para usar Poetic como lenguaje de programación! Je
— JosiahRyanW
5

05AB1E , 10 bytes

žpDvÐg<ú,¦

Pruébalo en línea!

Explicaciones:

ž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
fuente
5

Perl 6 , 37 bytes

Guardado 9 bytes gracias a @Massa.

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

Pruébalo en línea!

Explicación: 25...0 es un rango de 25 a 0 (como se esperaba). Repetimos en ese rango, diciendo (= imprimiendo con nueva línea) que muchos espacios y la cadena de caracteres que tienen códigos ASCII ( chrs) de 65 + ese número ( $_+65...65).

— Ramillies
fuente
1
25...0 es el camino más corto :-)
— Massa
intente say " "x$_,chrs $_+65...65 for 25...0:-)
— Massa
¡Muchas gracias! ¡Nunca supe de eso! Y la subforma también es mejor (lástima que hice esta desde la parte superior de mi cabeza). (Es por eso que me gusta usar Perl 6 para codegolf, siempre descubro algo nuevo.)
— Ramillies
4

Carbón , 19 11 bytes

-8 bytes gracias a ASCII-only.

Ｆ²⁶«Ｐ⮌…α⊕ι↗

Pruébalo en línea! El enlace es a la versión detallada.

— totalmente humano
fuente
¿Esto podría ser? tio.run/##S85ILErOT8z5/…
— ASCII
Espera, noooooo, hay un espacio líder
— solo ASCII el
Hijo de ... Necesito revisar cada comando y operador que tiene Charcoal. > _> Gracias!
— totalmente humano
Corregido tio.run/…
— ASCII
1
@ Solo ASCII CycleChop... pero olvidaste Increment(o como se llame)
— Erik the Outgolfer
4

Perl 5 , 36 bytes

Código de 35 bytes + 1 para -p.

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

Nota : TIO no admite entradas vacías , por lo que se proporciona una nueva línea, esto da como resultado una nueva línea extraña, pero cuando se ejecuta en la línea de comandos con una entrada vacía, no se muestra.

Pruébalo en línea!

— Dom Hastings
fuente
4

Cubix , 43 46 bytes

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

Pruébalo en línea!

Cubified

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

Míralo correr

Me las arreglé para afeitarme un poco más de esto, pero fue un poco más difícil de lo que pensaba. Hay un personaje sustituto después de la primera cita que me da 26.

  • '<sub> empuje 26 en la pila como el número base
  • :(! base duplicada como contador, decremento, prueba de verdad
  • uen verdadero omita el $comando y gire hacia la derecha
    • So;u empuje 32, salida como carácter, pop 32 y gire a la derecha en la disminución
  • $en falso salto el siguiente ucomando
  • ;:'@^ pop, duplicar el número base, empujar 64 en la pila y redirigir a una ruta tortuosa
  • $\s/:\/u;$Este es el orden de los pasos en la cara superior. Se reduce para intercambiar el contador con el 64. Termina con un salto sobre la redirección que lo puso aquí.
  • <+o;U redirigir para agregar, salida de caracteres, pop, giro en U a la izquierda
  • (!decremento, prueba de verdad. Si verdadero comienza en un camino que golpea el giro en U y vuelve a la redirección.
  • |(;No en falso, reflejo, prueba redundante, decremento redundante, pop, push 10 y carácter de salida
  • ;;(u!@Wdesplácese hacia abajo hasta el número base, disminuya, gire en U hacia la derecha en la prueba de verdad, pare si es falso, de lo contrario cambie de carril al duplicado al principio. Enjuague y repita.
— MickyT
fuente
4

Python, 83 bytes

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

Mi primera respuesta en codegolf :)

— Jacob Garby
fuente
1
¡Una bienvenida tardía a PPCG! ¡buena respuesta!
— Conor O'Brien
3

JavaScript, 75 74 bytes

1 byte guardado gracias a Rick Hitchcock

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

Pruébalo en línea!

Guarde un byte inicializando b( b=''), luego quitando blos corchetes.
— Rick Hitchcock
@RickHitchcock. Gracias.
3

Perl 5 , 49 bytes

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

Pruébalo en línea!

— Xcali
fuente
Parece que te estás perdiendo el primero A, ¡pero parece que eso se puede solucionar cambiando $"x25a $"x26!
— Dom Hastings
Cuando agregué el extra Z, olvidé dar cuenta de eso.
— Xcali
3

Pyke , 8 bytes

G_.<XFo}h-

Pruébalo aquí!

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

Puedo ver el idioma correcto haciendo esto en 6 bytes si tuvieran un incorporado prepend n spaces to stringasí como lo que hace Pyke

— Azul
fuente
3

PHP ( 63 58 55 bytes)

Este es posiblemente mi extraño rincón favorito de PHP, un rincón que hereda de Perl:

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

Esto genera la nueva línea final, como se permite explícitamente. Esto se puede ejecutar php -rpara guardar la apertura <?phpnecesaria para poner esto en un archivo.

Explicación: cuando una variable que contiene la cadena 'A'se incrementa en PHP, se convierte en 'B'y luego 'C'y así sucesivamente hasta que se 'Z'convierte 'AA'. No hay ningún dígito antes 'A'para comenzar en este álgebra descabellada, y el operador de decremento no lo deshace, por lo que guardamos el alfabeto incrementalmente invertido en $z(que por defecto NULLcuando se concatena con una cadena se comporta como la cadena vacía - el Lo mismo sucede con $sy $q). El espacio en blanco se acumula $sy toda la cadena se acumula hacia atrás en variable, lo $qque significa que tenemos que repetirlo al final.

Gracias a Titus por jugar golf con mis llaves y decirme que no necesito penalizarme por las banderas de evaluación en línea como -r.

— CR Drost
fuente
1
Eso es 57 bytes, si usa un salto de línea de Linux. -res gratis. Dos bytes más cortos:for($c=A;$c!=AA;$q="$s$z\n$q",$s.=" ")$z=$c++.$z;echo$q;
— Titus
@Titus gracias, te felicité por la respuesta.
— CR Drost
Nuevo Méjico. Solo ten en cuenta que -Ry no-F son gratis. Ver codegolf.meta.stackexchange.com/questions/2424/…
— Titus
Creo que puede guardar un byte si lo usa $c<AA.
— Ismael Miguel
1
@IsmaelMiguel lo siento, fui demasiado tierno. Estaba pensando cuando escribí eso, "tal vez hay una manera de barajar las cosas sin ganar bytes para que el caso A ocurra primero y luego podamos detectar AA vs. B, pero no creo que sea lo suficientemente inteligente como para verlo ". No quise ser impertinente e intentaré tener cuidado con eso en el futuro.
— CR Drost
3

SOGL V0.12 , 10 8 bytes

Z±{Xf}⁰¼

Pruébalo aquí!

— dzaima
fuente
Por curiosidad, ¿cuánto dura la versión comprimida?
— caird coinheringaahing
@cairdcoinheringaahing TL; DR demasiado tiempo. La compresión de SOGLs es una mierda (y está hecha específicamente para no) cosas repetitivas. Sería muy difícil saberlo ya que la compresión no está automatizada (la automatización haría que tomara 701 choose xintentos para cualquier número entero x) pero un intento aproximado fue de 450 bytes: P
— dzaima
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.