Реализуйте правило делимости на 7

25

Чтобы проверить, делится ли десятичное число на 7:

Стереть последнюю цифру. Умножьте это на 2 и вычтите из того, что осталось. Если результат делится на 7, исходное число делится на 7.

(также описано, например, здесь )

Это правило хорошо для ручной проверки делимости. Например:

2016 делится на 7?

Вычесть 6*2из 201; мы получаем 189. Это делится на 7? Чтобы проверить это, давайте снова применим правило.

Вычесть 9*2из 18; мы получаем 0. Таким образом, 2016 делится на 7.

В этой задаче вы должны применять это правило до тех пор, пока статус делимости не станет очевидным , то есть число не будет больше 70 (однако подробности см. Ниже). Сделать функцию или полную программу.

Входные данные : положительное целое число; Ваш код должен поддерживать ввод до 32767 (поддержка целых чисел произвольной точности является бонусом; см. ниже).

Вывод : целое число (возможно, отрицательное), не превышающее 70, которое является результатом применения правила делимости на 7 ноль или более раз.

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

Input                   Output      Alternative output

1                       1
10                      10          1
100                     10          1
13                      13          -5
42                      42          0
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
32767                   28          -14

---------- Values below are only relevant for the bonus

700168844221            70          7
36893488147419103232    32          -1
231584178474632390847141970017375815706539969331281128078915168015826259279872    8

Там, где указаны два возможных выхода, любой результат является правильным: второй соответствует применению правила еще раз. Запрещается применять правило к однозначному номеру: если вы удалите цифру, ничего (не 0) не останется.


Бонус : если ваш алгоритм

где nчисло десятичных цифр:

Вычтите 50% из числа байтов вашего кода.

Реальный бонус :

Кроме того, если ваш алгоритм считывает входные данные в нормальном направлении, начиная с самой значащей цифры, еще раз вычтите 50% - ваш счет составляет 25% от вашего количества байтов (это кажется возможным, но я не совсем уверен).

anatolyg
источник
1
@DenkerAffe Возвращение ввода как есть приемлемо. Я обновил тестовый пример input = 10, чтобы отразить это; это была идея с самого начала.
Анатолий
4
Я бы не хотел использовать это правило 1000000000000000000001.
Нил
1
Но что если в вашем языке есть long longвстроенный s или какой-нибудь эквивалентный тип?
SuperJedi224
1
Я говорил, что в некоторых реализациях это 128-разрядное целое число, которое более чем достаточно для последнего теста.
SuperJedi224
7
-1. Не все языки поддерживают произвольную точность.
Март Хо,

Ответы:

23

Golfscript, 27 22 байта

{.9>{.10/\10%2*-f}*}:f

Вы можете использовать это так:

1000f

объяснение

{.9>{.10/\10%2*-f}*}:f
{                  }:f    # Define block 'f' (similar to a function)
 .                        # Duplicate the first value of the stack
  9>{            }*       # If the value on top of the stack is greater than 9 then the block is executed
     .10/\10%2*-          # Same as nb/10 - (nb%10 * 2) with some stack manipulations '.' to duplicate the top of the stack and '\' to swap the the first and second element of the stack
                f         # Execute block 'f'

5 байтов сэкономлено благодаря Денису!

Dica
источник
1
Добро пожаловать в Программирование головоломок и Code Golf. Это хороший ответ, однако вы можете улучшить его, добавив разбивку кода и пояснения, как указано выше. Чтобы ответить на этот комментарий, введите @wizzwizz4( @затем мое имя пользователя) в начале (или в любом месте) комментария.
wizzwizz4
1
@ wizzwizz4 Лучше? Я не уверен, что понимаю, что вы подразумеваете под «разбивкой кода» (не извините носитель языка)
Dica
8
Я полагаю, под «разбивкой кода» он подразумевал объяснение, которое вы добавили. Это действительно очень хороший первый ответ. Добро пожаловать на сайт!
Алекс А.
1
Вы можете переписать {...}{}ifчасть как {...}*, которая будет просто применять нулевой блок кода один раз, в зависимости от значения, выдвинутого >. Кроме того, нам разрешено выполнить еще одну итерацию (поэтому замена 70на 9экономит байт), и я не думаю, что вам нужно выталкивать блок ;.
Деннис
3
@Dica, это первый ответ, достаточно хороший, чтобы получить 12+ откликов на вопрос с 624 просмотрами и получить похвалу от двух модераторов. Если вы продолжите в том же духе, вы скоро обгоните Денниса!
wizzwizz4
13

Haskell, 35 байт

until(<71)(\n->div n 10-2*mod n 10)

Пример использования: until(<71)(\n->div n 10-2*mod n 10) 36893488147419103232-> 32.

Ничего особенного объяснять, это прямая реализация алгоритма.

Ними
источник
9

Желе, 11 байт

d⁵Uḅ-2µ>9$¿

Попробуйте онлайн!

Как это работает

d⁵Uḅ-2µ>9$¿  Main link. Input: n

d⁵           Divmod; return [n : 10, n % 10].
  U          Upend; yield [n % 10, n : 10].
   ḅ-2       Convert from base -2 to integer, i.e., yield -2 × (n % 10) + (n : 10).

      µ      Push the previous chain as a link and begin a new, monadic chain.
          ¿  Apply the previous chain while...
       >9$     its return value is greater than 9.
Деннис
источник
И как всегда, желе побеждает. Деннис, сколько байт потребуется, чтобы реализовать переводчик Jelly в Jelly?
Bálint
6

Python 2, 38 байт

f=lambda x:f(x/10-x%10*2)if x>70else x

Попробуй это здесь !

Простой рекурсивный подход. Печатает x, если его <70 в противном случае применяет правило делимости и вызывает себя с результатом.

Denker
источник
вам не нужно место после)
Maltysen
@ Малтисен Правда. Копия вставлена ​​не тот, спасибо за подсказку!
Денкер
2
Если это слишком многословно. f=lambda x:x*(x<70)or f(x/10-x%10*2)
Seequ
1
@ Хороший трюк, спасибо! Это должно работать теоретически, но оно достигает максимальной глубины рекурсии с вводом 2016 года, в то время как моя версия не работает. Есть идеи почему?
Денкер
Ах, да, не учел это. Этот трюк считает x*(x<70) != 0конечным условием. Если x достигает 0 - как это происходит в 2016 году - конечное условие никогда не происходит.
Seequ
6

Pyth, 13 байт

.W>H9-/ZTyeZQ

Попробуйте онлайн: демонстрация или тестовый набор

Это напечатает все альтернативные ответы.

Объяснение:

.W>H9-/ZTyeZQ   
            Q   read a number from input
.W              while
  >H9              the number is greater than 9
                do the following with the number:
      /ZT          divide it by 10
     -             and subtract
         yeZ       2*(number%10)
Jakube
источник
5

Юлия, 27 26 байт

f(x)=x>9?f(x÷10-x%10*2):x

Это рекурсивная функция, которая принимает целое число и возвращает a BigInt. Если ввод большого числа, как в последнем примере, Джулия анализирует его как BigInt, поэтому ручное преобразование не требуется.

Подход - просто прямая реализация алгоритма. Это произведет альтернативные выходы. Взятие модуля при делении на 10 дает последнюю цифру, а частное от целочисленного деления на 10 - все, кроме последней цифры.

Спас Байт благодаря Денису!

Алекс А.
источник
Нам разрешено выполнить еще одну итерацию, поэтому замена 70на 9экономит байт.
Деннис
@ Денис Хороший звонок, спасибо!
Алекс А.
4

Pyth, 17 байт

L?<b70by-/bT*%bT2

Попробуй это здесь!

Тот же рекурсивный подход, что и в моем ответе на python . Определяет лямбда , yкоторый называется так: y12345.
Счетчик байтов в онлайн-интерпретаторе показывает 19 байтов, потому что я добавил лямбда-вызов к нему, так что вы можете просто попробовать его, нажав кнопку запуска.

объяснение

L?<b70by-/bT*%bT2

L                  # Defines the lambda y with the parameter b
 ?<b70             # if b < 70:
      b            # return b, else:
       -/bT*%bT2   # calculate b/10 - b%10*2 and return it
Denker
источник
В вашем объяснении есть опечатка, 17 должно быть 70: P
FryAmTheEggman
4

CJam - 19 байтов

Версия Do-while:

r~A*{`)]:~~Y*-_9>}g

Попробуйте онлайн или пока версия # 1:

r~{_9>}{`)]:~~Y*-}w

Попробуйте онлайн или пока версия # 2:

r~{_9>}{_A/\A%Y*-}w

Попробуйте онлайн .

r~                     | Read and convert input
  A*                   | Multiply by 10 to get around "if" rule
     `                 | Stringify
      )                | Split last character off
       ]               | Convert stack to array
        :~             | Foreach in array convert to value
          ~            | Dump array
           Y*          | Multiply by 2
             -         | Subtract
              _        | Duplicate
               9>      | Greater than 9?
    {            }g    | do-while
CJ Деннис
источник
3

Oracle SQL 11.2, 116 байт

WITH v(i)AS(SELECT:1 FROM DUAL UNION ALL SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70)SELECT MIN(i)FROM v;

Un-golfed

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70
)
SELECT MIN(i) FROM v;
школа для водителей
источник
3

Haskell, 157 192 184 167 159 147 138 + 5 байт - 50% = 71,5 байт

O (1) пробел, O (n) время, однопроходный!

h d=d%mod d 10
d%r=(quot(r-d)10,r)
p![d]=d-p*10
p![d,e]=d#(e-p)
p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)
m#0=m
m#n=n-2*m
(0!)

Используйте as 0![6,1,0,2]для применения правила к 2016 году, то есть передайте ему число в виде потока с наименее значащей цифрой в первую очередь. Таким образом, он будет передавать цифру цифра за цифрой, применяя правило с O (1) пространственной сложностью.

Код для разгула здесь:

import Data.Char

{- sub a b = sub2 0 a b
  where
    sub2 borrow (a:as) (b:bs) = res : sub2 borrow2 as bs
      where
        (borrow2, res) = subDig borrow a b
    sub2 borrow (a:as) [] = sub2 borrow (a:as) (0:[])
    sub2 _ [] _ = [] -}

--subDig :: Int -> Int -> Int -> (Int, Int)
subDig borrow a b = subDig2 (a - b - borrow)
  where
    subDig2 d = subDig3 d (d `mod` 10)
    subDig3 d r = ((r-d) `quot` 10, r)

seven ds = seven2 0 ds
seven2 borrow (d:e:f:gs) = seven2 (b + borrow2) (res:f:gs)
  where
    (a, b) = double d
    (borrow2, res) = subDig borrow e a
seven2 borrow (d:e:[]) = finalApp d (e-borrow)
seven2 borrow (d:[]) = d - borrow*10

double d = ((2*d) `mod` 10, (2*d) `quot` 10)

finalApp m 0 = m
finalApp m n = n - 2*m

num2stream :: Int -> [Int]
num2stream = reverse . map digitToInt . show
sev = seven . num2stream

Суть того, как это работает, заключается в том, что он реализует алгоритм вычитания цифра за цифрой , но использует тот факт, что каждое вычитаемое число состоит максимум из 2 цифр, и поэтому мы можем вычесть произвольное количество этих 1- или -значные цифры из основного (а также употребление наименее значимых цифр).

Алгоритм вычитания является O (1) и хранит только текущее значение заимствования. Я изменил это, чтобы добавить дополнительную цифру (0 или 1), и мы заметили, что это значение заимствования ограничено (в пределах диапазона [-2,2], поэтому нам нужно только 3 бита для его хранения).

Другие значения, хранящиеся в памяти, являются временными переменными, представляющими текущее 2-значное число, которое нужно добавить, один прогноз в потоке и применить один шаг алгоритма вычитания (т. Е. Он принимает две цифры и значение заимствования и возвращает одна цифра и новое значение заимствования).

Наконец, в конце он обрабатывает две последние цифры в потоке сразу, чтобы вернуть однозначное число, а не список цифр.

NB sevФункция в версии без заглавных букв будет работать над Integerпреобразованием в форму обратного потока.

азотистый
источник
Я предполагал, что бонус будет для нормального порядка цифр. Но я никогда этого не говорил, поэтому справедливо получить бонус за отмененный заказ, хотя это и менее весело. В любом случае, даже обратный порядок сложнее, чем я думал, так что это достаточно весело!
Анатолий
@anatolyg: Спасибо! Я не уверен, возможно ли сделать один проход O (1) реализации нормального порядка ... правило зависит от наименее значимых цифр, поэтому в теории прямое применение правила невозможно, кроме как в обратном порядке. Единственное, о чем я могу думать, это найти математически эквивалентную форму - например, Mod[18 - Quotient[n, 10] - 2*n, 21] - 18 + Quotient[n, 10]работает эмпирически для n между 10 и 99, но тем сложнее, чем больше цифр n имеет ...
закись
Хм, я подумал об этом, и казалось, что может быть способ сохранить первые 2 цифры и применить каждую последующую цифру, но умножить на (-2) ^ n, чтобы учесть, что она «фильтрует» ... насколько я могу сказать, что нет никакого способа сделать эту работу, не сохраняя все цифры в памяти и не жертвуя O (1) или даже O (N) ... Я думаю, что нормальный порядок определенно невозможен :(
закись
1
Боюсь, что 0при вызове вы также должны считать байты начальных !, например, как раздел (0!)(+ перевод строки), т.е. +5 байт. С другой стороны вы можете сократить первое совпадение с образцом !до p![d]=и p![d,e]=. Кроме того , использование модель оберегает вместо let: p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f).
Ними
1
@nitrous: О, я имею в виду (0!)свою собственную линию. (0!)это функция, которую вы даете в качестве ответа. 0Требуются, но не имеет ничего общего с входом, так что вы не можете Аутсорсинг вызывающего абонента. Конечно, вы также можете использовать f x=0!x, но это дольше.
Ними
3

GNU dc, 20 15 байт

[10~2*-d70<F]sF

Это определяет мою первую (когда-либо) функцию постоянного тока F. Он принимает входные данные в верхней части стека и оставляет выходные данные в верхней части стека. Пример использования:

36893488147419103232
lFxp
32
Тоби Спейт
источник
2

Mathematica, 47 44 байта

If[#>70,#0[{1,-2}.{⌊#/10⌋,#~Mod~10}],#]&

Простой рекурсивный подход. Возможно, будет дальше в гольф.

LegionMammal978
источник
#0[{1,-2}.QuotientRemainder[#,10]]сохраняет байт.
njpipeorgan
2

R, 43 байта

x=scan();while(x>70)x=floor(x/10)-x%%10*2;x

Объяснение:

x=scan()                                      # Takes input as a double
        ;                                     # Next line
         while(x>70)                          # While-loop that runs as long x > 70
                      floor(x/10)             # Divide x by 10 and round that down
                                 -x%%10*2     # Substract twice the last integer
                    x=                        # Update x
                                         ;    # Next line once x <= 70
                                          x   # Print x

Образцы прогонов:

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 9999
2: 
Read 1 item
[1] -3

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 32767
2: 
Read 1 item
[1] 28
Laterow
источник
1

JavaScript ES6, 38 байт

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i

Сбой с 36893488147419103232и использование ~~(1/10)также не удастся для700168844221

Тест:

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i
O.textContent = O.textContent.replace(/(-?\d+) +(-?\d+)/g, (_,i,o) =>
  _+": "+(a(+i)==o?"OK":"Fail")
);
<pre id=O>1                       1
10                      10
100                     10
13                      13
42                      42
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
700168844221            70
36893488147419103232    32</pre>

andlrc
источник
Я получаю два Failс ... 70 и 32
Конор О'Брайен
@ CᴏɴᴏʀO'Bʀɪᴇɴ Да, я все еще задаюсь вопросом, почему ...
andlrc
Потому что тип номера JavaScript не обрабатывает последний случай, по крайней мере.
Конор О'Брайен
1
f=n=>n>70?f((n-n%10*21)/10):nэто более короткая версия, но все еще работает только до 2**56.
Нил
@ Нейл, посмотрите мой ответ для произвольной точности, и, пожалуйста, не стесняйтесь в гольф, очень признателен.
Патрик Робертс
1

Mathematica, 33 байта

#//.a_/;a>70:>⌊a/10⌋-2a~Mod~10&

Прецедент

%[9999]
(* -3 *)
njpipeorgan
источник
1

Perl 5, 47 46 байт

Пришлось использовать bigintдля последнего теста. (Возвращает 20 без)

use bigint;$_=<>;while($_>9){$_-=2*chop;}print

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

Попробуй это здесь!

Пол Пикард
источник
1

ES6, 108 байт

f=(s,n=0)=>s>1e9?f(s.slice(0,-1),((1+s.slice(-1)-n%10)%10*21+n-s.slice(-1))/10):s>9?f(((s-=n)-s%10*21)/10):s

Работает для 2 ²⁵⁷ и 1000000000000000000001, но может использовать дальнейшую игру в гольф.

Нил
источник
@PatrickRoberts Упс, недосмотр при переформатировании для представления.
Нил
1

JavaScript ES6, 140 142 байта

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s

Это истинная математика с произвольной точностью, даже работает на самом большом тестовом примере.

Эта функция рекурсивно удаляет последнюю цифру из строки, а затем вычитает 2 * последнюю цифру из оставшейся числовой строки, итеративно увеличивая количество цифр для применения к намечаемому значению до тех пор, пока разница не станет положительной. Затем он добавляет эту разницу к концу строки с соответствующим дополнением 0s и вызывает себя рекурсивно, пока ее числовое значение не станет меньше или равно 9.

  • Гольф 7 байтов благодаря @Neil (да, я знаю, что набрал 2 байта, но я исправил несколько ошибок, из-за которых функция зависала или возвращала неправильный вывод в некоторых случаях).

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s;[['1',1],['10',1],['100',1],['13',-5],['42',0],['2016',0],['9',9],['99',-9],['9999',-3],['12345',3],['700168844221',7],['36893488147419103232',-1],['231584178474632390847141970017375815706539969331281128078915168015826259279872',8]].map(a=>document.write(`<pre>${f(a[0])==a[1]?'PASS':'FAIL'} ${a[0]}=>${a[1]}</pre>`))

Патрик Робертс
источник
Хорошо, но это может не сработать 1000000000000000000001.
Нил
1
Попробуй s.replace(/.$/,'-$&*2'). У меня нет никаких очевидных идей для остальных, хотя извините.
Нил
1

C #, 111 104 байта

int d(int n){var s=""+n;return n<71?n:d(int.Parse(s.Remove(s.Length-1))-int.Parse(""+s[s.Length-1])*2);}
TheLethalCoder
источник
1

Brain-Flak , 368 360 байт

Попробуйте онлайн!

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>){{}(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>([([([(({}<{}><>)<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})]<(())>)(<>)]){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)}{}

объяснение

Для начала весь код находится в цикле, который выполняется до тех пор, пока вершина стека не станет меньше нуля:

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
{{}
 ...
 ([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
}{}

Внутри цикла мы запускаем делимый на семь алгоритм:

Дублируйте вершину стека

(({}))

Возьмите мод 10 вершины стека (последняя цифра)

(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)

Это немного беспорядок, но он выполняет остальную часть алгоритма, я мог бы объяснить это позже, но я не совсем помню, как он работает:

([(({})<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})
Мастер пшеницы
источник
1

C, 56 байтов - 75% = 14

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

n;f(char*c){for(n=0;*c;)n-=n>6?7:'0'-n-n-*c++;return n;}

В алгоритме нет умножения или деления, только сложение и вычитание, а цифры обрабатываются за один проход слева направо. Работает следующим образом, начиная с 0 в аккумуляторе:

  1. Вычтите 7, если необходимо, и снова, если все еще необходимо
  2. Умножьте промежуточную сумму на три и добавьте следующую цифру

Шаг «умножить на три» записывается так, n-=-n-nчтобы сохранить байт и избежать оператора умножения.

Когда мы подходим к концу, мы не вычитаем семерки, поэтому результат будет в диапазоне 0-24; если вы хотите , строгий модуль (0-7), суррогат *cс *c||n>6в forсостоянии петли.

Это дает право на расширенный бонус, потому что это

  • поддерживает целые числа произвольной точности
  • выполняет только один проход на входе, слева направо
  • имеет пространственную сложность O (1)
  • имеет временную сложность O (n).

Программа испытаний и результаты

#include <stdio.h>
int main(int argc, char **argv) {
    while (*++argv)
        printf("%s -> %d\n", *argv, f(*argv));
    return 0;
}
540 -> 15
541 -> 16
542 -> 17
543 -> 18
544 -> 19
545 -> 20
546 -> 21
547 -> 22
548 -> 23
549 -> 24
550 -> 18
99 -> 15
999 -> 12
12345 -> 11
32767 -> 7
700168844221 -> 7
36893488147419103232 -> 11
231584178474632390847141970017375815706539969331281128078915168015826259279872 -> 11

Альтернативная версия

Вот тот, который повторяется (вы захотите, чтобы оптимизация компилятора выполняла преобразование хвостового вызова, или вы можете переполнить свой стек; я использовал gcc -std=c89 -O3):

f(c,n)char*c;{return n>6?f(c,n-7):*c?f(c+1,n+n+n+*c-'0'):n;}

Назовите это с '0' как второй аргумент.

Обе версии рассчитывают остаток по модулю семь из 60000-значного числа менее чем за 50 миллисекунд на моей машине.

Тоби Спейт
источник
Спасибо за бонус - он делает реальные изменения для C, чтобы в итоге стать таким конкурентоспособным! В настоящее время избиты только Jelly (11) и Pyth (13). :-)
Тоби Спейт
1

PHP, 50 байт

for($n=$argv[1];$n>9;)$n=$n/10|0-2*($n%10);echo$n;

использует альтернативный вывод; работает доPHP_INT_MAX


строковая версия, работает для любого (положительного) числа (64 байта):

for($n=$argv[1];$n>9;)$n=substr($n,0,-1)-2*substr($n,-1);echo$n;
Titus
источник
0

Java, 133 байта

int d(int n){String s=""+n;return n<71?n:d(Integer.parseInt(s.replaceFirst(".$",""))-Integer.parseInt(""+s.charAt(s.length()-1))*2);}

Я ненавижу, как многословен Integer.parseInt. Ungolfed:

static int div(int n) {
    if (n <= 70) {
        return n;
    } else {
        String num = ("" + n);
        int last = Integer.parseInt("" + num.charAt(num.length() - 1));
        int k = Integer.parseInt(num.replaceFirst(".$", "")) - last * 2;
        return div(k);
    }
}
Джастин
источник