Buzzby Berkeley Robot Hokey Pokey

Tarefa

Escreva um programa ou função para produzir uma animação artística ASCII, representando uma linha de robôs dançando as letras do Hokey Pokey (ou Cokey, se você preferir) no estilo de um número de Busby Berkeley!

Saída de exemplo

Entrada

Aceita três argumentos (considerados válidos):

N = número de robôs na linha (Min = 6)

B = duração de uma "batida" em milissegundos (Min = 10)

D = atraso em ms entre robôs sucessivos (Min = 0)

(No exemplo de saída acima: N = 8, B = 380, C = 75)

Especificações

1. N robôs são mostrados em uma fileira no palco.

2. Uma linha de texto do "verso" é mostrada por vez abaixo do palco (centralizada em 1 caractere e entre aspas).

3. Os robôs executam as ações para cada linha, como é mostrado até que o verso seja repetido 5 vezes.

4. Uma ação é executada representando um robô usando um conjunto de caracteres ASCII e aguardando uma duração especificada antes de executar a próxima ação. A duração de uma ação é medida em "batidas". A duração de uma batida é um número de milissegundos, B .

5. O primeiro robô começa a executar as ações para cada linha do verso imediatamente quando o texto da linha é exibido.

6. Cada robô subsequente atrasa o início de suas ações até um tempo específico ( D ) após o robô à sua direita (sua esquerda!) Iniciar suas ações.

7. As representações dos robôs variam de acordo com os caracteres ASCII que representam a "antena" de um robô, dos quais existem 5 tipos possíveis, distribuídos aleatoriamente toda vez que o programa é executado.

8. Cada tipo de antena deve ser usado por pelo menos um robô, mas o mesmo tipo não deve aparecer em nenhum robô separado por menos de três outros robôs. A quantidade de dois tipos de antenas pode diferir em não mais que 1 (por exemplo, 1xType_4 e 3xType_5's são ilegais, já que 3-1> 1)

Verso e Ações

O verso inteiro é repetido 5 vezes, uma linha de cada vez ...

Line  Text                            Action/Beats, 
----  -----------------------------   ------------------------------------
1     You put your ? in               ??/4
2     You take your ? out             AA/4
3     You put your ? in               ??/4
4     And you shake it all about      AA/1, ??/1, AA/1, ??/1
5     You do the Hokey Pokey and...   
      ...you turn yourself around     AA/1, H[1-7]/1
6     That's what it's all about!     AA/4, ZZ/4

Para cada repetição (R) do verso, substitua? e ?? ...

R   ?=           ??=
--  -----------  ---
1.  right foot   RF 
2.  left foot    LF
3.  right hand   RH
4.  left hand    LH
5.  whole self   WS

Ações e padrões ASCII

Cada ação rotulada é representada por 5 linhas de 8 símbolos ASCII.
A representação de cada ação é a seguinte ...

1 |   12     12        12    12        12     12      12   
2 |  ['']   ['']      ['']  ['']      ['']   ['']   \[*-] 
3 | └[__]┘ └[__]┘    └[__]┘┌[__]┘    └[__]┐ ┌[__]┐   [__]\ 
4 |   ||     /<        >\    <\        />    /  \     /|
5 |--------------------------------------------------------
  |\__AA__/\__RF__/\__LF__/\__RH__/\__LH__/\__WS__/\__ZZ__/ 

1 |   12     12_     34_      34      _34     _12     12    
2 |  ['']    [" ]    [ _]    [__]    [_ ]    [ "]    ['']
3 | >[__]<   [_<]    [<.]   <[..]>   [.>]    [>_]   <[__]>
4 |   ||      |\      ||      /|      ||      |\      ||
5 |--------------------------------------------------------
  |\__H1__/\__H2__/\__H3__/\__H4__/\__H5__/\__H6__/\__H7__/

Na linha 1, substitua "1-4" pelo símbolo correspondente a cada tipo de antena ...

1 | 1234 1234 1234 1234 1234 
  | \/\/ |┌┐| )||( |||| ┐/\┌ <-- Symbols 1-4 for...
  | 1    2    3    4    5    <-- ...antenna types 1-5

Saída

A cena inteira deve ser renderizada pelo menos uma vez imediatamente sempre que o conteúdo da cena mudar de alguma maneira. (Ou seja, assumindo que o atraso entre as ações dos robôs é> 0, a saída pode ser renderizada não menos que N vezes por ação.)

Idealmente, para uma animação, o console ou área de saída equivalente é limpo antes de cada atualização ser renderizada. Para fornecer idiomas incapazes de limpar o console, a saída também pode ser renderizada em um fluxo contínuo, sujeito ao mesmo requisito descrito acima.

Pontuação

Os vencedores são os programas mais curtos em cada idioma, e também o mais curto em geral.

Exceção 1 Como a limpeza do console de cada renderização é preferível, embora não obrigatória, os bytes usados ​​exclusivamente para essa finalidade de luxo não contam para o total de bytes. Isso inclui comandos para limpar o console e preenchimento de saída com linhas em branco para rolar o conteúdo do console para fora da vista.

Exceção 2 CSS ou meios efetivamente semelhantes usados ​​exclusivamente com a finalidade de estilizar a saída além dos requisitos mínimos não contam para o total de bytes. Por exemplo, *{color:blue;text-align:center;}conta como apenas 32-10 = 22 bytes, pois color:blue;não serve para satisfazer nenhuma especificação, enquanto o texto centralizado é especificado.

Meta

Inspirado por (mostrando minha idade) da dança Demônio TRS-80 , Nim Android e, claro, Busby Berkeley (e não, eu não sou que idade).

^{Senhoras e senhores, por favor dêem as boas-vindas à nossa adorável}

Grupo de dança de pilha de front-end completo, 1.320 1.378 1.425 1.495 bytes

^{JavaScript: 1.195 bytes | CSS: 103 bytes | HTML: 22 bytes}

Este é um desafio fofo. Ele também tem muitos casos especiais. Oh garoto, tantos casos especiais. E essas antenas ...

Ele será executado para sempre e reiniciado após a conclusão de todas as ações ( left foot, right footetc.).

Você pode experimentá-lo no jsFiddle ou usando o trecho de código abaixo:

t=setTimeout
c=l=a=i=0
_=(x,y,z)=>{if(!i)for(;++i<=x;q=~~(Math.random()*10))s.append(document.createElement('pre'))
for(i=l=0,c=a+1;i<33;)(i=>{t($=>{if(4==i){c=0
l=1}if(8==i){c=a+1
l=0}if(12==i|14==i){c=0
l=2}if(13==i|15==i)c=a+1
if(16==i){c=0
l=3}if(16<i&24>i)c=i-10
if(24==i){c=0
l=4}if(28==i)c=6
if(31<i){a=++a%5
_(x,y,z)}for(j=0;j<x;)(j=>{t($=>s.childNodes[j][h]=(-1<[1,3,8,9].indexOf(c)?'  ':2==c||4==c?'    ' :'   ')+(11==c||12==c?'_':'')+['\\/\\/','|┌┐|',')||(','||||','┐/\\┌'][(q+j)%4].substring($=8<c&12>c?2:0,$+2)+(8==c||9==c?'_':'')+'\n'+[`  ['']			   
 └[__]┘ 
   ||`,` ['']  
└[__]┘  
  /<`,`   ['']
  └[__]┘
    >\\`,` ['']
┌[__]┘
  <\\`,`   ['']
  └[__]┐
    />`,`  ['']
 ┌[__]┐
  /  \\`,` \\[*-]
  [__]\\
   <\\`,`  ['']
 >[__]<
   ||`,`  [" ]
  [_<]
   |\\`,`  [ _]
  [<.]
   ||`,`  [__]
 <[..]>
   /|`,`  [_ ]
  [.>]
   ||`,`  [ "]
  [>_]
   |\\`,`  ['']
 <[__]>
   ||`][c]+'\n-------',j*z)})(j++)
p[h='innerText']='"'+["You put your $ in","You take your $ out","And you shake it all about","You do the Hokey Pokey and you turn yourself around","That's what it's all about!"][l].replace('$',['right foot','left foot','right hand','left hand','whole self'][a])+'"'},i*y)})(i++)}

// let's dance (not included in the byte count – as if it would make any difference)
_(8, 400, 50)

*{text-align:center}x pre{display:inline-block;width:55px;text-align:left}pre{line-height:16px;margin:0

<x id=s></x><pre id=p>

^{Testado no Chrome e Firefox no macOS, Windows 10 e Ubuntu}

Edições

• Economizou 70 bytes removendo o contêiner extra para armazenar as antenas. Graças ao Bumpy . Também encontrou mais alguns espaços em branco, removeu o cache agora desnecessário createElemente removeu o acesso longo ao .firstChild.
• Economizei 47 bytes - acabei de perceber que eu realmente não preciso ligar getElementById. Isso também torna documentdesnecessário o armazenamento em cache .
• Economizou 4 bytes substituindo ||e &&com bit a bit &e |. Graças a TheLethalCoder .
• Economizou 54 bytes simplificando muitas coisas pequenas e otimizando o CSS.

C #, 1188 1376 1382 bytes após exceções

Compactado:

namespace System.Threading{using S=String;void H(int n,int b,int d){Console.CursorVisible=false;int t,u=0,v=5,w,x,y,z;S[]i=",That's what it's all about!,,You do the Hokey Pokey and you turn yourself around,And you shake it all about,,You take? out,You put? in".Split(',');i[0]=i[1];i[2]=i[3];i[5]=i[7];for(b=b<d*n?0:b-d*n;v-->0;)for(w=32;w-->0;Thread.Sleep(b))for(t=u,z=0;z++<n;Thread.Sleep(d)){S s="",r=i[w/4].Replace("?"," your "+(v<1?"whole self":(v%2<1?"right ":"left ")+(v/3<1?"hand":"foot")));u="88880000765432109090999900009999"[w];u=u>56?9+v:u-48;for(y=4;y-->0;s+="\n")for(x=0;x<n;x++)s+=S.Format(@"{0}{0}   |\   {0}   /|   {0}   |\   {0}   /|{4} /  \{4}  />{4}<\{4}{4}>\{4}/<{4} └{1}┘  >{1}<   [_<]{4}[<.]   <[..]>   [.>]{4}[>_]   <{1}>   {1}\  ┌{1}┐   └{1}┐┌{1}┘{4}└{1}┘└{1}┘   {2}  {2}   ["" ]{4}[ _]{4}{1}{4}[_ ]{4}[ ""]   {2}  \[*-]   {2}   {2}{2}{4}{2}{2}  {3}{3}  12_{4} 34_{4}  34{4}  _34{4} _12  {3}{3}{3} {3} 12{4} {3} 12{4}", "   ||   ","[__]"," [''] ","   12   ","    ").Substring(y*14+(x<z?u:t)<<3,8).Replace("12",@"\/|┌)|||┐/".Substring(x%5*2,2)).Replace("34",@"\/┐||(||\┌".Substring(x%5*2,2));Console.Clear();Console.Write(s+new S('-',n*8)+"\n"+new S(' ',n*4-r.Length/2)+r);}}}

Formatação ligeiramente melhor e envolvida em um programa executável:

namespace System.Threading{
    using S=String;

    //** Not counted towards score: execution wrapper
    class P{
        static void Main(S[]a){
            new P().H(int.Parse(a[0]),int.Parse(a[1]),int.Parse(a[2]));
        }
    //** End not counted towards score

        void H(int n,int b,int d){
            Console.CursorVisible=false;  // Not counted under exception 2
            int t,u=0,v=5,w,x,y,z;
            S[]i=",That's what it's all about!,,You do the Hokey Pokey and you turn yourself around,And you shake it all about,,You take? out,You put? in".Split(',');
            i[0]=i[1];
            i[2]=i[3];
            i[5]=i[7];
            for(b=b<d*n?0:b-d*n;v-->0;)
                for(w=32;w-->0;Thread.Sleep(b))
                    for(t=u,z=0;z++<n;Thread.Sleep(d)){
                        S s="",r=i[w/4].Replace("?"," your "+(v<1?"whole self":(v%2<1?"right ":"left ")+(v/3<1?"hand":"foot")));
                        u="88880000765432109090999900009999"[w];
                        u=u>56?9+v:u-48;
                        for(y=4;y-->0;s+="\n")
                            for(x=0;x<n;x++)
                                s+=S.Format(@"{0}{0}   |\   {0}   /|   {0}   |\   {0}   /|{4} /  \{4}  />{4}<\{4}{4}>\{4}/<{4} └{1}┘  >{1}<   [_<]{4}[<.]   <[..]>   [.>]{4}[>_]   <{1}>   {1}\  ┌{1}┐   └{1}┐┌{1}┘{4}└{1}┘└{1}┘   {2}  {2}   ["" ]{4}[ _]{4}{1}{4}[_ ]{4}[ ""]   {2}  \[*-]   {2}   {2}{2}{4}{2}{2}  {3}{3}  12_{4} 34_{4}  34{4}  _34{4} _12  {3}{3}{3} {3} 12{4} {3} 12{4}", "   ||   ","[__]"," [''] ","   12   ","    ").Substring(y*14+(x<z?u:t)<<3,8).Replace("12",@"\/|┌)|||┐/".Substring(x%5*2,2)).Replace("34",@"\/┐||(||\┌".Substring(x%5*2,2));
                        Console.Clear(); // Not counted under exception 1
                        Console.Write(s+new S('-',n*8)+"\n"+new S(' ',n*4-r.Length/2)+r);
                    }
        }
    } // Not counted towards score: end class
}

Experimente online!

1. Visite este link: tutorialspoint.com
2. Na guia Termo padrão na parte inferior da tela, digite:
   mono main.exe 8 400 40

Editar 1

Substituído string.Format(i,j)por i.Replace("?",j)salvar 6 bytes no geral.

Editar 2

Renovação completa com sugestões dos comentários.

JavaScript, 948 bytes

Provavelmente má forma de responder sua própria pergunta, mas de qualquer maneira ...

Tentei de todas as maneiras possíveis para compactar o texto, mas a maioria acabou mais do que o original com o algoritmo chave + incluído. Estou certo de que ainda há uma maneira mais ideal de compactar tudo, mas preciso traçar a linha em algum lugar.

Curiosamente, a pesquisa gerou uma ou duas idéias para outros desafios que eu poderia refinar e publicar mais tarde.

<pre id=O/>

f=(N,B,D)=>{Q=c=>(K={},k='~',[...c].map(v=>v<k?K[k=v]='':K[k]+=K[v]||v),K[k])
x=``,A=`//,||,)||(,,/`.split(',').sort(new Date)
r=new Array(N).fill(0),t=i=v=0,n=`\n`,T=setTimeout
C=_=>(w=Q(`ouhand t t's ake Y y all abtokey righlefwhole fooself ,${v+1},,1yr ${x[v*2]+x[v*2+1]}puintt,,Ashi,do the HPaturn yrarnd,,7,8,90123,Twi!,,6,`).split(',')[i++])<'A'?(r.map((_,m)=>T((a,b)=>R(r[N-a]=b),m*D,m,w)),i>22?(v++,i=0):0,v<3?T(C,B*(i<7||i>21?4:1)):0):C(t=w),R=_=>{for(o='',m=4;m--;o+=n){for(w=N;w--;)o+=Q(`┌┐└┘\\/||/${A[w%5]}   [__] [''] ||] _ __ _  [*-][" ][ _][_ ][ "] ┐ ┐><[_<] [<.]<[..]>[.>] [>_]<> /<></>/ //`).substr(r[w]*8+(3-m)*112,8)}
O.innerHTML=o+'-'.repeat(N*8)+' '.repeat(((N*8)-t.length)/2)+t}
C()}

( NB: Contém alguns caracteres no intervalo de 1 a 31 cujas representações são um pouco estranhas quando postadas aqui)

Assista ao ciclo completo de dança psicodélica no CodePen !