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.

— LiefdeWen
fuente

44

¿Está bien una lista de líneas?

— totalmente humano

66

Según en.wikipedia.org/wiki/Terza_rima, su final es incorrecto. Debe terminar con Z o ZZ.

— Chris

¿Puede haber salida adicional más allá del esquema de la rima? Esto podría ahorrarme unos pocos bytes.

— NK1406

@ NK1406 No, lo siento.

— LiefdeWen

1

@totallyhuman String array está bien.

— LiefdeWen

24

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

— Arnauld
fuente

¿Cómo decidiste base36? y estás seguro de que es óptimo?

— LiefdeWen

2

@LiefdeWen Es la base más baja para contener todas las letras, por lo que es óptima.

— Erik the Outgolfer

@ user202729 ¿Qué quieres decir? Él no es OP, ¿entonces es una de esas personas a las que te refieres?

— Erik the Outgolfer

17

Como un nodo lateral (no) interesante, 1333 = 666 * 2 + 1 y esta es mi 666a respuesta en PPCG.

— Arnauld

3

@Arnauld, asegúrese de usar el valor 1335 en algún lugar de su próxima respuesta.

— IanF1

15

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.

— Sr. Xcoder
fuente

45 bytes .

— usuario202729

1

(i='ABA';i<'ZZZ';i+=65793)Guarda un byte.

— Dennis

Usar en 59e5lugar de 'ZZZ'guardar otro byte.

— usuario202729

Puede usar i%29para 41 bytes

— Arnauld

10

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

— Hiperneutrino
fuente

9

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

— Conor O'Brien
fuente

@ ConorO'Brien - Acabo de notar que mi respuesta es bastante similar a la tuya. No dude en comentar si cree que está demasiado cerca y lo eliminaré.

— ElPedro

1

@ElPedro No, estás bien, no hay mucho espacio para la innovación en este desafío :)

— Conor O'Brien

9

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

— Hiperneutrino
fuente

Podrías hacerloAü«€û»

— Emigna

@Emigna Oh genial, gracias! : D

— HyperNeutrino

Bien, eso es lo que obtuve sin mirar.

— Urna de pulpo mágico

Según los comentarios, una lista de cadenas está bien como salida, puede eliminar la unión.

— kalsowerus

9

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.

— ElPedro
fuente

-1 byte

— Jo King

7

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.

— Erik el Outgolfer
fuente

7

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!

— Barra
fuente

6

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

— Neil
fuente

6

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
}

— DJMcMayhem
fuente

Escribo la primera versión y no recibo votos positivos, escribes una versión de golf y obtienes +5. ???

— Christopher

5

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

— plannapus
fuente

La manera ingenua sin fantasía sprintfes de 49 bytes

— Giuseppe

@Giuseppe eso sería porque no lo sprintf

— usé

OK, pero encontré un byter 40 :)

— Giuseppe

@Giuseppe ouch :)

— plannapus

1

otro [40 byter] [ tio.run/##K/r/… basado en la conversión de códigos ASCII, en el caso

— NofP

5

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

— Desarrollador en desarrollo
fuente

1

La impresión de una matriz de caracteres probablemente sería mucho más corta.

— Neil

1

¿Puedes hacer iun chartambién?

— Neil

2

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

— Olivier Grégoire

2

Actualmente, este es un fragmento en lugar de una función o programa, por lo que deberá agregar lo v->{...}mencionado anteriormente por @ OlivierGrégoire. ( En caso de que no sepa cómo funcionan las lambdas de Java 8, hice una explicación una vez antes ) . Además, puede quitar los corchetes del bucle como lo hizo Olivier, y como golf adicional puede cambiar la impresión a System.out.print(" "+i+++i--+i);(un espacio en su lugar de una nueva línea, y no necesita el espacio en c+++c--+c). Pruébalo aquí

— Kevin Cruijssen

1

Gracias @KevinCruijssen por los consejos, así como el documento java lambdas. Esa fue una guía muy fácil de seguir para implementar algunas lambdas simples. He actualizado en consecuencia!

— DevelopingDeveloper

5

> <> , 25 24 23 22 bytes

Guardado 2 bytes gracias a Jo King

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

Pruébalo en línea!

— Emigna
fuente

23 bytes eliminando una cita

— Jo King

Otro byte

— Jo King

@JoKing: ¡Gracias de nuevo!

— Emigna

5

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!

— ovs
fuente

4

Casco , 9 bytes

ẊS:`e…"AZ

Pruébalo en línea!

— Erik el Outgolfer
fuente

4

brainfuck , 41 bytes

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

Pruébalo en línea!

— ovs
fuente

+1 Sigo la mayor parte pero comienza con - [¿Eso significa que está configurando la celda 0 a -1 antes de comenzar el ciclo? ¿Alguna posibilidad de una explicación para un novato brainfuck si tienes tiempo? Por cierto, gracias por el -2 en mi esfuerzo.

— ElPedro

@ElPedro, esto depende del intérprete de brainfuck, el intérprete en tio.run almacena números de 8 bits sin signo en cada celda, por lo que la primera celda obtiene 255 antes del bucle.

— ovs

@ElPedro el segmento de inicialización es realmente generado por BF-Crunch .

— ovs

4

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

— Jo King
fuente

1

¡Esto es realmente muy bueno! ¡Buen trabajo!

— Polvo

3

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!

— Sr. Xcoder
fuente

3

J , 15 bytes

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

Pruébalo en línea!

— FrownyFrog
fuente

1

¡Esta es una forma complicada de hacer un palíndromo!

— Galen Ivanov

3

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!

— usuario28667
fuente

2

guardar un byte condo

— H.PWiz

3

Brain-Flak , 180 bytes

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

Pruébalo en línea!

Gracias a DJ por hacer que esto funcione

— Christopher
fuente

3

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

— totalmente humano
fuente

44

No creo que sea completamente justo devolver una lista de cadenas en lugar de separarlas con espacio o nueva línea según sea necesario.

— usuario28667

@ user28667 Por lo general, está permitido en desafíos (probablemente debería estar en la publicación IO predeterminada, si aún no lo está). El OP aún no ha respondido específicamente a este desafío. Sin embargo, esto no es motivo para rechazarlo.

— totalmente humano

@totallyhuman Por el momento, el desafío especifica explícitamente que se deben usar espacios o líneas nuevas para separar la salida, por lo que esta respuesta no es válida actualmente. Por lo tanto, estrictamente de acuerdo con las reglas del sitio, debe eliminarse o simplemente arreglarse anteponiendo a unlineso unwords.

— Laikoni

@Laikoni Parece que te ninja. El desafío no niega explícitamente una lista de líneas como salida. (Además, eso invalidaría una buena cantidad de respuestas). De cualquier manera, la respuesta ahora no es inválida.

— totalmente humano

3

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

— NofP
fuente

Creo que usar 9está perfectamente bien, ya que es un espacio en blanco, que está permitido por el OP.

— Giuseppe

3

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.

— Giuseppe
fuente

3

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!

— AdmBorkBork
fuente

1

($_,($_+1),$_)es una tupla alternativa del mismo largo

— Veskah

2

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!

— Galen Ivanov
fuente

1

Alternativa de 16 bytes:u:(i.25)+/66-#:5

— FrownyFrog

2

Befunge, 26 bytes

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

Pruébalo en línea!

— James Holderness
fuente

2

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

— Trébol rojo
fuente

1

Reemplazar rEeEeeeeEecon RrEEEEEahorra 3 bytes

— u_ndefined

@u_ndefined ¡Gracias! Hice este código antes de que se agregaran banderas a Pepe. Se actualizó la respuesta.

— RedClover

1

Retina , 24 bytes


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

Pruébalo en línea!

— Martin Ender
fuente

21 bytes pero sufre de las nuevas líneas ...

— Neil

@Neil Sí, ni siquiera necesitas el `.... Sin embargo, deshacerse de esas nuevas líneas es realmente molesto. Espero hacer que la impresión en bucles sea un poco más flexible y conveniente en Retina 1.0.

— Martin Ender

1

brainfuck , 73 bytes

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

Pruébalo en línea!

— Hiperneutrino
fuente

Una muy larga Terza Rima

Descripción

Entrada

Salida

Reglas

JavaScript (ES6), 51 50 49 bytes

¿Cómo?

C (gcc) , 41 bytes

Jalea , 7 bytes

brainfuck , 51 48 bytes

Explicación

05AB1E , 5 bytes

Explicación

brainfuck , 51 49 bytes

APL (Dyalog) , 14 bytes

Python 2 , 42 41 bytes

Carbón , 11 bytes

Brain-Flak , 90 bytes

R, 51 47 bytes

Java 8 , 132 85 62 60 Bytes

Golfed

Sin golf

> <> , 25 24 23 22 bytes

Befunge-98 (FBBI) , 27 23 21 bytes

Casco , 9 bytes

brainfuck , 41 bytes

brainfuck , 45 37 bytes

Cómo funciona:

Pyth , 7 bytes

05AB1E , 7 bytes

J , 15 bytes

Haskell , 34 32 31 bytes

Brain-Flak , 180 bytes

Haskell , 28 bytes

Explicación

R , 40 bytes

R , 40 36 bytes

PowerShell , 39 37 bytes

J , 18 16 bytes

Befunge, 26 bytes

Pepe, 59 56 bytes

Retina , 24 bytes

brainfuck , 73 bytes