我认为这里的大多数人都知道数字的7段显示是什么：

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

我们可以将两个数字之间的7段差（7SD）定义为需要切换以从一个切换到另一个的段数。例如，介于和之间的7SD 为5（需要切换三个水平段和下面两个垂直段），而介于6和8之间的7SD为1。12

此外，我们可以将两个数字之间的7SD定义为其相应数字之间的7SD之和。如果一个数字长于另一个数字，我们假设它们是右对齐的，然后添加显示更大数字的其他最高有效数字所需的段数。例如，考虑介于12345和之间的7SD 549：

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

给定n，您的任务是计算介于n和n + 1之间的7SD。

为方便起见，这是各个数字之间的7SD完整表。该行_代表一个空位置。

   _ 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

输入项

• 输入是一个正整数n。
• 您可以编写程序或函数，通过STDIN（或最接近的替代方案），命令行参数或函数参数获取输入。
• 您可以假定输入最多比语言的标准整数类型可以表示的最大数字小一，只要该类型支持的值至少为127（含）以下即可。

输出量

• 您应该在n和之间打印一个整数，即7SD n+1。
• 您可以通过STDOUT（或最接近的替代品），函数返回值或函数（out）参数输出。

计分

适用标准代码高尔夫球规则，最短代码（以字节为单位）获胜。

测试用例

出于某种晦涩的原因，尽管存在密切相关的序列A123587，但该序列尚未在OEIS中。以下是前100个数字（以开头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

7SD大于9的第一个输入1999应产生11。这是其他一些较大的示例：

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

果冻，25 22 21 20 字节

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

在线尝试！或验证所有测试用例。

背景

我们首先递增输入n并舍弃所有n +1不变的数字。

例如，如果n为5699999，我们得到以下结果。

n     : 5700000
n + 1 : 5699999
Result:  700000

此结果中的所有数字都有固定数量的段，必须进行切换。我们可以将切换列表转换为双射基数5以节省一些字节。

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

输出只是各个切换的总和。

这适用于大多数n值，但如果n +1的位数多于n，则必须格外小心。在这种情况下，所有数字都必须为9，我们通过从n +1砍掉尾随0来解决此问题。

例如，如果n为999999，我们得到以下结果。

n     :  999999
n + 1 : 1000000
Result: 100000

之所以可行，是因为前导1计算为4个切换（0和1之间的距离），而切换的实际量为2（0和1之间的距离），并且抑制一个尾随0会从总和中删除其2个切换。

怎么运行的

‘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字节

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

替代公式，也为46 40字节：

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

编辑：由于@xsot，节省了6个字节。

Python，50 48字节

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

说明

此功能对数字的最低有效位n进行操作，将数字的7SD加1直到第一个非9数字之后。

26523308是对数字映射进行编码的位掩码0-8。当n=0仅在n仅包含9s 时出现时，答案将减少2。这由表达式补偿0**n*2。至于数字9，位掩码评估为零，这将在添加2到7SD 时触发递归调用。

05AB1E，31 30 28 27 26字节

码：

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

说明（已过时）：

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

我们将以下内容更改为最后一个非9位数字：

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

对于特殊情况：

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

使用CP-1252编码。在线尝试！。

28字节替代：D[¤©•2X›ùì•sès®9Ê#¨]\rÚ9Q4*O。

Java，63个字节

随着Python再次超越Java，这个世界是对的。

原因，您知道，Java。

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

在ideone上看到

最大值为2147483647，因为这是Java的Integer.MAX_VALUE。

这是我的Python答案的端口，这是ES6答案的端口。

MATL，61 39 36字节

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

在线尝试！

说明

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

朱莉娅，44字节

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

在这里尝试。

丹尼斯保存了一个字节！

Python，71 66字节

xsot的48个字节。甚至更多的魔术数学！

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

在ideone上看到

因为先前的Python答案不起作用，而且远非最佳。ES6早期版本的简单端口。现在使用位旋转（来自ES6备用公式）剪切演员表！

通过明确使用floordiv +1字节，可以使其与Python 3配合使用。

Jolf，32个字节

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

在这里尝试！

说明

这是尼尔的答案的转译。

Ώ?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字节

那第一个令人尴尬。

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

测试套件。

J，53个字节

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

最初基于@Neil的解决方案。然后通过使用@Lynn 解决方案中的相同公式保存字节来进行改进。

基于字符串的54字节版本为

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

用法

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

视网膜，34字节

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

在线尝试！（第一行仅允许一次处理多个测试用例。）

说明

像到目前为止发现的大多数答案一样，我们不需要使用整个表，因为9在递增时只有最低有效的非数字变化。这也是这个答案的工作方式。

M!`.9*$

这与（M）正则表达式匹配，.9*$即9与末尾仅以s 分隔的第一个数字。该!告诉视网膜与本场比赛更换输入，舍弃一切，不影响7SD。

^9
0

如果输入现在以a开头9，则输入本身仅由9s组成，因此7段显示器需要在a前面加上1cost 2。解决此问题的最简单方法是9在这种情况下用a 替换前导0，因为增加9（to 0）2的成本为，而增加0（to 1）的成本为4，因此这会2按要求增加总体成本。

T`d`4523315412

现在，我们有了一个音译阶段，可以用增加其成本的方式替换每个数字（因为d扩展为0123456789）。请注意，这是7SD表的第一个对角线。

.
$*

这将n用的n副本替换每个数字1，即，将每个数字转换为一进制，并且由于没有分隔符，因此立即将它们加在一起。

.

最后，我们计算结果中的字符数（即的匹配数.），将一元和转换为十进制。