Canzoni dei Beatles ed esagoni

30

Scrivi due programmi triangolari (cioè piramidali).

Il primo dovrebbe essere un triangolo di testo rivolto verso l'alto con una larghezza di base minima di tre caratteri. Quindi avrebbe una struttura simile

 X
XXX

o

  X
 XXX
XXXXX

o

   X
  XXX
 XXXXX
XXXXXXX

o più grande. Ognuno di questi Xdeve essere sostituito con i caratteri del tuo codice reale, che può essere qualsiasi cosa tranne i terminatori di riga (quindi gli Xspazi potrebbero essere spazi). Tutti gli elementi Xdevono essere sostituiti e gli spazi e le nuove linee che aiutano a formare la forma triangolare devono rimanere così come sono.

Il secondo programma deve avere le stesse dimensioni e forma del primo, tranne per il fatto che il triangolo sarà rivolto verso il basso.

Quindi, se il tuo primo programma sembra

  X
 XXX
XXXXX

allora il tuo secondo programma sarebbe simile

yyyyy
 yyy
  y

dove ognuno yè un personaggio che devi inserire con il tuo codice reale (probabilmente diverso dal tuo Xcodice). Gli spazi e le nuove linee devono rimanere uguali anche qui.

Il tuo compito è quello di scrivere questi programmi in modo tale che ogni uscita (allo stdout o all'alternativa più vicina) il titolo di una distinta canzone dei Beatles , senza prendere alcun input. Questo articolo di Wikipedia servirà come la nostra lista di canzoni ufficiale per i Beatles. L'output dovrebbe essere uno dei titoli esattamente come elencato, ad es I Want You (She's So Heavy).

Questo è abbastanza facile, tuttavia, anche con il requisito del programma triangolo strano. Quindi formeremo un altro programma dai primi due che deve produrre un altro titolo della canzone.

Combinando tre copie di ciascuno dei due programmi triangolari possiamo creare un terzo programma a forma di esagono.

Se la larghezza di base del tuo primo programma fosse tre sarebbe simile a questa:

 XyyyX
XXXyXXX
yyyXyyy
 yXXXy

Se la larghezza della base fosse cinque sarebbe simile a questa:

  XyyyyyX
 XXXyyyXXX
XXXXXyXXXXX
yyyyyXyyyyy
 yyyXXXyyy
  yXXXXXy

Questo programma (quando eseguito con spazi e newline come gli altri) deve produrre un altro titolo di canzone dei Beatles, proprio come i primi due programmi. Anche:

  • I tuoi tre programmi devono produrre titoli di brani diversi.
  • Sono ammessi solo titoli di brani di lunghezza pari o superiore a otto caratteri.
  • È possibile scegliere solo uno dei Revolution, Revolution 1e Revolution 9perché i titoli sono così simili.
  • Devi scegliere le tue tre canzoni dei Beatles preferite. (Beh, prova a farlo.)

Si noti che sono richiesti programmi effettivi. Le funzioni non sono consentite. Anche la lettura del proprio codice sorgente in qualsiasi programma non è consentita.

Esempio

Se il tuo primo programma fosse

  A
 AAA
AAAAA

potrebbe emettere Across the Universe.

Quindi il tuo secondo programma

bbbbb
 bbb
  b

potrebbe produrre Revolution.

Quindi combinato nel programma esagonale

  AbbbbbA
 AAAbbbAAA
AAAAAbAAAAA
bbbbbAbbbbb
 bbbAAAbbb
  bAAAAAb

l'output potrebbe essere Get Back.

punteggio

Vince l'invio con la larghezza di base del triangolo più piccola. Nel probabile caso di vincite vince l'invio con la lunghezza sommata maggiore dei suoi tre titoli di brani.

code-challenge  geometry  source-layout 
— Hobby di Calvin
fonte
2
Sicuramente il tiebreaker dovrebbe essere la scelta migliore tra tre canzoni? ;)
— Doug McClean,
1
Ho difficoltà a scrivere una voce in Python senza semplicemente copiare il metodo di Sp3000 (non avrei mai pensato che mi sarei lamentato dello spazio sintattico!), Ma ho scritto una sceneggiatura per assemblare due triangoli in un esagono. Nel caso in cui sia utile a chiunque altro, eccolo qui in un Gist .
— Tim Pederick,
@ mbomb007 Gli spazi finali che non fanno parte del motivo a triangolo non sono ok.
— Calvin's Hobbies,
@TimPederick Dato che non riuscivo a far funzionare il tuo esagono-ifier, ho scritto uno script Python per farlo iniziando con 2 stringhe multilinea. Vedi qui se qualcuno vuole usarlo.
— mbomb007,
@ mbomb007 Siamo spiacenti ma non è consentito uno spazio finale poiché non fa parte del titolo. (Consentirei una nuova riga finale poiché molte dichiarazioni stampate ne aggiungono una.) Non sono sicuro della solita politica di backspace ma sono d'accordo con me.
— Calvin's Hobbies,

Risposte:

18

GolfScript, larghezza = 9 caratteri, titoli = 33 caratteri

Esagono

    "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"}

Stampe Let It Be . (9 caratteri)

Provalo online.

Come funziona

Il token "Let It Be"sulla prima riga spinge la stringa Let It Be nello stack.

La seconda riga inizia con }un "super commento" non documentato che interrompe immediatamente l'esecuzione.

Prima di uscire, GolfScript stampa il contenuto dello stack.

Triangolo X.

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

Stampa Twist and Shout . (15 caratteri)

Provalo online.

Come funziona

Le prime due righe spingono la stringa "\n }", che il comando ;scarta dallo stack.

Le linee rimanenti contengono i token "Twi", "st an"e "d Shout"che spingono la stringa Twist and Shout in tre pezzi.

Prima di uscire, GolfScript stampa il contenuto dello stack.

Triangolo Y.

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

Stampa ieri . (9 caratteri)

Provalo online.

Come funziona

I gettoni Let, Ite Besulla prima riga non sono definiti, in modo da non fanno nulla.

I seguenti tre righe contengono i token "Yeste", "rda"e "y"che spingono la stringa ieri in tre pezzi.

L' }ultima riga non fa nulla; il programma sarebbe comunque terminato.

Ancora una volta, GolfScript stampa il contenuto dello stack prima di uscire.

— Dennis
fonte
21

Befunge -93, larghezza = 13 15 , titoli = 31 24 caratteri

Un'interruzione di corrente la scorsa notte mi ha impedito di aggiornarlo quando l'ho capito, ma sono riuscito a ridurre la larghezza del triangolo e aumentare la lunghezza della canzone!

Programma di puntamento: "Dig a Pony", 10 caratteri:

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

Spiegazione

Ho davvero approfittato del trucco avvolgente di Befunge e ho scelto "Dig a Pony" proprio perché aveva uno spazio in sesta posizione. Ciò consente al flusso di programma di spostarsi attraverso il nome del brano. Provalo nell'interprete online per vedere come funziona.

Programma verso il basso: "If I Fell", 9 caratteri:

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


       .

(Il periodo è estraneo e incluso solo per mostrare le altre linee.)

Spiegazione

Le uniche righe rilevanti qui sono le prime due. Ho usato il trucco avvolgente (il puntatore dell'istruzione viene inviato immediatamente a sinistra) per spremere un altro personaggio. La seconda riga stampa il nome della canzone.

Combinato: "Drive My Car", 12 personaggi:

      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

Ecco la stessa cosa, ma con le linee aggiunte per mostrare l'esagono e i triangoli.

       -----------------
      /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\ /
       -----------------

Spiegazione

Qui entrano in gioco la terza e la quarta riga del triangolo rivolto verso il basso. Ci sono diversi reindirizzamenti sul bordo di entrambi i triangoli che servono a spostare il puntatore delle istruzioni attraverso quelle due linee e spingere "Guida mia macchina" sullo stack. Quindi viene stampato usando la >:#,_@punta nel triangolo rivolto verso l'alto. Per inciso, vengono utilizzati entrambi i triangoli verso l'alto e verso sinistra .

Ci potrebbe essere un modo per utilizzare più dello spazio vuoto, ma penso che il mio tempo è meglio spesi su altre questioni. : P

— El'endia Starman
fonte
Hmm. Le regole di PPCG sono che se un programma funziona in almeno un interprete, allora è valido. Buon posto, comunque.
— El'endia Starman,
Un'altra "regola" di PPCG è che l'interprete definisce la lingua, non le specifiche. Pertanto, il mio codice Befunge è essenzialmente valido.
— El'endia Starman,
18

Python 2, larghezza = 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#

Sì, beh ... Python.

I commenti di Python iniziano con #, quindi la maggior parte delle righe sono solo commenti. Per il triangolo rivolto verso l'alto, l'unica cosa che viene eseguita è

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

quale stampa Sgt. Pepper's Lonely Hearts Club Band.

Per il triangolo rivolto verso il basso, eseguiamo

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

che stampa Yellow Submarine, poiché la funzione idè vera.

Quando combiniamo i programmi, tuttavia, tutto ciò che accade sono le due righe sopra in sequenza. Dalla fine dei primi set di linee id=0, che ora sono falsi, il risultato finale è che ci avviciniamo (Reprise)a alla fine, ottenendo Sgt. Pepper's Lonely Hearts Club Band (Reprise)come risultato (Calvin ha detto che va bene ).

— SP3000
fonte
15
Questo mi fa pensare alla Marcia Imperiale più di qualsiasi canzone dei Beatles ...
— Calvin's Hobbies,
6
Riesco a sentire l'effetto sonoro del TIE-fighter solo vedendo questa forma
— Fatalizza il
@ Calvin'sHobbies Hahaha. Infatti!
— Luis Mendo,
17

Pupazzo di neve 1.0.2 , larghezza = 13

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

Finalmente! Una sfida in cui Snowman può prosperare! : D: D

Le barre sono principalmente per scopi estetici e la maggior parte di esse può essere sostituita da spazi (ma ciò renderebbe il tutto molto più noioso). Sono necessarie alcune barre per i commenti.

Programma A (output:) Birthday:

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

Questo è piuttosto semplice. Il primo carattere ( }) imposta le nostre variabili attive, quindi ci sono un sacco di commenti / no-ops. Quindi memorizza la stringa "Sun King\n "e la scarta immediatamente (tramite *, memorizzandola in un permavar che non usiamo mai). Quindi memorizza "Birthday\n".

]]è una no-op qui, dato che [[ foo ]]è un commento a blocchi in Snowman, ma poiché non c'è corrispondenza [[prima ]](all'interno del programma A stesso), semplicemente non fa nulla. Quindi 8AaLprende i primi 8 caratteri della stringa, la sPstampa e [[commenta il resto del programma (perché, di nuovo, non c'è corrispondenza ]].

Programma B (output:) Get Back:

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

Anche questo è piuttosto semplice. ?}è equivalente a }( ?imposta semplicemente tutte le variabili su inattivo, il che è un no-op qui ma, di nuovo, importante in seguito). Quindi memorizza la stringa "Get Back", esegue una serie di operazioni non consentite ( //alla fine della riga è sempre un commento) e stampa via sP.

Programma completo

L'output è, hai indovinato, Sun King1 .

Diamo un'occhiata a questa riga per riga:

  • Linea 1

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

    Questo imposta le nostre variabili attive, proprio come i programmi precedenti (possiamo vedere ora che ?è necessario in modo da non semplicemente attivarle e quindi ripristinarle con }}). Il resto della riga è commentato.

  • Linee 2-4

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

    Commenti...

  • Linea 5

      "Sun King//"[["Sun King

    Qui memorizziamo la stringa "Sun King//"e quindi iniziamo un commento di blocco. Questo essenzialmente salta tutto fino al prossimo ]].

  • Linea 6

     "*"BirthdaysP/"*"Birthday

    Ancora all'interno del commento del blocco ...

  • Linea 7

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

    Qui usciamo dal commento di blocco per un breve periodo di tempo, per eseguire il codice 8AaLsP. Questo è in realtà riutilizzato dal programma A. Dato che ho scelto tutte le canzoni che sono lunghe 8 lettere, posso semplicemente usare lo stesso codice per il programma combinato.

    Quindi diventa un po 'complicato. La prossima volta che emergiamo dal commento sul blocco, vediamo di 8AaLsPnuovo. Questa volta, tuttavia, tutte le variabili sono indefinite (abbiamo chiamato sp, stampa, in modalità consumo, che elimina le variabili). Dato che aalrichiede due argomenti, e questa volta ha solo uno ( 8), errori e lascia invariate le variabili.

    Allo stesso modo, spincontra il 8, si rende conto che è il tipo sbagliato da stampare e lascia le variabili così come sono.

  • Linee 8-13

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

    Ancora bloccato nel commento di quel blocco ...

  • Linea 14

          /"]]8AaLsP[[///

    Infine, proviamo a richiamare quella stessa sequenza print-first-8-chars ancora una volta, e fallisce ancora una volta, producendo altri due errori. (Ciò 8significa che le variabili sono ora 8 8, che è il numero corretto di variabili per aalora, ma non sono ancora i tipi giusti.)

1: così come quattro errori di runtime SnowmanExceptionsu STDERR, ma secondo meta non importa .

— Maniglia
fonte
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)Ma rende un po 'più difficile capire cosa sta succedendo ...
— curiousdannii,
14

> <> , larghezza = 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

I linguaggi 2D si divertono abbastanza con questa sfida.

Freccia verso l'alto

     /


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

Il flusso del programma inizia da in alto a sinistra, spostandosi verso destra. Il /riflesso verso l'alto e poiché> <> è toroidale riappariamo dal basso. Quindi ne colpiamo un altro /e riflettiamo di nuovo, e spingiamo i personaggi klawstaCuno a uno nello stack in ""modalità stringa . Infine, riflettiamo verso l'alto e colpiamo un >l?!;oloop, che è il modo idiomatico di stampare l'intero stack in> <>.

Questo stampa Catswalk.

Freccia verso il basso

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

Praticamente la stessa cosa, spingendo i personaggi fin dall'inizio e usando specchi e frecce per dirigere il flusso del programma. Questo stampa Birthday.

Combinato

     /

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

Le parti rilevanti sono sopra (ho tagliato molte linee nel mezzo). Usando la /freccia dall'alto verso l'alto, riflettiamo verso l'alto e ci avvolgiamo, ma poiché ora abbiamo la freccia verso il basso sotto, viene invece eseguita parte di quel codice. Spingiamo quindi i caratteri rilevanti nello stack e riutilizziamo il loop di output dalla freccia verso il basso.

Questo stampa Hey Jude.

— SP3000
fonte
5

Python 2, taglia 21

Questo programma richiede un terminale ANSI compatibile (DOS ANSI.SYS per essere specifico), poiché utilizzo \x1b[2Jper cancellare la console E spostare il cursore in alto a sinistra. Per renderlo compatibile con altri terminali ANSI, stampare \x1b[1J\x1b[H(questo può comunque adattarsi a un esagono di dimensione 21). Non sono stato in grado di testare questa parte, perché non ho un terminale che stampa i codici di escape ANSI.

Penso che il programma appaia piuttosto bello, simile al simbolo radioattivo (anche se l'ombreggiatura ASCII implica che i colori sono all'indietro) o l'icona dell'arma da cecchino di Metroid Prime: Hunters.

E ha fatto in forma di dimensioni 17, ma avevo dimenticato id=0nella freccia in su. Non credo di poterlo ridurre, dal momento che deve essere tutto su una linea ...

Inoltre, il credito va a Sp3000 per l'idea da utilizzare 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"##

Freccia in alto:

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

Freccia in giù:

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

"Hey Jude" è una delle mie canzoni dei Beatles preferite, ma non ne conosco molte. Non ho mai sentito le altre due canzoni che sto usando. Non è un genere che ascolto spesso.

— mbomb007
fonte
1
1. \x1b[2Jfunziona solo con ANSI.SYS; non dovrebbe fare nulla in altri terminali. Inoltre, si \x1b[;Haspetta un numero intero dopo il punto e virgola. Per rendere sia la riga che la colonna predefinite su 1, utilizzare \x1b[H. 2. \x1b[1J\x1b[He \x1b[H\x1b[Jdovrebbe funzionare su tutti i terminali ANSI. 3. Sui terminali Linux, è possibile semplicemente utilizzare \x1bcper ripristinare il terminale. 4. \x1bpuò essere sostituito con un byte ESC letterale, nel caso in cui ciò aiuti a migliorare il tuo punteggio.
— Dennis,
@Dennis Grazie per averlo chiarito. Non sarò ancora in grado di migliorare il mio punteggio, dal momento che non riesco a capire un modo per spezzare il codice della freccia su su più righe.
— mbomb007,
2

C (gcc) , larghezza base = 17

In alto, "Hey Jude"

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

Provalo online!

In basso, "Scatola di fiammiferi"

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

Provalo online!

Hexagon, "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");}///////////;

Provalo online!

— gastropner
fonte
1

gawk, lunghezza base 15

Ho appena scoperto che non funziona con mawk : /

Non è troppo complicato, ma essendo cresciuto negli anni '70, con i Beatles ancora onnipresenti in onda, ho dovuto rispondere a questa domanda. Prima ho pensato che Awk non fosse adatto, ma poi è venuto da me.

Poiché questi script contengono blocchi BEGIN e / o END, è necessario dire loro che non ci sarà input per eseguire il blocco END. Ciò può essere ottenuto premendo Ctrl-D dopo averli avviati o avviandoli in questo modo:

awk -f script.awk </dev/null

che penso sia più conveniente. echo | awk -f script.awkfunzionerà anche, ma se avessi usato una riga vuota come input l'avrei fatto completamente diverso.

Puntamento verso l'alto, stampa per nessuno (collegamento Youtube)

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

Il codice essenziale senza commenti è questo. Poiché nnon è definito, stampa "Per nessuno" se chiamato da solo.

    BEGIN {
   print n?

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

Puntando verso il basso, stampa Merlo

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

Il codice essenziale è questo. Se è nstato definito prima, non stampa nulla. Ho imposto l'output piacevole con una nuova riga dopo ogni nome di traccia, perché avevo lo spazio per farlo e sembra più bello nella console. nè definito nel processo; è necessario per l'esagono.

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

Esagono, stampe Sono così stanco

       #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"}#

Il codice essenziale Ora finalmente nviene usato quel misterioso . Poiché nè definito nella prima riga, il triangolo di puntamento verso l'alto stampa l'output alternativo e il triangolo di puntamento verso il basso stampa il vuoto.

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