Una Terza Rima molto lunga

38

Descrizione

Stampa lo schema delle rime per una Terza Rima molto lunga.

Ingresso

Nessuna.

Produzione

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

Regole

Puoi scegliere tra stanze separate con spazi bianchi o newline, quindi:

ABA BCB...

O

ABA
BCB
...

Sono consentiti un unico spazio bianco finale per riga e una nuova riga finale consentita.

L'output può essere maiuscolo o minuscolo.

Questo è code-golf , quindi vince il codice più breve in byte per ogni lingua.

code-golf  string  kolmogorov-complexity  alphabet 
— LiefdeWen
fonte
4
Un elenco di righe va bene?
— totalmente umano il
6
Secondo en.wikipedia.org/wiki/Terza_rima il tuo finale è sbagliato. Dovrebbe terminare con Z o ZZ.
— Chris, il
Può esserci un output aggiuntivo oltre lo schema delle rime? Questo potrebbe salvarmi qualche byte.
— NK1406,
@ NK1406 No scusa.
— LiefdeWen
1
@totallyhuman L'array di stringhe va bene.
— LiefdeWen

Risposte:

24

JavaScript (ES6), 51 50 49 byte

Salvato 1 byte grazie a @ l4m2

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

Provalo online!

Come?

Iniziamo con n = 45358 ( yzy in base-36). Sottraiamo 1333 da n ad ogni iterazione ( 111 in base-36). Ci fermiamo non appena n MOD 63 = 0 , perché 12033 ( 9a9 in base-36) è il primo valore per il quale questa condizione è soddisfatta e 63 è il modulo più piccolo con tale proprietà.

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
fonte
Come hai deciso base36? e sei sicuro che sia ottimale?
— Liefde:
2
@LiefdeWen È la base più bassa per contenere tutte le lettere, quindi è ottimale.
— Erik the Outgolfer,
@ user202729 Che vuoi dire? Non è OP, quindi è una di quelle persone a cui ti riferisci?
— Erik the Outgolfer,
17
Come nodo laterale (non) interessante, 1333 = 666 * 2 + 1 e questa è la mia 666a risposta su PPCG.
— Arnauld,
3
@Arnauld assicurati di utilizzare il valore 1335 da qualche parte nella prossima risposta.
— IanF1
10

Gelatina , 7 byte

ØAṡ2ŒBY

Provalo online!

-1 byte grazie 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
— HyperNeutrino
fonte
9

brainfuck , 51 48 byte

Salvato 3 byte grazie a @ovs.

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

Provalo online!

Spiegazione

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
fonte
@ ConorO'Brien - Ho appena notato che la mia risposta è abbastanza simile alla tua. Sentiti libero di commentare se pensi che sia troppo vicino e lo rimuoverò.
— ElPedro,
1
@ElPedro No, stai bene, non c'è molto spazio per l'innovazione in questa sfida :)
— Conor O'Brien
9

05AB1E , 5 byte

Aü«€û

Provalo online!

-1 byte grazie a Emigna
-1 byte grazie al cambio di regola; grazie a kalsowerus per averlo sottolineato

Hehe, attualmente batte Pyth. \ O /

Spiegazione

Aü«€û»  Full Program
A       Lowercase Alphabet
 ü«     Pairwise with merge-list
   €û   For each, palindromize
— HyperNeutrino
fonte
Si potrebbe fareAü«€û»
— Emigna il
@Emigna O figo, grazie! : D
— HyperNeutrino,
Bello, è quello che ho ottenuto anche senza guardare.
— Magic Octopus Urn,
Secondo i commenti, un elenco di stringhe va bene come output, è possibile rimuovere il join.
— Kalsowerus,
9

brainfuck , 51 49 byte

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

Provalo online!

Un tentativo di spiegazione ...

+++++                     #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 grazie a @ovs

Il mio primo tentativo di brainfuck così ogni suggerimento ricevuto con gratitudine. Se ne fossi più esperto, sono sicuro che potrei radere qualche byte in più, ma ci sono riuscito solo ieri.

— ElPedro
fonte
— Jo King
6

Carbone , 11 byte

Ｅ²⁵✂αι⁺²ι‖Ｏ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Brain-Flak , 90 byte

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

Provalo online!

Uno dei motivi per cui questo è più breve dell'altra risposta da scartare il cervello è perché usa caratteri maiuscoli anziché minuscoli, che hanno valori ASCII più piccoli e sono quindi più facili da spingere.

Spiegazione:

#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
fonte
Scrivo la prima versione e non ottengo voti, scrivi una versione da golf e ottengo +5. ???
— Christopher,
5

R, 51 47 byte

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

Produzione:

> 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
fonte
Il modo ingenuo senza fantasia sprintfè di 49 byte
— Giuseppe,
@Giuseppe sarebbe perché non l'ho usato sprintfcorrettamente :)
— plannapus il
OK, ma ho trovato un 40 byte :)
— Giuseppe,
@Giuseppe ouch :)
— plannapus,
1
un altro [40 byter] [ tio.run/##K/r/… basato sulla conversione di codici ASCII, nel caso
— NofP
5

Java 8 , 132 85 62 60 byte

  • 47 byte grazie a Neil
  • 26 byte grazie a Oliver
  • 3 byte e una formattazione molto migliore grazie a Kevin
  • Errore risolto da Oliver

golfed

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

Ungolfed

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);
    }
}
— DevelopingDeveloper
fonte
1
La stampa di un array di caratteri sarebbe probabilmente molto più breve.
— Neil,
1
Si può fare iuna charanche tu?
— Neil,
2
a->{for(char c=64;++c<90;)System.out.println(""+c++ +c--+c);}(62 byte)
— Olivier Grégoire il
2
Attualmente si tratta di uno snippet anziché di una funzione o di un programma, quindi dovrai aggiungere v->{...}quanto sopra citato da @ OlivierGrégoire. ( Nel caso in cui non sapessi come funzionano i lambda Java 8, una volta ho fatto una spiegazione. ) Inoltre, puoi rimuovere le parentesi del ciclo come ha fatto Olivier e come golf aggiuntivo puoi cambiare la stampa in System.out.print(" "+i+++i--+i);(uno spazio invece di una nuova riga e non è necessario lo spazio in c+++c--+c). Provalo qui.
— Kevin Cruijssen il
1
Grazie a @KevinCruijssen per i suggerimenti e per il documento java lambdas. Questa è stata una guida molto facile da seguire per implementare alcuni semplici lambda. Ho aggiornato di conseguenza!
— DevelopingDeveloper
4

Brainfuck , 41 byte

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

Provalo online!

— OVS
fonte
+1 Lo seguo per lo più ma inizia con - [Significa che stai impostando la cella da 0 a -1 prima di iniziare il ciclo? Qualche possibilità di una spiegazione per un principiante brainfuck se hai tempo? A proposito, grazie per il -2 sul mio sforzo.
— ElPedro,
@ElPedro dipende dall'interprete brainfuck, l'interprete di tio.run memorizza numeri a 8 bit senza segno in ogni cella, quindi la prima cella ottiene 255 prima del ciclo.
— Ovs,
@ElPedro il segmento di inizializzazione è effettivamente generato da BF-Crunch .
— Ovs,
4

brainfuck , 45 37 byte

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

Provalo online!

Stampa in maiuscolo, separato da spazi con uno spazio finale.

Come funziona:

+[[<+>>++<-]>] 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
fonte
1
Questo è davvero bello! Buon lavoro!
— Polvere
3

Brain-Flak , 180 byte

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

Provalo online!

Grazie a DJ per aver funzionato

— Christopher
fonte
3

Haskell , 28 byte

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

Provalo online!

succ è una scelta di denominazione così sfortunata ...

Spiegazione

[[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
— totallyhuman
fonte
4
Non mi sembra del tutto corretto restituire un elenco di stringhe invece di separarle con spazio o newline come richiesto.
— user28667
@ user28667 Di solito è consentito nelle sfide (probabilmente dovrebbe trovarsi sul post IO predefinito, se non lo è già). L'OP deve ancora rispondere in modo specifico a questa sfida. Questo, tuttavia, non ha motivo di votare.
— totalmente umano il
@totallyhuman Al momento la sfida specifica esplicitamente che spazi o newline dovrebbero essere usati per separare l'output, quindi questa risposta non è attualmente valida. Quindi, rigorosamente secondo le regole del sito, dovrebbe essere eliminato o semplicemente risolto anteponendo un unlineso unwords.
— Laikoni,
@Laikoni Mi sembra di averti ninja. La sfida non nega esplicitamente un elenco di righe come output. (Inoltre, che potrebbero invalidare una discreta quantità di risposte.) In entrambi i casi, la risposta è ora non è valido.
— totalmente umano il
3

R , 40 byte

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

Provalo online!

Un'altra alternativa in R alle risposte di Plannapus e Giuseppe . Postato a seguito della loro richiesta. Questa soluzione utilizza il codice ASCII per la codifica UTF8.

PS se i TAB fossero consentiti, si potrebbe sostituire la nuova riga (codice ASCII 10) con una tabulazione (codice ASCII 9) e la soluzione potrebbe ridursi a 39 byte:

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

— NOFP
fonte
Penso che usare 9vada benissimo, dato che è uno spazio bianco, che è consentito dall'OP.
— Giuseppe,
3

PowerShell , 39 37 byte

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

Provalo online!

Loop da 65a 89. Ogni iterazione, stiamo costruendo un array intero di (la corrente, un'altra e la corrente) della cifra corrente, usando pre-incremento e pre-decremento. charViene quindi ri-castato come un array, -joined editato insieme in un'unica stringa. Ogni stringa viene lasciata sulla pipeline e un implicito Write-Outputal completamento del programma ci dà una nuova riga tra ogni elemento gratuitamente.

In alternativa, lo stesso conteggio byte

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

Provalo online!

— AdmBorkBork
fonte
1
($_,($_+1),$_)è una tupla della stessa lunghezza alternativa
— Veskah,
2

Pepe, 59 56 byte

-3 byte grazie a u_ndefined

REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee

Provalo online!

Spiegazione:

# 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
— Trifoglio rosso
fonte
1
Sostituendo rEeEeeeeEecon i RrEEEEEsalvataggi 3 byte
— u_ndefined
@u_ndefined Grazie! Ho creato questo codice prima che le bandiere fossero aggiunte a Pepe. Aggiornato la risposta.
— RedClover,
1

Retina , 24 byte


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

Provalo online!

— Martin Ender
fonte
21 byte ma soffre di nuove righe finali ...
— Neil,
@Neil Sì, non ti serve nemmeno `.... Sbarazzarsi di quelle nuove linee finali è davvero fastidioso però. Spero di rendere la stampa in loop un po 'più flessibile e conveniente in Retina 1.0.
— Martin Ender,
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.