Exibição de sete barras


99

Escreva um programa que utilize uma sequência não vazia dos dígitos de 0 a 9 e imprima como eles seriam mostrados em uma exibição de sete segmentos usando barras ( /, \).

Estas são as formas precisas dos dígitos:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Quando um dígito ocorre após o outro, eles são encadeados na diagonal para cima e para a direita, com um espaço diagonal no meio. Então, por exemplo, 203seria o seguinte:

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

Observe que o 1personagem ocupa a mesma quantidade de espaço que os outros. As duas linhas do 1estão no lado direito da tela, não no esquerdo.

Então 159114seria assim:

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

Pode haver qualquer quantidade e combinação de novas linhas ou espaços iniciais / finais na saída, desde que os dígitos estejam na posição correta em relação um ao outro.

Portanto 159114, isso também seria válido:



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


Pegue a entrada do stdin ou da linha de comando ou escreva uma função que aceite uma string. Imprima o resultado em stdout ou poderá devolvê-lo como uma sequência se escrever uma função.

Qualquer cadeia não-vazia dos dígitos de 0 a 9 deve funcionar, incluindo cadeias de dígitos simples (por exemplo 8) e cordas com zeros (por exemplo, em 007, os zeros não precisam de ser impresso).

O código mais curto em bytes vence.


41
Totalmente offtopic: Isso parece incrível!
Martijn

4
Isto é muito, muito legal. No entanto, não tenho certeza se a complexidade do kolmogorov é apropriada para esta pergunta - eu pensei que isso exigia uma saída constante?
21415 Alexander-brett #

1
@ alexander-brett iirc que era a intenção original, no entanto, mais recentemente, ele foi usado para problemas em que a maior parte do código provavelmente será codificada.
Undergroundmonorail

Isso me fez ir como ... UAU! apenas Uau!
achou

Pergunta: Precisamos lidar com cadeias vazias ou com caracteres que não sejam dígitos?
Frederick

Respostas:


9

CJam, 77 71 70 69 63 62 bytes

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

Todos os caracteres são imprimíveis, portanto, copiar e colar deve funcionar perfeitamente.

Experimente online no intérprete CJam .

Idéia

Começamos examinando o número de dígitos n na entrada e pressionando um quadrado de espaços grandes o suficiente para cobrir a saída. Na implementação, esse quadrado será codificado como uma matriz bidimensional de cadeias de caracteres de um caractere.

Um quadrado de comprimento 2n + 1 seria o correto (ou seja, nenhum espaço em branco ao redor) para uma implementação direta, mas usaremos um comprimento de 5n para salvar alguns bytes. Felizmente, o espaço em branco circundante é permitido.

Se invertermos as linhas da representação de sete barras de 8 , obteremos o seguinte:

 \/
\/\
/\

A representação de todos os dígitos podem ser codificado como um inteiro de 8 bits, onde o i th bit é 0 sse o i th personagem deve se substituído por um espaço. Para os dígitos de 0 a 9 , os números inteiros resultantes são

247 208 235 250 220 190 191 240 255 254

que correspondem aos seguintes caracteres ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Para cada posição na entrada, depois de seleccionar o número inteiro de 8 bit correspondente, repetimos o i th carácter da representação de 8 exactamente um i vezes, onde uma i é o i th bits do número inteiro. Isso empurra uma matriz de seqüências de caracteres de um ou zero caracteres. Ao dividir essa matriz em partes de comprimento 3, obtemos uma matriz em que cada elemento corresponde a uma linha da representação.

Agora, calculamos o máximo vetorizado das strings que representam o quadrado e as strings que representam o dígito. As strings /e \são maiores que a string  , portanto, elas substituirão os espaços no quadrado. A cadeia vazia, no entanto, é menor que a cadeia  , portanto, cadeias vazias na representação de dígitos preservarão os espaços no quadrado.

Agora giramos as linhas e colunas por duas unidades para colocar a seguinte representação de dígitos na parte apropriada do quadrado e repetimos o processo para os dígitos restantes na entrada.

Finalmente, invertemos cada linha e inserimos um avanço de linha entre as linhas individuais.

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.

As últimas rotações atrapalhariam a saída se o comprimento lateral do quadrado fosse menor que 2n + 3 . Como 5n ≥ 2n + 3 para todos os números inteiros positivos n , o quadrado é grande o suficiente para evitar isso.


Seria sensato postar aqui uma versão base64 do seu código?
Trig

1
+1, mas para ser sincero, eu esperava que CJam et al. ficaria de fora desta: p
primo 12/06

@primo: Eu sinto o mesmo sobre Pyth e questões de matemática. : P Estou um pouco atrasado para a festa porque fui nerd por reorganizar as palavras . Não foi até a sua edição desta manhã que me lembrei desta pergunta.
Dennis

Os desafios do @Dennis parecem passar muito mais rápido do que antes. Eu ainda estou trabalhando em um de duas semanas atrás: p
primo

1
Eu sempre procuro CJam primeiro com a expectativa de que ele tenha a menor contagem de bytes. Ainda estou desapontado.
Engineer Toast

25

Python 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

A compressão parece boa para mim, mas estou tendo problemas para encontrar uma boa maneira de abandonar as sete variáveis ​​...

Felizmente, a especificação é bastante relaxada nas regras de espaço em branco, porque há muito espaço em branco inicial / final.

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

Explicação

As posições de segmento representadas pelas variáveis ​​são:

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

Cada segmento é codificado por um único caractere Unicode de 2 bytes. Por exemplo, ϻcodifica go segmento da seguinte maneira:

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

Na verdade, 2é o único dígito a não usar o segmento inferior direito de uma tela de sete segmentos.


19

C, 1098 345 323 319 bytes

Primeira Segunda Terceira tentativa. Finalmente decidiu abandonar o buffer de tela para salvar alguns bytes. Este programa pega um parâmetro de dígitos e imprime os dígitos no formato de 7 segmentos.

Participante da primeira vez. Apenas por diversão. Seja 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);}}

Expandido, sem aviso:

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

Arma mais rápida do oeste. Estou comprimindo o meu agora.
Alexey Burdin

15
Ei! Bem-vindo ao Code Golf. O objetivo desse desafio é tornar o código o mais curto possível, portanto, você deve fazer algumas otimizações em relação à remoção de espaços, instruções de curto-circuito, etc. Ótimo primeiro post! Apenas para referência, sua postagem inicial tem 1.098 bytes.
Kade

Obrigado. Apenas adicionei o idioma e a contagem de bytes. Meu original ainda tem comentários e uso. :)
algum usuário

Dica: Altere todos os nomes de variáveis ​​para caracteres únicos. Além disso, você usar `for (i = 0; i <digits` muito, talvez substituí-lo com uma macro?
Joshpbarron

Bom trabalho aqui. Para tornar a sua pontuação mais competitivo, você poderia dar uma olhada em nossas dicas para golfe em 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");retornará

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

Ele usa os recursos do ES6 e pode ter algum comportamento dependente da implementação devido à omissão de ponto e vírgula e parênteses, mas funciona no 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)
}

Explicação:

lé uma matriz que contém 10 caracteres de byte único que correspondem à forma de cada dígito. Por exemplo, o dígito 0 é representado pelo caractere î:

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

Os caracteres de entrada são usados ​​como chaves para a matriz, mantendo sua forma representando as contrapartes, que são lidas pouco a pouco.


2
São ==0e ==1realmente necessários antes ?. Int não é considerado booleano em js? @Regret
Alexey Burdin

1
@Regret: "w\x05k/\x1D>~\x07\x7F?"com cada caractere revertido bit a bit "\xee\xa0\xd6\xf4\xb8|~\xe0\xfe\xfc", cada um deles pode ser impresso. Isso dá mais 8 bytes. Embora, não é suficiente ...
Alexey Burdin

1
Você pode economizar 2 bytes removendo os parênteses f=(x)=>{}- eles não são necessários com apenas um argumento.
Scimonster

Você está absolutamente certo, @Alexey. Eu vou mudar isso.
Lamento

Funciona? Eu recebo mais 6 linhas com caracteres falsos.
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~/

O texto acima contém 6 caracteres não imprimíveis (a fonte pode ser baixada em Ideone ) e é equivalente ao seguinte:

#!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 um ^Fpode ser substituído por um caractere literal 6 (ACK) e \177substituído pelo caractere 127 (DEL).

O shebang é contado como 1, a segunda nova linha é desnecessária. A entrada é retirada do stdin.


Uso da amostra

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Explicação

A saída é gerada um byte de cada vez. Cada caractere é transliterado, e isso é interpretado como uma matriz de bits usando vec. Os bits são armazenados da seguinte maneira:

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

A saída alterna entre 3 e 5 barras, para que os bits se 56espalhem no 01próximo dígito. Bit 7não é usado.


8

C #, 360 355 331 bytes

Olá, primeira tentativa de código-golfe. Espero que isso não seja tão ruim para uma entrada em 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");retornará

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

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

1
Sei que já faz quase três anos, mas você pode jogar golfe com 30 bytes: Experimente online. 301 bytes . Boa resposta, porém, +1 de mim.
Kevin Cruijssen

Legal. Sinta-se livre para publicá-la como sua própria resposta então :)
Shion

1
Não, é o seu código. Apenas reduzi um pouco removendo os colchetes do loop for e combinando variáveis. E mudando string s(string n)para n=>usando um lambda. Ah, bem, você pode deixar assim, se preferir. :) No entanto, criei uma porta para Java que credita a você. ;)
Kevin Cruijssen

4

pitão 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)

Eu considerei 4 espaços como guias enquanto contava.
Não compactado e legível:

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)

Ei! Ótima resposta, mas você pode fazer algumas alterações para torná-la ainda mais curta. Alterar l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' 'para l[y+dy][x+dx]=[' ',c][r[map(int,s)[x/2]][i]=='1']salva 5 bytes, alterar return '\n'.join(''.join(x) for x in l)para print'\n'.join(''.join(x)for x in l)salvar 3 bytes, além de mais algumas alterações. Aqui está um link para um Gist, onde eu tenho o byte contagem regressiva para o 440 da 508.
Kade

6
Kelvin teria ficado muito satisfeito com essa pontuação.
Cristian Lupascu

3
Sua resposta é, na verdade, 272 bytes, mas você pode salvar mais um, porque um espaço é menor que uma guia. Veja aqui . Como você poderia ter 273,15 bytes de qualquer maneira?
mbomb007

1
273,15 bytes significa que @AlexeyBurdin descobriu a computação analógica em uma plataforma digital. Por que no mundo você publicou aqui, em vez de na Science? ;-)
hBy2Py

1
Isso significa apenas que a solução está congelada no zero absoluto, ou seja, não quero me concentrar em algo que tenha perdido . :)
Alexey Burdin

3

KDB (Q), 172 136 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];}

Explicação

1) Crie um dmapa com todas as formas dos dígitos.

2) Preencher a matriz com zeros extras e adicioná-los. ie "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 o índice para mapear " /\"e imprimir -1.

Teste

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

Tenho certeza que isso pode ser mais curto !!

Obrigado @hjk


1
A única redução que vi foi substituir 1 2 0 2 1 2 0 2 1por (9#1 2 0 2)(-6).
Hjk

1
Ah, e substituindo enlistpor 1#obras, então isso é outro -5.
HJK

1
você é uma estrela! Eu vou atualizar! mas não é possível substituir o enlistporém porque count[a 0]#0não é um átomo :(
WooiKent Lee 11/15/15

ah estranho que funcionou para mim ... deve ser uma peculiaridade. ;)
hjk

1
na verdade, list plus atom estenderá o átomo para o comprimento correto de qualquer maneira! você me lembrou esse mecanismo! : D
WooiKent Lee

2

Pip, 122 + 1 = 123 bytes

Usa a -nbandeira. Recebe entrada via argumento da linha de comando.

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

Os caracteres na string UTF-8 têm os seguintes pontos de código: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Ligeiramente não destruído:

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

A estratégia básica é encontrar os caracteres constituintes de cada número e enviesá-los adequadamente. Por exemplo, para 8, queremos isso (espaços representados por pontos):

/.
\\
/.
\\
/.

que se transformará nisso:

 .  
/\. 
\/\.
 \/ 

O bom recurso dessa estratégia é que vários números pré-inclinados podem ser simplesmente concatenados lado a lado.

Agora, podemos codificar /.\\/.\\/.na base 3 como 1200120012. Em seguida, podemos converter isso em decimal e tratá-lo como um ponto de código UTF-8.

A expressão J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maobtém os dados pré-inclinados pelo seguinte processo:

                            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

Depois de concatenar essas seqüências lado a lado $., criamos uma grade de espaços (2 * n +2 quadrado), percorremos a grade pré-inclinada e substituímos os espaços correspondentes na grade pós-inclinada pela opção caracteres apropriados. Para que isso aconteça, é possível modificar o código para imprimir cada estágio e fazer uma pausa para entrada do usuário:

Algoritmo em processo

A grade é realmente construída de cabeça para baixo, porque isso parecia facilitar a matemática.

Tenho certeza de que existem algoritmos melhores para usar. Mas eu queria ter minha própria ideia, em vez de copiar a de outra pessoa.

Mais sobre Pip


2

Brainfuck - 719 bytes

Apenas para contexto histórico, créditos para Daniel B Cristofani. Não sei exatamente quando isso foi criado, mas está disponível no Internet Archive em 9 de maio de 2003.

A saída para 9é diferente da descrição do problema.

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

2
Provavelmente, eu o escrevi em 2002. O Internet Archive diz que Panu Kalliokoski o adicionou ao seu repositório cerebral em agosto de 2002. Quanto aos 9, acho que usei os padrões da segunda edição de Microprocessadores e Interfaces , página 4.
Daniel Cristofani

1

Perl, 270 bytes

Eu realmente não deveria ter perdido meu tempo com isso.

$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,"
"}

substitua [$1]while/(.)/gpor [$_]for/./gpara salvar 4 bytes. substitua for($i=0;$i<=$l;$i++)por for$i(0..$l)para salvar 9 bytes.
Hbbs

1

JavaScript ( ES6 ), 191 206

Execute o snippet no Firefox para testar.

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

Porta da resposta C # .NET do @Shion , por isso não deixe de vota-lo também!

Experimente online.

Explicação:

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.