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.

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.

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.

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

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.

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.

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

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)

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

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"\/ "@^[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

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:

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

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/]

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

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>

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