Ich denke, die meisten Leute hier wissen, was eine 7-Segment-Anzeige für Ziffern ist:

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

Wir können die 7-Segment-Differenz (7SD) zwischen zwei Ziffern als die Anzahl der Segmente definieren, die umgeschaltet werden müssen, um von einem zum anderen zu wechseln. ZB die 7SD zwischen 1und 2ist 5 (die drei horizontalen Segmente und die unteren beiden vertikalen Segmente müssen umgeschaltet werden), und die 7SD zwischen 6 und 8 ist 1 .

Außerdem können wir die 7SD zwischen zwei Zahlen als die Summe der 7SDs zwischen den entsprechenden Ziffern definieren. Wenn eine Zahl länger als die andere ist, gehen wir davon aus, dass sie rechtsbündig sind, und fügen die Anzahl der Segmente hinzu, die erforderlich sind, um die zusätzlichen höchstwertigen Ziffern der größeren Zahl anzuzeigen. Betrachten Sie als Beispiel die 7SD zwischen 12345und 549:

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

Ihre Aufgabe ist es, 7SD zwischen n und n + 1 bei n zu berechnen .

Der Einfachheit halber finden Sie hier die vollständige Tabelle der 7SDs zwischen den einzelnen Ziffern. Die Zeile steht _für eine leere Position.

   _ 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

Eingang

• Die Eingabe ist eine einzelne positive Ganzzahl n.
• Sie können ein Programm oder eine Funktion schreiben und Eingaben über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument vornehmen.
• Sie können davon ausgehen, dass die Eingabe höchstens eine Zahl kleiner ist als die größte Zahl, die durch den Standard-Integer-Typ Ihrer Sprache dargestellt werden kann, sofern dieser Typ mindestens Werte bis einschließlich 127 unterstützt.

Ausgabe

• Sie sollten eine einzelne Ganzzahl ausgeben, die 7SD zwischen nund n+1.
• Sie können über STDOUT (oder die nächstgelegene Alternative), einen Funktionsrückgabewert oder ein Funktionsargument (out) ausgeben.

Wertung

Es gelten die Standardregeln für Code-Golf . Der kürzeste Code (in Byte) gewinnt.

Testfälle

Aus irgendeinem unbekannten Grund ist diese Sequenz noch nicht in OEIS enthalten, obwohl es die eng verwandte Sequenz A123587 gibt . Hier sind die ersten 100 Zahlen (beginnend mit 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

Der erste Eingang, für den die 7SD größer als 9 ist 1999, sollte 11 ergeben. Hier einige andere größere Beispiele:

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

Jelly , 25 22 21 20 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Wir erhöhen zuerst die Eingabe n und verwerfen alle Ziffern von n + 1 , die sich nicht geändert haben.

Wenn n beispielsweise 5699999 ist , erhalten wir Folgendes.

n     : 5700000
n + 1 : 5699999
Result:  700000

Alle Ziffern in diesem Ergebnis haben eine feste Anzahl von Segmenten, die umgeschaltet werden müssen. Wir können die Liste der Toggles in die bijektive Basis 5 konvertieren , um einige Bytes zu sparen.

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

Die Ausgabe ist einfach die Summe der einzelnen Umschaltungen.

Dies funktioniert für die meisten Werte von n , es ist jedoch besondere Vorsicht geboten, wenn n + 1 mehr Ziffern als n enthält . In diesem Fall müssen alle Ziffern 9 sein , und wir lösen dieses Problem, indem wir eine nachstehende 0 von n + 1 abtrennen .

Wenn n beispielsweise 999999 ist , erhalten wir Folgendes.

n     :  999999
n + 1 : 1000000
Result: 100000

Dies funktioniert , da die führenden 1 ausgewertet 4 schaltet (Abstand zwischen 0 und 1 ), während die tatsächlichen Menge des Knebels ist 2 (Abstand zwischen 0 und 1 ) und einer Unterdrückung der Hinter 0 entfernt deren 2 aus der Summe umschaltet.

Wie es funktioniert

‘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 bis 40 Byte

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

Alternative Formulierung, auch 46 40 Bytes:

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

Bearbeiten: 6 Bytes dank @xsot gespeichert.

Python, 50 48 Bytes

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

Erläuterung

Diese Funktion arbeitet mit der niedrigstwertigen Ziffer der Zahl nund summiert die 7SD der Ziffern, wenn sie um eins erhöht wird, bis nach der ersten nicht- 9Ziffer.

26523308ist eine Bitmaske, die das Mapping für die Ziffern codiert 0-8. Wenn n=0, die nur auftritt, wenn nnur 9s umfasst , wird die Antwort von zwei sein. Dies wird durch den Ausdruck kompensiert 0**n*2. Was die Ziffer 9betrifft, wird die Bitmaske mit Null bewertet, wodurch der rekursive Aufruf beim Hinzufügen 2zur 7SD ausgelöst wird.

05AB1E , 31 30 28 27 26 Bytes

Code:

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

Erklärung ( veraltet ):

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

Wir ändern Folgendes auf die letzte Ziffer, die nicht 9 ist:

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

Für die besonderen Fälle:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

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

Java, 63 Bytes

Die Welt ist in Ordnung, als Python erneut Java übergibt.

Weil, weißt du, Java.

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

Sieh es auf ideone

Maxes out bei 2147483647, da dies Javas ist Integer.MAX_VALUE.

Dies ist ein Port meiner Python-Antwort, der ein Port der ES6-Antwort ist .

MATL , 61 39 36 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es hier aus.

Dennis hat ein Byte gespeichert!

Python, 71 66 Bytes

48 Bytes xsot . Noch mehr magische Mathematik!

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

Sieh es auf ideone

Weil die vorherige Python-Antwort nicht funktioniert und alles andere als optimal ist. Ein einfacher Port einer früheren ES6-Version . Verwenden Sie jetzt Bit Twiddling (aus der alternativen ES6-Formulierung), um einen Cast auszuschneiden!

Kann dazu gebracht werden, mit Python 3 zu arbeiten, indem floordiv explizit für +1 Byte verwendet wird.

Jolf, 32 Bytes

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

Probieren Sie es hier aus!

Erläuterung

Dies ist eine Umsetzung von Neils Antwort.

Ώ?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 Bytes

Das erste war peinlich.

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

Test Suite .

J, 53 Bytes

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

Ursprünglich basiert auf @ Neils Lösung . Anschließend können Sie das Ergebnis verbessern, indem Sie ein Byte mit derselben Formel in @ Lynns Lösung speichern .

Die 54-Byte-Version, die auf dem String basiert, ist

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

Verwendung

   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 Bytes

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

Probieren Sie es online! (In der ersten Zeile können nur mehrere Testfälle gleichzeitig verarbeitet werden.)

Erläuterung

Wie die meisten Antworten inzwischen festgestellt haben, müssen wir nicht die vollständige Tabelle verwenden, da 9sich beim Inkrementieren nur die niedrigstwertigen, nicht einstelligen Änderungen ergeben. So funktioniert auch diese Antwort.

M!`.9*$

Dies entspricht ( M) dem regulären Ausdruck, .9*$dh der ersten Ziffer, die nur durch 9s vom Ende getrennt ist. Das !weist Retina an, die Eingabe durch dieses Match zu ersetzen und alles zu verwerfen, was die 7SD nicht beeinflusst.

^9
0

Beginnt die Eingabe nun mit einem 9, dh, die Eingabe selbst bestand nur aus 9s, so muss der 7-Segment-Anzeige ein, 1was kostet , vorangestellt werden 2. Die einfachste Möglichkeit, dies zu handhaben, besteht darin, die führende 9in diesem Fall durch eine zu ersetzen 0, da die Kosten für das Inkrementieren von a 9(bis 0) 2und die Kosten für das Inkrementieren von 0(bis 1) so sind 4, dass sich die Gesamtkosten nach 2Bedarf erhöhen.

T`d`4523315412

Jetzt haben wir eine Transliterationsphase, in der jede Ziffer durch die Kosten für ihre Erhöhung ersetzt wird (da die zu derweitert wird 0123456789). Beachten Sie, dass dies die erste Subdiagonale der 7SD-Tabelle ist.

.
$*

Dies ersetzt jede Ziffer ndurch nKopien von 1, dh es konvertiert jede Ziffer in unär, und da es keine Trennzeichen gibt, addiert es diese sofort zusammen.

.

Schließlich zählen wir die Anzahl der Zeichen (dh die Anzahl der Übereinstimmungen von .) im Ergebnis, wodurch die unäre Summe zurück in eine Dezimalzahl umgewandelt wird.