Visualizza le parole usando un display a 7 segmenti

13

Il mio primo Puzzle di programmazione e Code Golf è il display a sette barre . Ecco la mia prima sfida, anch'essa basata sul display a 7 segmenti.

Spesso penso, oltre ai numeri, che tipo di lettere posso visualizzare usando un semplice display a 7 segmenti. Si scopre che possono essere visualizzate molte lettere. In effetti, tutti tranne le lettere K, M, V, W, X possono essere visualizzati utilizzando un singolo display a 7 segmenti. Questo perché è possibile visualizzare lettere minuscole o maiuscole di una lettera. per esempio

"abcdef" può essere visualizzato come

 _     _     _  _
!_!!_ !   _!!_ !_ 
! !!_!!_ !_!!_ !

Nota che ogni personaggio è una matrice 3x3 composta da !e _.

Naturalmente, il display a 7 segmenti può essere utilizzato per visualizzare numeri e simboli:

 _     _  _  _           _  _     _    
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!

Alcune lettere possono contenere lettere maiuscole e minuscole:

 _                 _          
!   _ !_!!_   !   ! ! _ ! !   
!_ !_ ! !! !  !  !!_!!_!!_!!_!

Ecco la serie completa di personaggi:

 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  

 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_

Fai attenzione che ci sono uno spazio bianco ( ), un trattino ( -) e un punto interrogativo ( ?). La lettera I, Oe Zsono gli stessi numeri 1, 0e 2rispettivamente.

In questa sfida, si scriverà un programma o una funzione per visualizzare una stringa utilizzando il formato di visualizzazione a 7 segmenti sopra.

Regole

  1. È possibile scrivere un programma o una funzione

  2. Questo è code-golf, vince il codice più breve in byte

  3. Il programma o la funzione dovrebbe ricevere input da STDIN o come parametro. E genera una stringa su STDOUT o come stringa su 3 righe senza spazio iniziale ma terminata con newline. Maneggiare CHIOUcorrettamente le maiuscole / minuscole .

  4. Se lo si desidera, è possibile stampare spazi bianchi finali

  5. È necessario seguire il formato sopra. Utilizzo del trattino basso _e del punto esclamativo !per formare il display a 7 segmenti.

  6. È necessario supportare spazi bianchi ( ), trattino ( -) e punto interrogativo ( ?)

  7. Se la stringa contiene caratteri non supportati (k, m, v, w, x), viene visualizzato un singolo carattere di errore (3 linee dell'orizzonte, vedi esempio). Oltre ai 5 caratteri non supportati, puoi supporre che l'input sia composto solo da un set di caratteri supportato.

  8. Ho scelto di non avere una lettera per L minuscola ( l) a causa di confusioni ma se sei così incline, puoi visualizzarla come una 1a destra o a sinistra.

Esempi

$./a.out Start
 _     _    
!_ !_ !_! _ !_
 _!!_ ! !!  !_
$./a.out "7-seg dIsplay"
 _     _  _  _           _  _     _ 
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!
$./a.out "0123456789 chiou-?"
 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !
$./a.out "ABCDEFGHIJLNOPQRSTUZ"
 _     _     _  _  _                 _  _  _     _        _
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! ! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "abcdefghijlnopqrstuz"
 _           _  _  _                    _  _     _        _
!_!!_  _  _!!_ !_ !  !_      !!   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "Bad Form"
 _
 _
 _
$./a.out "Hello"
    _       
!_!!_ !  !   _
! !!_ !_ !_ !_!
$./a.out "World"
 _
 _
 _
code-golf  ascii-art 
— qualche utente
fonte
Sì, puoi presumere che non ci siano simboli non supportati. La mia intenzione è quella di assicurarmi che le stringhe contenenti k, m, v, w, xnon vengano visualizzate.
— alcuni utenti il
1
— DavidC
Penso che tu abbia confuso il ritorno a capo (CR, \r) con avanzamento riga (LF, \n). * nix utilizza LF e Windows utilizza CRLF. Solo alcuni sistemi legacy utilizzano CR da solo. Maggiori informazioni qui: en.wikipedia.org/wiki/Newline
— Winny il
Il tuo personaggio "8" sembra avere una barra "|" invece di un punto esclamativo "!". È previsto?
— coredump,
1
@Winny, hai ragione ovviamente. Ero troppo pigro per cercarlo quando l'ho scritto.
— alcuni utenti il

Risposte:

7

CJam, 123 114 112 110 byte

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"^A^W^G;^Þ¯     ^Þ^Û9³·^É¿»
^@
^P
^Ü^Ò½7¦^_¶´§=   ^O^V&5^U¯¼¹^T³6/"=i2b9Ue[3/"!_!"f.{S?}.+}/N*

Quanto sopra usa la notazione con il cursore, poiché il codice contiene caratteri non stampabili. Uno di questi è un byte null ( ^@), il che significa che questo codice può essere eseguito solo dalla riga di comando.

Al costo di solo altri due byte (per un totale di 112 ), possiamo risolvere questo problema.

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"AWG{ÞïIÞÛyó÷Éÿû
@
P
ÜÒýwæ_öôç}IOVfuUïüùTóvo"=i448+2b1>3/"!_!"f.{S?}.+}/N*

Questa volta, tutti i personaggi sono stampabili. Provalo online nell'interprete CJam .

Esempio di esecuzione

$ LANG=en_US
$ xxd -ps -r > 7seg.cjam <<< 51715f6575223b3d4b4d565758223a5426224022403f22202d6368696f752254657265757b69220117073b9eaf099e9b39b3b789bfbb0a000a100a9c92bd37a61fb6b4a73d090f16263515afbcb914b3362f223d6932623955655b332f22215f2122662e7b533f7d2e2b7d2f4e2a
$ wc -c 7seg.cjam 
110 7seg.cjam
$ echo -n '0123456789 chiou-?' | cjam 7seg.cjam; echo
 _     _  _     _  _  _  _  _                       _ 
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  
$ echo -n 'ABCDEFGHIJLNOPQRSTUYZ' | cjam 7seg.cjam; echo
 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 
$ echo -n 'World' | cjam 7seg.cjam; echo
 _ 
 _ 
 _

Idea (versione stampabile)

Ogni personaggio può essere mostrato sul display a 9 segmenti

!_!
!_!
!_!

sostituendo alcuni dei suoi personaggi personaggi con spazi.

Possiamo trasformare un carattere specifico in un numero intero sostituendo ogni segmento mostrato, in ordine di lettura naturale, con un 1 , ciascuno dei segmenti non mostrati con uno 0 e considerando le cifre binarie del risultato.

Il primo e il terzo segmento non vengono mai mostrati, quindi questo produrrà numeri interi negli intervalli [0,64) e [128,192) .

Possiamo codificare ciascuno di questi numeri interi come un singolo byte, ma la metà di essi genererà caratteri non stampabili. Pertanto, aggiungiamo 64 a ciascun numero intero prima di eseguire il casting su carattere, il che assicura che i punti di codice siano compresi negli intervalli [64.128) e [192.256) .

L'unico carattere non stampabile in questi due intervalli è DEL (punto di codice 127), che corrisponde alla seguente configurazione di visualizzazione non precedente:

!_!
!_!

È possibile invertire la codifica precedente aggiungendo 448 == 512 - 64 a ciascun punto di codice, convertendo in base 2 e rimuovendo la prima cifra binaria.

Tutto ciò che resta da trovare è un modo efficace di associare questi segmenet codificati con i loro corrispondenti caratteri ASCII.

Se mappiamo i caratteri " -chiou"ai caratteri di ";=KMVWX"e convertiamo l'intero input in maiuscolo, possiamo semplicemente memorizzare la codifica per tutti i caratteri tra 0(codice punto 48) e Z(codice punto 90), dando un intervallo di 43.

L'indicizzazione di array è modulare in CJam, quindi se Aè una stringa di lunghezza 43 A86=, A43=e A0=tutti producono gli stessi risultati. Il carattere con il punto di codice 86 è V, quindi memorizziamo semplicemente i segmenti codificati di V - Z e 0 - U , in ordine.

Nel codice effettivo, selezioniamo il segno at come carattere "forma errata", sostituiamo l'intero input con la stringa "@"se contiene una lettera proibita e invertiamo i passaggi dall'alto.

Codice (versione stampabile)

Q            e# Push an empty array for posterior concatenation.
q            e# Read from STDIN.
_eu          e# Copy the input and convert is to uppercase.
";=KMVWX":T& e# Intersect the result with with T := ";=KMVWX".
"@"@?        e# Select "@" if truthy and the input if falsy.
" -chiou"Ter e# Perform transliteration.
eu           e# Convert everything to uppercase.
{            e# For each character in the modified input:
  i          e#   Push its code point.
  "…"=       e#   Select the corresponding character from the string.
  i448+      e#   Push that character's code point and add 448.
  2b1>       e#   Convert to base 2 and discard the first digit.
  3/         e#   Group into triplets of digits (rows).
  "!_!"      e#   Push that string.
  f.{        e#   For each group of digits:
    S?       e#     Select the corresponding char of "!_!" for 1 and " " for 0.
  }          e#
  .+         e#   Concatenate along the rows with the previous results.
}/           e#
N*           e# Join, separating by linefeeds.
— Dennis
fonte
2

Perl, 475 469 424 390 280 272 byte

$_=<>;die" -
"x3if/[kmvwx]/i;y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);$i.=$z&1?' _ ':$"x3;$m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");$p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}print"$i
$m
$p
"

multilinea con commenti:

$_=<>;   # accept input
die" -   # check for invalid chars
"x3if/[kmvwx]/i;
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)   # loop over each character
    # lookup character from string using transliteration and convert to
    # number using ord() for bit checking:
    {$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);
    $i.=$z&1?' _ ':$"x3;    # first row
    $m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");   # second row
    $p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}    # third row
# print result:
print"$i
$m
$p
"

I pattern di bit che codificano i segmenti sono memorizzati in una stringa (che sfugge a 3 caratteri non stampabili usando \xe usando \0per lo spazio) e sono mappati sui caratteri di input usando l'operatore di traslitterazione Perl.

Per 5 dei 7 segmenti, un bit per bit e viene utilizzato insieme all'operatore ternario per generare uno spazio o il carattere del segmento. Per i due segmenti in basso a sinistra (codificati da 2 e 4 nel bitset), viene utilizzata una ricerca di sottostringa in una stringa di 8 caratteri per salvare 2 byte.

Grazie a Dom Hastings per i suoi consigli sul golf Perl.

Vecchia versione (usando regex per codificare i pattern), 390 byte:

$_=<>;if(/[kmvwx]/i){print" -\n"x3;exit}y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   ');$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').($z=~/[adhijopquyz\?0-4789]/?'!':' ');$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').($z=~/[b-egjklostuw-z0235689]/?'_':' ').($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')}print"$i\n$m\n$p\n"

multilinea con commenti:

$_=<>;   # accept input
if(/[kmvwx]/i){print" -\n"x3;exit}   # check for invalid chars
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)
{$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   '); # first row
$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').
($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').
($z=~/[adhijopquyz\?0-4789]/?'!':' '); # second row
$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').
($z=~/[b-egjklostuw-z0235689]/?'_':' ').
($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')} # third row
print"$i\n$m\n$p\n" # print result

La stringa viene letta e verificata la presenza di caratteri non validi utilizzando una regex, uscendo se ne vengono trovati. Quindi i caratteri minuscoli consentiti vengono sostituiti con caratteri non validi e l'intera stringa viene convertita in minuscolo.

Le righe vengono generate una alla volta, con 1 segmento per lettera nella prima riga e 3 nelle altre due. Per ogni riga, la stringa viene elaborata un carattere alla volta e il carattere viene confrontato con una regex per ogni segmento per verificare se a! o _ dovrebbe essere visualizzato. L'uso di un regex significa che per i caratteri in cui il segmento non è impostato, occorrono zero bit per segmento per carattere per codificare se impostarlo, e per quelli in cui si trova ci vogliono in media poco meno di 8 bit perché gli intervalli di caratteri regex possono essere Usato. Quindi funziona a circa 3 o 4 bit per segmento per carattere nell'insieme, o circa 21-24 bit per carattere.

Non gestisce il ritorno a capo.

— samgak
fonte
1
Ehi @samgak, felice di vedere più amore Perl! Ho notato alcune cose che potrebbero aiutarti a radere alcuni byte e volevo condividerli! Puoi usare alcune delle variabili magiche di Perl per aiutare a ridurre in questo; ' 'può essere sostituito con $"e ' 'può essere quello $"x3che taglia un po 'fuori, i tuoi \npossono essere letteralmente newline per sbarazzartene di alcuni. Anche la tua uscita anticipata può essere messa in cortocircuito, usando die, così if(/[kmvwx]/i){print" -\n"x3;exit}diventa die" - "x3if(/[kmvwx]/i). Con un po 'più di confusione puoi riorganizzare il loop per evitare le parentesi e non dovresti aver bisogno $zdi salvarne un altro!
— Dom Hastings,
1
Spero che tu non sia offeso, ma ho dato un'occhiata alla riduzione di più, gist.github.com/dom111/e651b5de8c7e7fc9a6cf . Fino a 323!
— Dom Hastings,
@DomHastings senza offesa, grazie per gli ottimi consigli sul golf! Ne ho usati quanti più ho potuto nella mia risposta modificata, che ho modificato per utilizzare la codifica bit a bit anziché le regex per i modelli di segmento. Sfortunatamente $ z è tornato e non riesco a capire come liberarmene. Inoltre, $_=lc<>non funziona, perché il codice non può discriminare tra CHIOU maiuscolo e minuscolo
— samgak
1

Lisp comune, 488 416

(lambda(z)(dotimes(r 3)(map()(lambda(c)(do((i 0(+ 17 i))n)((or(and(> i 901)(setf n 146))(=(char-code c)(ldb(byte 8 9)(setf n(ldb(byte 17 i)#36RIL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02)))))(loop for v from(* 3 r)for d across"!_!"do(format t"~:[ ~;~A~]"(logbitp v n)d)))))z)(terpri)))

Esempio

Con "abcdefg'hijklnopqrstuz", stampe:

 _           _  _  _  _           _           _  _     _        _ 
!_!!_  _  _!!_ !_ !   _ !_   !  ! _ !   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_! _ ! !  !!_! _ !_ ! !!_!!    !!   _!!_ !_!!_

Osservazioni

I personaggi e le loro rappresentazioni sono codificati in questo numero nella base 36:

IL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02

La rappresentazione binaria di questa cifra è divisa in gruppi di 17 bit.

Ad esempio, l'ultimo gruppo di 17 bit è 110000111101010, che è decomposto qui in due parti:

  1. 110000, il codice carattere del carattere 0

  2. 111101010, una codifica del disegno, meglio rappresentata come segue:

    010 (bits 0-2)         _ 
101 (bits 3-5)   =>   ! !
111 (bits 6-8)        !_!

    I bit nella prima e nell'ultima "colonna" sono per i !personaggi, quelli nella colonna centrale per il _personaggio. Se necessario, vengono memorizzate le versioni maiuscole e minuscole di un personaggio.

La funzione scorre tre volte sopra la stringa di input, una per ogni riga di output, cerca un carattere corrispondente nella tabella (o per impostazione predefinita è 146, ovvero tre barre) e stampa la rappresentazione nella riga corrente.

— coredump
fonte
Grazie per aver partecipato alla sfida. Ho notato che la tua "K" viene visualizzata come "L" nell'output. Potresti aver frainteso il requisito che non è possibile stampare caratteri non supportati insieme ad altri caratteri validi. Inoltre, vedo che hai aggiunto il 'personaggio, il che è carino; tuttavia, verrà visualizzato al di fuori di ciò che è in grado di offrire un display a 7 segmenti. Se si sposta !verso il basso di 1 riga, sarebbe perfetto.
— alcuni utenti il
Aggiornerò il 'carattere e modificherò la domanda Kperché, in effetti, ho inserito il punto Ksbagliato nella stringa di input ("... jlKn ...") ;-) Puoi vedere le barre triple (errore) solo dopo la L. Grazie per averlo notato.
— coredump,
1

JavaScript (ES6), 380 352 324 byte

( Nota: il codice usa la notazione con il cursore, in quanto contiene alcuni caratteri non stampabili. Per ottenere il codice originale, fare clic qui e selezionare i dati hnon elaborati . E no, non è un programma CJam.;)

d=s=>{a=' ',u=n=>r>>n&1?'!':a,v=n=>r>>n&1?'_':a,g='ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz0123456789-? ÿ',h='{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)^??^BK^0^G',x=y=z='';for(i=0;i<s.length;x+=a+v(0)+a,y+=u(4)+v(1)+u(3),z+=u(6)+v(2)+u(5)){q=g.indexOf(s[i++]);if(q<0)return d`ÿ`;r=h.charCodeAt(q)}return x+`
${y}
`+z}

Chiamato come d("7-seg display")o simile. Funziona con Firefox 40, ma potrebbe non funzionare con altri browser. Per qualche motivo, lo snippet HTML / JS non salva i non stampabili, ma è possibile copiare e incollare i dati grezzi da qui .

Ungolfed:

( Nota: g e hsono stati imbottiti con spazi per abbinare 8, -, ÿe spacecon i loro corrispondenti valori Unicode.)

d = function (s) {
  t = function (n) { return Math.floor(n) % 2; };
  g = 'ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz012345679? 8      -      ÿ      space ';
  h = '{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)?K \u007f \u0002 \u0007 \u0000';
  x = y = z = '';
  for(var i = 0; i < s.length; i++) {
    q = g.indexOf(s.charAt(i));
    if (q < 0)          // if g does not contain the character
      return d('ÿ');    // ÿ is equivalent to the error character, '\u0007'
    r = h.charCodeAt(q);
    x += ' ' + (r % 2 === 1 ? '_' : ' ') + ' ';
    y += (t(r / 16) === 1 ? '!' : ' ') + (t(r / 2) === 1 ? '_' : ' ') + (t(r / 8) === 1 ? '!' : ' ');
    z += (t(r / 64) === 1 ? '!' : ' ') + (t(r / 4) === 1 ? '_' : ' ') + (t(r / 32) === 1 ? '!' : ' ');
  }
  return x + '\n' + y + '\n' + z;
}

Spiegazione:

Ho subito notato che i 7 segmenti, convertiti in 0/ 1bit, sarebbero andati bene con i primi 128 caratteri Unicode. Il problema con questa idea è che 1/4 di questi caratteri sono caratteri di controllo non stampabili. Usarli nel mio codice sembrerebbe incredibilmente confuso (o incredibilmente intelligente; non ho deciso quale). Per risolvere questo problema mantenendo semplice il resto del codice, mi è venuta questa idea:

Con l'eccezione di -, spazio ed errore , nessuno dei caratteri mancava di entrambi i segmenti verticali inferiori. Quindi, per essere sicuro che tutti quei caratteri fossero rimasti tra 0020e 007f, ho semplicemente mappato i 64 e i 32 bit su questi segmenti, in questo modo:

     1
    ---
16 |   | 8
  2 ---
64 |   | 32
    ---
     4

I numeri degli altri 5 segmenti non sono troppo importanti; potrebbero essere organizzati in qualsiasi altro modo e avere comunque tutti gli stessi caratteri "in-bound".

Ad esempio, ecco la versione codificata di A :

     1
    ---
16 |   | 8
  2 ---
64 |   | 32

Dec: 64 + 32 + 16 + 8 + 2 + 1 = 123
Hex: 40 + 20 + 10 + 8 + 2 + 1 = 7B = u+007B = {

Ho quindi inserito la versione codificata di ogni personaggio di 7 seg h. Tuttavia, 8ha determinato 007f(la cancellazione codice di controllo; costante indipendentemente i segmenti sono disposti), spazio determinato 0000(il nullo codice; anch'esso costante), -ha determinato 0002, e l'errore provocato 0007. I copia-incollato i byte non elaborati nella posizione corretta per 8, -e l'errore ; lo spazio è stato facilmente raggiunto con \0.

Dopo tutta questa codifica, tutto quello che dovevo fare era usarlo per decodificare la stringa e inviarla in un formato leggibile a 7 seg. Ho usato una per ciclo e tre variabili ( x, ye z, ciascuna corrispondente ad una linea di uscita) di passare attraverso ogni carattere nella stringa e aggiungere il suo equivalente 7-seg all'uscita. Ho scelto ÿil carattere di errore perché AFAIK, non è su nessuna tastiera, ed è l'ultimo carattere u+0000-u+00ffdell'intervallo. Forse avrei potuto essere spiritoso e scelto Ξ(lettera greca xi) invece ....;)

Edit 1: ha salvato un sacco di spazio con la creazione di mini-funzioni per determinare se !, _o è necessaria.

Modifica 2: risparmia un po 'più di spazio usando i trucchi che ho imparato dall'ultima volta che ho visitato questo post.

Come al solito, i suggerimenti sono molto apprezzati!

— ETHproductions
fonte
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.