Виконайте правило поділу на 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% від вашого байтового числа (це здається можливим, але я не зовсім впевнений).


1
@DenkerAffe Повернення вводу як-то є прийнятним. Я оновив тестовий випадок введення = 10, щоб відобразити це; така ідея була з самого початку.
анатоліг

4
Я не хотів би використовувати це правило 1000000000000000000001.
Ніл

1
Але що робити, якщо у вашій мові long longвбудований s або інший еквівалентний тип?
SuperJedi224

1
Я говорив, що в деяких реалізаціях це 128-бітове ціле число, що є більш ніж великим для останнього тестового випадку.
SuperJedi224

7
-1. Не всі мови підтримують довільну точність.
Ho, березень

Відповіді:


23

Гольфскрипт, 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 байт збережено завдяки Деннісу!


1
Ласкаво просимо до головоломки програмування та коду для гольфу. Це хороша відповідь, однак ви можете вдосконалити її, додавши розбивку коду та пояснення, як і вищезазначені питання. Щоб відповісти на цей коментар, введіть @wizzwizz4( @тоді моє ім’я користувача) на початку (або в будь-якому місці) коментаря.
wizzwizz4

1
@ wizzwizz4 Краще? Я не впевнений, що я розумію, що ви маєте на увазі під «розбиттям коду» (не вибачте з носіїв мови)
Діка,

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?
Балінт

6

Python 2, 38 байт

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

Спробуйте тут !

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


вам не потрібно місця після)
Мальтісен,

@Maltysen Правда. Копія вставила неправильну, дякую за підказку!
Денкер

2
The if занадто багатослівний. f=lambda x:x*(x<70)or f(x/10-x%10*2)
seequ

1
@Seeq Приємний трюк, дякую! Це повинно працювати в теорії, але воно досягає максимальної глибини рекурсії з 2016 року як вхідного, тоді як моя версія цього не робить. Будь-яка ідея чому?
Денкер

Ага, правда, не вважав цього. Цей трюк вважається x*(x<70) != 0умовою кінця. Якщо х доходить до 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)

5

Юлія, 27 26 байт

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

Це рекурсивна функція, яка приймає ціле число і повертає a BigInt. Якщо вхід є великою кількістю, як у останньому прикладі, Джулія розбирає його як a BigInt, тому ніяке ручне перетворення не потрібно.

Підхід - це просто пряма реалізація алгоритму. Це дасть альтернативні виходи. Беручи модуль при діленні на 10, виходить остання цифра, а коефіцієнт від цілого поділу на 10 дає все, крім останньої цифри.

Збережено байт завдяки Деннісу!


Нам дозволяється виконати ще одну ітерацію, тому заміна 70на 9економить байт.
Денніс

@Dennis Добрий дзвінок, дякую!
Алекс А.

4

Піт, 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

Ви маєте помилку в своєму поясненні, 17 має бути 70: P
FryAmTheEggman

4

CJam - 19 байт

Версія до часу:

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

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;

Без гольфу

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

Використовуйте як 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 біти).

Інші значення, що зберігаються в пам'яті, є тимчасовими змінними, що представляють поточне двозначне число, яке потрібно додати, один погляд вперед у потоці та застосувати один крок алгоритму віднімання (тобто потрібно дві цифри і значення позики, і повертається одна цифра і нове значення позики).

Нарешті, в кінці він обробляє дві останні цифри у потоці одразу, щоб повернути одноцифрове число, а не список цифр.

Примітка sevФункція у версії, що не має волі, буде працювати над ангією Integer, перетворюючи її у зворотну форму потоку.


Я задумав, що бонус буде для звичайного порядку цифр. Але я ніколи цього не говорив, тому справедливо отримувати бонус за відмінене замовлення, навіть якщо це менш весело. У будь-якому випадку, навіть перевернутий порядок важче, ніж я думав, тому це досить весело!
anatolyg

@anatolyg: Дякую! Я не впевнений, чи можливо зробити один прохід O (1) виконання нормального порядку ... правило залежить від найменш значущих цифр, тому теоретично пряме застосування правила неможливе, окрім як у зворотному порядку. Єдине інше, що я можу придумати, - це знайти математично еквівалентну форму - наприклад, Mod[18 - Quotient[n, 10] - 2*n, 21] - 18 + Quotient[n, 10]працює емпірично для n між 10 і 99, але ускладнюється тим більше цифр, які має n ...
азотистий

Хм, я подумав про це, і, здавалося, може бути спосіб, зберігаючи передні дві цифри і застосовуючи кожну наступну цифру, але множуючи на (-2) ^ n, щоб врахувати його "фільтрацію через" ... наскільки я можна сказати, хоча немає можливості зробити цю роботу, не зберігаючи всі цифри в пам'яті і не пожертвувавши O (1) 'ness або навіть o (n)' ness ... Я думаю, що нормальний порядок, безумовно, неможливий :(
азотистий

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

Математика, 47 44 байт

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

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


#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

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>


Я отримую два Fails ... 70 та 32
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Так, мені все ще цікаво, чому ...
andlrc

Оскільки тип номера JavaScript, принаймні, не обробляє останній регістр.
Conor O'Brien

1
f=n=>n>70?f((n-n%10*21)/10):nє коротшою версією, але все ще працює лише до 2**56.
Ніл

@Neil бачити мою відповідь за довільну точність, і будь ласка, не соромтеся до гольфу, дуже вдячний.
Патрік Робертс

1

Математика, 33 байти

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

Тестовий випадок

%[9999]
(* -3 *)

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.

  • Завдяки @Neil займає 7 байтів (так, я знаю, що я набрав 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);}

1

Мозок-Флак , 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 в кінцевому підсумку таким конкурентоспроможним! В даний час побили лише Джеллі (11) та Піта (13). :-)
Toby Speight

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;

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. Безголівки:

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);
    }
}
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.