^{Sandbox Post}

Introducción

Los paneles de información están en todas partes. Cuando la tecnología se volvió más barata, los carteles de papel se transformaron en signos luminosos que muestran palabras que aparecen en un lado y salen por el otro, como el de la figura:

Cuando se inicia uno de estos signos, generalmente comienza vacío y el texto sale del lado derecho hacia la izquierda, moviéndose hasta que desaparece.

Su funcionalidad es encender y apagar las pequeñas bombillas (LED) para dar la sensación de movimiento.

Si en lugar de texto solo necesitamos mostrar números, el póster puede ser mucho menos sofisticado usando los llamados marcadores de siete segmentos como los siguientes:

En este caso, cada número está representado por la combinación de encendido / apagado de solo 7 segmentos de luz que permiten representar todos los números:

La pregunta que nos hacemos es cuántos cambios de luces (cuántos encendidos y apagados) se deben hacer para pasar por uno de estos carteles un número determinado.

Por ejemplo, para mostrar el 123 en un signo de 3 dígitos que comienza con todos los LED apagados tendremos:

Esto hace un total de 42 cambios de luces.

Desafío

Dado un número no negativo y una longitud de signo positivo, calcule el número de cambios de luces.

Reglas

• Suponga que la entrada consiste en un número no negativo (N> = 0) y una longitud de signo positivo (M> 0)
• Asumir longitud del signo> = longitud del número (M> = dígitos (N))

Casos de prueba

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

Python 2 , 129 126 119 104 bytes

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

Pruébalo en línea!

Thx para un gran 15 bytes de ovs .

Como se especifica, toma un número no negativo y una longitud de signo positivo, y devuelve los cambios totales.

Jalea , 23 bytes

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

Un enlace diádico que acepta el número entero para mostrar a la izquierda y la longitud del signo a la derecha que produce el número de cambios (también funciona si el número de dígitos en el número entero para mostrar es mayor que la longitud del signo).

Pruébalo en línea!

¿Cómo?

Durante todo el espectáculo, cada pantalla de 7 segmentos (en algún momento) pasa del vacío al primer dígito, luego al segundo y así sucesivamente, y finalmente del último al vacío nuevamente. Cada una de las transiciones cuesta el XOR bit a bit de los segmentos activos de los dígitos desde y hacia los dígitos (donde vacío es un "dígito" con 0 segmentos activos). Robé los segmentos en forma de números enteros de una revisión anterior de la respuesta de ETHproductions , pero cualquier permutación de los 7 segmentos funcionaría igual de bien.

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 bytes

Guardado 1 byte gracias 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))

Pruébalo en línea!

Japt, 31 30 bytes

Adaptado de la solución Jonathan's Jelly. Toma la entrada en orden inverso con el número que se mostrará como una matriz de dígitos.

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

Intentalo

Limpio , 280 bytes

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

Pruébalo en línea!

Tiene que haber un camino más corto ...

Carbón , 40 bytes.

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

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona convirtiendo la entrada en los valores del segmento binario y luego contando el número de cambios entre cada carácter. Explicación:

      Ｓ                     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 bytes

Toma entrada como (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

Pruébalo en línea!

¿Cómo?

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

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

Comentado

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