Une très longue Terza Rima

38

La description

Afficher le schéma de rimes pour une très longue Terza Rima.

Contribution

Aucun.

Sortie

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

Règles

Vous pouvez choisir entre séparer des strophes avec des espaces ou des nouvelles lignes, donc soit:

ABA BCB...

OU

ABA
BCB
...

Un seul espace de fin est autorisé par ligne et un nouveau trait est autorisé.

La sortie peut être en majuscule ou en minuscule.

C'est du code-golf , donc le code le plus court en octets pour chaque langue gagne.

code-golf  string  kolmogorov-complexity  alphabet 
— LiefdeWen
source
4
Est-ce qu'une liste de lignes est acceptable?
— totalement humain
6
Selon en.wikipedia.org/wiki/Terza_rima, votre fin est fausse. Il devrait se terminer par Z ou ZZ.
— Chris
Peut-il y avoir une sortie supplémentaire au-delà du schéma des rimes? Cela pourrait me sauver quelques octets.
— NK1406
@ NK1406 Nope désolé.
— LiefdeWen
1
@totallyhuman Le tableau de chaînes est correct.
— LiefdeWen

Réponses:

24

JavaScript (ES6), 51 50 49 octets

Sauvegardé 1 octet grâce à @ l4m2

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

Essayez-le en ligne!

Comment?

Nous commençons avec n = 45358 ( yzy en base 36). Nous soustrayons 1333 de n à chaque itération ( 111 en base-36). Nous nous arrêtons dès que n MOD 63 = 0 , car 12033 ( 9a9 en base-36) est la première valeur pour laquelle cette condition est remplie et 63 est le plus petit modulo avec une telle propriété.

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
source
Comment avez-vous décidé de base36? et êtes-vous sûr que c'est optimal?
— LiefdeWen
2
@LiefdeWen C'est la base la plus basse qui contient toutes les lettres, donc c'est optimal.
— Erik l'Outgolfer
@ user202729 Que voulez-vous dire? Il n'est pas OP, alors il est l'une de ces personnes à qui vous faites référence?
— Erik l'Outgolfer
17
En tant que noeud latéral (non) intéressant, 1333 = 666 * 2 + 1 et ceci est ma 666e réponse sur PPCG.
— Arnauld
3
@Arnauld, veuillez vous assurer d'utiliser la valeur 1335 quelque part dans votre prochaine réponse.
— IanF1
10

Gelée , 7 octets

ØAṡ2ŒBY

Essayez-le en ligne!

-1 octet grâce à 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
source
9

brainfuck , 51 48 octets

Sauvegardé de 3 octets grâce à @ovs.

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

Essayez-le en ligne!

Explication

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
source
@ ConorO'Brien - Je viens de remarquer que ma réponse est assez similaire à la vôtre. N'hésitez pas à commenter si vous pensez que c'est trop proche et je l'enlèverai.
— ElPedro
1
@ElPedro Non, ça va, l'innovation n'a pas beaucoup de place dans ce défi :)
— Conor O'Brien
9

05AB1E , 5 octets

Aü«€û

Essayez-le en ligne!

-1 octet grâce à Emigna
-1 octet grâce au changement de règle; merci à kalsowerus pour l'avoir signalé

Hehe, bat actuellement Pyth. \ o /

Explication

Aü«€û»  Full Program
A       Lowercase Alphabet
 ü«     Pairwise with merge-list
   €û   For each, palindromize
— HyperNeutrino
source
Vous pourriez faireAü«€û»
— Emigna
@ Emigna O cool, merci! : D
— HyperNeutrino
Bien, c'est ce que j'ai aussi sans regarder.
— Urne Magic Octopus,
Selon les commentaires, une liste de chaînes constitue une sortie, vous pouvez supprimer la jointure.
— kalsowerus
9

brainfuck , 51 49 octets

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

Essayez-le en ligne!

Une tentative d'explication ...

+++++                     #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 grâce à @ovs

Ma première tentative de brainfuck donc toute allusion reçue avec gratitude. Si j'en avais plus l'habitude, je suis sûr de pouvoir supprimer quelques octets de plus, mais je n'y suis entré que hier.

— ElPedro
source
— Jo King
6

Charbon de bois , 11 octets

Ｅ²⁵✂αι⁺²ι‖Ｏ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

Brain-Flak , 90 octets

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

Essayez-le en ligne!

Une raison plus courte que l'autre solution cerveau-flak réside dans le fait qu'il utilise des majuscules au lieu de minuscules, qui ont des valeurs ASCII plus petites et sont donc plus faciles à utiliser.

Explication:

#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
source
J'écris la première version et ne reçois pas de votes positifs, vous écrivez une version de golf et obtenez +5. ???
— Christopher
5

R, 51 47 octets

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

Sortie:

> 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
— planificateur
source
La manière naïve sans fantaisie sprintfest de 49 octets
— Giuseppe
@ Giuseppe ce serait parce que je n'ai pas utilisé sprintfcorrectement :)
— plannapus
OK, mais j'ai trouvé un 40 octets :)
— Giuseppe
@Giuseppe ouch :)
— plané
1
un autre [40 byter] [ tio.run/##K/r/… basé sur la conversion de codes ASCII, dans le cas où
— NofP
5

Java 8 , 132 85 62 60 octets

  • 47 octets grâce à Neil
  • 26 octets grâce à Oliver
  • 3 octets et un meilleur formatage grâce à Kevin
  • Erreur corrigée par Oliver

Golfé

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
source
1
Imprimer un tableau de caractères serait probablement beaucoup plus court.
— Neil
1
Pouvez-vous en faire iun charaussi?
— Neil
2
a->{for(char c=64;++c<90;)System.out.println(""+c++ +c--+c);}(62 bytes)
— Olivier Grégoire
2
Actuellement, il s’agit d’un extrait de code et non d’une fonction ou d’un programme. Vous devrez donc ajouter le v->{...}texte mentionné ci-dessus par @ OlivierGrégoire. ( Si vous ne savez pas comment Java 8 travail lambdas, j'ai fait une explication une fois. ) En outre, vous pouvez supprimer les crochets de la boucle comme Olivier a fait, et le golf supplémentaire que vous pouvez changer l'impression à System.out.print(" "+i+++i--+i);(un espace au lieu d'une nouvelle ligne, et vous n'avez pas besoin d'espace à c+++c--+c). Essayez ici.
— Kevin Cruijssen
1
Merci @KevinCruijssen pour les astuces et le document java lambdas. C’était un guide très facile à suivre pour mettre en œuvre des lambdas simples. J'ai mis à jour en conséquence!
— DevelopingDeveloper
4

brainfuck , 41 octets

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

Essayez-le en ligne!

— ovs
source
+1 Je suis la plupart du temps, mais cela commence par - [Cela signifie-t-il que vous définissez la cellule 0 sur -1 avant de commencer la boucle? Toute chance d'une explication pour un débutant brainfuck si vous avez le temps? Btw, merci pour le -2 sur mon effort.
— ElPedro
@ElPedro cela dépend de l'interprète brainfuck, l'interprète de tio.run stocke les nombres de 8 bits non signés dans chaque cellule, de sorte que la première cellule obtient 255 avant la boucle.
— ovs
@ElPedro the initialization segment is actually generated by BF-Crunch.
— ovs
4

brainfuck, 45 37 bytes

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

Try it online!

Prints in uppercase, separated by spaces with a trailing space.

How it Works:

+[[<+>>++<-]>] 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
source
1
This is actually really nice! Good job!
— Dust
3

Brain-Flak, 180 bytes

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

Try it online!

Thanks to DJ for getting this working

— Christopher
source
3

Haskell, 28 bytes

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

Try it online!

succ is such an unfortunate naming choice...

Explanation

[[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
source
4
I do not feel like it is completely fair to return a list of strings instead of separating them with space or newline as required.
— user28667
@user28667 It's usually allowed in challenges (it probably should be on the Default IO post, if it's not already). The OP is yet to respond in this challenge specifically. This is, however, no reason to downvote.
— totallyhuman
@totallyhuman At the moment the challenge explicitly specifies that either spaces or newlines should be used to separate the output, thus this answer is currently invalid. So strictly according to the site rules it should be deleted, or just fixed by prepending a unlines or unwords.
— Laikoni
@Laikoni I seem to have ninja'd you. The challenge doesn't explicitly deny a list of lines as output. (Plus, that would invalidate a fair amount of answers.) Either way, the answer is now not invalid.
— totallyhuman
3

R, 40 bytes

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

Try it online!

One more alternative in R to Plannapus and Giuseppe's answers. Posted following their request. This solution uses ASCII code to UTF8 coding.

PS if TABs were allowed, one could replace the newline (ASCII code 10) with a tabulation (ASCII code 9), and the solution could shrink to 39 bytes:

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

— NofP
source
I think using 9 is perfectly fine, since it's whitespace, which is allowed by the OP.
— Giuseppe
3

PowerShell, 39 37 bytes

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

Try it online!

Loops from 65 to 89. Each iteration, we're constructing an integer array of (the current, one more, and the current) of the current digit, using pre-increment and pre-decrement. That's then re-cast as a char-array, and -joined together into a single string. Each string is left on the pipeline and an implicit Write-Output at program completion gives us a newline between each element for free.

Alternatively, same byte count

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

Try it online!

— AdmBorkBork
source
1
($_,($_+1),$_) is an alternative same-length tuple
— Veskah
2

Pepe, 59 56 bytes

-3 bytes thanks to u_ndefined

REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee

Try it online!

Explanation:

# 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
— RedClover
source
1
Replacing rEeEeeeeEe with RrEEEEE saves off 3 bytes
— u_ndefined
@u_ndefined Thanks! I made this code before flags were added to Pepe. Updated the answer.
— RedClover
1

Retina, 24 bytes


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

Try it online!

— Martin Ender
source
21 bytes but suffers from trailing newlines...
— Neil
@Neil Yeah, you don't even need the `.... Getting rid of those trailing newlines is really annoying though. I'm hoping to make printing in loops a bit more flexible and convenient in Retina 1.0.
— Martin Ender
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.