Pilha transbordando

47

(Inspirado por esta pergunta )

Objetivo

Sua tarefa é escrever um programa ou função para imprimir uma versão ASCII do logotipo Stack Overflow no STDOUT

 \|/
(-)
(-)
(-)
(-)

Seu programa deve receber duas entradas, chamadas aqui de H e N. A altura da pilha "contêiner" (os parênteses) é determinada por H. O número de itens na pilha é determinado por N. Se N> H, o pilha "transbordará".

Entrada / Saída

H determinará a altura dos contêineres

Por exemplo:

H = 1:

( )

H = 2:

( )
( )

H = 3:

( )
( )
( )

H sempre será pelo menos 1

N determinará quantos itens estão na pilha. Os exemplos a seguir são todos H = 2:

N = 0

( )
( )

N = 1

( )
(-)

N = 2

(-)
(-)

N = 3

 \
(-)
(-)

N = 4

 \|
(-)
(-)

N = 5

 \|/
(-)
(-)

N = 6

 \|/
(-)-
(-)

N = 7

 \|/
(-)-
(-)-

N nunca será maior que 2H+3(Em outras palavras, a pilha nunca passará pelo chão).

Regras

  • Sem brechas padrão.
  • Seu programa não deve produzir erros.
  • Todos os casos de teste devem passar.
  • Você pode inserir H e N da maneira que desejar.
  • Eu duvido seriamente que seu idioma tenha um embutido para isso.
  • Cada linha pode opcionalmente ter um espaço extra no final. Uma linha em branco acima de uma pilha em que N <= H é opcional, assim como uma nova linha à direita.
  • Isso é código-golfe , então o código mais curto em bytes vence!

Casos de teste

Além de todos os casos de teste H = 2 da seção Entrada / Saída, todos os seguintes casos de teste devem ser aprovados:

H = 1, N = 1

(-)

H = 1, N = 5

 \|/
(-)-

H = 4, N = 7

 \|/
(-)
(-)
(-)
(-)

H = 5, N = 0

( )
( )
( )
( )
( )

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar snippet de código

code-golf ascii-art Daniel M.
fonte
4
Posso postar um programa não concorrente que realmente transborda a pilha em vez de imprimir o logotipo?
dorukayhan quer Monica de volta 04/04
@dorukayhan Se ele só transborda quando n> h :)
Daniel M.
Quero dizer, posso criar um programa que trava de um estouro de pilha?
dorukayhan quer Monica de volta 04/04
@dorukayhan somente se ele falhar quando há mais itens do que a pilha pode conter
Daniel M.

Respostas:

14

Pitão, 43 41 40 bytes

<" \|/"g#0hK-QJEVJs[\(?<N_Kd\-\)*<N-K3\-

Experimente online. Suíte de teste.

Primeira passagem, rápida e suja. Entrada para STDIN como N\nH.

Explicação

  1. Salve a segunda entrada (altura) em J( JE) e subtraia-a da primeira entrada (o número de itens). ( -QJE)
  2. Salve a diferença (número de itens que estão transbordando) em K. ( K-QJE)
  3. Adicione 1 ao número. ( hK-QJE)
  4. Tome max(0, previous). Isso é necessário, pois números negativos quebrariam o próximo passo. ( g#0hK-QJE)
  5. Pegue no máximo muitas letras da sequência " \|/"para obter a primeira linha e imprimir. ( <" \|/"g#0hK-QJE)
  6. Loop Nover range(0, J). ( VJ) Para cada Nimpressão, a concatenação do seguinte: ( s[)
    • "("( \()
    • " "se houver pelo menos N+1espaços livres na pilha ( <N_K), "-"caso contrário. ( ?<N_Kd\-)
    • ")"( \))
    • "-"se houver pelo menos N+4pedaços transbordando na pilha ( <N-K3), ""caso contrário. ( *<N-K3\-)
PurkkaKoodari
fonte
13

JavaScript (ES6), 105 102 bytes

@Edit: salvou 3 bytes graças a @PatrickRoberts.

f=
(n,h)=>` \\|/`.substr(0,n+1-h)+[...Array(h)].map((_,i)=>`
(${i+n<h?` `:`-`})${i+h+3<n?`-`:``}`).join``
;
<div oninput=o.textContent=f(+n.value,+h.value)>n<input id=n type=number min=0 value=0>h<input id=h type=number min=0 value=0><pre id=o>
Expandir snippet

Neil
fonte
Você pode substituir substringpor substrpara salvar 3 bytes e substituir i+n<h?' ':'-'por '- '[i+n<h]para salvar 2 bytes e substituir i+h+3<n?'-':''por ' -'[i+h+3<n]para salvar 1 byte. Isso vai levá-lo sob 100
Patrick Roberts
@PatrickRoberts Não me lembro se substros subscritos negativos foram ignorados ou não, mas não posso usar suas outras dicas porque os subscritos de string são strings, portanto, os booleanos não são bons o suficiente.
1155 Neil
porcaria que eu esqueci sobre isso, bom ponto
Patrick Roberts
Uso realmente inteligente do modelo marcado para salvar esses dois caracteres!
Benjamin Gruenbaum
@BenjaminGruenbaum o que é um "modelo marcado"?
Patrick Roberts
12

JavaScript (ES6), 126 122 112 bytes

h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)

Teste

f=h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`

`}</pre>`)
Expandir snippet

Teste alternativo (se o seu navegador não suportar ES6)

Veja o teste em Babeljs.io e marque "avaliar".

Abordagem alternativa interessante em 136 bytes

h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )${0>-o?0:-o}
(-)-${o=0>o-3?0:o-3}
(-)${n<h-o?n:h-o}`.replace(/(\n.*)(\d+)/g,(_,s,r)=>s.repeat(r))

Isso move os valores de repetição para a cadeia de modelo e usa uma regexp e substitui para injetar os grupos de repetição. Infelizmente, a assinatura .replace()é muito longa.

Patrick Roberts
fonte
Eu recebo um erro ...?
Addison Crump
1
@VTCAKAVSMoACE, seu navegador deve suportar a sintaxe ES6. Isso funciona bem para mim. Sinta-se livre para colar o teste no Babel .
Patrick Roberts
O @VTCAKAVSMoACE Chrome 52 (na versão beta em junho de 2016) suporta todo o ES6 e ES7, exceto a otimização da chamada de cauda e o carregamento do módulo.
gcampbell
10

C ++ 14 (função lambda), 196

Guardado 1 byte graças a Quentin.

Economizou 2 bytes graças a Adam Martin.

#include<iostream>
using namespace std;[](int h,int n){auto s=" \\|/( ) (-) (-)-"s;int t=max(min(n-h,3),0);n-=t;cout<<s.substr(0,t+1)+'\n';for(;h;h--)n-=t=n>h?2:h<=n,cout<<s.substr(4+4*t,4)+'\n';}

A própria função leva 157 bytes.

Veja em ação aqui .

Versão não destruída:

[](int h, int n) {
    auto s = " \\|/( ) (-) (-)-"s;
    int t = max(min(n - h, 3), 0);
    n -= t;
    cout << s.substr(0, t + 1) + '\n';
    for(; h; h--) {
        if (n > h) t = 2;
        else if (h > n) t = 0;
        else t = 1;
        n -= t;
        cout << s.substr(4 + 4 * t, 4) + '\n';
    }
};
vaultah
fonte
2
Eu vejo nenhum ponto em incluindo includes e using namespace std;na contagem de bytes, a menos que a sua resposta é um programa completo (que não é).
Alexander Revo 4/16
9

CJam, 57 bytes

Sri:X'(*+X),W%X)X')*+X),X))f+]zN*X5*,X'-*_"\|/"\++ri<S+er

Teste aqui.

Definitivamente poderia usar alguma melhoria. A idéia é construir uma grade onde as -\|/-células sejam substituídas por números inteiros consecutivos, por exemplo

 345
(2)6
(1)7
(0)8

E depois substituí-los pelos caracteres corretos (potencialmente espaços) no final.

Martin Ender
fonte
6

Python 2, 101 100 98 bytes

def f(h,n):
 print" \|/"[:max(0,n-h+1)]
 for i in range(h):print("(-)","( )")[h-i>n]+"-"*(n>i+h+3)
Chuck Morris
fonte
Espaços depois printsão desnecessários
Cyoce
@ Cyy Obrigado, isso economiza 2 caracteres.
Chuck Morris
4

JavaScript (ES6), 87 80 bytes

F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)

Usa recursão para criar a sequência de saída de baixo para cima.

EDIT : Graças a @ Neil por raspar 7 bytes de 87 bytes

Original

(h,n)=>(E=s=>h--?E(`
(${n>0?'-':' '})${--n>2*h+3?'-':''}`+s):` \\|/`.substr(0,n+1)+s)``

Snippet de teste:

F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)


h.oninput = n.oninput = () => output.innerHTML = F(+h.value, +n.value);
<label>h <input type="number" min="0" value="0" id="h" /></label>
<label>n <input type="number" min="0" value="0" id="n" /></label>
<hr />
<pre id="output"></pre>
Expandir snippet

George Reith
fonte
obrigado pelo bom trecho! Deve dar um ponto extra: P
Kimmax 4/16
1
@Kimmax Graças companheiro, ninguém quer ser mexer com o console
George Reith
Pelo menos quando tentei, a pilha era muito grande e teria apenas 78 bytes com recursão comum.
Neil
O console do snippet está mostrando um SyntaxErrorpara mim.
ArtOfCode 06/06
1
Necessidade @ArtOfCode usar um navegador compatível ES6
George Reith
3

JavaScript (ES6), 149 139 137 bytes

h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`

Gostei da ideia da @ MartinEnder sobre a indexação dos -\|/personagens e queria ver como ela se sairia no ES6. Aparentemente, não me saí tão bem. Tentando descobrir se isso poderia ser melhorado usando for...of.

Editar% s

  • Consegui remover o regexp e a chamada .replace, movendo a indexação diretamente para o g()lugar.
  • Eu acidentalmente contei f=na contagem de segundo byte

Teste

f=h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`

`}</pre>`)
Expandir snippet

Patrick Roberts
fonte
3

Java, 186 177 bytes

void f(int h,int n){for(int i=0;i<h+1;i++)System.out.print((i>0?"(":" ")+(i>0?n>h-i-2?"-":" ":n>h+0?"\\":" ")+(i>0?")":n>h+1?"|":" ")+(i>0?n>h+2+i?"-":" ":n>h+2?"/":" ")+"\n");}

Tentativa sem golfe online

String f(int h, int n)
{
    String s=" ";
    s+=n>h+0?"\\":" ";
    s+=n>h+1? "|":" ";
    s+=n>h+2? "/":" ";
    s+="\n";

    for(int i=0; i<h; i++)
    {
        s+="(";
        s+=n>h-i-1?"-":" ";
        s+=")";
        s+=n>h+3+i?"-":" ";
        s+="\n";
    }

    return s;
}
Khaled.K
fonte
Você pode salvar bytes usando um lambda você provavelmente pode até mesmo deixar de fora o corpo lambda
Daniel M.
2
Preciso de algum IDE personalizado para compilar código Java sem polarização ? : D
Kimmax
@Kimmax .. D'oh!
precisa saber é o seguinte
3

Excel, 131 bytes

Entrada tomada como uma tupla, Altura Hem A1, Nem B1. A fórmula que contém células precisa ter o Quebra de texto ativado. Sugira o uso de uma fonte com espaçamento mono.

=LEFT(" \|/",MAX(0,B1-A1+1))&"
"&REPT("(-)-
",MAX(0,B1-A1-3))&REPT("( )
",MAX(0,A1-B1))&REPT("(-)
",A1-MAX(0,B1-A1-3)-MAX(0,A1-B1))
Wernisch
fonte
Solução maravilhosa! Você deve acrescentar que esta entrada tomada como o 2-tupla de A1e B1e adicione a nota simples que este exige que o celular chamando para ter a opção de texto envoltório para ser verdade. Também talvez que para obter o alinhamento adequado ele deve ter uma fonte mono-espaçada, como Courier New ou Console Lucidia
Taylor Scott
1
Obrigado @TaylorScott. Resposta atualizada com suas sugestões.
Wernisch
2

C ++ 11, 155 148 145 bytes

void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}

Ungolfed :

void f(int h,int n)
{
  cout << string{" \\|/", max(min(3, n-h), 0) + 1} << '\n';
  for(int i=0; i<h; ++i)
    cout << (h-i <= n ? "(-)" : "( )") << (i < max(n-h-3,0) ? "-\n" : "\n");
}

Uso :

#include <iostream>
#include <string>
using namespace std;

void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}

int main()
{
  int h,n;
  cin >> h >> n;
  f(h, n);
}
Alexander Revo
fonte
137 bytes
ceilingcat
1

Python 3, 134 121 118 111 bytes

def f(h,n):print('\|/'[:max(0,n-h)]+'\n'+'\n'.join('(-)-'if h<n-x-3else('(-)','( )')[x+n<h] for x in range(h)))

Teste aqui: https://repl.it/CYL1/0

Sem golfe:

def f(h,n):
  top=['\|/'[:max(0,n-h)]]
  stack=['( )'if x+n<h else'(-)'for x in range(h)]
  overflow=top+stack
  v=n-3
  while v>h:
      overflow[h-v]+='-' #add side overflow
      v-=1

  print('\n'.join(overflow))

Eu gostaria de adicionar o excesso de lado à compreensão da lista, mas não consegui compactá-lo, então tive que seguir o loop while. 13 bytes salvos!

atlasologist
fonte
Como a saída está desativada, você provavelmente precisará alterar '\|/'[:max(0,n-h)]para ser semelhante à solução Python 2.
busfault 28/06
1

Pip , 50 bytes

Ps.(0Xa."\|/")@<bDC0Fi,aP"()"WV"- "@[b<a-ib<a+4+i]

Experimente online!

Ugh, isso é muito longo ... embora não saiba como encurtá-lo. A indexação cíclica, que geralmente é útil, custa bytes extras dessa vez.

DLosc
fonte
1

PowerShell , 109 108 104 bytes

param($n,$h)-join" \|/"[0..(($d=$n-$h),0)[$d-lt0]]
1..$h|%{("( )","(-)")[$h-$_-lt$n]+"-"*($h+$_+2-lt$n)}

Experimente online!

Perdeu muito na indexação cara, mas ainda decente. Não tenho certeza se meu índice de matemática é ideal, no entanto. Roubou alguma lógica das outras respostas para salvar um byte. Também foi lembrada a precedência de exibir alguns parênteses para -4 bytes.

Veskah
fonte
0

05AB1E , 45 bytes

-U…( )¸¹иε²N›ið'-:]RεX4-N@i'-«]" \|/"XdX*>£š»

Definitivamente pode ser jogado .. Não muito feliz com isso em sua forma atual tbh.

Experimente online ou verifique todos os casos de teste .

Explicação:

-                # Subtract the 2nd (implicit) input `n` from the 1st (implicit) input `h`
                 #  i.e. `h`=3, `n`=8 → 5
 U               # Pop and store it in variable `X`
…( )             # Push string "( )"
    ¸            # Wrap it into a list: ["( )"]
     ¹и          # Repeat it the first input (`h`) amount of times
                 #  i.e. 3 → ["( )","( )","( )"]
ε                # Map each to:
 ²N›i            #  If the second input `n` is larger than the map-index N:
                 #    i.e. `n`=8 >= N=0 → 1 (truthy)
     ð'-:       '#   Replace the space with a "-"
                 #    i.e. "( )" → "(-)"
]                # Close both the if and map
 R               # Reverse the list
ε                # Map each to:
 X4-N@i          #  If `X` minus 4 is larger than or equal to the map-index N:
                 #     i.e. `X`=5 and N=0 → 5-4 >= 0 → 1 (truthy)
                 #     i.e. `X`=5 and N=2 → 5-4 >= 2 → 0 (falsey)
       '-«      '#   Append a "-"
]                # Close both the if and map
 " \|/"          # Push String " \|/"
       Xd        # Check if `X` is 0 or positive (0 if negative, 1 if 0 or positive)
                 #  i.e. `X`=5 → 1 (truthy)
         X*      # Multiply it by `X`
                 #  i.e. 1 * 5 → 5
           >     # Increase it by 1
                 #  i.e. 5 → 6
            £    # Take that many character of the string " \|/"
                 #  i.e. 6 → " \|/"
             š   # Prepend it to the list
                 #  i.e. ["(-)-","(-)-","(-)"] and " \|/" → [" \|/","(-)-","(-)-","(-)"]
              »  # Join the list by newlines (and output implicitly)
                 #  i.e. [" \|/","(-)-","(-)-","(-)"] → " \|/\n(-)-\n(-)-\n(-)"
Kevin Cruijssen
fonte
Se isso faz você se sentir melhor, aqui está o que eu tinha: LR'(ì')«¹x‚3+¬UŸ¦ζJ¹XŸJ¦1úr)˜»e isso é apenas a metade.
Urna Mágica de Polvo