Escreva dois programas em forma de triângulo (ou seja, pirâmide).

O primeiro deve ser um triângulo de texto apontando para cima, com uma largura base mínima de três caracteres. Então teria uma estrutura como

 X
XXX

ou

  X
 XXX
XXXXX

ou

   X
  XXX
 XXXXX
XXXXXXX

ou maior. Cada um deles Xdeve ser substituído pelos caracteres do seu código real, que pode ser qualquer coisa, exceto terminadores de linha (portanto, os Xespaços podem ser). Todos os Xitens devem ser substituídos e os espaços e as novas linhas que ajudam a formar a forma do triângulo são necessários para permanecer como estão.

O segundo programa deve ter o mesmo tamanho e formato do primeiro, exceto que o triângulo estará apontando para baixo.

Portanto, se seu primeiro programa parecer

  X
 XXX
XXXXX

então seu segundo programa seria semelhante

yyyyy
 yyy
  y

onde cada yum é um caractere, você precisa preencher com seu código real (provavelmente diferente do seu Xcódigo). Os espaços e novas linhas também devem permanecer os mesmos aqui.

Sua tarefa é escrever esses programas de modo que cada um produza (para stdout ou alternativa mais próxima) o título de uma música distinta dos Beatles , sem receber nenhuma entrada. Este artigo da Wikipedia servirá como nossa lista de músicas oficial para os Beatles. A saída deve ser um dos títulos exatamente como listado, por exemplo I Want You (She's So Heavy).

Isso é bastante fácil, no entanto, mesmo com o requisito de programa estranho do triângulo. Então, vamos formar outro programa dos dois primeiros que deve produzir mais um título de música.

Combinando três cópias de cada um dos dois programas triangulares, podemos criar um terceiro programa em forma de hexágono.

Se a largura base do seu primeiro programa fosse três, ficaria assim:

 XyyyX
XXXyXXX
yyyXyyy
 yXXXy

Se a largura da base fosse cinco, ficaria assim:

  XyyyyyX
 XXXyyyXXX
XXXXXyXXXXX
yyyyyXyyyyy
 yyyXXXyyy
  yXXXXXy

Este programa (quando executado com espaços e novas linhas como os outros) deve produzir outro título da música dos Beatles, assim como os dois primeiros programas. Além disso:

• Seus três programas devem produzir títulos de músicas diferentes.
• Somente títulos de músicas com oito caracteres ou mais são permitidos.
• Você pode escolher apenas um de Revolution, Revolution 1e Revolution 9porque os títulos são muito semelhantes.
• Você deve escolher suas três músicas favoritas dos Beatles. (Bem, tente .)

Observe que os programas reais são necessários. Funções não são permitidas. A leitura do seu próprio código-fonte em qualquer programa também não é permitida.

Exemplo

Se o seu primeiro programa foi

  A
 AAA
AAAAA

poderia produzir Across the Universe.

Então seu segundo programa

bbbbb
 bbb
  b

poderia produzir Revolution.

Em seguida, combinado no programa hexágono

  AbbbbbA
 AAAbbbAAA
AAAAAbAAAAA
bbbbbAbbbbb
 bbbAAAbbb
  bAAAAAb

a saída pode ser Get Back.

Pontuação

A submissão com a menor largura da base do triângulo vence. No provável caso de empate, vence a finalização com o maior comprimento total de seus três títulos.

GolfScript, largura = 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"}

Impressões Let It Be . (9 caracteres)

Experimente online.

Como funciona

O token "Let It Be"na primeira linha empurra a sequência Let It Be na pilha.

A segunda linha começa com }um "super comentário" não documentado que interrompe a execução imediatamente.

Antes de sair, o GolfScript imprime o conteúdo da pilha.

Triângulo X

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

Imprime torção e grito . (15 caracteres)

Experimente online.

Como funciona

As duas primeiras linhas pressionam a cadeia "\n }", que o comando ;descarta da pilha.

As linhas restantes contêm os tokens "Twi", "st an"e "d Shout", que empurram a corda Twist and Shout em três pedaços.

Antes de sair, o GolfScript imprime o conteúdo da pilha.

Triângulo Y

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

Imprime ontem . (9 caracteres)

Experimente online.

Como funciona

As fichas Let, Ite Bena primeira linha são indefinido, para que eles não fazem nada.

As três linhas seguintes contêm as fichas "Yeste", "rda"e "y", que empurram a cadeia ontem em três peças.

O }na última linha não faz nada; o programa teria terminado de qualquer maneira.

Mais uma vez, o GolfScript imprime o conteúdo da pilha antes de sair.

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

Uma queda de energia na noite passada me impediu de atualizar isso quando eu descobri, mas consegui reduzir a largura do triângulo e aumentar a duração da música!

Programa de apontamento: "Dig a Pony", 10 caracteres:

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

Explicação

REALMENTE aproveitei o truque envolvente de Befunge e escolhi "Dig a Pony" especificamente porque tinha um espaço na 6ª posição. Isso permite que o fluxo do programa se mova pelo nome da música. Experimente no intérprete online para ver como funciona.

Programa de apontar para baixo: "Se eu caí", 9 caracteres:

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


       .

(O período é estranho e incluído apenas para fazer as outras linhas aparecerem.)

Explicação

As únicas linhas relevantes aqui são as duas primeiras. Usei o truque de empacotamento (o ponteiro de instrução é enviado para a esquerda imediatamente) para apertar mais um caractere. A segunda linha imprime o nome da música.

Combinado: "Dirija meu carro", 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 

Aqui está a mesma coisa, mas com linhas adicionadas para mostrar o hexágono e os 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\ /
       -----------------

Explicação

É aqui que a terceira e quarta linhas do triângulo apontando para baixo entram em jogo. Existem vários redirecionamentos na borda dos dois triângulos que servem para mover o ponteiro de instrução por essas duas linhas e pressionar "Drive My Car" na pilha. Em seguida, é impresso usando o >:#,_@bit no triângulo apontando para cima. Aliás, os triângulos apontando para a esquerda e a direita são usados.

Não pode ser uma maneira de usar mais o espaço vazio, mas acho que meu tempo é melhor gasto em outras questões. : P

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

Sim, bem ... Python.

Os comentários em Python começam com #, portanto, a maioria das linhas é apenas comentários. Para o triângulo voltado para cima, a única coisa que executa é

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

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

Para o triângulo voltado para baixo, executamos

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

que imprime Yellow Submarine, uma vez que a função idé verdadeira.

Quando combinamos os programas, no entanto, tudo o que acontece são as duas linhas acima em sequência. Desde o final dos primeiros conjuntos de linhas id=0, que agora é falso, o resultado final é que apostamos em um (Reprise)até o fim, obtendo Sgt. Pepper's Lonely Hearts Club Band (Reprise)nossa saída (Calvin disse que está tudo bem ).

Boneco de neve 1.0.2 , largura = 13

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

Finalmente! Um desafio onde o boneco de neve pode prosperar! : D: D

As barras são principalmente para fins estéticos, e a maioria delas pode ser substituída por espaços (mas isso faria com que parecesse muito mais chato). Algumas barras são necessárias para comentários.

Programa A (saída:) Birthday:

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

Essa é bem simples. O primeiro caractere ( }) configura nossas variáveis ​​ativas, então há um monte de comentários / no-ops. Em seguida, ele armazena a string "Sun King\n "e a descarta imediatamente (via *, armazenando-a em um permavar que nunca usamos). Então ele armazena "Birthday\n".

]]é um no-op aqui, já que [[ foo ]]há um comentário em bloco no Snowman, mas como não há correspondência [[antes disso ]](no próprio programa A), ele simplesmente não faz nada. Em seguida, 8AaLpega os 8 primeiros caracteres da string, sPimprime e [[comenta o restante do programa (porque, novamente, não há correspondência ]].

Programa B (saída:) Get Back:

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

Esse também é bem direto. ?}é equivalente a }( ?simplesmente define todas as variáveis ​​como inativas, o que é um não operacional aqui, mas novamente importante depois). Em seguida, ele armazena a string "Get Back", faz um monte de no-ops (o //final da linha é sempre um comentário) e imprime via sP.

Programa completo

A saída é, você adivinhou, Sun King¹ .

Vejamos esta linha por linha:

• Linha 1

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

  Isso define nossas variáveis ​​ativas, assim como os programas anteriores (podemos ver agora que ?é necessário para não apenas ativá-las e depois recuar }}). O restante da linha está comentado.

• Linhas 2-4

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

  Comentários...

• Linha 5

    "Sun King//"[["Sun King
  

  Aqui, armazenamos a string "Sun King//"e, em seguida, iniciamos um comentário em bloco. Isso basicamente pula tudo até o próximo ]].

• Linha 6

   "*"BirthdaysP/"*"Birthday
  

  Ainda dentro do comentário do bloco ...

• Linha 7

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

  Aqui interrompemos o comentário do bloco por um curto período de tempo, para executar o código 8AaLsP. Na verdade, isso é reutilizado no programa A. Como escolhi todas as músicas com 8 letras, posso simplesmente usar o mesmo código para o programa combinado.

  Então fica um pouco complicado. A próxima vez que emergimos do comentário do bloco, vemos 8AaLsPnovamente. Desta vez, no entanto, todas as variáveis ​​são indefinidas (chamamos sp, print, no modo de consumo, o que elimina as variáveis). Como aalrequer dois argumentos e, desta vez, possui apenas um ( 8), ele erro e deixa as variáveis ​​inalteradas.

  Da mesma forma, spencontra o 8, percebe que é do tipo errado a ser impresso e deixa as variáveis ​​como estão.

• Linhas 8-13

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

  Ainda preso no comentário do bloco ...

• Linha 14

        /"]]8AaLsP[[///
  

  Por fim, tentamos chamar a mesma sequência print-first-8-chars novamente e ela falhará novamente, produzindo outros dois erros. (O 8meio que as variáveis ​​são agora 8 8, que é o número correto de variáveis ​​no aalmomento, mas ainda não são os tipos corretos.)

^{1: bem como quatro erros de tempo de execução SnowmanExceptionno STDERR, mas conforme meta que não importa .}

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

As linguagens 2D se divertem bastante com esse desafio.

Seta para cima

     /


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

O fluxo do programa começa no canto superior esquerdo, movendo-se para a direita. O /reflete-se, e desde> <> é toroidal que reaparecem a partir do fundo. Em seguida, tocamos em outro, /refletimos novamente e empurramos os caracteres klawstaCum a um para a pilha no ""modo de seqüência de caracteres . Finalmente, refletimos para cima e atingimos um >l?!;oloop, que é a maneira idiomática de imprimir a pilha inteira em> <>.

Isso imprime Catswalk.

Seta para baixo

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

Basicamente a mesma coisa, empurrando os caracteres desde o início e usando espelhos e setas para direcionar o fluxo do programa. Isso imprime Birthday.

Combinado

     /

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

As partes relevantes estão acima (cortei muitas linhas no meio). Usando a /seta para cima, refletimos para cima e contornamos, mas como agora temos a seta para baixo, parte desse código é executado. Em seguida, enviamos os caracteres relevantes para a pilha e reutilizamos o loop de saída da seta para baixo.

Isso imprime Hey Jude.

Python 2, tamanho 21

Este programa requer um terminal compatível com ANSI (DOS ANSI.SYS para ser específico), pois eu uso \x1b[2Jpara limpar o console E mover o cursor para o canto superior esquerdo. Para torná-lo compatível com outros terminais ANSI, imprima\x1b[1J\x1b[H (ainda pode caber em um hexágono tamanho 21). Não pude testar esta parte, porque não tenho um terminal que imprima códigos de escape ANSI.

Eu acho que o programa parece bem legal, semelhante ao símbolo radioativo (embora o sombreamento ASCII implique que as cores estão ao contrário) ou o ícone da arma de franco-atirador de Metroid Prime: Hunters.

Ele fez fit em tamanho 17, mas eu tinha esquecido id=0na seta para cima. Eu não acho que posso reduzi-lo novamente, já que isso deve estar em uma linha ...

Além disso, o Sp3000 dá crédito à idéia 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"##

Seta para cima:

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

Seta para baixo:

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

"Hey Jude" é uma das minhas músicas favoritas dos Beatles, mas eu realmente não conheço muitas. Eu nunca ouvi as outras duas músicas que estou usando. Não é um gênero que eu ouço com frequência.

C (gcc) , largura da base = 17

Parte superior, "Hey Jude"

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

Experimente online!

Abaixo, "Caixa de fósforos"

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

Experimente online!

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

Experimente online!

gawk, comprimento da base 15

Acabei de descobrir que não funciona com mawk : /

Não é muito complicado, mas sendo crescido nos anos 70, com os Beatles ainda onipresentes no ar, eu tive que responder a isso. Primeiro, pensei que o awk não era adequado, mas depois veio a mim.

Como esses scripts contêm blocos BEGIN e / ou END, eles precisam ser informados de que não haverá entrada para executar o bloco END. Isso pode ser alcançado pressionando Ctrl-D após iniciá-los ou iniciando-os assim:

awk -f script.awk </dev/null

o que eu acho mais conveniente. echo | awk -f script.awktambém funcionará, mas se eu tivesse usado uma linha vazia como entrada, teria feito isso completamente diferente.

Apontar para cima, imprime para ninguém (link do Youtube)

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

O código essencial sem comentários é este. Como nnão está definido, ele imprime "For No One" se for chamado por si só.

    BEGIN {
   print n?

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

Apontando para baixo, imprime Blackbird

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

O código essencial é este. Se nfoi definido antes, não imprime nada. Apliquei a saída agradável com uma nova linha após cada nome de faixa, porque eu tinha espaço para fazer isso e parece melhor no console. né definido no processo; isso é necessário para o hexágono.

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

Hexágono, impressões Estou tão 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"}#

O código essencial. Agora, finalmente, esse misterioso né usado. Como né definido na primeira linha, o triângulo apontando para cima imprime a saída alternativa e o triângulo apontando para baixo imprime o vazio.

    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
      }