Seven Slash Display


99

Scrivi un programma che accetta una stringa non vuota delle cifre da 0 a 9 e stampa come verrebbero visualizzati su un display a sette segmenti usando le barre ( /, \).

Queste sono le forme precise delle cifre:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Quando una cifra si presenta dopo l'altra, sono incatenate in diagonale verso l'alto e verso destra, con uno spazio diagonale in mezzo. Quindi, per esempio, 203diventerebbe questo:

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

Nota che il 1personaggio occupa la stessa quantità di spazio degli altri. Le due linee di 1sono sul lato destro del display, non a sinistra.

Quindi 159114diventerebbe questo:

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

Potrebbero esserci quantità e combinazioni di righe o spazi iniziali / finali nell'output, purché le cifre siano nella posizione corretta l'una rispetto all'altra.

Quindi 159114, anche questo sarebbe valido:



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


Prendi l'input da stdin o dalla riga di comando o scrivi una funzione che accetta una stringa. Stampa il risultato su stdout oppure puoi restituirlo come stringa se scrivi una funzione.

Qualsiasi stringa non vuota delle cifre da 0 a 9 dovrebbe funzionare, incluse stringhe singole cifre (ad esempio 8) e stringhe con zeri (ad es 007, gli zeri do devono essere stampati).

Vince il codice più breve in byte.


41
Totalmente offtopico: sembra fantastico!
Martijn,

4
Questo è davvero fantastico. Tuttavia, non sono sicuro che la complessità di kolmogorov sia appropriata per questa domanda: pensavo che ciò richiedesse un risultato costante?
alexander-brett,

1
@ alexander-brett iirc che era l'intenzione originale, tuttavia, più recentemente è stato usato per problemi in cui la maggior parte del codice sarà probabilmente hardcoding.
undergroundmonorail

Questo mi ha fatto andare come ... WOW! solo WOW!
Renae Lider,

Domanda: dobbiamo gestire stringhe vuote o stringhe con caratteri non numerici?
Federico,

Risposte:


9

CJam, 77 71 70 69 63 62 byte

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

Tutti i caratteri sono stampabili, quindi copia e incolla dovrebbero funzionare bene.

Provalo online nell'interprete CJam .

Idea

Iniziamo esaminando il numero di cifre n nell'input e spingendo un quadrato di spazi abbastanza grande da coprire l'output. Nell'implementazione, questo quadrato verrà codificato come una matrice bidimensionale di stringhe di un carattere.

Un quadrato di lunghezza 2n + 1 sarebbe giusto (vale a dire, nessuno spazio bianco circostante) per un'implementazione semplice, ma ne useremo uno di lunghezza 5n per salvare un paio di byte. Per fortuna, è consentito lo spazio bianco circostante.

Se invertiamo le linee della rappresentazione a 7 barre di 8 , otteniamo quanto segue:

 \/
\/\
/\

La rappresentazione di tutte le cifre può essere codificato come numero intero a 8 bit, dove l'i esimo bit è 0 se e solo se l'i esimo carattere dovrebbe ottenere sostituito con uno spazio. Per le cifre da 0 a 9 , gli interi risultanti sono

247 208 235 250 220 190 191 240 255 254

che corrispondono ai seguenti caratteri ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Per ogni cifra in ingresso, dopo aver selezionato il corrispondente 8 bit integer, ripetiamo l'i esimo carattere della rappresentazione di 8 esattamente un i tempi, in cui un i è l'i esimo bit del numero intero. Questo spinge una matrice di stringhe di uno o zero caratteri. Dividendo questo array in blocchi di lunghezza 3, otteniamo un array in cui ogni elemento corrisponde a una linea della rappresentazione.

Ora, calcoliamo il massimo vettoriale delle stringhe che rappresentano il quadrato e le stringhe che rappresentano la cifra. Le stringhe /e \sono più grandi della stringa  , quindi sostituiranno gli spazi nel quadrato. La stringa vuota, tuttavia, è più piccola della stringa  , quindi le stringhe vuote nella rappresentazione delle cifre manterranno gli spazi nel quadrato.

Ora ruotiamo le righe e le colonne di due unità per posizionare la seguente rappresentazione delle cifre nella parte corretta del quadrato e ripetere il processo per le cifre rimanenti nell'input.

Infine, invertiamo ogni riga e inseriamo un avanzamento riga tra le singole righe.

Codice

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.

Le ultime rotazioni rovinerebbero l'output se la lunghezza del lato del quadrato fosse inferiore a 2n + 3 . Poiché 5n ≥ 2n + 3 per tutti gli interi positivi n , il quadrato è abbastanza grande da impedirlo.


Sarebbe sensato pubblicare qui una versione base64 del tuo codice?
TRiG,

1
+1, ma ad essere sincero, speravo che CJam et al. starei fuori questo: p
primo

@primo: Mi sento allo stesso modo con Pyth e le domande di matematica. : P Sono un po 'in ritardo alla festa perché sono stato secchiato da Rearranging Words . Non è stato fino alla tua modifica stamattina che mi sono ricordato di questa domanda.
Dennis,

Le sfide di @Dennis sembrano andare molto più velocemente di prima. Sto ancora lavorando su uno di due settimane fa: p
primo

1
Cerco sempre prima CJam con l'aspettativa che abbia il conteggio di byte più basso. Devo ancora essere deluso.
Ingegnere Toast,

25

Python 3, 189 183 174 byte

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 compressione mi sembra a posto, ma ho difficoltà a trovare un buon modo per abbandonare le sette variabili ...

Per fortuna le specifiche sono abbastanza rilassate sulle regole degli spazi bianchi, perché c'è un sacco di spazi bianchi iniziali / finali.

Allargato:

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

Spiegazione

Le posizioni dei segmenti rappresentate dalle variabili sono:

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

Ogni segmento è codificato da un singolo carattere Unicode a 2 byte. Ad esempio, ϻcodifica gil segmento in questo modo:

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

In effetti, 2è l'unica cifra a non utilizzare il segmento in basso a destra di un display a sette segmenti.


19

C, 1098 345 323 319 byte

Primo secondo terzo tentativo. Alla fine ha deciso di abbandonare il buffer dello schermo per salvare alcuni byte. Questo programma accetta un parametro di cifre e stampa le cifre in formato a 7 segmenti.

Partecipante per la prima volta. Solo per divertimento. Sii gentile.

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

Espanso, senza preavviso:

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

La pistola più veloce in Occidente. Sto comprimendo il mio ora.
Alexey Burdin,

15
Hey! Benvenuti in Code Golf. Lo scopo di questa sfida è di rendere il tuo codice il più breve possibile, quindi dovresti apportare alcune ottimizzazioni per quanto riguarda la rimozione di spazi, istruzioni di cortocircuito, ecc., Quindi riportare il conteggio dei byte nella parte superiore del tuo post con la lingua. Ottimo primo post però! Solo per riferimento, il tuo post iniziale è lungo 1.098 byte.
Kade,

Grazie. Ho appena aggiunto la lingua e il conteggio dei byte. Il mio originale ha anche commenti e utilizzo. :)
alcuni utenti il

Suggerimento: cambia tutti i nomi delle variabili in singoli caratteri. Inoltre, usi `for (i = 0; i <digit`` molto, forse lo sostituisci con una macro?
Joshpbarron,

Ottimo lavoro qui. Per rendere il vostro punteggio più competitiva, si può dare un'occhiata ai nostri suggerimenti per giocare a golf in C .
Alex A.

14

JavaScript, 192 178 167 162 byte

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

Utilizzo: f("1337");tornerà

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

Utilizza le funzionalità di ES6 e può avere un comportamento dipendente dall'implementazione a causa dell'omissione di punti e virgola e parentesi e simili, ma funziona in Firefox.

Allargato:

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

Spiegazione:

lè un array contenente 10 caratteri a byte singolo che corrispondono alla forma di ogni cifra. Ad esempio, la cifra 0 è rappresentata dal carattere î:

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

I caratteri di input vengono utilizzati come chiavi dell'array mantenendo la loro forma che rappresenta le controparti, che vengono letti bit per bit.


2
Sono ==0e ==1anzi necessari prima ?. Int non è considerato booleano in js? @Regret
Alexey Burdin,

1
@Regret: "w\x05k/\x1D>~\x07\x7F?"con ogni carattere invertito bit per bit "\xee\xa0\xd6\xf4\xb8|~\xe0\xfe\xfc", ognuno di questi è stampabile. Questo dà 8 byte in più. Anche se, non abbastanza ...
Alexey Burdin,

1
È possibile radere 2 byte rimuovendo la parentesi in f=(x)=>{}- non sono necessari con un solo argomento.
Scimonster,

Hai assolutamente ragione, @Alexey. Lo cambierò.
Rammarico

Funziona? Ottengo altre 6 righe con personaggi spuri.
edc65,

10

Perl - 103 byte

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

Quanto sopra contiene 6 caratteri non stampabili (la fonte può essere scaricata da Ideone ) ed è equivalente alla seguente:

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

Ciascuno ^Fpuò essere sostituito da un carattere letterale 6 (ACK) e \177sostituito dal carattere 127 (DEL).

Lo shebang è contato come 1, la seconda riga è incessante. L'input è preso dallo stdin.


Esempio di utilizzo

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Spiegazione

L'output viene generato un byte alla volta. Ogni carattere viene traslitterato e questo viene quindi interpretato come un array di bit usando vec. I bit vengono memorizzati nel modo seguente:

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

L'output si alterna tra 3 e 5 barre, in modo che i bit si 56riversino nella 01cifra successiva. Bit 7non utilizzato.


8

C #, 360 355 331 byte

Ciao, primo tentativo di code-golf. Spero che questo non ottenga un punteggio troppo basso per un C # -enter.

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

Utilizzo: p("159114");tornerà

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

Allargato:

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
So che sono passati quasi tre anni, ma puoi giocare a golf 30 byte: provalo online. 301 byte . Bella risposta però, +1 da parte mia.
Kevin Cruijssen,

Freddo. Sentiti libero di pubblicarlo come risposta personale quindi :)
Shion,

1
No, è il tuo codice. Ho solo accorciato un po 'rimuovendo le parentesi for-loop e combinando le variabili. E cambiando string s(string n)per n=>utilizzando un lambda. Ah bene, puoi lasciarlo così se preferisci. :) Ho comunque creato una porta per Java che ti accredita. ;)
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)

Ho considerato i 4 spazi come schede durante il conteggio.
Non compresso e leggibile:

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! Ottima risposta, ma puoi apportare alcune modifiche per renderlo ancora più breve. Passando 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']Salva 5 byte, passando return '\n'.join(''.join(x) for x in l)a print'\n'.join(''.join(x)for x in l)Salva 3 byte, oltre ad alcune altre modifiche. Ecco un link a un Gist in cui ho ottenuto il conteggio dei byte fino a 440 da 508.
Kade

6
Kelvin sarebbe stato molto contento di quel punteggio.
Cristian Lupascu,

3
La tua risposta è in realtà 272 byte, ma puoi salvarne uno in più perché uno spazio è più corto di una scheda. Vedi qui . Come hai potuto avere 273.15 byte comunque?
mbomb007,

1
273.15 byte significa che @AlexeyBurdin ha individuato il calcolo analogico su una piattaforma digitale. Perché nel mondo lo hai pubblicato qui, invece che su Science? ;-)
hBy2Py

1
Questo significa solo che la soluzione è congelata allo zero assoluto, cioè non voglio concentrarmi su una cosa che ha già perso . :)
Alexey Burdin,

3

KDB (Q), 172 136 byte

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

Spiegazione

1) Crea una dmappa con tutte le forme delle cifre.

2) Riempi la matrice con zeri extra e aggiungili insieme. cioè "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) Utilizzare l'indice per mappare " /\"e stampare con -1.

Test

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

Sono sicuro che questo può essere più breve !!

Grazie @hjk


1
L'unica riduzione che ho notato è di sostituire 1 2 0 2 1 2 0 2 1con (9#1 2 0 2)(-6).
hjk,

1
Oh, e sostituendo enlistcon 1#opere, quindi questo è un altro -5.
hjk,

1
sei una stella! Aggiornerò! ma non posso sostituire il enlistperò perché count[a 0]#0non è atomo :(
WooiKent Lee l'

ah strano ha funzionato per me però ... deve essere una stranezza. ;)
hjk l'

1
in realtà, list plus atom estenderà comunque l'atomo alla lunghezza corretta! mi hai ricordato un simile meccanismo! : D
WooiKent Lee,

2

Pip, 122 + 1 = 123 byte

Usa la -nbandiera. Accetta input tramite argomento della riga di 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

I caratteri della stringa UTF-8 hanno i seguenti punti di codice: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Leggermente non golfato:

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 strategia di base è trovare i caratteri costitutivi di ciascun numero e quindi inclinarli in modo appropriato. Ad esempio, per 8, vogliamo questo (spazi rappresentati da punti):

/.
\\
/.
\\
/.

che si trasformerà in questo:

 .  
/\. 
\/\.
 \/ 

La bella caratteristica di questa strategia è che più numeri pre-inclinati possono essere semplicemente concatenati fianco a fianco.

Ora, possiamo codificare /.\\/.\\/.in base 3 come 1200120012. Quindi possiamo convertirlo in decimale e trattarlo come un punto di codice UTF-8.

L'espressione J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maottiene i dati pre-inclinati mediante il seguente 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

Una volta concatenate queste stringhe affiancate usando $., creiamo quindi una griglia di spazi (2 * n +2 quadrati), passiamo attraverso la griglia pre-inclinata e sostituiamo gli spazi corrispondenti nella griglia post-inclinata con il personaggi appropriati. Per vederlo accadere, è possibile modificare il codice per stampare ogni fase e mettere in pausa per l'input dell'utente:

Algoritmo in corso

La griglia è in realtà costruita sottosopra, perché sembrava rendere più semplice la matematica.

Sono sicuro che ci sono algoritmi migliori da usare. Ma volevo inventare la mia idea piuttosto che copiare quella di qualcun altro.

Altro su Pip


2

Brainfuck - 719 byte

Solo per contesto storico, crediti a Daniel B Cristofani. Non sono esattamente sicuro quando sia stato creato, ma è disponibile da Internet Archive già dal 9 maggio 2003.

L'output per 9è diverso rispetto alla descrizione del problema.

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

2
Probabilmente l'ho scritto nel 2002. Internet Archive dice che Panu Kalliokoski lo ha aggiunto al suo repository Brainfuck nell'agosto 2002. Per quanto riguarda il 9, penso di aver usato gli schemi della seconda edizione di Microprocessors and Interfacing , pagina 4.
Daniel Cristofani

1

Perl, 270 byte

Non avrei dovuto perdere tempo con questo.

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

sostituire [$1]while/(.)/gcon [$_]for/./gper salvare 4 byte. sostituire for($i=0;$i<=$l;$i++)con for$i(0..$l)per salvare 9 byte.
Hobbs

1

JavaScript ( ES6 ), 191 206

Esegui snippet in Firefox per testare.

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 byte

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 della risposta C # .NET di @Shion , quindi assicurati di votare anche lui!

Provalo online.

Spiegazione:

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.