Я думаю, что большинство людей здесь знают, что такое 7-сегментный дисплей для цифр:

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

Мы можем определить 7-сегментную разницу (7SD) между двумя цифрами как количество сегментов, которые необходимо переключить для переключения с одного на другой. Например, 7SD между 1и 2равен 5 (три горизонтальных сегмента и два нижних вертикальных сегмента должны быть переключены), а 7SD между 6 и 8 равен 1 .

Кроме того, мы можем определить 7SD между двумя числами, чтобы быть суммой 7SD между их соответствующими цифрами. Если одно число длиннее другого, мы предполагаем, что они выровнены по правому краю, и добавим количество сегментов, необходимое для отображения дополнительных наиболее значимых цифр большего числа. В качестве примера рассмотрим 7SD между 12345и 549:

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

Ваша задача - вычислить 7SD между n и n + 1 , учитывая n .

Для удобства приведена полная таблица 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 включительно.

Выход

• Вы должны напечатать одно целое число, 7SD между nи n+1.
• Вы можете выводить через STDOUT (или ближайшую альтернативу), возвращаемое значение функции или аргумент функции (out).

счет

Применяются стандартные правила игры в гольф , самый короткий код (в байтах) выигрывает.

Тестовые случаи

По какой-то неясной причине эта последовательность еще не включена в OEIS, хотя есть тесно связанная последовательность A123587 . Вот первые 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 , и мы решаем эту проблему, отсекая завершающий 0 из n + 1 .

Например, если 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

Изменить: Сохранено 6 байтов благодаря @xsot.

Python, 50 48 байтов

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

объяснение

Эта функция работает с наименьшей значащей цифрой числа n, суммируя 7SD цифр при увеличении на единицу до первой нецифровой 9цифры.

26523308является битовой маской, которая кодирует отображение для цифр 0-8. Когда n=0, что происходит только тогда, когда nсодержит только 9s, ответ будет отклонен на два. Это компенсируется выражением 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 байт

48 байтов xsot . Еще больше волшебной математики!

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

Посмотри на Ideone

Потому что предыдущий ответ Python не работает и далек от оптимального. Простой порт предыдущей версии ES6 . Теперь, используя немного твидлинга (из альтернативной формулировки ES6), вырежьте бросок!

Можно заставить работать с Python 3, явно используя floordiv для +1 байта.

Джольф, 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*$то есть первой цифре, которая отделена только 9s от конца. !Говорит Retina заменить вход с этим матчем, отбрасывая все , что не влияет на 7SD.

^9
0

Если ввод теперь начинается с « 9что», то сам ввод состоит только из 9s, поэтому 7-сегментный дисплей должен предвосхитить 1стоимость 2. Самый простой способ справиться с этим - заменить 9в этом случае начальную букву на 0, поскольку стоимость увеличения 9(до 0) равна, 2а стоимость увеличения 0(до 1) равна 4, так что это увеличивает общую стоимость по 2мере необходимости.

T`d`4523315412

Теперь у нас есть этап транслитерации, который заменяет каждую цифру стоимостью ее увеличения (поскольку dрасширяется до 0123456789). Обратите внимание, что это первая поддиагональ таблицы 7SD.

.
$*

Это заменяет каждую цифру nс nкопиями 1, т.е. он преобразует каждую цифру унарный, и так как нет сепараторов немедленно добавляет их вместе.

.

Наконец, мы подсчитываем количество символов (то есть количество совпадений .) в результате, который преобразует унарную сумму обратно в десятичную.