Tôi nghĩ rằng hầu hết mọi người ở đây đều biết màn hình 7 đoạn cho các chữ số là gì:

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

Chúng ta có thể định nghĩa chênh lệch 7 đoạn (7SD) giữa hai chữ số là số phân đoạn cần được chuyển đổi để chuyển từ loại này sang số khác. Ví dụ: 7SD giữa 1và 2là 5 (ba phân đoạn ngang và hai phân đoạn dọc thấp hơn cần được bật) và 7SD giữa 6 và 8 là 1 .

Hơn nữa, chúng ta có thể định nghĩa 7SD giữa hai số là tổng của 7SD giữa các chữ số tương ứng của chúng. Nếu một số dài hơn số kia, chúng tôi giả sử chúng được căn phải và thêm số phân đoạn cần thiết để hiển thị các chữ số có ý nghĩa nhất bổ sung của số lớn hơn. Ví dụ, xem xét 7SD giữa 12345và 549:

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

Nhiệm vụ của bạn là tính toán 7SD giữa n và n + 1 , được đưa ra n .

Để thuận tiện, đây là bảng đầy đủ 7SD giữa các chữ số riêng lẻ. Hàng _đại diện cho một vị trí trống.

   _ 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

Đầu vào

• Đầu vào là một số nguyên dương duy nhất n .
• Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm.
• Bạn có thể giả sử rằng đầu vào ít nhất là một số nhỏ hơn số lớn nhất có thể được biểu thị bằng loại số nguyên tiêu chuẩn của ngôn ngữ của bạn, miễn là loại đó hỗ trợ ít nhất các giá trị lên đến và bao gồm 127.

Đầu ra

• Bạn nên in một số nguyên duy nhất, 7SD giữa nvà n+1.
• Bạn có thể xuất thông qua STDOUT (hoặc thay thế gần nhất), đối số trả về hàm hoặc đối số hàm (out).

Chấm điểm

Áp dụng quy tắc golf tiêu chuẩn , mã ngắn nhất (tính bằng byte).

Các trường hợp thử nghiệm

Đối với một số lý do mơ hồ, trình tự này chưa có trong OEIS, mặc dù có trình tự liên quan chặt chẽ A123587 . Dưới đây là 100 số đầu tiên (bắt đầu bằng 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

Đầu vào đầu tiên mà 7SD lớn hơn 9 1999sẽ mang lại 11. Dưới đây là một số ví dụ lớn hơn khác:

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

Thạch , 25 22 21 20 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Trước tiên, chúng tôi tăng n đầu vào và loại bỏ tất cả các chữ số của n + 1 không thay đổi.

Ví dụ: nếu n là 5699999 , chúng tôi nhận được như sau.

n     : 5700000
n + 1 : 5699999
Result:  700000

Tất cả các chữ số trong kết quả này có một số phân đoạn cố định phải được bật. Chúng ta có thể chuyển đổi danh sách các toggles sang cơ sở 5 tính toán để lưu một số byte.

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

Đầu ra chỉ đơn giản là tổng của các toggles riêng lẻ.

Điều này hoạt động với hầu hết các giá trị của n , nhưng phải đặc biệt cẩn thận nếu n + 1 có nhiều chữ số hơn n . Trong trường hợp này, tất cả các chữ số phải là 9 và chúng tôi giải quyết vấn đề này bằng cách cắt bỏ một dấu 0 từ n + 1 .

Ví dụ: nếu n là 999999 , chúng tôi nhận được như sau.

n     :  999999
n + 1 : 1000000
Result: 100000

Điều này hoạt động bởi vì 1 hàng đầu ước tính thành 4 toggles (khoảng cách giữa 0 và 1 ), trong khi số lượng toggles thực tế là 2 (khoảng cách giữa 0 và 1 ) và việc loại bỏ một trailing 0 sẽ loại bỏ 2 toggles của nó khỏi tổng.

Làm thế nào nó hoạt động

‘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

Công thức thay thế, cũng 46 40 byte:

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

Chỉnh sửa: Đã lưu 6 byte nhờ @xsot.

Python, 50 48 byte

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

Giải trình

Hàm này hoạt động trên chữ số có nghĩa ít nhất của số n, tính tổng 7SD của các chữ số khi tăng thêm một cho đến sau 9chữ số đầu tiên .

26523308là một bitmask mã hóa ánh xạ cho các chữ số 0-8. Khi n=0, chỉ xảy ra khi nchỉ bao gồm 9s, câu trả lời sẽ bị tắt bởi hai. Điều này được bù bởi biểu thức 0**n*2. Đối với chữ số 9, bitmask ước tính bằng 0 sẽ kích hoạt cuộc gọi đệ quy trong khi thêm 2vào 7SD.

05AB1E , 31 30 28 27 26 byte

Mã số:

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

Giải thích ( lỗi thời ):

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

Chúng tôi đang thay đổi sau đây thành chữ số không 9 cuối cùng:

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

Đối với các trường hợp đặc biệt:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

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

Java, 63 byte

Thế giới đã đúng khi Python vượt qua Java một lần nữa.

Nguyên nhân, ya biết, Java.

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

Xem nó trên ideone

Tối đa là 2147483647, vì đó là Java Integer.MAX_VALUE.

Đây là một cổng của câu trả lời Python của tôi , một cổng của câu trả lời ES6 .

MATL , 61 39 36 byte

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử nó ở đây.

Dennis đã lưu một byte!

Python, 71 66 byte

48 byte bởi xsot . Toán học kỳ diệu hơn nữa!

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

Xem nó trên ideone

Bởi vì câu trả lời Python trước không hoạt động và không còn tối ưu. Một cổng đơn giản của phiên bản ES6 trước đó . Bây giờ bằng cách sử dụng bit twiddling (từ công thức thay thế ES6) để cắt bỏ một diễn viên!

Có thể được thực hiện để làm việc với Python 3 bằng cách sử dụng floordiv cho byte +1.

Jolf, 32 byte

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

Hãy thử nó ở đây!

Giải trình

Đây là một bản dịch của câu trả lời của 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

Đó là lần đầu tiên xấu hổ.

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

Phòng thử nghiệm .

J, 53 byte

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

Ban đầu dựa trên giải pháp của @ Neil . Sau đó, cải thiện bằng cách lưu một byte bằng cách sử dụng cùng một công thức trong giải pháp của @ Lynn .

Phiên bản 54 byte dựa trên chuỗi là

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

Sử dụng

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

Võng mạc , 34 byte

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

Hãy thử trực tuyến!(Dòng đầu tiên chỉ cho phép xử lý nhiều trường hợp thử nghiệm cùng một lúc.)

Giải trình

Giống như hầu hết các câu trả lời đã được phát hiện cho đến bây giờ, chúng ta không cần phải sử dụng bảng đầy đủ, vì chỉ những 9thay đổi không có chữ số ít quan trọng nhất khi tăng. Đó cũng là cách câu trả lời này hoạt động.

M!`.9*$

Điều này khớp với ( M) regex .9*$tức là chữ số đầu tiên chỉ được phân tách bằng 9s từ cuối. Yêu cầu !Retina thay thế đầu vào bằng trận đấu này, loại bỏ mọi thứ không ảnh hưởng đến 7SD.

^9
0

Nếu đầu vào bắt đầu với một 9điều đó có nghĩa, đầu vào riêng của mình bao gồm chỉ số 9s, do đó nhu cầu màn hình 7-segment để thêm vào trước một 1mà chi phí 2. Cách đơn giản nhất để xử lý việc này là thay thế hàng đầu 9trong trường hợp này bằng một 0, vì chi phí tăng 9(đến 0) là 2và chi phí tăng 0(đến 1) là 4, do đó, điều này làm tăng chi phí chung theo 2yêu cầu.

T`d`4523315412

Bây giờ chúng ta có một giai đoạn chuyển ngữ thay thế từng chữ số với chi phí của nó để tăng nó (kể từ khi dmở rộng đến 0123456789). Lưu ý rằng đây là đường con đầu tiên của bảng 7SD.

.
$*

Điều này thay thế mỗi chữ số nbằng các nbản sao của 1, tức là nó chuyển đổi từng chữ số thành đơn vị, và vì không có dấu tách ngay lập tức thêm chúng lại với nhau.

.

Cuối cùng, chúng tôi đếm số lượng ký tự (tức là số lượng khớp .) trong kết quả, chuyển đổi tổng số đơn trở lại thành số thập phân.