Escriba dos programas en forma de triángulo (es decir, pirámide).

El primero debe ser un triángulo de texto apuntando hacia arriba con un ancho base mínimo de tres caracteres. Entonces tendría una estructura como

 X
XXX

o

  X
 XXX
XXXXX

o

   X
  XXX
 XXXXX
XXXXXXX

o más grande Cada uno de los X's debe ser reemplazado con los caracteres de su código real, que puede ser cualquier cosa excepto terminadores de línea (por lo que los X' s podrían ser espacios). Todos los X's deben ser reemplazados y los espacios y líneas nuevas que ayudan a formar la forma del triángulo deben permanecer tal como están.

El segundo programa debe tener el mismo tamaño y forma que el primero, excepto que el triángulo apuntará hacia abajo.

Entonces, si su primer programa se ve así

  X
 XXX
XXXXX

entonces su segundo programa se vería así

yyyyy
 yyy
  y

donde cada uno yes un carácter que debe completar con su código real (probablemente diferente de su Xcódigo). Los espacios y las nuevas líneas deben permanecer igual aquí también.

Su tarea es escribir estos programas de modo que cada uno produzca (para stdout o la alternativa más cercana) el título de una canción distinta de los Beatles , sin tomar ninguna entrada. Este artículo de Wikipedia servirá como nuestra lista oficial de canciones para The Beatles. El resultado debe ser uno de los títulos exactamente como se enumeran, por ejemplo I Want You (She's So Heavy).

Sin embargo, esto es bastante fácil, incluso con el extraño requisito del programa de triángulos. Así que vamos a formar otro programa de los dos primeros que debe generar otro título de canción.

Al combinar tres copias de cada uno de los dos programas triangulares, podemos crear un tercer programa con forma de hexágono.

Si el ancho base de su primer programa fuera tres, se vería así:

 XyyyX
XXXyXXX
yyyXyyy
 yXXXy

Si el ancho de la base fuera cinco, se vería así:

  XyyyyyX
 XXXyyyXXX
XXXXXyXXXXX
yyyyyXyyyyy
 yyyXXXyyy
  yXXXXXy

Este programa (cuando se ejecuta con espacios y líneas nuevas como los demás) debe generar otro título de canción de los Beatles, al igual que los dos primeros programas. También:

• Sus tres programas deben emitir diferentes títulos de canciones.
• Solo se permiten títulos de canciones de ocho caracteres de longitud o más.
• Solo puedes elegir uno de Revolution, Revolution 1y Revolution 9porque los títulos son muy similares.
• Debes elegir tus tres canciones favoritas de los Beatles. (Bueno, intenta hacerlo)

Tenga en cuenta que se requieren programas reales. Las funciones no están permitidas. Tampoco está permitido leer su propio código fuente en ningún programa.

Ejemplo

Si tu primer programa fue

  A
 AAA
AAAAA

podría salir Across the Universe.

Entonces tu segundo programa

bbbbb
 bbb
  b

podría salir Revolution.

Luego combinado en el programa hexagonal

  AbbbbbA
 AAAbbbAAA
AAAAAbAAAAA
bbbbbAbbbbb
 bbbAAAbbb
  bAAAAAb

la salida puede ser Get Back.

Tanteo

La presentación con el ancho base más pequeño del triángulo gana. En el caso probable de empates, la presentación con la mayor longitud sumada de sus tres títulos de canciones gana.

GolfScript, ancho = 9 caracteres, títulos = 33 caracteres

Hexágono

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

Impresiones Let It Be . (9 caracteres)

Pruébalo en línea.

Cómo funciona

El token "Let It Be"en la primera línea empuja la cadena Let It Be en la pila.

La segunda línea comienza con }un "super comentario" indocumentado que anula la ejecución de inmediato.

Antes de salir, GolfScript imprime el contenido de la pila.

Triángulo X

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

Imprime Twist and Shout . (15 caracteres)

Pruébalo en línea.

Cómo funciona

Las dos primeras líneas empujan la cadena "\n }", que el comando ;descarta de la pila.

Las líneas restantes contienen las fichas "Twi", "st an"y "d Shout", que empujan la cadena de torsión y grito en tres piezas.

Antes de salir, GolfScript imprime el contenido de la pila.

Triángulo Y

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

Impresiones de ayer . (9 caracteres)

Pruébalo en línea.

Cómo funciona

Los tokens Let, Ity Been la primera línea no están definidos, por lo que no hacen nada.

Las tres líneas siguientes contienen las fichas "Yeste", "rda"y "y", que empujan la cadena de ayer en tres pedazos.

El }en la última línea no hace nada; el programa habría terminado de todos modos.

Una vez más, GolfScript imprime el contenido de la pila antes de salir.

Befunge -93, ancho = 13 15 , títulos = 31 24 caracteres

Un corte de energía anoche me impidió actualizar esto cuando lo descubrí, ¡pero logré reducir el ancho del triángulo y aumentar la duración de la canción!

Programa de señalamiento: "Dig a Pony", 10 caracteres:

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

Explicación

REALMENTE aproveché el truco envolvente de Befunge y elegí "Dig a Pony" específicamente porque tenía un espacio en la sexta posición. Esto permite que el flujo del programa se mueva a través del nombre de la canción. Pruébelo en el intérprete en línea para ver cómo funciona.

Programa apuntando hacia abajo: "If I Fell", 9 caracteres:

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


       .

(El período es extraño y solo se incluye para que aparezcan las otras líneas).

Explicación

Las únicas líneas relevantes aquí son las dos primeras. Utilicé el truco envolvente (el puntero de instrucciones se envía a la izquierda de inmediato) para introducir un carácter más. La segunda línea imprime el nombre de la canción.

Combinado: "Drive My Car", 12 caracteres:

      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 

Esto es lo mismo, pero con líneas agregadas para mostrar el hexágono y los triángulos.

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

Explicación

Aquí es donde entran en juego las líneas tercera y cuarta del triángulo apuntando hacia abajo. Hay varios redireccionamientos en el borde de ambos triángulos que sirven para mover el puntero de instrucciones a través de esas dos líneas y empujar "Conducir mi auto" en la pila. Luego se imprime usando la >:#,_@broca en el triángulo apuntando hacia arriba. Por cierto, se utilizan los triángulos apuntando hacia arriba a la izquierda y a la derecha.

No podría ser una manera de utilizar más del espacio vacío, pero creo que mi tiempo es mejor gastado en otras cuestiones. :PAGS

Python 2, ancho = 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í, bueno ... Python.

Los comentarios de Python comienzan con #, por lo que la mayoría de las líneas son solo comentarios. Para el triángulo que mira hacia arriba, lo único que se ejecuta es

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

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

Para el triángulo que mira hacia abajo, ejecutamos

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

que imprime Yellow Submarine, ya que la función ides verdadera.

Sin embargo, cuando combinamos los programas, todo lo que sucede son las dos líneas anteriores en secuencia. Dado que el final de la primera línea se establece id=0, lo que ahora es falso, el resultado final es que añadimos (Reprise)a al final, obteniendo Sgt. Pepper's Lonely Hearts Club Band (Reprise)como salida (Calvin dijo que esto está bien ).

Muñeco de nieve 1.0.2 , ancho = 13

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

¡Finalmente! ¡Un desafío donde Snowman puede prosperar! : D: D

Las barras son principalmente para fines estéticos, y la mayoría de ellas se pueden reemplazar con espacios (pero eso haría que parezca mucho más aburrido). Algunas barras son necesarias, para comentarios.

Programa A (salida:) Birthday:

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

Este es bastante simple. El primer carácter ( }) configura nuestras variables activas, luego hay un montón de comentarios / no-ops. Luego almacena la cadena "Sun King\n "e inmediatamente la descarta (a través de *, almacenándola en un permavar que nunca usamos). Luego se almacena "Birthday\n".

]]es un no-op aquí, ya que [[ foo ]]es un comentario de bloque en Snowman, pero dado que no hay coincidencia [[antes de esto ]](dentro del programa A), simplemente no hace nada. Luego 8AaLtoma los primeros 8 caracteres de la cadena, lo sPimprime y [[comenta el resto del programa (porque, de nuevo, no hay coincidencia ]].

Programa B (salida:) Get Back:

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

Este también es bastante sencillo. ?}es equivalente a }( ?simplemente establece todas las variables como inactivas, lo cual es un no-op aquí pero nuevamente, importante más adelante). Luego almacena la cadena "Get Back", hace un montón de no-ops ( //hasta el final de la línea siempre es un comentario) e imprime a través de sP.

Programa completo

La salida es, lo has adivinado, Sun King¹ .

Veamos esta línea por línea:

• Línea 1

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

  Esto establece nuestras variables activas, al igual que los programas anteriores (podemos ver ahora que ?se necesita para no simplemente activarlas y luego desactivarlas }}). El resto de la línea está comentada.

• Líneas 2-4

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

  Comentarios ...

• Línea 5

    "Sun King//"[["Sun King
  

  Aquí almacenamos la cadena "Sun King//"y luego iniciamos un comentario de bloque. Esto esencialmente omite todo hasta el siguiente ]].

• Linea 6

   "*"BirthdaysP/"*"Birthday
  

  Todavía dentro del comentario de bloque ...

• Línea 7

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

  Aquí salimos del comentario del bloque por un corto período de tiempo, para ejecutar el código 8AaLsP. En realidad, esto se reutiliza del programa A. Como elegí todas las canciones que tienen 8 letras, simplemente puedo usar el mismo código para el programa combinado.

  Entonces se pone un poco complicado. La próxima vez que salgamos del comentario del bloque, volveremos a ver 8AaLsP. Esta vez, sin embargo, todas las variables están indefinidas (llamamos sp, imprimir, en modo consumo, lo que elimina las variables). Como aalrequiere dos argumentos, y esta vez solo tiene uno ( 8), produce errores y deja las variables sin cambios.

  Del mismo modo, spencuentra el 8, se da cuenta de que es el tipo incorrecto para imprimir y deja las variables como están.

• Lineas 8-13

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

  Todavía atrapado en ese comentario de bloque ...

• Línea 14

        /"]]8AaLsP[[///
  

  Finalmente, intentamos llamar a la misma secuencia print-first-8-chars una vez más, y falla una vez más, produciendo otros dos errores. ( 8Significa que las variables son ahora 8 8, que es el número correcto de variables por aalahora, pero aún no son los tipos correctos).

^{1: así como cuatro errores de tiempo de ejecución SnowmanExceptiona STDERR, pero según el meta eso no importa .}

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

Los lenguajes 2D lo pasan muy bien con este desafío.

Flecha hacia arriba

     /


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

El flujo del programa comienza desde la parte superior izquierda, moviéndose hacia la derecha. El se /refleja hacia arriba, y como> <> es toroidal, reaparecemos desde abajo. Luego golpeamos a otro /y reflexionamos nuevamente, y empujamos los caracteres klawstaCuno por uno a la pila en ""modo cadena . Finalmente, reflexionamos hacia arriba y tocamos un >l?!;obucle, que es la forma idiomática de imprimir toda la pila en> <>.

Esto imprime Catswalk.

Flecha hacia abajo

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

Básicamente lo mismo, empujar a los personajes desde el principio y usar espejos y flechas para dirigir el flujo del programa. Esto imprime Birthday.

Conjunto

     /

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

Las partes relevantes están arriba (he cortado muchas líneas en el medio). Usando la /flecha hacia arriba, reflexionamos hacia arriba y nos envolvemos, pero como ahora tenemos la flecha hacia abajo debajo, parte de ese código se ejecuta en su lugar. Luego empujamos los caracteres relevantes a la pila y reutilizamos el bucle de salida desde la flecha hacia abajo.

Esto imprime Hey Jude.

Python 2, talla 21

Este programa requiere un terminal compatible con ANSI (DOS ANSI.SYS para ser específico), ya que uso \x1b[2Jpara borrar la consola Y muevo el cursor a la esquina superior izquierda. Para que esto sea compatible con otros terminales ANSI, imprima \x1b[1J\x1b[H(todavía puede caber en un hexágono de tamaño 21). No pude probar esta parte, porque no tengo un terminal que imprima códigos de escape ANSI.

Creo que el programa se ve muy bien, similar al símbolo radiactivo (aunque el sombreado ASCII implica que los colores están al revés) o el ícono del arma de francotirador de Metroid Prime: Hunters.

Se hizo ajuste de tamaño 17, pero me había olvidado id=0en la flecha hacia arriba. No creo que pueda reducirlo, ya que todo tiene que estar en una línea ...

Además, el crédito va a Sp3000 por la idea de usar 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"##

Flecha hacia arriba:

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

Flecha hacia abajo:

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

"Hey Jude" es una de mis canciones favoritas de los Beatles, pero realmente no sé muchas. Nunca he escuchado las otras dos canciones que estoy usando. No es un género que escucho a menudo.

C (gcc) , ancho base = 17

Arriba, "Hola Jude"

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

Pruébalo en línea!

Abajo, "Caja de fósforos"

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

Pruébalo en línea!

Hexágono, "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");}///////////;

Pruébalo en línea!

gawk, longitud base 15

Me acabo de enterar que no funciona con mawk : /

No es demasiado complicado, pero como crecí en los años 70, con The Beatles todavía omnipresente en el aire, tuve que responder a esto. Primero pensé que awk no era adecuado, pero luego se me ocurrió.

Dado que estos scripts contienen bloques BEGIN y / o END, se les debe decir que no habrá entrada para ejecutar el bloque END. Esto se puede lograr presionando Ctrl-D después de iniciarlos o iniciando de esta manera:

awk -f script.awk </dev/null

lo cual creo que es más conveniente. echo | awk -f script.awktambién funcionará, pero si hubiera usado una línea vacía como entrada, habría hecho esto completamente diferente.

Hacia arriba, impresiones para nadie (enlace de Youtube)

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

El código esencial sin comentarios es este. Como nno está definido, imprime "Para nadie" si se llama solo.

    BEGIN {
   print n?

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

Apuntando hacia abajo, imprime Mirlo

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

El código esencial es este. Si nse definió antes, no imprime nada. Hice cumplir la buena salida con una nueva línea después de cada nombre de pista, porque tenía espacio para hacerlo y se ve mejor en la consola. nse define en el proceso; eso es necesario para el hexágono.

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

Hexágono, impresiones Estoy tan cansado

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

El código esencial Ahora finalmente nse usa ese misterioso . Como nse define en la primera línea, el triángulo que apunta hacia arriba imprime la salida alternativa y el triángulo que apunta hacia abajo imprime el vacío.

    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
      }