^{Sandbox Post}

Intro

I pannelli informativi sono ovunque. Quando la tecnologia è diventata più economica, i poster di carta sono stati trasformati in segni luminosi che mostrano parole che appaiono da un lato e escono dall'altro, come quello nella figura:

Quando uno di questi segni si avvia, di solito inizia a svuotarsi e il testo esce dal lato destro a sinistra, spostandosi fino a quando scompare.

La sua funzionalità è quella di accendere e spegnere le piccole lampadine (LED) per dare la sensazione di movimento.

Se invece del testo dobbiamo solo mostrare i numeri, il poster può essere molto meno sofisticato usando i cosiddetti marcatori a sette segmenti come il seguente:

In questo caso ogni numero è rappresentato dalla combinazione on / off di soli 7 segmenti luminosi che consentono di rappresentare tutti i numeri:

La domanda che ci poniamo è: quanti cambiamenti di luci (quanti accendere e spegnere) dovrebbero essere fatti per passare attraverso uno di questi manifesti un certo numero?

Ad esempio, per mostrare il 123 in un segno di 3 cifre che inizia con tutti i LED spenti avremo:

Ciò comporta un totale di 42 cambi di luci.

Sfida

Dato un numero non negativo e una lunghezza del segno positivo calcolare il numero di cambi di luci.

Regole

• Si supponga che l'input sia costituito da un numero non negativo (N> = 0) e una lunghezza del segno positivo (M> 0)
• Assumi Lunghezza segno> = Lunghezza numero (M> = cifre (N))

Casi test

123, 3        => 42
45, 5         => 60
111, 3        => 12
98765, 10     => 220
0, 3          => 36

Python 2 , 129 126 119 104 byte

def f(n,k,p=0):z=p<1or n>0;q=-~ord('}/lx2Z^o~z'[n%10])*z;return(z and f(n/10,k,q))+k*bin(p^q).count('1')

Provalo online!

Grazie per ben 15 byte dagli ovs .

Come specificato, accetta un numero non negativo e una lunghezza del segno positivo e restituisce le modifiche totali.

Gelatina , 23 byte

Dị“¤]þ+>~Œ¶?w‘Ø0j^ƝBFS×

Un collegamento diadico che accetta il numero intero da visualizzare a sinistra e la lunghezza del segno a destra che produce il numero di modifiche (funziona anche se il numero di cifre nell'intero da visualizzare è maggiore della lunghezza del segno).

Provalo online!

Come?

Durante l'intero spettacolo ogni display a 7 segmenti (ad un certo punto) passa da vuoto a prima cifra, quindi alla seconda e così via, e infine dall'ultima a vuota di nuovo. Ciascuna delle transizioni costa l'XOR bit a bit dei segmenti on della da-digit e to-digit (dove vuoto è una "cifra" con 0 su segmenti). Ho rubato i segmenti on come numeri interi da una precedente revisione della risposta di ETHproductions , ma qualsiasi permutazione dei 7 segmenti farebbe altrettanto.

Dị“¤]þ+>~Œ¶?w‘Ø0j^ƝBFS× - Link: integer to display, V; integer sign length, L  e.g. 123, 3
D                       - cast V to decimal digits                                  [1,2,3]
  “¤]þ+>~Œ¶?w‘          - code-page indices list = [3,93,31,43,62,126,19,127,63,119]
 ị                      - index into (1-based & modular) (vectorises)             [3,93,31]
              Ø0        - literal = [0,0]                                             [0,0]
                j       - join                                                [0,3,93,31,0]
                  Ɲ     - pairwise application of:
                 ^      -   bitwise XOR                                        [3,94,66,31]
                   B    - convert to binary digits (vectorises)               [[1,1],[1,0,1,1,1,1,0],[1,0,0,0,0,1,0],[1,1,1,1,1]]
                    F   - flatten                                             [1,1,1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,1,1]
                     S  - sum                                                            14
                      × - multiply by L                                                  42

JavaScript (Node.js) , 104 94 93 93 byte

Salvato 1 byte grazie a @Shaggy

B=n=>n&&n%2+B(n>>1)
F=(d,w,q)=>w*B(q^(q=d&&"w`>|i]_p}".charCodeAt(d%10)))+(d&&F(d/10|0,w,q))

Provalo online!

Japt, 31 30 byte

Adattato dalla soluzione Jelly di Jonathan. Accetta l'input in ordine inverso con il numero da visualizzare come un array di cifre.

*Vm!c"w]+>~?" pT ä^T x_¤¬x

Provalo

Pulito , 280 byte

import StdEnv,Data.List
~ =toInt
?s=sum[(~s>>p)rem 2\\p<-[0..6]]
$n l#j=repeatn l 0
#n=j++[~c-47\\c<-:toString n]++j
#k=[getItems(map((!!)[0,119,3,62,31,75,93,125,19,127,95])n)[i-l..i-1]\\i<-[0..length n]]
=sum(zipWith@(tl k)k)
@[u][]= ?u
@[u:x][v:y]= ?((bitxor)u v)+ @x y
@[][]=0

Provalo online!

Deve esserci un modo più breve ..

Carbone , 40 byte

≔⁺×⁷0⭆Ｓ§⪪”)∧？？%←⁶%*An”⁷ＩιθＩ×ＮΣＥθ¬⁼ι§θ⁺⁷κ

Provalo online! Il collegamento è alla versione dettagliata del codice. Funziona convertendo l'input nei valori del segmento binario, quindi contando il numero di modifiche tra ciascun carattere. Spiegazione:

      Ｓ                     Convert first input to string
     ⭆                      Map over digits and join
         ”)∧？？%←⁶%*An”      Compressed segment value string
        ⪪             ⁷     Split into groups of seven characters
                        ι   Current digit
                       Ｉ    Convert to integer
       §                    Index into groups
    0                       Literal `0`
  ×⁷                        Repeat seven times
 ⁺                          Concatentate
≔                        θ  Assign to variable `q`

     θ          Variable `q`
    Ｅ           Map over characters
             κ  Current index
           ⁺⁷   Add seven
          θ     Variable `q`
         §      Cyclically index
        ι       Current character
       ⁼        Compare
      ¬         Logical not
   Σ            Sum results
  Ｎ             Second input
 ×              Multiply
Ｉ               Cast to string
                Implicitly print

JavaScript (Node.js) , 88 byte

Accetta input come (integer)(width).

n=>w=>[...n+'',g=n=>n&&1+g(n&n-1)].map(c=>s+=g(x^(x=Buffer('w$]m.k{%o')[c])),x=s=0)|s*w

Provalo online!

Come?

$\{d_1,d_2,\dots,d_n\}$$n$$w$$N$

$T_{x,y}$$x$$y$${T'}_{x}$$x$

Commentate

n => w =>                       // n = integer; w = width of display
  [ ...n + '',                  // coerce n to a string and split it
    g = n =>                    // g = helper function counting the number of 1's
      n && 1 + g(n & n - 1)     // by defining it here, we also force an extra iteration
  ]                             // with an undefined digit (interpreted as the blank digit)
  .map(c =>                     // for each entry c in this array:
    s += g(                     //   add to s the result of a call to g():
      x ^ (x =                  //     XOR the previous value of x
        Buffer('w$]m.k{%?o')[c] //     with the new one, picked from a 10-entry lookup
      )                         //     gives undefined (coerced to 0) for the last entry
    ),                          //   end of call to g()
    x = s = 0                   //   start with x = 0 and s = 0
  ) | s * w                     // end of map(); return s * w