Stack Overflowing

47

(Ispirato da questa domanda )

Obbiettivo

Il tuo compito è scrivere un programma o una funzione per stampare una versione ASCII del logo Stack Overflow su STDOUT

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

Il programma dovrebbe prendere due input, qui indicati come H e N. L'altezza del "contenitore" dello stack (le parentesi) è determinata da H. Il numero di elementi nello stack è determinato da N. Se N> H, il lo stack "overflow".

Input Output

H determinerà l'altezza dei contenitori

Per esempio:

H = 1:

( )

H = 2:

( )
( )

H = 3:

( )
( )
( )

H sarà sempre almeno 1

N determinerà quanti oggetti sono nella pila. I seguenti esempi sono tutti H = 2:

N = 0

( )
( )

N = 1

( )
(-)

N = 2

(-)
(-)

N = 3

 \
(-)
(-)

N = 4

 \|
(-)
(-)

N = 5

 \|/
(-)
(-)

N = 6

 \|/
(-)-
(-)

N = 7

 \|/
(-)-
(-)-

N non sarà mai più di 2H+3(In altre parole, lo stack non passerà mai attraverso il terreno).

Regole

  • Nessuna scappatoia standard.
  • Il tuo programma non deve produrre errori.
  • Tutti i casi di test devono passare.
  • È possibile inserire H e N nel modo desiderato.
  • Dubito seriamente che la tua lingua sia integrata per questo.
  • Ogni riga può facoltativamente avere uno spazio extra alla fine. Una riga vuota sopra una pila in cui N <= H è facoltativo, così come una nuova riga finale.
  • Questo è code-golf , quindi vince il codice più breve in byte!

Casi test

Oltre a tutti i casi di test H = 2 della sezione Input / Output, devono passare tutti i seguenti casi di test:

H = 1, N = 1

(-)

H = 1, N = 5

 \|/
(-)-

H = 4, N = 7

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

H = 5, N = 0

( )
( )
( )
( )
( )

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

code-golf  ascii-art 
— Daniel M.
fonte
4
Posso pubblicare un programma non in competizione che trabocca effettivamente dallo stack invece di stampare il logo?
— Dorukayhan vuole che Monica torni il
@dorukayhan Se trabocca solo quando n> h :)
— Daniel M.
Voglio dire, posso creare un programma che si arresta in modo anomalo a causa di un overflow dello stack?
— Dorukayhan vuole che Monica torni il
@dorukayhan solo se si blocca quando ci sono più oggetti di quanti lo stack possa contenere
— Daniel M.

Risposte:

14

Pyth, 43 41 40 byte

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

Provalo online. Suite di test.

Primo passaggio, veloce e sporco. Ingresso in STDIN come N\nH.

Spiegazione

  1. Salvare il secondo input (altezza) su J( JE) e sottrarlo dal primo input (il numero di elementi). ( -QJE)
  2. Salva la differenza (numero di elementi traboccanti) in K. ( K-QJE)
  3. Aggiungi 1 al numero. ( hK-QJE)
  4. Prendi max(0, previous). Ciò è necessario poiché i numeri negativi interrompono il passaggio successivo. ( g#0hK-QJE)
  5. Prendi al massimo tante lettere dalla stringa " \|/"per ottenere la prima riga e stampare. (<" \|/"g#0hK-QJE )
  6. Loop Nover range(0, J). ( VJ) Per ogni Nstampa la concatenazione di quanto segue: ( s[)
    • "("( \()
    • " "se ci sono almeno N+1spazi liberi nello stack ( <N_K), "-"altrimenti. ( ?<N_Kd\-)
    • ")"( \))
    • "-"se ci sono almeno N+4pezzi traboccanti nella pila ( <N-K3), ""altrimenti. ( *<N-K3\-)
— PurkkaKoodari
fonte
13

JavaScript (ES6), 105 102 byte

@Edit: salvato 3 byte grazie 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>
Espandi frammento

— Neil
fonte
È possibile sostituire substringcon substrper salvare 3 byte e sostituire i+n<h?' ':'-'con '- '[i+n<h]per salvare 2 byte e sostituire i+h+3<n?'-':''con ' -'[i+h+3<n]per salvare 1 byte. Questo ti porterà sotto i 100 anni
— Patrick Roberts
@PatrickRoberts Non riuscivo a ricordare se substrgli abbonamenti negativi ignorati o meno, ma non posso usare gli altri tuoi suggerimenti perché gli abbonamenti alle stringhe sono stringhe, quindi i booleani non sono abbastanza buoni.
— Neil,
merda, l'ho dimenticato, buon punto
— Patrick Roberts,
Uso davvero intelligente del modello con tag per salvare quei due personaggi!
— Benjamin Gruenbaum,
@BenjaminGruenbaum che cos'è un "modello con tag"?
— Patrick Roberts,
12

JavaScript (ES6), 126 122 112 byte

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)

Test

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>`)
Espandi frammento

Test alternativo (se il tuo browser non supporta ES6)

Guarda il test su Babeljs.io e seleziona "valuta".

Approccio alternativo interessante a 136 byte

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))

Questo sposta gli importi di ripetizione nella stringa del modello e utilizza una regexp e sostituisci per iniettare i gruppi ripetuti. Sfortunatamente la firma per .replace()è troppo lunga.

— Patrick Roberts
fonte
Viene visualizzato un errore ...?
— Addison Crump,
1
@VTCAKAVSMoACE il tuo browser deve supportare la sintassi ES6. Funziona bene per me. Sentiti libero di incollare il test in Babel .
— Patrick Roberts,
@VTCAKAVSMoACE Chrome 52 (in versione beta a giugno 2016) supporta tutti ES6 ed ES7 tranne l'ottimizzazione delle chiamate di coda e il caricamento del modulo.
— gcampbell,
10

C ++ 14 (funzione lambda), 196

Salvato 1 byte grazie a Quentin.

Salvato 2 byte grazie 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';}

La stessa funzione richiede 157 byte.

Guardalo in azione qui .

Versione non golfata:

[](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
Non vedo alcun punto nel includere se includee using namespace std;nel conteggio dei byte, a meno che la tua risposta non sia un programma completo (che non lo è).
— Alexander Revo,
9

CJam, 57 byte

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

Provalo qui.

Potrei sicuramente usare qualche miglioramento. L'idea è quella di costruire una griglia in cui le -\|/-celle vengano sostituite con numeri interi consecutivi, ad es

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

E poi sostituirli con i caratteri corretti (potenzialmente spazi) alla fine.

— Martin Ender
fonte
6

Python 2, 101 100 98 byte

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
Gli spazi dopo printnon sono necessari
— Cyoce
@Cyoce Grazie, che salva 2 caratteri.
— Chuck Morris,
4

JavaScript (ES6), 87 80 byte

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

Utilizza la ricorsione per creare la stringa di output dal basso verso l'alto.

EDIT : grazie a @Neil per la rasatura di 7 byte da 87 byte

Originale

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

Snippet di prova:

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>
Espandi frammento

— George Reith
fonte
grazie per il bel frammento! Dovrebbe dare un punto in più: P
— Kimmax
1
@Kimmax Grazie amico, nessuno vuole fare casini con la console
— George Reith,
Almeno quando ho provato, lo stack era piuttosto grande, e sarebbe solo 78 byte con ricorsione normale.
— Neil,
La console dello snippet sta mostrando una SyntaxErrorper me.
— ArtOfCode
1
@ArtOfCode È necessario utilizzare un browser conforme a ES6
— George Reith,
3

JavaScript (ES6), 149 139 137 byte

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

Mi è piaciuta l'idea di @ MartinEnder sull'indicizzazione dei -\|/personaggi e volevo vedere come sarebbe andata in ES6. Apparentemente non ho fatto così bene. Cercando di capire se questo potrebbe essere migliorato usando for...of.

Le modifiche

  • Sono riuscito a rimuovere regexp e la chiamata a .replace, spostando invece l'indicizzazione direttamente in g().
  • Ho contato per errore f=nel secondo conteggio byte

Test

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>`)
Espandi frammento

— Patrick Roberts
fonte
3

Java, 186 177 byte

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

Ungolfed prova 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
Puoi salvare byte usando un lambda
— Daniel M.
2
Ho bisogno di un IDE personalizzato per compilare il codice Java Ungoled ? : D
— Kimmax,
@Kimmax .. D'oh!
— Khaled.K,
3

Excel, 131 byte

Input preso come tupla, Altezza Hin A1, Nin B1. La cella contenente la formula deve avere la funzione A capo automatico attivata. Suggerisci di utilizzare un carattere mono-spaziato.

=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
Soluzione meravigliosa! Dovresti aggiungere che questo prende l'input come 2-tupla da A1e B1aggiungi la semplice nota che ciò richiede che la cella chiamante abbia l'opzione di avvolgimento del testo come vera. Inoltre, forse per ottenere il corretto allineamento dovrebbe avere un carattere mono-spaziato come Courier New o Lucidia Console
— Taylor Scott,
1
Grazie @TaylorScott. Risposta aggiornata con i tuoi suggerimenti.
— Wernisch,
2

C ++ 11, 155 148 145 byte

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

Utilizzo :

#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
— ceilingcat
1

Python 3, 134 121 118 111 byte

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)))

Provalo qui: https://repl.it/CYL1/0

Un-giocato a golf:

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))

Vorrei aver aggiunto l'overflow laterale alla comprensione dell'elenco, ma non sono riuscito a comprimerlo, quindi ho dovuto seguire il ciclo while. 13 byte salvati!

— atlasologist
fonte
L'output è disattivato, probabilmente dovrai cambiarlo '\|/'[:max(0,n-h)]per essere come la soluzione Python 2.
— busfault,
1

Pip , 50 byte

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

Provalo online!

Ugh, è troppo lungo ... non so come accorciarlo più, comunque. L'indicizzazione ciclica, che di solito è utile, questa volta costa byte extra.

— DLosc
fonte
1

PowerShell , 109 108 104 byte

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

Provalo online!

Perso molto per l'indicizzazione costosa ma ancora decente. Non sono sicuro che il mio indice matematico sia comunque ottimale. Ho rubato della logica alle altre risposte per salvare un byte. Ricorda anche la precedenza di far apparire alcune parentesi per -4 byte.

— Veskah
fonte
0

05AB1E , 45 byte

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

Può sicuramente essere giocato a golf .. Non troppo contento nella sua forma attuale tbh.

Provalo online o verifica tutti i casi di test .

Spiegazione:

-                # 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 ti fa sentire meglio, ecco quello che avevo: LR'(ì')«¹x‚3+¬UŸ¦ζJ¹XŸJ¦1úr)˜»e questo è solo per metà.
— Magic Octopus Urn,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.