Seven Slash Display

99

Escriba un programa que tome una cadena no vacía de los dígitos del 0 al 9 e imprima cómo se mostrarían en una pantalla de siete segmentos utilizando barras ( /, \).

Estas son las formas precisas de dígitos:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Cuando un dígito ocurre después de otro, se encadenan diagonalmente hacia arriba y hacia la derecha, con un espacio diagonal en el medio. Entonces, por ejemplo, 203se convertiría en esto:

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

Tenga en cuenta que el 1personaje ocupa la misma cantidad de espacio que los demás. Las dos líneas 1están en el lado derecho de la pantalla, no a la izquierda.

Entonces 159114se convertiría en esto:

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

Puede haber cualquier cantidad y combinación de nuevas líneas o espacios iniciales / finales en la salida, siempre que los dígitos estén en la posición correcta entre sí.

Entonces 159114, esto también sería válido:



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


Tome la entrada de stdin o la línea de comando, o escriba una función que tome una cadena. Imprima el resultado en stdout o puede devolverlo como una cadena si escribe una función.

Cualquier cadena no vacía de los dígitos del 0 al 9 debería funcionar, incluidas las cadenas de un solo dígito (p 8. Ej. ) Y las cadenas con ceros a la izquierda (p. Ej. 007, Los ceros necesita ser impresa).

El código más corto en bytes gana.

Pasatiempos de Calvin
fuente
41
Totalmente fuera de tema: ¡Esto se ve increíble!
Martijn
44
Esto es muy, muy genial. Sin embargo, no estoy seguro de que la complejidad de kolmogorov sea apropiada para esta pregunta: ¿pensé que eso requería una salida constante?
alexander-brett
1
@ alexander-brett iirc esa era la intención original, sin embargo, más recientemente se ha utilizado para problemas en los que la mayoría del código probablemente se va a codificar.
undergroundmonorail
Esto me hizo ir como ... ¡GUAU! ¡simplemente guau!
Renae Lider
Pregunta: ¿Necesitamos manejar cadenas vacías o cadenas con caracteres que no sean dígitos?
Frederick

Respuestas:

9

CJam, 77 71 70 69 63 62 bytes

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

Todos los caracteres son imprimibles, por lo que copiar y pegar debería funcionar bien.

Pruébelo en línea en el intérprete de CJam .

Idea

Comenzamos examinando el número de dígitos n en la entrada y presionando un cuadrado de espacios lo suficientemente grande como para cubrir la salida. En la implementación, este cuadrado se codificará como una matriz bidimensional de cadenas de un carácter.

Un cuadrado de longitud 2n + 1 sería correcto (es decir, sin espacios en blanco circundantes) para una implementación sencilla, pero usaremos uno de longitud 5n para guardar un par de bytes. Afortunadamente, se permite el espacio en blanco circundante.

Si invertimos las líneas de la representación de siete barras diagonales de 8 , obtenemos lo siguiente:

 \/
\/\
/\

La representación de todos los dígitos se puede codificar como un entero de 8 bits, donde el i- ésimo bit es 0 si el i- ésimo carácter debe reemplazarse con un espacio. Para los dígitos del 0 al 9 , los enteros resultantes son

247 208 235 250 220 190 191 240 255 254

que corresponden a los siguientes caracteres ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Para cada dígito en la entrada, después de seleccionar el entero de 8 bits correspondiente, repetimos el i- ésimo carácter de la representación de 8 exactamente a i veces, donde a i es el i th bit del entero. Esto empuja una serie de cadenas de uno o cero caracteres. Al dividir esta matriz en trozos de longitud 3, obtenemos una matriz donde cada elemento corresponde a una línea de la representación.

Ahora, calculamos el máximo vectorizado de las cadenas que representan el cuadrado y las cadenas que representan el dígito. Las cadenas /y \son más grandes que la cadena  , por lo que reemplazarán los espacios en el cuadrado. Sin embargo, la cadena  vacía es más pequeña que la cadena , por lo que las cadenas vacías en la representación de dígitos preservarán los espacios en el cuadrado.

Ahora rotamos las filas y columnas por dos unidades para colocar la siguiente representación de dígitos en la parte adecuada del cuadrado y repetir el proceso para los dígitos restantes en la entrada.

Finalmente, invertimos cada fila e insertamos un salto de línea entre las filas individuales.

Código

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.

Las últimas rotaciones estropearían la salida si la longitud del lado del cuadrado fuera menor que 2n + 3 . Como 5n ≥ 2n + 3 para todos los enteros positivos n , el cuadrado es lo suficientemente grande como para evitar esto.

Dennis
fuente
¿Sería sensato publicar aquí una versión base64 de su código?
TRiG
1
+1, pero para ser honesto, esperaba que CJam et al. se quedaría con esta: p
primo
@primo: Siento lo mismo por las preguntas de Pyth y matemáticas. : P Llego un poco tarde a la fiesta porque me reorganizaron los nerds por Reorganizar palabras . No fue hasta su edición de esta mañana que recordé esta pregunta.
Dennis
Los desafíos de @Dennis parecen pasar mucho más rápido de lo que solían hacerlo. Todavía estoy trabajando en uno de hace dos semanas: p
primo
1
Siempre busco CJam primero con la expectativa de que tendrá el recuento de bytes más bajo. Todavía tengo que estar decepcionado.
Engineer Toast
25

Pitón 3, 189 183 174 bytes

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 compresión me parece bien, pero tengo problemas para encontrar una buena forma de deshacerme de las siete variables ...

Afortunadamente, la especificación es bastante relajada en las reglas de espacios en blanco, porque hay muchos espacios en blanco iniciales / finales.

Expandido:

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

Explicación

Las posiciones de segmento representadas por las variables son:

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

Cada segmento está codificado por un único carácter Unicode de 2 bytes. Por ejemplo, ϻcodifica gel segmento de esta manera:

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

De hecho, 2es el único dígito que no utiliza el segmento inferior derecho de una pantalla de siete segmentos.

Sp3000
fuente
19

C, 1.098 mil 345 323 319 bytes

primero Segundo Tercer intento. Finalmente decidió deshacerse del búfer de pantalla para guardar algunos bytes. Este programa toma un parámetro de dígitos e imprime los dígitos en formato de 7 segmentos.

Participante por primera vez. Solo por diversión. Sé 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);}}

Ampliado, sin advertencia:

#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);
        }
    }
}
algun usuario
fuente
El arma más rápida del oeste. Estoy comprimiendo el mío ahora.
Alexey Burdin
15
¡Oye! Bienvenido a Code Golf. El propósito de este desafío es hacer que su código sea lo más corto posible, por lo que debe hacer algunas optimizaciones con respecto a la eliminación de espacios, declaraciones cortas, etc., y luego informar su conteo de bytes en la parte superior de su publicación con el idioma. ¡Gran primer post sin embargo! Solo como referencia, su publicación inicial tiene 1.098 bytes de longitud.
Kade
Gracias. Acabo de agregar el idioma y el recuento de bytes. Mi original incluso tiene comentarios y uso. :)
algún usuario
Consejo: Cambie todos los nombres de variables a caracteres individuales. Además, se utiliza `for (i = 0; i <digits` mucho, quizá sustituirla por una macro?
Joshpbarron
Buen trabajo aqui. Para hacer que su puntuación más competitivos, se puede echar un vistazo a nuestros consejos para jugar al golf en C .
Alex A.
14

JavaScript, 192 178 167 162 bytes

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

Uso: f("1337");volverá

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

Utiliza características de ES6 y puede tener un comportamiento dependiente de la implementación debido a la omisión de punto y coma y paréntesis, pero funciona en Firefox.

Expandido:

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

Explicación:

les una matriz que contiene 10 caracteres de un solo byte que corresponden a la forma de cada dígito. Por ejemplo, el dígito 0 está representado por el carácter î:

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

Los caracteres de entrada se utilizan como claves para la matriz que mantiene su forma que representa las contrapartes, que se leen poco a poco.

Lamentar
fuente
2
Son ==0y de ==1hecho son necesarios antes ?. ¿No se considera int como booleano en js? @Regret
Alexey Burdin
1
@Regret: "w\x05k/\x1D>~\x07\x7F?"con cada carácter invertido en bits se convierte en "\xee\xa0\xd6\xf4\xb8|~\xe0\xfe\xfc"imprimible. Esto da 8 bytes más. Aunque, no lo suficiente ...
Alexey Burdin
1
Puede eliminar 2 bytes quitando el paréntesis f=(x)=>{}, no son necesarios con un solo argumento.
Scimonster
Tienes toda la razón, @Alexey. Voy a cambiar eso
Lamento el
¿Funciona? Tengo 6 filas más con personajes espurios.
edc65
10

Perl - 103 bytes

#!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~/

Lo anterior contiene 6 caracteres no imprimibles (la fuente se puede descargar en Ideone ), y es equivalente a lo siguiente:

#!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~/

Cada uno ^Fpuede ser reemplazado por un carácter literal 6 (ACK), y \177reemplazado por el carácter 127 (DEL).

El shebang se cuenta como 1, la segunda línea nueva no es necesaria. La entrada se toma de stdin.


Uso de muestra

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Explicación

La salida se genera un byte a la vez. Cada carácter se transcribe, y esto se interpreta como una matriz de bits usando vec. Los bits se almacenan de la siguiente manera:

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

La salida alterna entre 3 y 5 barras inclinadas, de modo que los bits se 56extienden al 01siguiente dígito. El bit 7no se usa.

primo
fuente
8

C #, 360 355 331 bytes

Hola, primer intento de code-golf. Espero que esto no sea tan malo para una entrada 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);}

Uso: p("159114");volverá

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

Expandido:

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);
    }
Shion
fuente
1
Sé que han pasado casi tres años, pero puedes jugar al golf 30 bytes: Pruébalo en línea. 301 bytes . Buena respuesta, sin embargo, +1 de mi parte.
Kevin Cruijssen
Bueno. Siéntase libre de publicarlo como su propia respuesta entonces :)
Shion
1
No, es tu código. Simplemente acorté un poco quitando los corchetes for-loop y combinando variables. Y cambiando string s(string n)a n=>mediante el uso de una lambda. Ah, bueno, puedes dejarlo así si lo prefieres. :) Sin embargo, creé un puerto para Java acreditándote. ;)
Kevin Cruijssen
4

pitón 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)

Consideré 4 espacios como pestañas mientras contaba.
Sin comprimir y legible:

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)
Alexey Burdin
fuente
¡Oye! Gran respuesta, pero puedes hacer algunos cambios para hacerlo aún más corto. Cambiar l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' 'a l[y+dy][x+dx]=[' ',c][r[map(int,s)[x/2]][i]=='1']guardar 5 bytes, cambiar return '\n'.join(''.join(x) for x in l)a print'\n'.join(''.join(x)for x in l)guardar 3 bytes, más algunos cambios más. Aquí hay un enlace a un Gist donde obtuve el conteo de bytes hasta 440 desde 508.
Kade
66
Kelvin habría estado muy satisfecho con ese puntaje.
Cristian Lupascu
3
Su respuesta es en realidad 272 bytes, pero puede guardar uno más porque un espacio es más corto que una pestaña. Ver aquí . ¿Cómo podrías tener 273,15 bytes de todos modos?
mbomb007
1
273,15 bytes significa que @AlexeyBurdin descubrió la computación analógica en una plataforma digital. ¿Por qué en el mundo lo publicaste aquí, en lugar de en Science? ;-)
hBy2Py
1
Esto significa solo que la solución está congelada en cero absoluto, es decir, no quiero centrarme en algo que ya ha perdido . :)
Alexey Burdin
3

KDB (Q), 172136 bytes

{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];}

Explicación

1) Crear d mapa con todas las formas de los dígitos.

2) Rellene la matriz con ceros adicionales y agréguelos juntos. es decir, "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) Use el índice para mapear " /\"e imprimir con-1 .

Prueba

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"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

Estoy seguro de que esto puede ser más corto !!

Gracias @hjk

WooiKent Lee
fuente
1
La única reducción que descubrí es reemplazar 1 2 0 2 1 2 0 2 1con (9#1 2 0 2)(-6).
hjk
1
Ah, y reemplazar enlistcon 1#obras, entonces ese es otro -5.
hjk
1
¡eres una estrella! Voy a actualizar! pero no puede reemplazar el enlistaunque porque count[a 0]#0no es un átomo :(
WooiKent Lee
aunque extraño, funcionó para mí ... debe ser una peculiaridad. ;)
hjk
1
en realidad, list plus atom extenderá el átomo a la longitud correcta de todos modos! me recuerdas tal mecanismo! : D
WooiKent Lee
2

Pip, 122 + 1 = 123 bytes

Usa la -nbandera. Toma entrada a través de la línea de comando argumento.

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

Los caracteres de la cadena UTF-8 tienen los siguientes puntos de código: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Ligeramente incólume:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^[email protected]<>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 estrategia básica es encontrar los caracteres constituyentes de cada número y luego sesgarlos adecuadamente. Por ejemplo, para 8, queremos esto (espacios representados por puntos):

/.
\\
/.
\\
/.

que se convertirá en esto:

 .  
/\. 
\/\.
 \/ 

La buena característica de esta estrategia es que múltiples números pre-sesgados pueden simplemente concatenarse uno al lado del otro.

Ahora, podemos codificar /.\\/.\\/.en la base 3 como 1200120012. Luego podemos convertir esto a decimal y tratarlo como un punto de código UTF-8.

La expresión J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maobtiene los datos previamente sesgados mediante el siguiente proceso:

                            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

Una vez que hemos concatenado estas cadenas una al lado de la otra $., creamos una cuadrícula de espacios (2 * n +2 cuadrados), recorremos la cuadrícula sesgada y reemplazamos los espacios correspondientes en la cuadrícula sesgada con personajes apropiados Para ver cómo sucede, se puede modificar el código para imprimir cada etapa y pausar la entrada del usuario:

Algoritmo en proceso

La cuadrícula en realidad está construida al revés, porque eso parecía facilitar las matemáticas.

Estoy seguro de que hay mejores algoritmos para usar. Pero quería tener mi propia idea en lugar de copiar la de otra persona.

Más sobre Pip

DLosc
fuente
2

Brainfuck - 719 bytes

Solo para contexto histórico, créditos a Daniel B Cristofani. No estoy exactamente seguro de cuándo se creó, pero está disponible en Internet Archive a partir del 9 de mayo de 2003.

La salida para 9es diferente que en la descripción del problema.

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]
primo
fuente
2
Probablemente lo escribí en 2002. El Archivo de Internet dice que Panu Kalliokoski lo agregó a su repositorio de brainfuck en agosto de 2002. En cuanto al 9, creo que usé los patrones de la segunda edición de Microprocesadores e Interfaces , página 4.
Daniel Cristofani
1

Perl, 270 bytes

Realmente no debería haber perdido mi tiempo en esto.

$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,"
"}
Frederick
fuente
reemplace [$1]while/(.)/gcon [$_]for/./gpara guardar 4 bytes. reemplace for($i=0;$i<=$l;$i++)con for$i(0..$l)para guardar 9 bytes.
hobbs
1

JavaScript ( ES6 ), 191 206

Ejecute el fragmento en Firefox para probar.

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>

edc65
fuente
0

Java 8, 341 bytes

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

Puerto de la respuesta C # .NET de @Shion , ¡así que asegúrese de votarlo también!

Pruébalo en línea.

Explicación:

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
Kevin Cruijssen
fuente