Sept slash display


99

Ecrivez un programme qui prend une chaîne non vide des chiffres de 0 à 9 et affiche leur affichage sur un affichage à sept segments à l' aide de barres obliques ( /, \).

Ce sont les formes de chiffres précis:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Lorsqu'un chiffre apparaît l'un après l'autre, ils sont chaînés en diagonale vers le haut et à droite, avec un espace diagonal entre eux. Ainsi, par exemple, 203deviendrait ceci:

    /\
     /\
  /\  /
  \ \
/\ \/
 / 
 \/

Notez que le 1personnage occupe la même quantité d’espace que les autres. Les deux lignes du 1sont à droite de l'écran et non à gauche.

Ainsi 159114deviendrait ceci:

           \
          \/\
         \
          \
       \
        \
    /\
    \/\
  /   /
  \/\
 \  /
  \

Il peut y avoir toute quantité et combinaison de nouvelles lignes ou d’espaces dans la sortie tant que les chiffres sont dans la position correcte les uns par rapport aux autres.

Donc 159114, cela serait aussi valable pour:



          \        
         \/\     
        \
         \
      \    
       \          
   /\     
   \/\
 /   /
 \/\         
\  /
 \    


Prenez une entrée de stdin ou de la ligne de commande, ou écrivez une fonction qui prend une chaîne. Imprimez le résultat sur stdout ou vous pouvez le renvoyer sous forme de chaîne si vous écrivez une fonction.

Toute chaîne non vide des chiffres 0 à 9 devrait fonctionner, y compris les chaînes (par exemple , un seul chiffre 8) et les chaînes par des zéros (par exemple 007, les zéros ne doivent être imprimés).

Le code le plus court en octets gagne.


41
Totalement offtopic: Cela a l'air génial!
Martijn

4
C'est vraiment très cool. Cependant, je ne suis pas sûr que la complexité de kolmogorov convienne à cette question - je pensais que cela nécessitait une sortie constante?
alexander-brett

1
@ alexander-brett iirc qui était l'intention initiale, cependant, plus récemment, il a été utilisé pour des problèmes où la majorité du code sera probablement codé en dur.
undergroundmonorail

Cela m'a fait aller comme ... WOW! juste wow!
Renae Lider

Question: Devons-nous gérer des chaînes vides ou des chaînes avec des caractères non numériques?
frederick

Réponses:


9

CJam, 77 71 70 69 63 62 octets

r_,5*_Sa*a*\{~"÷Ðëúܾ¿ðÿþ"=i2bS"\/"4*W<+.*3/..e>2fm>2m>}/Wf%N*

Tous les caractères sont imprimables, le copier-coller devrait donc fonctionner correctement.

Essayez-le en ligne dans l' interprète CJam .

Idée

Nous commençons par examiner le nombre de chiffres n dans l'entrée et en poussant un carré d'espaces assez grand pour couvrir la sortie. Dans l'implémentation, ce carré sera codé sous la forme d'un tableau à deux dimensions de chaînes à un caractère.

Un carré de longueur 2n + 1 conviendrait parfaitement (c’est-à-dire qu’il n’ya pas d’espace blanc) pour une implémentation simple, mais nous en utiliserons un de longueur 5n pour économiser quelques octets. Heureusement, les espaces blancs environnants sont autorisés.

Si nous inversons les lignes de la représentation sept barres obliques de 8 , nous obtenons ce qui suit:

 \/
\/\
/\

La représentation de tous les chiffres peut être codé comme un entier 8 bits, où le i ème bit est 0 ssi le i ème personnage doit me remplacer par un espace. Pour les chiffres de 0 à 9 , les entiers résultants sont

247 208 235 250 220 190 191 240 255 254

qui correspondent aux caractères ISO-8559-1 suivants:

÷Ðëúܾ¿ðÿþ

Pour chaque chiffre dans l'entrée, après avoir sélectionné le nombre entier de 8 bits, on répète le i correspondant ième caractère de la représentation de 8 exactement un i fois, où un i est le i ème bit du nombre entier. Cela pousse un tableau de chaînes de un ou zéro caractères. En divisant ce tableau en morceaux de longueur 3, nous obtenons un tableau où chaque élément correspond à une ligne de la représentation.

Maintenant, nous calculons le maximum vectorisé des chaînes qui représentent le carré et les chaînes qui représentent le chiffre. Les chaînes /et \sont plus grandes que la chaîne  , elles vont donc remplacer les espaces dans le carré. Toutefois, la chaîne  vide est plus petite que la chaîne . Par conséquent, les chaînes vides dans la représentation numérique préservent les espaces du carré.

Nous tournons maintenant les lignes et les colonnes de deux unités pour placer la représentation numérique suivante dans la partie appropriée du carré et répétons le processus pour les chiffres restants de l'entrée.

Enfin, nous inversons chaque ligne et insérons un saut de ligne entre les lignes individuelles.

Code

r_,      e# Read a token from STDIN and push the length of a copy.
5*_      e# Multiply the length by 5 and push a copy.
Sa*      e# Repeat the array [" "] that many times.
a*       e# Repeat the array [[" " ... " "]] that many times.
\{       e# For each character C in the input:
  ~      e#   Push eval(C), i.e., the digit the character represents.

  "÷Ðëúܾ¿ðÿþ"

         e#   Push the encodings of all 10 seven slash representations.

  =      e#   Select the proper one.
  i2b    e#   Push the resulting characters code point in base 2, i.e., its bits.
  S      e#   Push " ".
  "\/"4* e#   Push "\/\/\/\/".
  +W<    e#   Concatenate and eliminate the last character.
  .*     e#   Vectorized repetition.

         e#   For the digit 5, e.g., we have [1 0 1 1 1 1 1 0] and  " \/\/\/\" on
         e#   the stack, so .* yields [" " "" "/" "\" "/" "\" "/" ""].

  3/     e#   Divide the representation into chunks of length 3, i.e., its lines.
  ..e>   e#   Compute the twofold vectorized maximum, as explained above.
  2fm>   e#   Rotate each line to characters to the right.
  2m>    e#   Rotate the lines two units down.
}/
Wf%      e# Reverse each line.
N*       e# Place linefeeds between them.

Les dernières rotations gâcheraient la sortie si la longueur du côté du carré était inférieure à 2n + 3 . Puisque 5n ≥ 2n + 3 pour tous les entiers positifs n , le carré est suffisamment grand pour empêcher cela.


Serait-il judicieux de publier ici une version base64 de votre code?
TRiG

1
+1, mais pour être honnête, j'espérais que CJam et al. serait assis celui-ci sur: p
primo

@primo: Je ressens la même chose à propos de Pyth et des questions de mathématiques. : P Je suis un peu en retard à la fête parce que je me suis fait tripoter par des mots réarrangés . Ce n’est que jusqu’à votre édition de ce matin que je me suis souvenu de cette question.
Dennis

Les défis de @Dennis semblent aller beaucoup plus vite qu'auparavant. J'y travaille encore il y a deux semaines: p
primo

1
Je cherche toujours CJam en premier en espérant qu'il aura le plus petit nombre d'octets. Je n'ai pas encore été déçu.
Ingénieur Toast

25

Python 3, 189 183 174 octets

s="a%sa"%input()
while s[1:]:b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")];S=len(s)*"  ";print(S+a+b,c+d+"\n"+S+e+f+g);*s,_=s

La compression me convient, mais j'ai du mal à trouver un bon moyen d'abandonner les sept variables ...

Heureusement, la spécification est assez détendue sur les règles d'espaces, car il y a beaucoup d'espaces en tête / en fin.

Étendu:

s="a%sa"%input()
while s[1:]:
  b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "
                 for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")]
  S=len(s)*"  "
  print(S+a+b,c+d+"\n"+S+e+f+g)
  *s,_=s

Explication

Les positions de segment représentées par les variables sont:

    ab               /\
    efg               /\
  ab cd            /\  /
  efg              \ \
ab cd            /\ \/
efg               /
 cd               \/

Chaque segment est codé par un seul caractère Unicode de 2 octets. Par exemple, ϻencode gle segment comme suit:

bin(ord("ϻ")) = bin(1019) = "0b1111111011"
                               ^^^^^^^^^^
                               9876543210

En effet, 2c’est le seul chiffre à ne pas utiliser le segment inférieur droit d’un affichage à sept segments.


19

C, 1098 345 323 319 octets

Première Deuxième Troisième tentative. Finalement décidé d'abandonner le tampon d'écran pour économiser quelques octets. Ce programme prend un paramètre de chiffres et imprime les chiffres au format 7 segments.

Premier participant. Juste pour le fun. Sois gentil.

a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977},i,j,k,n,m;char*c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
main(w,char**v){f(i,n=strlen(v[1]))f(k,(m=n-i-1)?2:3){f(j,m*2)P(32);f(w,3)Q(m,k,w);if(!k&&i)f(w,2)Q(m+1,2,w+1);P(10);}}

Élargi, sans avertissement:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977};
char *c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
int main(int w, char **v)
{
    int i,j,k,n,m;
    f(i,n=strlen(v[1])) {
        m=n-i-1;
        f(k,m?2:3) {
            f(j,m*2) P(32);
            f(w,3) Q(m,k,w);
            if (!k&&i) f(w,2) Q(m+1,2,w+1);
            P(10);
        }
    }
}

Le pistolet le plus rapide dans l'ouest. Je compresse le mien maintenant.
Alexey Burdin

15
Hey! Bienvenue chez Code Golf. Le but de ce défi est de rendre votre code aussi court que possible. Vous devez donc procéder à des optimisations en ce qui concerne la suppression des espaces, les déclarations de raccourcis, etc., puis indiquez le nombre d'octets en haut de votre publication avec la langue. Excellent premier post cependant! Juste pour référence, votre publication initiale est longue de 1 098 octets.
Kade

Merci. Vient d’ajouter la langue et le nombre d’octets. Mon original a même des commentaires et utilisation. :)
un utilisateur du

Conseil: remplacez tous les noms de variables par des caractères uniques. Aussi, vous utilisez `for (i = 0; i <digits` beaucoup, peut-être le remplacer par une macro?
Joshpbarron

Bon travail ici. Pour rendre votre pointage plus compétitif, vous pouvez jeter un oeil à nos conseils pour jouer au golf en C .
Alex A.

14

JavaScript, 192 178 167 162 octets

f=x=>{n=b="\n";for(k in x)for(i=0;i<8;)b+=("î\xA0Öô¸|~àþü".charCodeAt(x[k])>>i++&1?i%2?"/":"\\":" ")+(i%3?"":n+"  ".repeat(k));return b.split(n).reverse().join(n)}

Utilisation: f("1337");reviendra

      /\
        \
    /\   
     /\
  /\  /
   /\
 \  /
  \

Il utilise des fonctionnalités de ES6 et peut avoir un comportement dépendant de l'implémentation en raison de l'omission des points-virgules et des parenthèses, etc., mais cela fonctionne dans Firefox.

Étendu:

f=x=>
{
    n = b = "\n";

    for (k in x)
        for (i=0; i<8;)
            b += ("î\xA0Öô¸|~àþü".charCodeAt(x[k]) >> i++ & 1? i%2? "/" : "\\" : " ") + (i%3? "" : n+"  ".repeat(k));

    return b.split(n).reverse().join(n)
}

Explication:

lest un tableau contenant 10 caractères sur un octet correspondant à la forme de chaque chiffre. Par exemple, le chiffre 0 est représenté par le caractère î:

/\        11
\ \  -->  101  --> 11 101 110 = î
 \/       011

Les caractères en entrée sont utilisés comme clés pour que le tableau conserve leur forme, représentant des contreparties, qui sont lues bit par bit.


2
Sont ==0et ==1bien nécessaires avant ?. Int n'est-il pas considéré comme un booléen dans js? @Regret
Alexey Burdin

1
@Regret: "w\x05k/\x1D>~\x07\x7F?"avec chaque caractère inversé au niveau du bit "\xee\xa0\xd6\xf4\xb8|~\xe0\xfe\xfc", chacun de ceux-ci est imprimable. Cela donne 8 octets supplémentaires. Bien que pas assez ...
Alexey Burdin

1
Vous pouvez supprimer 2 octets en supprimant les parenthèses f=(x)=>{}- elles ne sont pas nécessaires avec un seul argument.
Scimonster

Vous avez absolument raison, @Alexey. Je vais changer ça.
Regret

Est-ce que ça marche? Je reçois 6 autres lignes avec des personnages parasites.
edc65

10

Perl - 103 octets

#!perl -n
print$i+$%2?U^(u,$i--%2?v9:z)[$i<4+$%2&vec$_,4*$-3-$i,1]:$/.!($i=$--)
while$+=2*y/0-9/wPkz\\>?p~/

Ce qui précède contient 6 caractères non imprimables (la source peut être téléchargée sur Ideone ) et correspond à ce qui suit:

#!perl -n
print$i+$^F%2?U^(u,$i--%2?v9:z)[$i<4+$^F%2&vec$_,4*$^F-3-$i,1]:$/.!($i=$^F--)
while$^F+=2*y/0-9/wPkz\\>?p\177~/

Chacun ^Fpeut être remplacé par un caractère littéral 6 (ACK) et \177par le caractère 127 (DEL).

Le shebang est compté comme 1, la deuxième nouvelle ligne est inutile. L'entrée est prise de stdin.


Exemple d'utilisation

$ echo 0123 | perl seven-slash.pl

      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

$ echo 456789 | perl seven-slash.pl

          /\
          \/\
        /\  /
        \/\
      /\ \/
        \
    /
    \/\
  /  \/
  \/\
 \  /
\/\

Explication

La sortie est générée un octet à la fois. Chaque caractère est translittéré, et ceci est ensuite interprété comme un tableau de bits utilisant vec. Les bits sont stockés de la manière suivante:

   /\           56 
   \/\          234
 /\ \/   ->   56 01
 \/\          234 
  \/           01

La sortie alterne entre 3 et 5 barres obliques, de sorte que les bits 56débordent 01du chiffre suivant. Le bit 7n'est pas utilisé.


8

C #, 360 355 331 octets

Bonjour, première tentative de code-golf. J'espère que cela ne marque pas trop mal pour une entrée en C #.

string p(string n){var l=new string[n.Length*2+1];var i=l.Length-1;for(;i>0;){var x=@"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0]-48)*7,7);for(var j=i-3;j>=0;){l[j--]+="  ";}l[i--]+=" "+x[5]+x[6];l[i--]+=""+x[2]+x[3]+x[4];l[i]+=""+x[0]+x[1];n=n.Remove(0, 1);}return string.Join("\n",l);}

Utilisation: p("159114");reviendra

          \
         \/\
        \
         \
      \
       \
   /\
   \/\
 /   /
 \/\
\  /
 \

Étendu:

string p(string n)
    {
        var l = new string[n.Length * 2 + 1];
        var i = l.Length - 1;
        for (; i > 0; )
        {
            var x = @"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0] - 48) * 7, 7);

            for (var j = i - 3; j >= 0; )
            {
                l[j--] += "  ";
            }
            l[i--] += " " + x[5] + x[6];
            l[i--] += "" + x[2] + x[3] + x[4];
            l[i] += "" + x[0] + x[1];

            n = n.Remove(0, 1);
        }

        return string.Join("\n", l);
    }

1
Je sais que cela fait presque trois ans, mais vous pouvez jouer au golf 30 octets: essayez-le en ligne. 301 octets . Bonne réponse cependant, +1 de moi.
Kevin Cruijssen

Cool. N'hésitez pas à l'afficher comme votre propre réponse alors :)
Shion

1
Non, c'est ton code. J'ai juste raccourci un peu en supprimant les crochets de la boucle for et en combinant les variables. Et changer string s(string n)à l' n=>aide d'un lambda. Ah bon, vous pouvez simplement le laisser comme ça si vous préférez. :) J'ai cependant créé un port pour Java qui vous crédite. ;)
Kevin Cruijssen

4

python 2, 317 298 278 273,15

def f(s):
    r=range;n=len(s)*2;l=[[' ']*-~n for x in r(-~n)]
    for x in r(0,n,2):
        for i,[d,y,c]in enumerate(zip('0112012','1021012',r'\\\\///')):l[n-2-x+int(y)][x+int(d)]=[' ',c][('%7s'%(bin(ord('}(7/jO_,\x7fo'[map(int,s)[x/2]])))[2:])[i]=='1']
    for x in l:print''.join(x)

J'ai considéré 4 espaces comme des onglets en comptant.
Non compressé et lisible:

def f(s):
    r=['1111101','0101000','0110111','0101111','1101010','1001111','1011111','0101100','1111111','1101111']
    ''.join(map(lambda x:chr(eval('0b'+x)),r))
    n=len(s)*2
    l=[[' ']*(n+1) for x in xrange(n+1)]
    shifts=[(0,1,'\\'),(1,0,'\\'),(1,2,'\\'),(2,1,'\\'),(0,0,'/'),(1,1,'/'),(2,2,'/')]
    for x in xrange(0,n,2):
        y=n-2-x
        for i,[dx,dy,c] in enumerate(shifts):
            l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' '
    return '\n'.join(''.join(x) for x in l)

Hey! Excellente réponse, mais vous pouvez faire quelques changements pour le rendre encore plus court. Passer l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' 'en mode l[y+dy][x+dx]=[' ',c][r[map(int,s)[x/2]][i]=='1']sauvegarde de 5 octets, passer return '\n'.join(''.join(x) for x in l)en mode print'\n'.join(''.join(x)for x in l)sauvegarde de 3 octets, plus quelques modifications supplémentaires. Voici un lien vers un Gist où j'ai eu le décompte d'octets à 440 à partir de 508.
Kade

6
Kelvin aurait été très satisfait de ce score.
Cristian Lupascu

3
Votre réponse est en réalité de 272 octets, mais vous pouvez en enregistrer une de plus car un espace est plus court qu'un onglet. Voir ici . Comment pourriez-vous avoir 273,15 octets de toute façon?
mbomb007

1
273,15 octets signifie que @AlexeyBurdin a découvert l'informatique analogique sur une plate-forme numérique. Pourquoi dans le monde l' avez-vous publié ici, plutôt que dans Science? ;-)
hBy2Py

1
Cela signifie seulement que la solution est gelée au zéro absolu, c'est-à-dire que je ne veux pas me concentrer sur une chose qui a déjà été perdue . :)
Alexey Burdin

3

KDB (Q), 172 136 octets

{d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;
 -1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}

Explication

1) Créer une dcarte avec toutes les formes des chiffres.

2) Remplissez la matrice avec des zéros supplémentaires et ajoutez-les ensemble. c'est-à-dire "01"

0           0 0 0 2 0   
0           0 0 0 0 2
1 2 0 0 0 + 0 0 0 0 0
2 0 2 0 0   0
0 2 1 0 0   0

3) Utilisez l’index pour cartographier " /\"et imprimer avec -1.

Tester

q){d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;-1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}"0123456789"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

Je suis sûr que ça peut être plus court !!

Merci @hjk


1
La seule réduction que j'ai remarquée est de remplacer 1 2 0 2 1 2 0 2 1par (9#1 2 0 2)(-6).
HJK

1
Oh, et remplacer enlistpar des 1#œuvres, donc c'est un autre -5.
hjk

1
tu es une étoile! Je vais mettre à jour! mais ne peux pas remplacer le enlistbien parce que count[a 0]#0n'est pas atome :(
WooiKent Lee

ah étrange cela a fonctionné pour moi si ... doit être une bizarrerie. ;)
hjk

1
en fait, list plus atome étendra l'atome à la bonne longueur quand même! tu m'as rappelé un tel mécanisme! : D
WooiKent Lee

2

Pip, 122 + 1 = 123 octets

Utilise le -ndrapeau. Prend une entrée via un argument de ligne de commande.

l:$.(J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Ma)z:2*#ap:sXz+2RLz+2Fi,5Fj,z{c:[4-ii]//2+j(pc@0c@1):(lij)}RVp

Les caractères de la chaîne UTF-8 ont les points de code suivant: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Légèrement non-golfé:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^t@a.2<>2}Ma)
z:2*#a+2
p:sXzRLz
Fi,5
 Fj,2*#a {
  x:i//2+j
  y:(4-i)//2+j
  p@y@x:l@i@j
 }
P RVp

La stratégie de base consiste à rechercher les caractères constitutifs de chaque numéro, puis à les biaiser de manière appropriée. Par exemple, pour 8, nous voulons ceci (espaces représentés par des points):

/.
\\
/.
\\
/.

qui se transformera en ceci:

 .  
/\. 
\/\.
 \/ 

La fonctionnalité intéressante de cette stratégie est que plusieurs nombres pré-asymétriques peuvent simplement être concaténés côte à côte.

Maintenant, nous pouvons encoder /.\\/.\\/.en base 3 comme 1200120012. Ensuite, nous pouvons convertir cela en décimal et le traiter comme un point de code UTF-8.

L'expression J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maobtient les données pré-asymétriques par le processus suivant:

                            Ma   Map this lambda function to each character in input:
        (A_TB3M"...")            Create list of the code points of each character in UTF-8
                                   string, converted to base 3
                     @_          Index into that list using the input character
                       .2        Concatenate 2 to the end of the base-3 value (all of the
                                   pre-skewed number grids end in 2, i.e. space)
       ^                         Split the number into a list of its digits
 "\/ "@                          Index into this string with those digits, giving a list
                                   of slashes & spaces
J                                Join the list together into a string
                         <>2     Group string two characters at a time

Une fois que nous avons concaténé ces chaînes côte à côte $., nous créons une grille d’espaces (2 * n +2 carrés), parcourons la grille pré-asymétrique et remplaçons les espaces correspondants dans la grille post-asymétrique par les caractères appropriés. Pour le voir se produire, on peut modifier le code pour imprimer chaque étape et mettre en pause pour la saisie de l'utilisateur:

Algorithme en cours

La grille est en réalité construite à l'envers, car cela semblait faciliter les calculs.

Je suis sûr qu'il existe de meilleurs algorithmes à utiliser. Mais je voulais proposer ma propre idée plutôt que de copier celle de quelqu'un d'autre.

Plus sur Pip


2

Brainfuck - 719 octets

Pour contexte historique seulement, crédits à Daniel B Cristofani. Je ne sais pas exactement quand cela a été créé, mais il est disponible sur Internet Archive dès le 9 mai 2003.

La sortie 9est différente de celle décrite dans la description du problème.

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

2
Je l'ai probablement écrit en 2002. D'après Internet Archive , Panu Kalliokoski l'a ajoutée à son référentiel brainfuck en août 2002. Quant au 9, je pense avoir utilisé les modèles de la deuxième édition de Microprocessors and Interfacing , page 4.
Daniel Cristofani

1

Perl, 270 octets

Je n'aurais vraiment pas dû perdre mon temps avec ça.

$e="\\";$g=" ";$_=reverse<>;$l=length;push@a,(119,18,107,91,30,93,125,19,127,95)[$1]while/(.)/g;for($i=0;$i<=$l;$i++){$j=2*($l-$i);$b=$a[$i];$c=$i&&$a[$i-1];print" "x$j,$b&1?"/":$g,$b&2?$e:$g,$g,$c&32?$e:$g,$c&64?"/":$g,"
"," "x$j,$b&4?$e:$g,$b&8?"/":$g,$b&16?$e:$g,"
"}

remplacez [$1]while/(.)/gpar [$_]for/./gpour sauvegarder 4 octets. remplacez for($i=0;$i<=$l;$i++)par for$i(0..$l)pour sauvegarder 9 octets.
Hobbs

1

JavaScript ( ES6 ), 191 206

Exécutez le fragment de code dans Firefox pour tester.

F=m=>(
  a='    \\/  /\\/\\ /  /\\  \\\\ \\'.match(/.../g),
  o=f='',r=' ',
  [for(d of m)(
    n=1e3+'¯B\x91ÿ$ê\x86A\x87ë'.charCodeAt(d)+'', // here there are 3 valid characters tha the evil stackoverflow editor just erase off, so I had to put them as hex escape
    o='\n'+f+' '+a[n[2]]+'\n'+r+a[n[1]]+o,
    r=f+a[n[3]],
    f+='  ')],
  r+o
)


//TEST

go=_=>O.innerHTML =(v=I.value)+'\n'+F(v)

go()
<input id=I value='0123456789'><button onclick='go()'>-></button>
<pre id=O></pre>


0

Java 8, 341 octets

n->{int i=n.length*2,j=i+1,k=0,t;String l[]=new String[j],x;for(;j-->0;l[j]="");for(;i>0;l[i--]+=" "+x.substring(5,7),l[i--]+=x.substring(2,5),l[i]+=x.substring(0,2))for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\').substring(t=(n[k++]-48)*7,t+7),j=i-2;j-->0;)l[j]+="  ";return"".join("\n",l);}

La réponse du port de @Shion en C # .NET , assurez-vous donc également de lui donner son vote!

Essayez-le en ligne.

Explication:

n->{                       // Method with character-array parameter and String return-type
  int i=n.length*2,        //  Two times the length of the input array
      j=i+1,               //  Index integer, starting at `i+1`
      k=0,t;               //  Temp integers
  String l[]=new String[j],//  String-array for the rows, default filled with `null`
         x;                //  Temp-String
  for(;j-->0;l[j]="");     //  Replace all `null` with empty Strings
  for(;i>0                 //  Loop `i` downwards in the range [`n.length*2`, 0)
      ;                    //   After every iteration:
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         " "               //     A space
         +x.substring(5,7),//     And the 6th and 7th characters of temp-String `x`
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         x.substring(2,5), //     The 3rd, 4th and 5th characters of temp-String `x`
       l[i]+=              //    Append the row at index `i` with:
         x.substring(0,2)) //     The 1st and 2nd characters of the temp-String `x`
    for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\')
                           //   String containing all digit-parts
          .substring(t=(n[k++]-48)*7,t+7),
                           //   and take the substring of 7 characters at index
                           //   `n[k]` as integer multiplied by 7
        j=i-2;j-->0;)      //   Inner loop `j` in the range (`i`-2, 0]
      l[j]+="  ";          //    And append the rows at index `j` with two spaces
  return"".join("\n",l);}  //  Return the rows delimited with new-lines
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.