Descrição

Saída do esquema de rima por um Terza Rima muito longo.

Entrada

Nenhum.

Saída

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

Regras

Você pode escolher entre separar estrofes com espaços em branco ou novas linhas, portanto:

ABA BCB...

OU

ABA
BCB
...

Um único espaço em branco à direita permitido por linha e uma nova linha à direita é permitida.

A saída pode ser maiúscula ou minúscula.

Isso é código-golfe , portanto o código mais curto em bytes para cada idioma vence.

— LiefdeWen
fonte

4

Uma lista de linhas está correta?

— totallyhuman

6

De acordo com en.wikipedia.org/wiki/Terza_rima, seu final está errado. Deve terminar com Z ou ZZ.

— 18717 Chris

Pode haver saída adicional além do esquema da rima? Isso pode me economizar alguns bytes.

— NK1406

@ NK1406 Não, desculpe.

— LiefdeWen

1

@totallyhuman A matriz String está correta.

— LiefdeWen

24

JavaScript (ES6), 51 50 49 bytes

Guardado 1 byte graças a @ l4m2

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

Experimente online!

Quão?

Começamos com n = 45358 ( yzy na base 36). Subtraímos 1333 de n em cada iteração ( 111 na base 36). Paramos assim que n MOD 63 = 0 , porque 12033 ( 9a9 na base 36) é o primeiro valor para o qual essa condição é atendida e 63 é o menor módulo com essa propriedade.

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

Como você decidiu base36? e você tem certeza de que é o ideal?

— LiefdeWen

2

@LiefdeWen É a base mais baixa para conter todas as letras, por isso é ideal.

— Erik the Outgolfer

@ user202729 Como assim? Ele não é OP, então é uma daquelas pessoas a quem você se refere?

— Erik the Outgolfer

17

Como um nó lateral (des) interessante, 1333 = 666 * 2 + 1 e esta é a minha 666ª resposta sobre PPCG.

— Arnauld

3

@ Arnauld, certifique-se de usar o valor 1335 em algum lugar da sua próxima resposta.

— IanF1

15

C (gcc) , 41 bytes

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

Experimente online!

Corrigido e -9 graças a user202729 . -1 graças a Dennis e -2 graças a Arnauld também.

— Mr. Xcoder
fonte

45 bytes .

— user202729

1

(i='ABA';i<'ZZZ';i+=65793)salva um byte.

— Dennis

Use em 59e5vez de 'ZZZ'salvar outro byte.

— user202729

Você pode usar i%29para 41 bytes

— Arnauld

10

Geléia , 7 bytes

ØAṡ2ŒBY

Experimente online!

-1 byte graças 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 bytes

Economizou 3 bytes graças a @ovs.

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

Experimente online!

Explicação

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 - Acabei de perceber que minha resposta é bem parecida com a sua. Por favor, sinta-se livre para comentar se você acha que está muito perto e eu o removerei.

— ElPedro

1

@ElPedro Não, você está bem, não há muito espaço para inovação neste desafio :)

— Conor O'Brien

9

05AB1E , 5 bytes

Aü«€û

Experimente online!

-1 byte graças a Emigna
-1 byte graças a alteração de regra; graças a kalsowerus por apontar isso

^{_{Hehe, atualmente vence Pyth. \ o /}}

Explicação

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

— HyperNeutrino
fonte

Você poderia fazerAü«€û»

— Emigna

@ Emigna O legal, obrigado! : D

— HyperNeutrino

Legal, foi o que eu consegui sem olhar.

— Magic Octopus Urn

De acordo com os comentários, uma lista de strings é boa como saída, você pode remover a junção.

— kalsowerus

9

brainfuck , 51 49 bytes

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

Experimente online!

Uma tentativa de explicação ...

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

Minha primeira tentativa de foda cerebral, para que qualquer sugestão recebida com gratidão. Se eu tivesse mais experiência com isso, tenho certeza de que poderia raspar mais alguns bytes, mas só o fiz ontem.

— ElPedro
fonte

-1 byte

— Jo King

7

APL (Dyalog) , 14 bytes

25↑0 1 0⊖3/⍪⎕A

Experimente online!

Observe que o ⎕←item adicionado é para o TIO gerar o texto e normalmente não é necessário.

— Erik, o Outgolfer
fonte

7

Python 2 , 42 41 bytes

^{-1 byte graças a Halvard Hummel}

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

Experimente online!

— Cajado
fonte

6

Carvão , 11 bytes

Ｅ²⁵✂αι⁺²ι‖Ｏ

Experimente online! Link é a versão detalhada do código. Explicação:

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

— Neil
fonte

6

Flak cerebral , 90 bytes

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

Experimente online!

Uma razão pela qual essa resposta é mais curta que a outra resposta cerebral é porque ela usa caracteres maiúsculos em vez de minúsculos, que possuem valores ASCII menores e, portanto, são mais fáceis de pressionar.

Explicação:

#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

Eu escrevo a primeira versão e não recebo nenhum voto positivo, você escreve uma versão de golfe e recebe +5. ???

— Christopher

5

R, 51 47 bytes

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

Saída:

> 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

A maneira ingênua, sem fantasia sprintfé 49 bytes

— Giuseppe

@ Giuseppe isso seria porque eu não usei sprintfcorretamente :) #

— plannapus

OK, mas eu encontrei um Byter 40 :)

— Giuseppe

@Giuseppe ouch :)

— plannapus

1

outro [40 byter] [ tio.run/##K/r/… com base na conversão de códigos ASCII, no caso

— NofP

5

Java 8 , 132 85 62 60 bytes

47 bytes graças a Neil
26 bytes graças a Oliver
3 bytes e formatação muito melhor graças a Kevin
Erro corrigido por Oliver

Golfe

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

Imprimir uma matriz de caracteres provavelmente seria muito menor.

— Neil

1

Você pode fazer ium chartambém?

— Neil

2

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

— Olivier Grégoire

2

Atualmente, este é um trecho de código em vez de uma função ou programa, portanto, você precisará adicionar o v->{...}mencionado acima por @ OlivierGrégoire. ( Caso você não saiba como o Java 8 lambdas funciona, eu expliquei uma vez antes. ) Além disso, você pode remover os colchetes do loop como o Olivier e, como golfe adicional, pode alterar a impressão para System.out.print(" "+i+++i--+i);(um espaço ao invés de uma nova linha e você não precisa do espaço em c+++c--+c). Experimente aqui.

— Kevin Cruijssen

1

Obrigado @KevinCruijssen pelas dicas e pelo documento java lambdas. Esse foi um guia muito fácil de seguir para implementar algumas lambdas simples. Eu atualizei de acordo!

— DevelopingDeveloper

5

> <> , 25 24 23 22 bytes

Economizou 2 bytes graças a Jo King

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

Experimente online!

— Emigna
fonte

23 bytes removendo uma citação

— Jo King

Outro byte

— Jo King

@ JoKing: Obrigado novamente!

— Emigna

5

Befunge-98 (FBBI) , 27 23 21 bytes

-4 bytes graças a James Holderness

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

Experimente online!

— ovs
fonte

4

Casca , 9 bytes

ẊS:`e…"AZ

Experimente online!

— Erik, o Outgolfer
fonte

4

brainfuck , 41 bytes

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

Experimente online!

— ovs
fonte

+1 Eu sigo a maioria, mas começa com - [Isso significa que você está configurando a célula 0 para -1 antes de iniciar o loop? Alguma chance de uma explicação para um novato, se você tiver tempo? Btw, obrigado pelo -2 no meu esforço.

— ElPedro

@ElPedro, isso depende do intérprete do cérebro, o intérprete em tio.run armazena números de 8 bits não assinados em cada célula, para que a primeira célula receba 255 antes do loop.

— ovs 21/12/19

@ElPedro, o segmento de inicialização é realmente gerado pelo BF-Crunch .

— ovs 21/12/19

4

brainfuck , 45 37 bytes

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

Experimente online!

Imprime em maiúsculas, separadas por espaços com um espaço à direita.

Como 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

— Brincadeira
fonte

1

Isso é realmente muito bom! Bom trabalho!

— Poeira

3

Pitão , 7 bytes

jC[GtGG

Experimente aqui!

_{Hehe, atualmente vence Jelly. \ o /}

Traduz facilmente para o seguinte programa 05ab1e:

05AB1E , 7 bytes

AA¦A)ø»

Experimente online!

— Mr. Xcoder
fonte

3

J , 15 bytes

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

Experimente online!

— FrownyFrog
fonte

1

Esta é uma maneira complicada de criar um palíndromo!

— Galen Ivanov

3

Haskell , 34 32 31 bytes

Baseado na resposta totalmente humana . -1 byte graças a H.PWiz

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

Experimente online!

— user28667
fonte

2

salve um byte com #do

— H.PWiz

3

Flacidez cerebral , 180 bytes

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

Experimente online!

Obrigado ao DJ por fazer isso funcionar

— Christopher
fonte

3

Haskell , 28 bytes

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

Experimente online!

succ é uma escolha de nome tão infeliz ...

Explicação

[[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
fonte

4

Não acho que seja completamente justo retornar uma lista de cadeias de caracteres em vez de separá-las com espaço ou nova linha, conforme necessário.

— user28667

@ user28667 Geralmente é permitido em desafios (provavelmente deve estar na postagem de E / S padrão, se ainda não estiver). O OP ainda não respondeu especificamente a esse desafio. Isso não é, no entanto, motivo para voto negativo.

— totallyhuman

@totallyhuman No momento, o desafio especifica explicitamente que espaços ou novas linhas devem ser usadas para separar a saída, portanto, essa resposta é atualmente inválida. Portanto, estritamente de acordo com as regras do site, ele deve ser excluído ou corrigido apenas com a adição de um unlinesou unwords.

— Laikoni

@Laikoni Eu pareço ter ninja'd você. O desafio não nega explicitamente uma lista de linhas como saída. (Além disso, isso invalidaria uma quantidade razoável de respostas.) De qualquer forma, a resposta agora não é inválida.

— totallyhuman

3

R , 40 bytes

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

Experimente online!

Mais uma alternativa em R às respostas de Plannapus e Giuseppe . Postado após seu pedido. Esta solução usa código ASCII para codificação UTF8.

PS se as TABs fossem permitidas, seria possível substituir a nova linha (código ASCII 10) por uma tabulação (código ASCII 9) e a solução poderia diminuir para 39 bytes:

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

— NofP
fonte

Eu acho que usar 9é perfeitamente bom, pois é um espaço em branco, o que é permitido pelo OP.

— Giuseppe

3

R , 40 36 bytes

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

Experimente online!

Uma alternativa à resposta do plannapus ; isso acaba sendo um pouco mais golfista; Eu publiquei por seu pedido.

Veja também esta resposta de 40 bytes da NofP, que é bastante agradável.

— Giuseppe
fonte

3

PowerShell , 39 37 bytes

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

Experimente online!

Loops de 65para 89. A cada iteração, estamos construindo uma matriz inteira (a atual, mais uma e a atual) do dígito atual, usando pré-incremento e pré-decremento. Isso é, então, relançado como uma charmatriz e -joineditado em uma única sequência. Cada string é deixada no pipeline e um implícito Write-Outputna conclusão do programa nos fornece uma nova linha entre cada elemento gratuitamente.

Como alternativa, a mesma contagem de bytes

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

Experimente online!

— AdmBorkBork
fonte

1

($_,($_+1),$_)é uma tupla alternativa do mesmo comprimento

— Veskah 18/07/19

2

J , 18 16 bytes

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

Alterado a.{~ para u:após as soluções de Conor O'Brien e FrownyFrog

Experimente online!

— Galen Ivanov
fonte

1

Alternative 16 byte:u:(i.25)+/66-#:5

— FrownyFrog

2

Befunge, 26 bytes

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

Experimente online!

— James Holderness
fonte

2

Pepe, 59 56 bytes

^{-3 bytes graças a u_ndefined}

REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee

Experimente online!

Explicação:

# 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

— Trevo vermelho
fonte

1

Substituir rEeEeeeeEepor RrEEEEEsalva 3 bytes

— u_ndefined 06/08/19

@u_ndefined Thanks! Eu criei esse código antes que as bandeiras fossem adicionadas ao Pepe. Atualizado a resposta.

— RedClover 06/08/19

1

Retina , 24 bytes


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

Experimente online!

— Martin Ender
fonte

21 bytes , mas sofre de novas linhas de arrasto ...

— Neil

@ Neil Sim, você nem precisa do `.... Livrar-se dessas novas linhas é realmente irritante. Espero tornar a impressão em loops um pouco mais flexível e conveniente no Retina 1.0.

— Martin Ender

1

brainfuck , 73 bytes

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

Experimente online!

— HyperNeutrino
fonte

Uma longa Terza Rima

Descrição

Entrada

Saída

Regras

JavaScript (ES6), 51 50 49 bytes

Quão?

C (gcc) , 41 bytes

Geléia , 7 bytes

brainfuck , 51 48 bytes

Explicação

05AB1E , 5 bytes

Explicação

brainfuck , 51 49 bytes

APL (Dyalog) , 14 bytes

Python 2 , 42 41 bytes

Carvão , 11 bytes

Flak cerebral , 90 bytes

R, 51 47 bytes

Java 8 , 132 85 62 60 bytes

Golfe

Ungolfed

> <> , 25 24 23 22 bytes

Befunge-98 (FBBI) , 27 23 21 bytes

Casca , 9 bytes

brainfuck , 41 bytes

brainfuck , 45 37 bytes

Como funciona:

Pitão , 7 bytes

05AB1E , 7 bytes

J , 15 bytes

Haskell , 34 32 31 bytes

Flacidez cerebral , 180 bytes

Haskell , 28 bytes

Explicação

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