Dato un display a 7 segmenti con alcuni segmenti accesi e alcuni spenti, trova una sequenza di cifre (0-9), in modo tale che dopo aver attivato i segmenti corrispondenti per ogni cifra, tutti i segmenti vengono disattivati.

Esempio

  _
  _    [3] =>     |   [1] =>    [OFF]
  _               |

Numeri e segmenti corrispondenti:

 _         _   _         _    _    _    _    _ 
| |    |   _|  _|  |_|  |_   |_     |  |_|  |_|
|_|    |  |_   _|    |   _|  |_|    |  |_|   _|

Regole

Codegolf wins vince l'ingresso più breve.

Ingresso

Un elenco non vuoto di segmenti attivati, indicato come

1. Una sequenza di numeri. I segmenti sono numerati dall'alto verso il basso, da sinistra a destra; a partire da 0 o 1. I numeri non devono essere in ordine.

2. Una singola cifra di 7 bit. MSB / LSB non specificato (quindi è possibile scegliere).

Sono consentiti caratteri non numerici tra i numeri (ma non è necessario che siano supportati).

Per esempio. per numero 7: 136oppure 1010010oppure0100101

Produzione

Una sequenza di numeri da "applicare" al display. Non limitato in alcun modo, ad esempio l'ordine delle cifre. Per esempio. per stato iniziale corrispondente al numero 1, uscite validi sarebbe 1, 111, 010, etc.

Un'uscita alternativa è una cifra di 10 bit (di nuovo, MSB / LSB è la tua scelta). Per esempio. per 1come input, l'output sarebbe 1000000000o 0000000001.

Alcune combinazioni hanno diverse soluzioni non ripetitive, ad es. i segmenti corrispondenti alla lettera maiuscola Hpossono essere disattivati ​​da 013, ma anche 489e 0258.

Se non esiste alcuna soluzione (che credo non sia possibile), l'output è vuoto.

Gelatina , 26 25 byte

2ṗ⁵’µ×“wØ][:koR¶{‘^/=µÐfḢ

Provalo online!

Accetta l'input come numero intero a 7 bit. Restituisce la forma binaria di un numero intero a 10 bit.

Questo bruto forza tutte le possibilità. Rimuovi ilḢ per ottenere tutti gli output possibili o sostituirlo con un Xper ottenere un output casuale possibile.

Programma di visualizzazione magica!

Come funziona

2ṗ⁵’µ×“wØ][:koR¶{‘^/=µÐfḢ  - main link, takes one integer
2ṗ⁵’                       - generate all length-10 binary arrays
    µ                µÐf   - now we find those arrays which correspond to digit-
                              sequences which work to switch off all segments:
                              Filter (keep) those arrays which:
     ×                      - multiplied by 
      “wØ][:koR¶{‘          - [119, 18, 93, 91, 58, 107, 111, 82, 127, 123] 
                               (encoding for turned-on segments given number)
                  ^/        - reduced by XOR
                    =      - are equal to (implicit) the program's input
                        Ḣ  - output the first of these valid arrays

JavaScript (ES6), 60 byte

n=>[65,35,55,42,48,54,110].reduce((r,v,i)=>r^=n>>i&1&&v+v,0)

Questo funziona perché:

• Le opzioni 1 e 7 consentono di alternare solo il segmento superiore
• Attiva 1, 2 e 6 per alternare solo il segmento in alto a sinistra
• Attiva 1, 2, 3, 5 e 6 per alternare solo il segmento in alto a destra
• Le opzioni 2, 4 e 6 consentono di alternare solo il segmento centrale
• Le opzioni 5 e 6 consentono di alternare solo il segmento in basso a sinistra
• Attiva / disattiva 2, 3, 5 e 6 per alternare solo il segmento in basso a destra
• Attiva / disattiva 2, 3, 4, 6 e 7 per alternare solo il segmento inferiore

JavaScript (ES6), 117 107 101 86 84 byte

Risparmiato 15 byte grazie a Neil

Accetta l'input come numero intero a 7 bit, dove LSB è il segmento superiore. Restituisce un numero intero a 10 bit in cui l'LSB è composto da cifre 0.

f=(n,k)=>[83,0,57,73,10,71,87,1,91,75].reduce((n,v,i)=>n^=k>>i&1&&v+36,n)?f(n,-~k):k

dimostrazione

f=(n,k)=>[83,0,57,73,10,71,87,1,91,75].reduce((n,v,i)=>n^=k>>i&1&&v+36,n)?f(n,-~k):k

console.log("'1' shape", "-->", f(0b0100100).toString(2))
console.log("'7' shape", "-->", f(0b0100101).toString(2))
console.log("'H' shape", "-->", f(0b0111110).toString(2))

Mathematica, 40 byte

BitXor@@{260,802,10,514,3,266,293}[[#]]&

(Si può giocare più a golf scegliendo attentamente l'output per ciascun segmento e passare da LSB a MSB.)

Prendi ad esempio un elenco di posizioni {2,4,5,7}e genera un numero di 10 bit ( 384= 0110000000in binario) in ordine MSB (0, ..., 9).

Nell'esempio corrisponde a

  |_
  |_

e l'uscita corrisponde a {7,8}.

Spiegazione:

I numeri magici (elenco hardcoded) è l'output che viene restituito per ogni segmento. (codificato in binario) E, se un numero appare nell'elenco due volte, l'effetto è lo stesso del suo non apparire, quindi viene usato XOR bit a bit. Dobbiamo solo XOR l'output del possibile valore dei segmenti attivati.

Gelatina , 12 byte

ị“A#7*06n‘^/

Provalo online!

Questo non ha una forza bruta ed è notevolmente più breve della mia altra soluzione. Accetta input come un elenco di segmenti attivati ​​e output come LSB è il segmento superiore.

Uscita come elenco di spostamenti di cifre.

Come funziona

Questo sarà veloce

ị“A#7*06n‘^/ - main link, takes input as a list of turned-on segments (eg. [1,3,6])
 “A#7*06n‘   - list literal [65,35,55,42,48,54,110] where each element is a 7-bit
                 integer, where each integer corresponds to how to turn off
                 a segment (eg. turn off the first segment with 7 and 1 =>2^7+2^1=>64)
ị            - get the elements in the list corresponding to the input indices
          ^/ - XOR reduce these elements to get a single 7-bit integer