91 garrafas de cerveja ASCII na parede

17

Dado um único número inteiro, xonde 0 <= x <= 91uma pilha de garrafas de cerveja sai com tantas garrafas (e prateleiras) ausentes. Por uma questão de simplicidade, mostrarei apenas as 6 primeiras garrafas e o que seria para cada uma das primeiras entradas.

Aqui está a pilha de garrafas, cada número é a garrafa que você deve remover para essa entrada (indexada em 1):

https://pastebin.com/wSpZRMV6

Observe que estamos usando 91 em vez de 99, porque 99 resultaria em uma pilha instável de garrafas.

Exemplo

Com 0 garrafas faltando ( x=0):

             |=|            
             | |            
             | |            
            /   \           
           .     .          
           |-----|          
           |     |          
           |-----|          
           |_____|          
        =============       
         |=|     |=|        
         | |     | |        
         | |     | |        
        /   \   /   \       
       .     . .     .      
       |-----| |-----|      
       |     | |     |      
       |-----| |-----|      
       |_____| |_____|      
    =====================    
     |=|     |=|     |=|     
     | |     | |     | |     
     | |     | |     | |     
    /   \   /   \   /   \    
   .     . .     . .     .   
   |-----| |-----| |-----|   
   |     | |     | |     |   
   |-----| |-----| |-----|   
   |_____| |_____| |_____|   
=============================
 [THERE ARE MORE UNDER THIS]

Para obter a saída completa de 0, consulte aqui: https://pastebin.com/ZuXkuH6s

Com a 1garrafa ausente ( x=1):

         |=|     |=|        
         | |     | |        
         | |     | |        
        /   \   /   \       
       .     . .     .      
       |-----| |-----|      
       |     | |     |      
       |-----| |-----|      
       |_____| |_____|      
    =====================    
     |=|     |=|     |=|     
     | |     | |     | |     
     | |     | |     | |     
    /   \   /   \   /   \    
   .     . .     . .     .   
   |-----| |-----| |-----|   
   |     | |     | |     |   
   |-----| |-----| |-----|   
   |_____| |_____| |_____|   
=============================
 [THERE ARE MORE UNDER THIS]

Mais uma vez, estas são as duas primeiras linhas daqui: https://pastebin.com/ZuXkuH6s (com 1 removido) ...

Com 2 garrafas faltando:

                 |=|        
                 | |        
                 | |        
                /   \       
               .     .      
               |-----|      
               |     |      
               |-----|      
               |_____|      
    =====================    
     |=|     |=|     |=|     
     | |     | |     | |     
     | |     | |     | |     
    /   \   /   \   /   \    
   .     . .     . .     .   
   |-----| |-----| |-----|   
   |     | |     | |     |   
   |-----| |-----| |-----|   
   |_____| |_____| |_____|   
=============================
 [THERE ARE MORE UNDER THIS]

[ENTRADAS ADICIONAIS REMOVIDAS]

Faltam 91 garrafas ( n = 91):

:(

Você deve mostrar um rosto infeliz, porque está sem cerveja.

Regras

  • Os frascos devem ser removidos da esquerda para a direita.
  • As prateleiras são removidas quando nenhuma cerveja permanece no topo das prateleiras.
  • Para uma entrada de 0, você está produzindo 91 garrafas empilhadas em um triângulo.
    • A linha inferior tem 13 garrafas, a parte superior tem 1.
  • 1 espaço entre cada garrafa em cada prateleira.
  • As prateleiras devem ser inseridas entre cada linha de garrafas.
    • Prateleiras podem usar =, -ou #como o personagem.
    • As prateleiras devem ser 3 mais largas (de cada lado) do que as garrafas que elas seguram.
  • Isso é código-golfe , vitórias mais baixas na contagem de bytes.
code-golf ascii-art Urna de polvo mágico
fonte
Você poderia fornecer, por exemplo, uma pasta de pelo menos um dos casos de teste inteiros?
Conor O'Brien
São necessários espaços à direita após a última garrafa de uma prateleira?
11137 Jonathan Frech
Os espaços precedentes são necessários, enquanto você os remove da esquerda para a direita, os espaços à direita da arte ASCII são com você.
Magic Octopus Urn
@ ConorO'Brien, visto que você não especificou qual caso de teste, eu gostaria de ter colocado um rosto infeliz em uma pasta; P.
Magic Octopus Urn
11
Pensei que você tivesse escolhido a 91 para impedir qualquer tipo de embutido. o0
totallyhuman

Respostas:

15

Carvão , 99 91 bytes

Ａ⁻⁹¹ＮθＡ¹³η:(Ｗθ«Ａ⌊⟦θη⟧ζＡ⁻θζθＡ⁻η¹ηＦζ«↑⁴↖.\↑²←|=↓³←↙¹↓.Ｐ⁶↓²Ｐ⁶↓¹Ｐ______←| »¿θ«Ｍ⁹↑Ｍ³→×=⁻×⁸ζ³↑Ｍ⁴←

Experimente online! Link é a versão detalhada do código. Na verdade, a versão real tem apenas 83 70 bytes:

Ｆ¹⁵Ｆι⊞υκ:(Ｆ⁻⁹¹Ｎ«Ｆ¬⊟υ«Ｍ³±⁹×=⁺⁵×⁸⊟υ↑Ｍ⁴←»↑⁴↖.\↑²←|=↓³←↙¹↓.Ｐ⁶↓²Ｐ⁶↓¹Ｐ×_⁶←|←

Explicação:

Ｆ¹⁵Ｆι⊞υκ

Preencha uma matriz que forneça informações sobre onde as prateleiras vão e quanto tempo elas são.

:(

Imprima um rosto infeliz, embora isso seja imediatamente substituído pela primeira garrafa de cerveja (se houver).

Ｆ⁻⁹¹Ｎ«

Passe pelas restantes garrafas de cerveja.

   Ｆ¬⊟υ«

Verifique se uma prateleira precisa ser desenhada.

        Ｍ³±⁹×=⁺⁵×⁸⊟υ↑Ｍ⁴←»

Imprima a prateleira e posicione-a pronta para desenhar o próximo frasco acima dela.

   ↑⁴↖.\↑²←|=↓³←↙¹↓.Ｐ⁶↓²Ｐ⁶↓¹Ｐ×_⁶←|←

Desenhe uma garrafa e posicione-a pronta para desenhar outra garrafa.

Neil
fonte
6
Hã. Pena que este desafio não é de cerca de 99 garrafas de cerveja. Preciso obter 8 bytes de inatividade :): P
HyperNeutrino 12/08
11
@EriktheOutgolfer É por isso que sugeriu golfe 8 bytes: P E yay ele realmente fez golfe 8 bytes: D
HyperNeutrino
2
@HyperNeutrino Não exatamente; I golfed 11, então ungolfed 3 ...
Neil
11
@KevinCruijssen Normalmente você incrementaria usando um forloop. Isso é um whileloop, então eu tenho que fazer algo mais manualmente.
Neil
11
@KevinCruijssen Embora, pensando bem, um forloop fosse o caminho a seguir o tempo todo ... 13 bytes salvos! (Bem, eu tenho um pouco de sorte com a facilidade de preencher minha matriz.)
Neil
10

Python 3 , 306 299 265 253 255 252 247 244 bytes

Tentativa rápida, pode ser otimizada

Edit: -2 bytes graças a @MrXcoder

Editar: -32 bytes, pois não são necessários espaços à direita

Editar: -12 bytes combinando as duas funções

Edit: -5 bytes graças a @ musicman523

Editar: +7 bytes para remover a prateleira após a última linha

Editar: -3 bytes

Editar: -5 bytes devido a uma função lambda ser usada apenas uma vez no mapa

Edit: -3 bytes usando a função stringcenter

def l(y,x=13,z=" "):b=min(x,91-y);A,D="  |%s|  ","|-----|";print(y<91and(l(y+x,x-1)or"".join(map(lambda t:((t+z)*b)[:-1].center(103)+"\n",(A%"=",A%z,A%z," /   \ ",".     .",D,"|     |",D,"|_____|")))+z*(49-4*x)+"="*(x*8+5)*(x<13))or(x>12)*":(")

Experimente online!

Halvard Hummel
fonte
@ Mr.Xcoder que não vai funcionar para x = 2, x = 4, x = 5, x = 7, ...
Halvard Hummel
Oh, você está certo. Desculpe!
Mr. Xcoder
Você pode colocar d=no cabeçalho, porém, uma vez que não é recursivo para -2 bytes
Mr. Xcoder
2
248 bytes removendo a Evariável
musicman523
5

JavaScript (ES6), 251 256 bytes

Editar: salvou 2 bytes graças a @dzaima .
Edit: Adicionado 7 bytes para corrigir o problema com o parâmetro.:(

c=>(f=(c,w=13)=>c>0&&f(c-w,w-1)+(c=c<w?c:w,r=(n,s=' ')=>s.repeat(n),a='\n'+r(52-w*4),'  |=|  0  | |  0  | |  0 /   \\ 0.     .0|-----|0|     |0|-----|0|_____|'.split(0).map(x=>a+r((w-c)*8+2)+r(c,' '+x)).join('')+a+r(w*8+5,'#')),(c=91-c)?f(c).slice(6):':(')

Aqui está a versão (basicamente) não-destruída:

function (consumed) {
  let remaining = 91 - consumed;

  function inner (count, width = 13) {
    if (count <= 0) return false;

    function repeat (count, string = ' ') {
      return string.repeat(count);
    }

    const pattern = [
      '  |=|  ',
      '  | |  ',
      '  | |  ',
      ' /   \\ ',
      '.     .',
      '|-----|',
      '|     |',
      '|-----|',
      '|_____|' ];

    let clamped = Math.min(count, width);
    let alignment = '\n' + repeat((13 - width) * 4);
    let empty = alignment + repeat((width - clamped) * 8 + 2);
    let shelf = alignment + repeat((width * 8) + 5, '#');
    let bottles = pattern.map(row => empty + repeat(clamped, ' ' + row));

    return inner(count - width, width - 1) + bottles.join('') + shelf;
  }

  return (remaining) ? inner(remaining).slice(6) : ':(';
}

Código de teste

Mostrar snippet de código

Aaron Hill
fonte
Muito impressionante, ótima resposta. Eu gosto da sua r"macro"; Eu senti que poderia haver um método mais curto, mas nada que eu tentei o derrubou.
ETHproductions
2

C (gcc) , 360 358 bytes

#define P printf(
r,i,j;char*b[]={"  |=|  ","  | |  ","  | |  "," /   \\ ",".     .","|-----|","|     |","|-----|","|_____|"};w(n){P"%*c",n,' ');}main(n,a)char**a;{(n=-atoi(a[1]))<-90?P":(\n"):({while(++r<14)if((n+=r)>0){for(j=0;j<9;++j){w(4*(13-r)+1);for(i=r;i>0;)--i<n?P b[j]),w(1):w(8);P"\n");}if(r<13){w(4*(13-r)-2);for(i=0;++i<8*r+6;)P"=");P"\n");}}});}

Experimente online!

Explicação:

#define P printf(
r,i,j;
char*b[]={
    "  |=|  ",
    "  | |  ",
    "  | |  ",
    " /   \\ ",
    ".     .",
    "|-----|",
    "|     |",
    "|-----|",
    "|_____|"};

// function to print `n` spaces:
w(n){P"%*c",n,' ');}

main(n,a)char**a;
{
    // no beer left?
    (n=-atoi(a[1]))<-90

        // sad face
        ?P":(\n")

        // else create stack
        // using GCC extension "expression statement" `({ <statement> })` here,
        // shorter than if-else or a function call
        :({
            // loop over 13 rows
            while(++r<14)

                // found non-empty row?
                if((n+=r)>0)
                {
                    // loop over text lines of beer bottles
                    for(j=0;j<9;++j)
                    {
                        w(4*(13-r)+1);

                        // for each bottle
                        for(i=r;i>0;)

                            // print either 8 spaces or line of the bottle
                            --i<n?P b[j]),w(1):w(8);P"\n");
                    }

                    // except for last row, ...
                    if(r<13)
                    {
                        // ... print shelf
                        w(4*(13-r)-2);
                        for(i=0;++i<8*r+6;)
                            P"=");
                        P"\n");
                    }
                }
        });
}
Felix Palmen
fonte
0

Python 2, 436 bytes

Caramba!!

Meu método é muito detalhado, mas de qualquer maneira: essencialmente "desenha" cada linha de garrafas, adiciona espaços e depois "apaga" o que for necessário, imprimindo o que resta.

B=['  |=|   ','  | |   ','  | |   ',' /   \\  ','.     . ','|-----| ','|     | ','|-----| ','|_____| ']
N=lambda r:sum(n for n in range(1,r+1))
n=input()
R=0
while N(R)<n:R+=1
L=R-n+N(R-1)
e=range(1,R)+([R],[])[L!=0]
for r in range(1,14):
    if r in e:continue
    if(r-1 in e)<1:print('',' '*(1+(13-r)*4)+'='*(r*8-3))[r!=1]
    i=(0,R-L)[r==R];w=(8*i+(13-r)*4,0)[i==0];print'\n'.join([' '*w+((13-r)*4*' '+l*r)[w:]for l in B])
if n=91:print':('

Halvard Hummel é muito melhor.

Daniel
fonte