Penso che la maggior parte delle persone qui sappiano cos'è un display a 7 segmenti per cifre:

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

Possiamo definire la differenza di 7 segmenti (7SD) tra due cifre per essere il numero di segmenti che devono essere attivati ​​per passare da uno all'altro. Ad esempio, la 7SD tra 1e 2è 5 (i tre segmenti orizzontali e i due segmenti verticali inferiori devono essere attivati), e la 7SD tra 6 e 8 è 1 .

Inoltre, possiamo definire la 7 SD tra due numeri per essere la somma delle 7 SD tra le cifre corrispondenti. Se un numero è più lungo dell'altro, assumiamo che siano allineati a destra e aggiungiamo il numero di segmenti necessari per visualizzare le cifre aggiuntive più significative del numero più grande. Ad esempio, considera il 7SD tra 12345e 549:

  x:  1 2 3 4 5
  y:      5 4 9
7SD:  2+5+2+0+1 = 10

Il tuo compito è calcolare 7SD tra n e n + 1 , dato n .

Per comodità, ecco la tabella completa di 7 SD tra singole cifre. La riga _rappresenta una posizione vuota.

   _ 0 1 2 3 4 5 6 7 8 9

_  0 6 2 5 5 4 5 6 3 7 6
0  6 0 4 3 3 4 3 2 3 1 2
1  2 4 0 5 3 2 5 6 1 5 4
2  5 3 5 0 2 5 4 3 4 2 3
3  5 3 3 2 0 3 2 3 2 2 1
4  4 4 2 5 3 0 3 4 3 3 2
5  5 3 5 4 2 3 0 1 4 2 1
6  6 2 6 3 3 4 1 0 5 1 2
7  3 3 1 4 2 3 4 5 0 4 3
8  7 1 5 2 2 3 2 1 4 0 1
9  6 2 4 3 1 2 1 2 3 1 0

Ingresso

• L'input è un singolo numero intero positivo n.
• È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), argomento della riga di comando o argomento della funzione.
• Puoi supporre che l'input sia al massimo uno in meno del numero più grande che può essere rappresentato dal tipo intero standard della tua lingua, purché quel tipo supporti almeno i valori fino a 127 inclusi.

Produzione

• È necessario stampare un singolo numero intero, la 7SD tra ne n+1.
• È possibile eseguire l'output tramite STDOUT (o l'alternativa più vicina), il valore restituito dalla funzione o l'argomento della funzione (out).

punteggio

Si applicano le regole standard del codice golf , vince il codice più breve (in byte).

Casi test

Per qualche oscura ragione, questa sequenza non è ancora in OEIS, sebbene ci sia la sequenza strettamente correlata A123587 . Ecco i primi 100 numeri (che iniziano con n = 1, 2, 3, ...):

5, 2, 3, 3, 1, 5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 
5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 6, 4, 5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 6, 4

Il primo input per il quale la 7SD è maggiore di 9 è 1999che dovrebbe produrre 11. Ecco alcuni altri esempi più grandi:

n          7SD
1999        11
12345        1
999999      14
5699999     15
8765210248   1

Gelatina , 25 22 21 20 byte

‘DṁDḟ"DFị9979482ḃ5¤S

Provalo online! o verifica tutti i casi di test .

sfondo

Innanzitutto incrementiamo l'ingresso n e scartiamo tutte le cifre di n + 1 che non sono state modificate.

Ad esempio, se n è 5699999 , otteniamo quanto segue.

n     : 5700000
n + 1 : 5699999
Result:  700000

Tutte le cifre in questo risultato hanno un numero fisso di segmenti che devono essere attivati. Siamo in grado di convertire l'elenco di toggle in base biiettiva 5 per salvare alcuni byte.

digit:   1 2 3 4 5 6 7 8 9 0
toggles: 4 5 2 3 3 1 5 4 1 2

L'output è semplicemente la somma dei singoli toggle.

Funziona con la maggior parte dei valori di n , ma è necessario prestare particolare attenzione se n + 1 ha più cifre di n . In questo caso, tutte le cifre devono essere di 9 e risolviamo questo problema tagliando uno 0 finale da n + 1 .

Ad esempio, se n è 999999 , otteniamo quanto segue.

n     :  999999
n + 1 : 1000000
Result: 100000

Questo funziona perché il 1 principale viene valutato in 4 toggle (distanza tra 0 e 1 ), mentre la quantità effettiva di toggle è 2 (distanza tra 0 e 1 ) e la soppressione di uno 0 finale rimuove i suoi 2 toggle dalla somma.

Come funziona

‘DṁDḟ"DFị9979482ḃ5¤S  Main link. Argument: n

‘                     Compute n+1.
 D                    Convert n+1 from integer to base 10.
   D                  Convert n from integer to base 10.
  ṁ                   Mold the left result as the right result.
                      This chops of a 0 if n+1 has more digits than n.
    ḟ"D               Vectorized filter-false with the base 10 digits of n.
                      This removes the digits from n+1 that are identical to
                      the corresponding digits of n.
       F              Flatten the resulting list of lists.
         9979482ḃ5¤   Convert 9979482 to bijective base 5.
                      This yields [4, 5, 2, 3, 3, 1, 5, 4, 1, 2].
        ị             Retrieve the digits at the right that correspond to the
                      indices at the left.
                   S  Compute the sum of the results.

JavaScript (ES6), 46 40 byte

f=n=>n?+"452331541"[n%10]||f(n/10|0)+2:2

Formulazione alternativa, anche 46 40 byte:

f=n=>n?26523308>>n%10*3&7||f(n/10|0)+2:2

Modifica: salvato 6 byte grazie a @xsot.

Python, 50 48 byte

f=lambda n:26523308-0**n*2>>n%10*3&7or f(n/10)+2

Spiegazione

Questa funzione opera sulla cifra meno significativa del numero n, sommando la 7SD delle cifre quando viene incrementata di una fino a dopo la prima non 9cifra.

26523308è una maschera di bit che codifica il mapping per le cifre 0-8. Quando n=0, che si verifica solo quando ncomprende solo 9s, la risposta sarà disattivata per due. Questo è compensato dall'espressione 0**n*2. Per quanto riguarda la cifra 9, la maschera di bit viene valutata a zero, il che attiverà la chiamata ricorsiva durante l'aggiunta 2alla 7SD.

05AB1E , 31 30 28 27 26 byte

Codice:

9Ü©T%•2X›ùì•sè¹g®g-·¹Ú9Q·O

Spiegazione ( obsoleta ):

9Ü                              # Trim off trailing 9's
  ©                             # Copy this into the register
   T%                           # Get the last non-9 digit
     žh                         # Short for 0123456789
       •2X›ù앧                 # Compressed version of 4523315412
               ‡                # Transliterate

Stiamo cambiando quanto segue nell'ultima cifra non 9:

0 -> 4
1 -> 5
2 -> 2
3 -> 3
4 -> 3
5 -> 1
6 -> 5
7 -> 4
8 -> 1
9 -> 2

Per i casi speciali:

                ¹g              # Get the length of the input
                  ®g            # Get the length of the input with all trailing 9 gone
                    -           # Substract, giving the number of 9's at the end of 
                                  the input
                     2*         # Multiply by two
                       O        # Sum everything up
                        ¹Ú      # Uniquify the input
                          9Qi   # If this is equal to 9 (only 9's in the input)
                             Ì  #   Increment by 2 (_ -> 1)

Utilizza la codifica CP-1252 . Provalo online! .

28 byte alternativa: D[¤©•2X›ùì•sès®9Ê#¨]\rÚ9Q4*O.

Java, 63 byte

Il mondo è raddrizzato quando Python passa di nuovo Java.

Perché, sai, Java.

int f(int n){return n>0?n%10<9?26523308>>n%10*3&7:2+f(n/10):2;}

Guardalo su ideone

Massima a 2147483647, dato che è di Java Integer.MAX_VALUE.

Questa è una porta della mia risposta Python che è una porta della risposta ES6 .

MATL , 61 39 36 byte

tQvV15\'3dAsMh818RG5'6Y27WZaw)Z}Z~Bz

Provalo online!

Spiegazione

tQv            % Implicit input. Duplicate, add 1, concatenate vertically
V              % Convert to 2D char array: each number in a row, possibly left-padded 
               % with a space
15\            % Modulo 15. With modular indexing this corresponds to the order
               % '9', ' ', '0', '1', ..., '8'
'3dAsMh818RG5' % This string encodes active segments for each of the 11 chars
6Y2            % Source alphabet printable ASCII chars (predefined literal)
7W             % Target alphabet: [0 1 ... 127]
Za             % Base conversion: decode string into vector of 11 numbers, where each
               % number from 0 to 127 encodes the 7-segment representation of a digit,
               % in the order '9', ' ', '0', '1', ..., '8'
w              % Swap top two elements in stack
)              % Use as index. Gives 2-row array, where each column is a digit 
Z}             % Split into the two rows
Z~             % Bitwise XOR, elementwise
B              % Convert to binary. Each number gives a row
z              % Number of nonzero elements. Implicitly display

Julia, 44 byte

!x=x<1?2:(t=x%10÷1)<9?3045058÷6^t%6:2+!.1x

Provalo qui.

Dennis ha salvato un byte!

Python, 71 66 byte

48 byte di xsot . Ancora più matematica magica!

f=lambda n:(2+f(n/10)if n%10==9else 26523308>>n%10*3&7)if n else 2

Guardalo su ideone

Perché la precedente risposta di Python non funziona ed è tutt'altro che ottimale. Una semplice porta di una precedente versione ES6 . Ora usa bit twiddling (dalla formulazione alternativa ES6) per ritagliare un cast!

Può essere fatto funzionare con Python 3 usando esplicitamente floordiv per +1 byte.

Jolf, 32 byte

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2

Provalo qui!

Spiegazione

Questa è una traduzione della risposta di Neil.

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2
Ώ                                 define a function Ώ of H
 ?H                            2  (when H is zero, return is 2)
      %Ht                         H mod 10
     γ                            γ = ^
   ?<    9                        is it less than 9?
                                  if so:
           ."452331541"γ           get the γth element of that string
          P                        as a number
                                  else
                        +2         add two to
                          Ώ        Ώ over
                           c/Ht    int(H / 10)

Pyth - 78 30 27 byte

Quella prima era imbarazzante.

s@LjC"
(J"ThC{I#.tjRThBQT

Test Suite .

J, 53 byte

2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*

Originariamente basato sulla soluzione di @ Neil . Quindi migliorato salvando un byte usando la stessa formula nella soluzione di @ Lynn .

La versione a 54 byte basata sulla stringa è

2:`((2+10$:@<.@%~[)`('452331541'".@{~])@.(9>])10&|)@.*

uso

   f =: 2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*
   f 1999
11
   f 1999 12345 999999 5699999 8765210248
11 1 14 15 1

Retina , 34 byte

M!`.9*$
^9
0
T`d`4523315412
.
$*
.

Provalo online! (La prima riga consente solo l'elaborazione di più casi di test contemporaneamente.)

Spiegazione

Come ormai la maggior parte delle risposte ha scoperto, non è necessario utilizzare la tabella completa, poiché solo le 9modifiche non numeriche meno significative durante l'incremento. È anche così che funziona questa risposta.

M!`.9*$

Questo corrisponde a ( M) il regex, .9*$ovvero la prima cifra che è separata solo da 9s dalla fine. Il !dice a Retina di sostituire l'input con questa corrispondenza, scartando tutto ciò che non influisce sul 7SD.

^9
0

Se l'input ora inizia con un 9che significa, l'input stesso consisteva solo di 9s, quindi il display a 7 segmenti deve anteporre un 1che costa 2. Il modo più semplice per gestire questo è sostituire il lead 9in questo caso con a 0, poiché il costo dell'incremento di a 9(a 0) è 2e il costo dell'incremento 0(a 1) è 4, quindi questo aumenta il costo complessivo di 2quanto richiesto.

T`d`4523315412

Ora abbiamo una fase di traslitterazione che sostituisce ogni cifra con il suo costo per incrementarla (dal momento che si despande a 0123456789). Si noti che questa è la prima sottodiagonale della tabella 7SD.

.
$*

Questo sostituisce ogni cifra ncon ncopie di 1, cioè converte ogni cifra in unaria e, poiché non ci sono separatori, li somma immediatamente.

.

Infine, contiamo il numero di caratteri (cioè il numero di corrispondenze di .) nel risultato, che converte la somma unaria in decimale.