Pile débordante

47

(Inspiré par cette question )

Objectif

Votre tâche consiste à écrire un programme ou une fonction pour imprimer une version ASCII du logo Stack Overflow sur STDOUT.

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

Votre programme doit prendre deux entrées, appelées ici H et N. La hauteur du "conteneur" de la pile (les parenthèses) est déterminée par H. Le nombre d'éléments de la pile est déterminé par N. Si N> H, le la pile va "déborder".

Entrée sortie

H déterminera la hauteur des conteneurs

Par exemple:

H = 1:

( )

H = 2:

( )
( )

H = 3:

( )
( )
( )

H sera toujours au moins 1

N déterminera le nombre d'éléments contenus dans la pile. Les exemples suivants sont tous H = 2:

N = 0

( )
( )

N = 1

( )
(-)

N = 2

(-)
(-)

N = 3

 \
(-)
(-)

N = 4

 \|
(-)
(-)

N = 5

 \|/
(-)
(-)

N = 6

 \|/
(-)-
(-)

N = 7

 \|/
(-)-
(-)-

N ne sera jamais plus que 2H+3(en d'autres termes, la pile ne passera jamais par le sol).

Règles

  • Aucune échappatoire standard.
  • Votre programme ne doit générer aucune erreur.
  • Tous les cas de test doivent réussir.
  • Vous pouvez entrer H et N comme vous le souhaitez.
  • Je doute sérieusement que votre langue ait une fonction intégrée pour cela.
  • Chaque ligne peut éventuellement avoir un espace supplémentaire à la fin. Une ligne vide au-dessus d'une pile où N <= H est facultative, de même qu'une fin de ligne.
  • C'est du code-golf , donc le code le plus court en octets gagne!

Cas de test

En plus de tous les tests H = 2 de la section Entrée / Sortie, tous les tests suivants doivent réussir:

H = 1, N = 1

(-)

H = 1, N = 5

 \|/
(-)-

H = 4, N = 7

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

H = 5, N = 0

( )
( )
( )
( )
( )

Classements

Voici un extrait de pile permettant de générer un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf  ascii-art 
— Daniel M.
source
4
Puis-je publier un programme non concurrent qui déborde de la pile au lieu d’imprimer le logo?
— Dorukayhan veut que Monica revienne le
@dorukayhan Si elle ne déborde que lorsque n> h :)
— Daniel M.
Je veux dire, puis-je créer un programme qui tombe en panne à cause d'un débordement de pile?
— Dorukayhan veut que Monica revienne le
@ dorukayhan uniquement si le système se bloque lorsqu'il y a plus d'éléments que la pile ne peut en contenir
— Daniel M.

Réponses:

14

Pyth, 43 41 40 octets

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

Essayez-le en ligne. Suite de tests.

Premier passage, rapide et sale. Entrée dans STDIN en tant que N\nH.

Explication

  1. Enregistrez la deuxième entrée (hauteur) dans J( JE) et soustrayez-la de la première entrée (nombre d'éléments). ( -QJE)
  2. Enregistrez la différence (nombre d'éléments débordants) dans K. ( K-QJE)
  3. Ajoutez 1 au nombre. ( hK-QJE)
  4. Prendre max(0, previous). Ceci est nécessaire car des nombres négatifs briseraient l'étape suivante. ( g#0hK-QJE)
  5. Prenez au maximum autant de lettres de la chaîne " \|/"pour obtenir la première ligne et imprimer. ( <" \|/"g#0hK-QJE)
  6. Boucle Nterminée range(0, J). ( VJ) Pour chaque Nimpression, la concaténation de ce qui suit: ( s[)
    • "("( \()
    • " "s'il y a au moins N+1des espaces libres dans la pile ( <N_K), "-"sinon. ( ?<N_Kd\-)
    • ")"( \))
    • "-"s'il y a au moins des N+4morceaux débordants dans la pile ( <N-K3), ""sinon. ( *<N-K3\-)
— PurkkaKoodari
source
13

JavaScript (ES6), 105 102 octets

@Edit: 3 octets enregistrés grâce à @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>
Développer l'extrait

— Neil
source
Vous pouvez remplacer substringpar substrpour sauvegarder 3 octets, et i+n<h?' ':'-'par '- '[i+n<h]pour sauvegarder 2 octets et remplacer i+h+3<n?'-':''par ' -'[i+h+3<n]pour sauvegarder 1 octet. Ça vous fera moins de 100 ans
— Patrick Roberts
@ PatrickRoberts Je ne me souvenais pas si les substrsous- scripts négatifs étaient ignorés ou non, mais je ne peux pas utiliser vos autres astuces car les sous-scripts de chaîne sont des chaînes, donc les booléens ne sont pas assez bons.
— Neil
merde j'ai oublié à ce sujet, bon point
— Patrick Roberts
Utilisation vraiment intelligente du modèle marqué afin de sauvegarder ces deux personnages!
— Benjamin Gruenbaum
@BenjaminGruenbaum, qu'est-ce qu'un "modèle étiqueté"?
— Patrick Roberts
12

JavaScript (ES6), 126 122 112 octets

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)

Tester

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>`)
Développer l'extrait

Autre test (si votre navigateur ne supporte pas ES6)

Voir le test sur Babeljs.io et cochez la case "évaluer".

Approche alternative intéressante à 136 octets

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

Cela déplace les montants de répétition dans la chaîne de modèle et utilise une expression rationnelle à remplacer pour injecter les groupes répétitifs. Malheureusement, la signature .replace()est trop longue.

— Patrick Roberts
source
J'ai une erreur ...?
— Addison Crump
1
@VTCAKAVSMoACE votre navigateur doit prendre en charge la syntaxe ES6. Ça fonctionne bien pour moi. N'hésitez pas à coller le test dans Babel .
— Patrick Roberts
@VTCAKAVSMoACE Chrome 52 (en version bêta à compter de juin 2016) prend en charge l'ensemble de l'ES6 et de l'ES7, à l'exception de l'optimisation des appels en aval et du chargement du module.
— Gcampbell
10

C ++ 14 (fonction lambda), 196

Sauvé 1 octet grâce à Quentin.

2 octets sauvés grâce à 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 fonction elle-même prend 157 octets.

Voir en action ici .

Version non-golfée:

[](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
source
2
Je ne vois pas l'intérêt d'inclure includes et using namespace std;dans le nombre d'octets, à moins que votre réponse ne soit un programme complet (ce qui n'est pas le cas).
— Alexander Revo
9

CJam, 57 octets

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

Testez-le ici.

Pourrait certainement utiliser certaines améliorations. L’idée est de construire une grille où les -\|/-cellules sont remplacées par des entiers consécutifs, par exemple

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

Et puis pour les remplacer par les caractères corrects (potentiellement des espaces) à la fin.

— Martin Ender
source
6

Python 2, 101 100 98 octets

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
source
Les espaces après ne printsont pas nécessaires
— Cyoce
@ Cyoce Merci, cela économise 2 caractères.
— Chuck Morris
4

JavaScript (ES6), 87 80 octets

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

Utilise la récursivité pour créer la chaîne de sortie de bas en haut.

EDIT : Merci à @Neil d’ avoir supprimé 7 octets sur 87 octets

Original

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

Extrait de test:

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>
Développer l'extrait

— George Reith
source
merci pour le bel extrait! Devrait donner un point supplémentaire: P
— Kimmax
1
@ Kimmax Merci mate, personne ne veut jouer avec la console
— George Reith
Au moins quand j'ai essayé, la pile était assez grande, et ce ne serait que 78 octets avec une récursivité ordinaire.
— Neil
La console d'extrait montre un SyntaxErrorpour moi.
— ArtOfCode
1
@ArtOfCode Besoin d'utiliser un navigateur compatible ES6
— George Reith
3

JavaScript (ES6), 149 139 137 octets

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

J'aimais l'idée de @ MartinEnder d'indexer les -\|/personnages et je voulais voir comment elle se comporterait dans ES6. Apparemment, je n'ai pas si bien réussi. Essayer de savoir si cela pourrait être amélioré en utilisant for...of.

Édite

  • J'ai réussi à supprimer l'expression rationnelle et l'appel à .replace, en déplaçant l'indexation directement dans g().
  • J'ai accidentellement compté f=dans le deuxième décompte d'octets

Tester

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>`)
Développer l'extrait

— Patrick Roberts
source
3

Java, 186 177 octets

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 essayer en ligne

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
source
Vous pouvez économiser des octets en utilisant un lambda - vous pouvez probablement même laisser de côté le corps du lambda
— Daniel M.
2
Ai -je besoin d'un IDE personnalisé pour compiler le code Java Ungoled ? : D
— Kimmax
@ Kimmax .. D'oh!
— Khaled.K
3

Excel, 131 octets

Entrée prise sous forme de tuple, hauteur Hen A1, Nen B1. L'habillage du texte doit être activé dans les cellules contenant une formule. Suggérez d'utiliser une police mono-espacée.

=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
source
Merveilleuse solution! Vous devez ajouter que cette entrée prend comme le 2-tuple from A1et B1et ajouter la simple note que cela nécessite que la cellule appelante ait l'option de texte intégral pour avoir la valeur true. Aussi, peut-être que pour obtenir le bon alignement, il devrait avoir une police à simple interligne telle que Courier New ou Lucidia Console
— Taylor Scott
1
Merci @TaylorScott. Réponse mise à jour avec vos suggestions.
— Wernisch
2

C ++ 11, 155 148 145 octets

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

Utilisation :

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

Python 3, 134 121 118 111 octets

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

Testez-le ici: https://repl.it/CYL1/0

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

J'aimerais avoir ajouté le débordement latéral à la compréhension de la liste, mais je ne pouvais pas l'insérer, alors je devais partir avec la boucle while. 13 octets sauvés!

— atlasologue
source
La sortie est désactivée, vous devrez probablement changer le '\|/'[:max(0,n-h)]pour ressembler à la solution Python 2.
— busfault
1

Pip , 50 octets

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

Essayez-le en ligne!

Ugh, c'est trop long ... je ne sais pas comment le raccourcir, cependant. L'indexation cyclique, généralement utile, coûte des octets supplémentaires cette fois-ci.

— DLosc
source
1

PowerShell , 109 108 104 octets

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

Essayez-le en ligne!

Perdu sur une indexation coûteuse mais toujours décente. Je ne suis pas sûr que mon index mathématiques soit optimal cependant. A volé un peu de logique dans les autres réponses pour sauvegarder un octet. Rappelons également la priorité de faire apparaître des parenthèses pour -4 octets.

— Veska
source
0

05AB1E , 45 octets

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

Peut certainement être joué au golf .. Pas trop heureux à ce sujet dans sa forme actuelle tbh.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

-                # 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
source
Si ça te fait te sentir mieux, voici ce que j'avais: LR'(ì')«¹x‚3+¬UŸ¦ζJ¹XŸJ¦1úr)˜»et ce n'est qu'à moitié fait.
— Urne magique Octopus
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.