Descripción

Salida del esquema de rima para un Terza Rima muy largo

Entrada

Ninguna.

Salida

ABA
BCB
CDC
DED
EFE
FGF
GHG
HIH
IJI
JKJ
KLK
LML
MNM
NON
OPO
PQP
QRQ
RSR
STS
TUT
UVU
VWV
WXW
XYX
YZY

Reglas

Puede elegir entre separar las estrofas con espacios en blanco o líneas nuevas, así que:

ABA BCB...

O

ABA
BCB
...

Se permite un solo espacio en blanco al final por línea y una nueva línea al final.

La salida puede ser mayúscula o minúscula.

Este es el código de golf , por lo que gana el código más corto en bytes para cada idioma.

JavaScript (ES6), 51 50 49 bytes

Guardado 1 byte gracias a @ l4m2

f=(n=45358)=>n%63?f(n-1333)+n.toString(36)+' ':''

Pruébalo en línea!

¿Cómo?

Comenzamos con n = 45358 ( yzy en base-36). Restamos 1333 de n en cada iteración ( 111 en base-36). Nos detenemos tan pronto como n MOD 63 = 0 , porque 12033 ( 9a9 en base-36) es el primer valor para el que se cumple esta condición, y 63 es el módulo más pequeño con dicha propiedad.

Decimal | Base-36 | MOD 63
--------+---------+-------
  45358 |   yzy   |   61
  44025 |   xyx   |   51
  42692 |   wxw   |   41
  41359 |   vwv   |   31
  40026 |   uvu   |   21
  38693 |   tut   |   11
  37360 |   sts   |    1
  36027 |   rsr   |   54
  34694 |   qrq   |   44
  33361 |   pqp   |   34
  32028 |   opo   |   24
  30695 |   non   |   14
  29362 |   mnm   |    4
  28029 |   lml   |   57
  26696 |   klk   |   47
  25363 |   jkj   |   37
  24030 |   iji   |   27
  22697 |   hih   |   17
  21364 |   ghg   |    7
  20031 |   fgf   |   60
  18698 |   efe   |   50
  17365 |   ded   |   40
  16032 |   cdc   |   30
  14699 |   bcb   |   20
  13366 |   aba   |   10
  12033 |   9a9   |    0

C (gcc) , 41 bytes

f(i){for(i='ABA';i%29;i+=65793)puts(&i);}

Pruébalo en línea!

Corregido y -9 gracias al usuario202729 . -1 gracias a Dennis y -2 gracias a Arnauld también.

Jalea , 7 bytes

ØAṡ2ŒBY

Pruébalo en línea!

-1 byte gracias a Dennis

ØAṡ2ŒBY  Main Link
ØA       Alphabet
  ṡ2     Slice into overlapping slices of length 2
    ŒB   Palindromize (bounce) each
      Y  Join by newlines

brainfuck , 51 48 bytes

Guardado 3 bytes gracias a @ovs.

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

Pruébalo en línea!

Explicación

INITIALIZE TAPE:

0000:           (none)
0001: C_NEWLINE (10)
0002: V_COUNT   (25)
0003: V_ALPHA   (64)
++++++++[>+>+++>++++++++<<<-]>++>+

V_COUNT TIMES:              [-
    INCREMENT V_ALPHA         >+
    PRINT V_ALPHA             .
    PRINT V_ALPHA PLUS ONE    +.
    PRINT V_ALPHA             -.
    PRINT C_NEWLINE           <<.
END LOOP                    >]

05AB1E , 5 bytes

Aü«€û

Pruébalo en línea!

-1 byte gracias a Emigna
-1 byte gracias al cambio de regla; gracias a kalsowerus por señalar eso

^{_{Jeje, actualmente vence a Pyth. \ o /}}

Explicación

Aü«€û»  Full Program
A       Lowercase Alphabet
 ü«     Pairwise with merge-list
   €û   For each, palindromize

brainfuck , 51 49 bytes

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

Pruébalo en línea!

Un intento de explicación ...

+++++                     #Put 5 in cell 0 because that is the highest common denominator of 10, 65 and 25
[                         #Start loop
>+++++                    #Counter in cell 1 is 25 (How many lines we must print)
>+++++++++++++            #Counter in cell 2 is 65 (ASCII A)  
>++                       #Counter in cell 3 is 10 (Newline)
<<<-]                     #Decrement the outer counter until the cells have the right values (muliples of 5).
>                         #Move to the counter that says how many lines we must print.
[>.                       #Print the character in cell 2
+.                        #Add one to the character in cell 2 and print it
-.                        #Subtract one from the character in cell 2 and print it
+                         #Add one to the character in cell 2 for the next loop
>.                        #Print a new line
<<-]                      #Decrement cell 1 and run again until cell 1 is 0

-2 con agradecimiento a @ovs

Mi primer intento de brainfuck por lo que cualquier pista recibió con gratitud. Si tuviera más experiencia con él, entonces estoy seguro de que podría eliminar algunos bytes más, pero solo me metí en eso ayer.

APL (Dyalog) , 14 bytes

25↑0 1 0⊖3/⍪⎕A

Pruébalo en línea!

Tenga en cuenta que lo agregado ⎕←es para que TIO muestre el texto y normalmente no es necesario.

Python 2 , 42 41 bytes

^{-1 byte gracias a Halvard Hummel}

i=65;exec"print'%c'*3%(i,i+1,i);i+=1;"*25

Pruébalo en línea!

Carbón , 11 bytes

Ｅ²⁵✂αι⁺²ι‖Ｏ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 ²⁵         Literal 25
Ｅ           Map over implicit range
    α       Predefined uppercase letters
   ✂ ι⁺²ι   Slice 2 characters
            Implicitly print result on separate lines
         ‖Ｏ Reflect with overlap

Brain-Flak , 90 bytes

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

Pruébalo en línea!

Una razón por la que esto es más corto que la otra respuesta de cerebro-flak es porque usa caracteres en mayúsculas en lugar de minúsculas, que tienen valores ASCII más pequeños y, por lo tanto, son más fáciles de presionar.

Explicación:

#Push 25
((((()()()){}){}){}())

#While true
{

    #Keep track of the number on top of the stack...
    # We'll call it 'a'
    (({})

        #Push A +...
        <((({}

        # 64 (push)
        ((((()()()()){}){}){}){})
        # + 1 (push)
        ())
        # - 1 (push)
        [()])

        # Push 10
        ((()()()()()){})>

    # Now that's all pushed, we push a - 1 to decrement the loop counter
    [()])

# Endwhile
}

R, 51 47 bytes

L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))

Salida:

> L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))
ABA BCB CDC DED EFE FGF GHG HIH IJI JKJ KLK LML MNM NON OPO PQP QRQ RSR STS TUT UVU VWV WXW XYX YZY

Java 8 , 132 85 62 60 Bytes

• 47 bytes gracias a Neil
• 26 bytes gracias a Oliver
• 3 bytes y mucho mejor formato gracias a Kevin
• Error arreglado por Oliver

Golfed

a->{for(char i=64;++i<90;)System.out.println(""+i+++i--+i);}

Sin golf

public class TerzaRima {
    interface A{
        void a(String a);
    }
    static A a = a -> {
        for (char i = 64; ++i < 90; ) System.out.println("" + i++ + i-- + i);
    };
    public static void main(String[] args){
        a.a(null);
    }
}

> <> , 25 24 23 22 bytes

Guardado 2 bytes gracias a Jo King

"!;::o1+:o$oao:'Y')0.A

Pruébalo en línea!

Befunge-98 (FBBI) , 27 23 21 bytes

-4 bytes gracias a James Holderness

j'@1+3k:,1+,,a,'Y/!1+

Pruébalo en línea!

Casco , 9 bytes

ẊS:`e…"AZ

Pruébalo en línea!

brainfuck , 41 bytes

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

Pruébalo en línea!

brainfuck , 45 37 bytes

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

Pruébalo en línea!

Imprime en mayúsculas, separadas por espacios con un espacio final.

Cómo funciona:

+[[<+>>++<-]>] Intialises the tape with the format n^2
               1 2 4 8 16 32 64 128 0 0'
<<---          Navigates to the desired section and tweaks the counter
               1 2 4 8 16 32 64 125<
[-----<+.+.-.<.>>] Prints the Terza Rima, using:
                 125 as the loop counter (decremented by 5 each loop)
                 64 as the current alphabetic character (incremented and printed each loop)
                 32 as the space character

Pyth , 7 bytes

jC[GtGG

Pruébalo aquí!

_{Jeje, actualmente supera a Jelly. \ o /}

Se traduce fácilmente al siguiente programa 05ab1e:

05AB1E , 7 bytes

AA¦A)ø»

Pruébalo en línea!

J , 15 bytes

u:2$~&3\65+i.26

Pruébalo en línea!

Haskell , 34 32 31 bytes

Basado en la respuesta totalmente humana . -1 byte gracias a H.PWiz

do x<-['A'..'Y'];x:succ x:x:" "

Pruébalo en línea!

Brain-Flak , 180 bytes

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

Pruébalo en línea!

Gracias a DJ por hacer que esto funcione

Haskell , 28 bytes

[[x,succ x,x]|x<-['A'..'Y']]

Pruébalo en línea!

succ es una elección de nombre tan desafortunada ...

Explicación

[[x,succ x,x]|x<-['A'..'Y']]

[            |x<-          ]  -- for x in...
                 ['A'..'Y']   -- the alphabet sans Z
 [x,succ x,x]                 -- construct a string of x, the successor of x and x

R , 40 bytes

cat(intToUtf8(rbind(x<-65:89,x+1,x,10)))

Pruébalo en línea!

Una alternativa más en R a las respuestas de Plannapus y Giuseppe . Publicado siguiendo su solicitud. Esta solución utiliza código ASCII para la codificación UTF8.

PD: si se permitieran TAB, se podría reemplazar la nueva línea (código ASCII 10) con una tabulación (código ASCII 9), y la solución podría reducirse a 39 bytes:

cat(intToUtf8(rbind(x<-65:89,x+1,x,9)))

R , 40 36 bytes

cat(paste0(L<-LETTERS,L[-1],L)[-26])

Pruébalo en línea!

Una alternativa a la respuesta de plannapus ; esto resulta ser un poco más golfista; Lo publiqué por su pedido.

Vea también esta respuesta de 40 bytes de NofP, que es bastante agradable.

PowerShell , 39 37 bytes

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

Pruébalo en línea!

Bucles de 65a 89. En cada iteración, estamos construyendo una matriz entera de (el actual, uno más y el actual) del dígito actual, usando pre-incremento y pre-decremento. Luego se vuelve a emitir como una charmatriz y se editan -joinen una sola cadena. Cada cadena se deja en la tubería y un implícito Write-Outputen la finalización del programa nos da una nueva línea entre cada elemento de forma gratuita.

Alternativamente, el mismo conteo de bytes

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

Pruébalo en línea!

J , 18 16 bytes

2(,{.)\u:65+i.26

Cambiado a.{~a u:las soluciones de Conor O'Brien y FrownyFrog

Pruébalo en línea!

Befunge, 26 bytes

:"A"+:,:1+,,1+:64*`#@_55+,

Pruébalo en línea!

Pepe, 59 56 bytes

^{-3 bytes gracias a u_ndefined}

REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee

Pruébalo en línea!

Explicación:

# Prepare stacks

  # prepare stack R [Z]
  REeEeEEeEe  # push Z

  # prepare stack r [A,B,A]
  rEeEeeeeeE  # push A
  RrEEEEE     # copy and increment A (getting B)
  rEEEee      # duplicate A to end

# Start loop
REE           # create label Z

  reee        # output stack r contents
  rEEEEEeeE   # increment all

  reeE        # end line

Ree           # loop while r[p] != Z

Retina , 24 bytes

ABA
;{:G`
T`_p`p`[^Y]..

Pruébalo en línea!

brainfuck , 73 bytes

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

Pruébalo en línea!