Beatles Songs and Hexagons

30

Écrivez deux programmes en forme de triangle (c.-à-d. Pyramide).

Le premier doit être un triangle de texte pointant vers le haut avec une largeur de base minimale de trois caractères. Il aurait donc une structure comme

 X
XXX

ou

  X
 XXX
XXXXX

ou

   X
  XXX
 XXXXX
XXXXXXX

ou plus. Chacun des caractères Xdoit être remplacé par les caractères de votre code réel, qui peuvent être tout sauf des terminateurs de ligne (les caractères Xpeuvent donc être des espaces). Tous les éléments Xdoivent être remplacés et les espaces et les nouvelles lignes qui aident à former la forme triangulaire doivent rester tels quels.

Le deuxième programme doit avoir la même taille et la même forme que le premier, sauf que le triangle pointe vers le bas.

Donc, si votre premier programme ressemble

  X
 XXX
XXXXX

alors votre deuxième programme ressemblerait

yyyyy
 yyy
  y

où chacun yest un caractère que vous devez remplir avec votre code réel (probablement différent de votre Xcode). Ici aussi, les espaces et les nouvelles lignes doivent rester les mêmes.

Votre tâche consiste à écrire ces programmes de telle sorte qu'ils émettent chacun (vers la sortie standard ou l'alternative la plus proche) le titre d'une chanson des Beatles distincte , sans aucune entrée. Cet article Wikipedia servira de liste de chansons officielle pour les Beatles. La sortie doit être l'un des titres exactement comme indiqué, par exemple I Want You (She's So Heavy).

C'est assez facile, cependant, même avec l'exigence du programme triangle étrange. Nous allons donc former un autre programme parmi les deux premiers qui doit sortir encore un autre titre de chanson.

En combinant trois copies de chacun des deux programmes triangulaires, nous pouvons créer un troisième programme en forme d'hexagone.

Si la largeur de base de votre premier programme était de trois, cela ressemblerait à ceci:

 XyyyX
XXXyXXX
yyyXyyy
 yXXXy

Si la largeur de base était de cinq, cela ressemblerait à ceci:

  XyyyyyX
 XXXyyyXXX
XXXXXyXXXXX
yyyyyXyyyyy
 yyyXXXyyy
  yXXXXXy

Ce programme (lorsqu'il est exécuté avec les espaces et les nouvelles lignes comme les autres) doit produire un autre titre de chanson des Beatles, tout comme les deux premiers programmes. Également:

  • Vos trois programmes doivent produire différents titres de chanson.
  • Seuls les titres de chansons de huit caractères ou plus sont autorisés.
  • Vous ne pouvez en choisir qu'un Revolution, Revolution 1et Revolution 9parce que les titres sont tellement similaires.
  • Vous devez choisir vos trois chansons préférées des Beatles. (Eh bien, essayez .)

Notez que des programmes réels sont requis. Les fonctions ne sont pas autorisées. La lecture de votre propre code source dans n'importe quel programme n'est pas non plus autorisée.

Exemple

Si votre premier programme était

  A
 AAA
AAAAA

il pourrait sortir Across the Universe.

Ensuite, votre deuxième programme

bbbbb
 bbb
  b

pourrait sortir Revolution.

Puis combiné dans le programme hexagonal

  AbbbbbA
 AAAbbbAAA
AAAAAbAAAAA
bbbbbAbbbbb
 bbbAAAbbb
  bAAAAAb

la sortie pourrait être Get Back.

Notation

La soumission avec la plus petite largeur de base de triangle gagne. Dans le cas probable d'égalité, la soumission avec la plus grande longueur additionnée de ses trois titres de chanson gagne.

code-challenge geometry source-layout Loisirs de Calvin
la source
2
Le bris d'égalité devrait-il être le meilleur choix parmi trois chansons? ;)
Doug McClean
1
J'ai du mal à écrire une entrée Python sans simplement copier la méthode de Sp3000 ( je n'aurais jamais pensé me plaindre des espaces syntaxiques!), Mais j'ai écrit un script pour assembler deux triangles en hexagone. Dans le cas où il est utile à quelqu'un d'autre, le voici dans un Gist .
Tim Pederick
@ mbomb007 Les espaces de fin ne faisant pas partie du motif en triangle ne sont pas corrects.
Calvin's Hobbies
@TimPederick Comme je n'ai pas pu faire fonctionner votre hexagone, j'ai écrit un script Python pour le faire en commençant par 2 chaînes multi-lignes. Voyez ici si quelqu'un veut l'utiliser.
mbomb007
@ mbomb007 Désolé mais un espace de fin n'est pas autorisé car il ne fait pas partie du titre. (J'autoriserais un retour à la ligne, car de nombreuses instructions d'impression en ajoutent une.) Je ne suis pas sûr de la politique de retour arrière habituelle, mais elles me conviennent.
Calvin's Hobbies

Réponses:

18

GolfScript, largeur = 9 caractères, titres = 33 caractères

Hexagone

    "Let It Be"
   }";"Yeste"}";      
  "Twi""rda""Twi"
 "st an""y""st an"
"d Shout"}"d Shout"
Let It Be"Let It Be
 "Yeste"}";"Yeste"
  "rda""Twi""rda"
   "y""st an""y"
    }"d Shout"}

Imprime Let It Be . (9 caractères)

Essayez-le en ligne.

Comment ça marche

Le jeton "Let It Be"sur la première ligne pousse la chaîne Let It Be sur la pile.

La deuxième ligne commence par }un "super commentaire" non documenté qui abandonne immédiatement l'exécution.

Avant de quitter, GolfScript imprime le contenu de la pile.

Triangle X

    "
   }";
  "Twi"
 "st an"
"d Shout"

Imprime Twist and Shout . (15 caractères)

Essayez-le en ligne.

Comment ça marche

Les deux premières lignes poussent la chaîne "\n }", que la commande ;rejette de la pile.

Les lignes restantes contiennent les jetons "Twi", "st an"et "d Shout", qui poussent la chaîne Twist and Shout en trois morceaux.

Avant de quitter, GolfScript imprime le contenu de la pile.

Triangle Y

Let It Be
 "Yeste"
  "rda"
   "y"
    }

Imprime hier . (9 caractères)

Essayez-le en ligne.

Comment ça marche

Les jetons Let, Itet Besur la première ligne ne sont pas définies, de sorte qu'ils ne font rien.

Les trois lignes suivantes contiennent les jetons "Yeste", "rda"et "y", qui poussent la chaîne Hier en trois morceaux.

Le }sur la dernière ligne ne fait rien; le programme aurait fini de toute façon.

Une fois de plus, GolfScript imprime le contenu de la pile avant de quitter.

Dennis
la source
21

Befunge -93, largeur = 13 15 , titres = 31 24 caractères

Une coupure de courant hier soir m'a empêché de mettre à jour cela quand je l'ai compris, mais j'ai réussi à réduire la largeur du triangle et à augmenter la longueur des chansons!

Programme de pointage: "Dig a Pony", 10 caractères:

      v
     v> 
    v#  >
   "<     
  v <>"y"v>
 <v"Dig a P"
"^>:#,_@.>"no

Explication

J'ai vraiment profité du tour de passe-passe de Befunge et j'ai choisi "Dig a Pony" spécifiquement parce qu'il avait un espace en 6ème position. Cela permet au flux du programme de se déplacer dans le nom du morceau. Essayez-le dans l' interpréteur en ligne pour voir comment cela fonctionne.

Programme de pointage vers le bas: "If I Fell", 9 caractères:

< v"f I Fell"
 v>"I">:#,_@
  "raC yM "
   v"Drive


       .

(La période est étrangère et uniquement incluse pour que les autres lignes apparaissent.)

Explication

Les seules lignes pertinentes ici sont les deux premières. J'ai utilisé l'astuce de bouclage (le pointeur d'instruction est envoyé immédiatement à gauche) pour presser un caractère de plus. La deuxième ligne imprime le nom du morceau.

Combiné: "Drive My Car", 12 caractères:

      v< v"f I Fell"v
     v> v>"I">:#,_@v> 
    v#  >"raC yM "v#  >
   "<     v"Drive"<     
  v <>"y"v>     v <>"y"v>
 <v"Dig a P"   <v"Dig a P"
"^>:#,_@.>"no "^>:#,_@.>"no
< v"f I Fell"v< v"f I Fell"
 v>"I">:#,_@v> v>"I">:#,_@
  "raC yM "v#  >"raC yM "
   v"Drive"<     v"Drive
         v <>"y"v>     
        <v"Dig a P"   
       "^>:#,_@.>"no

Voici la même chose, mais avec des lignes ajoutées pour montrer l'hexagone et les triangles.

       -----------------
      /v\< v"f I Fell"/v\
     /v> \v>"I">:#,_@/v> \
    /v#  >\"raC yM "/v#  >\
   /"<     \v"Drive/"<     \
  /v <>"y"v>\     /v <>"y"v>\
 /<v"Dig a P"\   /<v"Dig a P"\
/"^>:#,_@.>"no\ /"^>:#,_@.>"no\
-------------------------------
\< v"f I Fell"/v\< v"f I Fell"/
 \v>"I">:#,_@/v> \v>"I">:#,_@/
  \"raC yM "/v#  >\"raC yM "/
   \v"Drive/"<     \v"Drive/
    \     /v <>"y"v>\     /
     \   /<v"Dig a P"\   /
      \ /"^>:#,_@.>"no\ /
       -----------------

Explication

C'est là que les troisième et quatrième lignes du triangle pointant vers le bas entrent en jeu. Il y a plusieurs redirections au bord des deux triangles qui servent à déplacer le pointeur d'instruction à travers ces deux lignes et à pousser "Drive My Car" sur la pile. Ensuite, il est imprimé en utilisant le >:#,_@bit dans le triangle pointant vers le haut. Soit dit en passant, les triangles pointant vers la gauche et vers la droite sont utilisés.

Il pourrait y avoir un moyen d'utiliser plus d'espace vide, mais je pense que mon temps est mieux consacré à d'autres questions. : P

El'endia Starman
la source
Hmm. Les règles de PPCG sont que si un programme fonctionne avec au moins un interpréteur, il est valide. Bon endroit, cependant.
El'endia Starman
Une autre "règle" de PPCG est que l'interpréteur définit la langue, pas la spécification. Ainsi, mon code Befunge est, essentiellement, valide.
El'endia Starman du
18

Python 2, largeur = 51

                         #print "Yellow Submarine" if id else "(Reprise)"   ##
                        #.##...............................................##.#
                       #...##.............................................##...#
                      #.....##...........................................##.....#
                     #.......##.........................................##.......#
                    #.........##.......................................##.........#
                   #...........##.....................................##...........#
                  #.............##...................................##.............#
                 #...............##.................................##...............#
                #.................##...............................##.................#
               #...................##.............................##...................#
              #.....................##...........................##.....................#
             #.......................##.........................##.......................#
            #.........................##.......................##.........................#
           #...........................##.....................##...........................#
          #.............................##...................##.............................#
         #...............................##.................##...............................#
        #.................................##...............##.................................#
       #...................................##.............##...................................#
      #.....................................##...........##.....................................#
     #.......................................##.........##.......................................#
    #.........................................##.......##.........................................#
   #...........................................##.....##...........................................#
  #.............................................##...##.............................................#
 #...............................................##.##...............................................#
print "Sgt. Pepper's Lonely Hearts Club Band",;id=0#print "Sgt. Pepper's Lonely Hearts Club Band",;id=0
print "Yellow Submarine" if id else "(Reprise)"   ##print "Yellow Submarine" if id else "(Reprise)"   #
 #...............................................##.##...............................................#
  #.............................................##...##.............................................#
   #...........................................##.....##...........................................#
    #.........................................##.......##.........................................#
     #.......................................##.........##.......................................#
      #.....................................##...........##.....................................#
       #...................................##.............##...................................#
        #.................................##...............##.................................#
         #...............................##.................##...............................#
          #.............................##...................##.............................#
           #...........................##.....................##...........................#
            #.........................##.......................##.........................#
             #.......................##.........................##.......................#
              #.....................##...........................##.....................#
               #...................##.............................##...................#
                #.................##...............................##.................#
                 #...............##.................................##...............#
                  #.............##...................................##.............#
                   #...........##.....................................##...........#
                    #.........##.......................................##.........#
                     #.......##.........................................##.......#
                      #.....##...........................................##.....#
                       #...##.............................................##...#
                        #.##...............................................##.#
                         #print "Sgt. Pepper's Lonely Hearts Club Band",;id=0#

Ouais, eh bien ... Python.

Les commentaires Python commencent par #, donc la majorité des lignes ne sont que des commentaires. Pour le triangle orienté vers le haut, la seule chose qui s'exécute est

print "Sgt. Pepper's Lonely Hearts Club Band",;id=0

qui imprime Sgt. Pepper's Lonely Hearts Club Band.

Pour le triangle orienté vers le bas, nous exécutons

print "Yellow Submarine" if id else "(Reprise)"

qui imprime Yellow Submarine, puisque la fonction idest véridique.

Cependant, lorsque nous combinons les programmes, tout ce qui se passe est les deux lignes ci-dessus dans l'ordre. Depuis la fin des premiers jeux de lignes id=0, ce qui est désormais faux, le résultat final est que nous plaquons un (Reprise)à la fin, obtenant Sgt. Pepper's Lonely Hearts Club Band (Reprise)comme sortie (Calvin a dit que c'était correct ).

Sp3000
la source
15
Cela me fait penser à la Marche Impériale plus qu'à n'importe quelle chanson des Beatles ...
Calvin's Hobbies
6
Je peux entendre l'effet sonore du chasseur TIE juste en voyant cette forme
Fatalize
@ Calvin'sHobbies Hahaha. Effectivement!
Luis Mendo
17

Bonhomme de neige 1.0.2 , largeur = 13

      }?}///////////}
     ///"Get Back"////
    ///////////////////
   /////////////////////
  "Sun King//"[["Sun King
 "*"BirthdaysP/"*"Birthday
"]]8AaLsP[[///"]]8AaLsP[[//
?}///////////}?}///////////
 "Get Back"////"Get Back"/
  ///////////////////////
   /////////////////////
    //"[["Sun King//"[[
     sP/"*"BirthdaysP/
      /"]]8AaLsP[[///

Finalement! Un défi où Snowman peut prospérer! : D: D

Les barres obliques sont principalement à des fins esthétiques, et la majorité d'entre elles peuvent être remplacées par des espaces (mais cela donnerait un aspect beaucoup plus ennuyeux). Quelques barres obliques sont nécessaires, pour les commentaires.

Programme A (sortie:) Birthday:

      }
     ///
    /////
   ///////
  "Sun King
 "*"Birthday
"]]8AaLsP[[//

Celui-ci est assez simple. Le premier caractère ( }) configure nos variables actives, puis il y a un tas de commentaires / pas d'opérations. Il stocke ensuite la chaîne "Sun King\n "et la rejette immédiatement (via *, en la stockant dans un permavar que nous n'utilisons jamais). Ensuite, il stocke "Birthday\n".

]]est un no-op ici, car il [[ foo ]]s'agit d'un commentaire de bloc dans Snowman, mais puisqu'il n'y a pas de correspondance [[avant cela ]](dans le programme A lui-même), il ne fait tout simplement rien. 8AaLSaisit ensuite les 8 premiers caractères de la chaîne, l' sPimprime et [[commente le reste du programme (car encore une fois, il n'y a pas de correspondance ]].

Programme B (sortie:) Get Back:

?}///////////
 "Get Back"/
  /////////
   ///////
    //"[[
     sP/
      /

Celui-ci est également assez simple. ?}est équivalent à }( ?définit simplement toutes les variables sur inactives, ce qui est un no-op ici mais encore une fois, important plus tard). Ensuite, il stocke la chaîne "Get Back", fait un tas de no-ops ( //jusqu'à la fin de la ligne est toujours un commentaire) et imprime via sP.

Programme complet

La sortie est, vous l'aurez deviné, Sun King1 .

Regardons cette ligne par ligne:

  • Ligne 1

          }?}///////////}

    Cela définit nos variables actives, tout comme les programmes précédents (nous pouvons voir maintenant que le ?est nécessaire afin de ne pas simplement les activer puis les désactiver }}). Le reste de la ligne est commenté.

  • Lignes 2-4

         ///"Get Back"////
    ///////////////////
   /////////////////////

    Commentaires...

  • Ligne 5

      "Sun King//"[["Sun King

    Ici, nous stockons la chaîne "Sun King//", puis commençons un commentaire de bloc. Cela saute essentiellement tout jusqu'au prochain ]].

  • Ligne 6

     "*"BirthdaysP/"*"Birthday

    Toujours dans le commentaire de bloc ...

  • Ligne 7

    "]]8AaLsP[[///"]]8AaLsP[[//

    Ici, nous séparons le commentaire de bloc pendant une courte période de temps, pour exécuter le code 8AaLsP. Ceci est en fait réutilisé à partir du programme A. Comme j'ai choisi toutes les chansons de 8 lettres, je peux simplement utiliser le même code pour le programme combiné.

    Ensuite, cela devient un peu délicat. La prochaine fois que nous sortirons du commentaire de bloc, nous 8AaLsPreverrons. Cette fois, cependant, toutes les variables ne sont pas définies (nous avons appelé sp, print, en mode consommation, ce qui supprime les variables). Puisque aalrequiert deux arguments, et cette fois il n'en a qu'un ( 8), il fait une erreur et laisse les variables inchangées.

    De même, sprencontre le 8, se rend compte que c'est le mauvais type à imprimer et laisse les variables telles quelles.

  • Lignes 8-13

    ?}///////////}?}///////////
 "Get Back"////"Get Back"/
  ///////////////////////
   /////////////////////
    //"[["Sun King//"[[
     sP/"*"BirthdaysP/

    Toujours coincé dans ce commentaire de bloc ...

  • Ligne 14

          /"]]8AaLsP[[///

    Enfin, nous essayons d'appeler à nouveau la même séquence print-first-8-chars, et elle échoue à nouveau, produisant deux autres erreurs. ( 8Cela signifie que les variables sont maintenant 8 8, ce qui est le nombre correct de variables pour l' aalinstant, mais toujours pas les bons types.)

1: ainsi que quatre erreurs d'exécution SnowmanExceptionsur STDERR, mais selon la méta, cela n'a pas d'importance .

Poignée de porte
la source
The slashes are mostly for aesthetic purposes, and the majority of them can be replaced with spaces (but that would make it look a whole lot more boring)Mais cela rend un peu plus difficile de comprendre ce qui se passe ...
curiousdannii
14

> <> , largeur = 11

     /"yadhtri"\ /
           v"B"/   
        ?!;>ol      
  duJ yeH" /"eduJ yeH
 o   >l?!;   o   >l?!;
staC"/"klaw staC"/"klaw
"yadhtri"\ /"yadhtri"\ 
     v"B"/       v"B"/
  ?!;>ol      ?!;>ol 
   " /"eduJ yeH" /"e
       o   >l?!;   
      staC"/"klaw

Les langages 2D passent un bon moment avec ce défi.

Flèche vers le haut

     /


  duJ yeH
 o   >l?!;
staC"/"klaw

Le déroulement du programme commence en haut à gauche et se déplace vers la droite. Le /reflet monte, et puisque> <> est toroïdal, nous réapparaissons par le bas. Nous en frappons ensuite un autre /et réfléchissons à nouveau, et poussons les caractères klawstaCun par un vers la pile en ""mode chaîne . Enfin, nous réfléchissons vers le haut et frappons une >l?!;oboucle, ce qui est la façon idiomatique d'imprimer la pile entière dans> <>.

Cela imprime Catswalk.

Flèche vers le bas

"yadhtri"\ 
     v"B"/
  ?!;>ol 
   " /"e

Fondamentalement, la même chose, en poussant les personnages dès le départ et en utilisant des miroirs et des flèches pour diriger le flux du programme. Cela imprime Birthday.

Combiné

     /

  ?!;>ol      ?!;>ol 
     /"eduJ yeH" /

Les parties pertinentes sont au-dessus (j'ai coupé beaucoup de lignes au milieu). En utilisant la /flèche vers le haut, nous réfléchissons vers le haut et nous enroulons autour, mais comme nous avons maintenant la flèche vers le bas en dessous, une partie de ce code est exécutée à la place. Nous poussons ensuite les caractères appropriés dans la pile et réutilisons la boucle de sortie à partir de la flèche vers le bas.

Cela imprime Hey Jude.

Sp3000
la source
5

Python 2, taille 21

Ce programme nécessite un terminal compatible ANSI (DOS ANSI.SYS pour être spécifique), car j'utilise \x1b[2Jpour effacer la console ET déplacer le curseur en haut à gauche. Pour le rendre compatible avec d'autres terminaux ANSI, imprimez \x1b[1J\x1b[H(cela peut toujours tenir dans un hexagone de taille 21). Je n'ai pas pu tester cette partie, car je n'ai pas de terminal qui imprime les codes d'échappement ANSI.

Je pense que le programme a l'air plutôt cool, similaire au symbole radioactif (bien que l'ombrage ASCII implique que les couleurs sont à l'envers) ou à l'icône de l'arme de tireur d'élite de Metroid Prime: Hunters.

Il a fait en forme de la taille 17, mais je l' avais oublié id=0dans la flèche. Je ne pense pas que je puisse le réduire, car cela doit être sur une seule ligne ...

En outre, le crédit revient à Sp3000 pour l'idée à utiliser id.

          #exec('print"'       ##
         ###'\x1b[2J"+(id '   ####
        #####'and"Hey Ju'    ######
       #######'de"or"Ca'    ########
      #########'tswalk'    ##########
     ###########'")')     ############
    ##############       ##############
   ################     ################
  ##################   ##################
 #################### ####################
id=0;print"Birthday"##id=0;print"Birthday"#
exec('print"'       ##exec('print"'       #
 '\x1b[2J"+(id '   ####'\x1b[2J"+(id '   #
  'and"Hey Ju'    ######'and"Hey Ju'    #
   'de"or"Ca'    ########'de"or"Ca'    #
    'tswalk'    ##########'tswalk'    #
     '")')     ############'")')     #
      #       ###############       #
       #     #################     #
        #   ###################   #
         # ##################### #
          #id=0;print"Birthday"##

Flèche vers le haut:

          #
         ###
        #####
       #######
      #########
     ###########
    #############
   ###############
  #################
 ###################
id=0;print"Birthday",

Flèche vers le bas:

exec('print"'       #
 '\x1b[2J"+(id '   #
  'and"Hey Ju'    #
   'de"or"Ca'    #
    'tswalk'    #
     '")')     #
      #       #
       #     #
        #   #
         # #
          #

"Hey Jude" est l'une de mes chansons préférées des Beatles, mais je n'en connais vraiment pas beaucoup. Je n'ai jamais entendu les deux autres chansons que j'utilise. Ce n'est pas un genre que j'écoute souvent.

mbomb007
la source
1
1. \x1b[2Jfonctionne uniquement avec ANSI.SYS; il ne devrait rien faire dans d'autres terminaux. Attend également \x1b[;Hun entier après le point-virgule. Pour rendre la ligne et la colonne par défaut à 1, utilisez \x1b[H. 2. \x1b[1J\x1b[Het \x1b[H\x1b[Jdevrait fonctionner sur tous les terminaux ANSI. 3. Sur les terminaux Linux, vous pouvez simplement utiliser \x1bcpour réinitialiser le terminal. 4. \x1bpeut être remplacé par un octet ESC littéral, au cas où cela aiderait à améliorer votre score.
Dennis
@Dennis Merci d'avoir clarifié cela. Je ne pourrai toujours pas améliorer mon score, car je n'arrive pas à trouver un moyen de diviser le code de la flèche vers le haut sur plusieurs lignes.
mbomb007
2

C (gcc) , largeur de base = 17

Haut, "Hey Jude"

        s
       ;//
      s;///
     main(//
    ){puts(//
   #define T//
  s?"Michell"//
 "e":"Hey Jud"//
"e");}///////////

Essayez-le en ligne!

En bas, "Matchbox"

s=1;/////////////
 #ifndef T//////
  main(){puts//
   ("Matchb"//
    "ox");}//
     # endif
      /////
       //\
        ;

Essayez-le en ligne!

Hexagone, "Michelle"

        ss=1;/////////////s
       ;//#ifndef T//////;//
      s;///main(){puts//s;///
     main(//("Matchb"//main(//
    ){puts(//"ox");}//){puts(//
   #define T//# endif#define T//
  s?"Michell"///////s?"Michell"//
 "e":"Hey Jud"////\"e":"Hey Jud"//
"e");}///////////;"e");}///////////
s=1;/////////////ss=1;/////////////
 #ifndef T//////;//#ifndef T//////
  main(){puts//s;///main(){puts//
   ("Matchb"//main(//("Matchb"//
    "ox");}//){puts(//"ox");}//
     # endif#define T//# endif
      /////s?"Michell"///////
       //\"e":"Hey Jud"////\
        ;"e");}///////////;

Essayez-le en ligne!

gastropner
la source
1

gawk, longueur de base 15

Je viens de découvrir que cela ne fonctionne pas avec mawk : /

Ce n'est pas trop compliqué, mais ayant grandi dans les années 70, avec les Beatles toujours omniprésents à l'antenne, j'ai dû répondre à cela. D'abord, je pensais que awk n'était pas adapté, mais ensuite il m'est venu.

Étant donné que ces scripts contiennent des blocs BEGIN et / ou END, il faut leur dire qu'il n'y aura pas d'entrée pour exécuter le bloc END. Ceci peut être réalisé soit en appuyant sur Ctrl-D après les avoir démarrés, soit en les démarrant comme ceci:

awk -f script.awk </dev/null

ce qui je pense est plus pratique. echo | awk -f script.awkfonctionnera également, mais si j'avais utilisé une ligne vide en entrée, j'aurais fait cela complètement différent.

Pointant vers le haut, imprime pour personne (lien Youtube)

       #
      # #
     #   #
    BEGIN {
   print n?#
  #         #
 n"So Tired":#
n="For No One"}

Le code essentiel sans commentaires est le suivant. Comme il nn'est pas défini, il affiche "For No One" s'il est appelé par lui-même.

    BEGIN {
   print n?

 n"So Tired":
n="For No One"}

Pointant vers le bas, imprime Blackbird

END{a="Blackb"#
 a=n?_:a"ird"#
  printf a  #
   n="I'm "#
    if(a) #
     print
      } #
       #

Le code essentiel est le suivant. Si a nété défini avant, il n'imprime rien. J'ai appliqué la sortie sympa avec une nouvelle ligne après chaque nom de piste, car j'avais la place pour le faire et ça a l'air plus agréable dans la console. nest défini dans le processus; ce qui est nécessaire pour l'Hexagone.

END{a="Blackb"
 a=n?_:a"ird"
  printf a
   n="I'm "
    if(a)
     print
      }

Hexagone, imprime Je suis tellement fatigué

       #END{a="Blackb"##
      # #a=n?_:a"ird"## #
     #   #printf a  ##   #
    BEGIN {n="I'm "#BEGIN {
   print n?#if(a) #print n?#
  #         #print#         #
 n"So Tired":#} #n"So Tired":#
n="For No One"}#n="For No One"}
END{a="Blackb"##END{a="Blackb"#
 a=n?_:a"ird"## #a=n?_:a"ird"#
  printf a  ##   #printf a  #
   n="I'm "#BEGIN {n="I'm "#
    if(a) #print n?#if(a) #
     print#         #print
      } #n"So Tired":#} #
       #n="For No One"}#

Le code essentiel. Maintenant, enfin, ce mystérieux nest utilisé. Parce que nest défini dans la première ligne, le triangle pointant vers le haut imprime la sortie alternative et le triangle pointant vers le bas imprime le vide.

    BEGIN {n="I'm "
   print n?

 n"So Tired":
n="For No One"}
END{a="Blackb"
 a=n?_:a"ird"
  printf a  
   n="I'm "
    if(a) 
     print
      }
Cabbie407
la source