Учитывая положительное целое число, выведите истинное / ложное значение относительно того, может ли число съесть само себя.

правила

Самая левая голова, правая - хвост

Если голова больше или равна хвосту, голова съедает хвост, и новая голова становится их суммой.

Если $sum \ge 10$ то голова заменяется .$sum \mod 10$

$sum=0$ нельзя игнорировать, однако входной номер никогда не будет иметь начальных нулей.

Пример:

number=2632
head-2, tail-2

2632 -> 463
head-4, tail-3

463 -> 76
head-7, tail-6

76 -> 3
If only one digit remains in the end, the number can eat itself.

Если в какой-то момент голова не может съесть хвост, ответ будет ложным.

number=6724
072
False (0<2)

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

True:
[2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121]

False:
[6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194]

Это код-гольф, поэтому выигрывает самый короткий код.

JavaScript (ES6),  52 51  50 байт

Сохранено 1 байт благодаря @tsh

Принимает ввод в виде строки. Возвращает логическое значение.

f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]

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

комментарии

f = n =>                 // f = recursive function taking n (a string)
  n > [n % 10]           // The last digit is isolated with n % 10 and turned into a
                         // singleton array, which is eventually coerced to a string
                         // when the comparison occurs.
                         // So we do a lexicographical comparison between n and its
                         // last digit (e.g. '231'>'1' and '202'>'2', but '213'<'3').
  ?                      // If the above result is true:
    f(                   //   do a recursive call:
      -(-n[0] - n) % 10  //     We compute (int(first_digit) + int(n)) mod 10. There's no
                         //     need to isolate the last digit since we do a mod 10 anyway.
      + n.slice(1, -1)   //     We add the middle part, as a string. It may be empty.
    )                    //   end of recursive call
  :                      // else:
    !n[1]                //   return true if n has only 1 digit, or false otherwise

Желе , 11 байт

Ṛṙ-µṖÄ%⁵:ḊẠ

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

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

Ṛṙ-µṖÄ%⁵:ḊẠ  Main link. Argument: n

Ṛ            Reverse n, after casting it to a digit list.
 ṙ-          Rotate the result -1 units to the left, i.e., 1 unit to the right.
             Let's call the resulting digit list D.
   µ         Begin a new chain with argument D.
    Ṗ        Pop; remove the last digit.
     Ä       Accumulate; take the cumulative sum of the remaining digits.
      %⁵     Take the sums modulo 10.
         Ḋ   Dequeue; yield D without its first digit.
        :    Perform integer division between the results to both sides.
             Integer division is truthy iff greater-or-equal is truthy.
          Ạ  All; return 1 if all quotients are truthy, 0 if not.

Perl 6 , 63 62 байта

{!grep {.[*-1]>.[0]},(.comb,{.[0,*-1].sum%10,|.[1..*-2]}...1)}

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

Объяснение:

{                                                            } # Anonymous code block
                     (                                  ... )       # Create a sequence
                      .comb,  # Starting with the input converted to a list of digits
                            {                          }   # With each element being
                             .[0,*-1]   # The first and last element of the previous list
                                     .sum%10  # Summed and modulo 10
                                            ,|.[1..*-2]   # Followed by the intermediate elements
                                                        ...1 # Until the list is length 1
 !grep   # Do none of the elements of the sequence
       {.[*-1]>.[0]},   # Have the last element larger than the first?

Java (JDK) , 83 байта

n->{int r=0,h=n;while(h>9)h/=10;for(;n>9;h=(h+n)%10,n/=10)r=h<n%10?1:r;return r<1;}

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

кредиты

• -1 байт благодаря Кевину Круйссену

Mathematica, 62 байта

0(IntegerDigits@#//.{a_,r___,b_}/;a>=b:>{Mod[a+b,10],r})=={0}&

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

{a_,r___,b_}       (* match the first digit, 0 or more medial digits, and the last digit... *)
/;a>=b             (* under the condition that the number is edible... *)
:>{Mod[a+b,10],r}  (* and replace it with the next iteration *)

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

Вместо вызова Length[__]==1мы можем сохранить несколько байтов с 0(__)=={0}, умножив все элементы в списке, 0 а затем сравнив их со списком {0}.

Python 3 , 50 байт

Первая строка украдена из ответа Чёрной Совы Кая .

p,*s=map(int,input())
while s:*s,k=s;p%10<k>q;p+=k

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

Выход через код выхода. Сбой (1) для ложных входов и завершение (0) для правдивых входов.

Python 2 , 105 82 81 байт

i,x=map(int,input()),1
for y in i[:0:-1]:
 if i[0]%10<y:x=0
 else:i[0]+=y
print x

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

Большое спасибо за огромное -23 от @ ØrjanJohansen

Спасибо @VedantKandoi (и @ ØrjanJohansen) за еще один -1

Брахилог , 23 байта

ẹ{bkK&⟨h{≥₁+tg}t⟩,K↰|Ȯ}

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

Это 1-байтовое сохранение по сравнению с решением Fatalize . Это использует рекурсивный подход вместо итеративного

объяснение

ẹ                          Input into a list of digits
 {                    }    Assert that either
  bk                       | the list has at least 2 elements (see later)
      ⟨h{     }t⟩           | and that [head, tail]
         ≥₁                |  | is increasing (head >= tail)
           +               |  | and their sum
            t              |  | mod 10 (take last digit)
             g             |  | as single element of a list
                ,          | concatenated with
  bkK            K         | the number without head and tail (this constrains the number to have at least 2 digits)
                  ↰        | and that this constraint also works on the newly formed number
                   |Ȯ      | OR is a 1 digit number

APL (Dyalog Unicode) , 33 байта ^SBCS

Функция анонимного неявного префикса, принимающая строку в качестве аргумента.

{⊃⍵<t←⊃⌽⍵:0⋄3::1⋄∇10|t+@1⊢¯1↓⍵}⍎¨

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

⍎¨ оценивать каждый символ (это дает нам список цифр)

{… } Примените к этому следующее «dfn»; ⍵это аргумент (список цифр):

  ⌽⍵ изменить аргумент

  ⊃ выбрать первый элемент (это хвост)

  t← назначить t(для т аила)

  ⍵< для каждой из исходных цифр посмотрите, не меньше ли это

  ⊃ выберите первое истинное / ложное

 : если так:

  0 вернуть ложь

 ⋄ тогда:

 3:: если с этого момента происходит ошибка индекса (вне пределов):

  1 вернуть истину

  ¯1↓⍵ сбросить последнюю цифру

  ⊢ привести к этому (отделяет 1и ¯1поэтому они не будут формировать один массив)

  t+@1 добавить хвост к первой цифре (голова)

  10| мод-10

  ∇ рекурсию

Как только мы нажмем одну цифру, ¯1↓этот список @1будет пустым, что приведет к ошибке индекса, поскольку первая цифра отсутствует, в результате чего функция вернет true.

Python 3 , 77 байт

p,*s=map(int,input())
print(all(n<=sum(s[i+1:],p)%10for i,n in enumerate(s)))

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

И мое старое решение с рекурсивным подходом

Python 3 , 90 байт

f=lambda x,a=0:2>len(x)if 2>len(x)or(int(x[0])+a)%10<int(x[-1])else f(x[:-1],a+int(x[-1]))

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

Принимает ввод в виде строки.

Брахилог , 24 байта

ẹ;I⟨⟨h{≥₁+tg}t⟩c{bk}⟩ⁱ⁾Ȯ

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

Мне следует изменить ⁱповедение по умолчанию так, чтобы оно повторялось неизвестное количество раз (в настоящее время оно повторяется 1 раз по умолчанию, что совершенно бесполезно). Мне тогда не понадобится […];I[…]⁾, экономя 3 байта

объяснение

Эта программа содержит некрасивую вилку внутри вилки. Существует также некоторая сантехника, необходимая для работы со списками цифр, а не чисел (потому что, если мы удалим голову и хвост, у 76нас останется 0, что не сработает вопреки тому, с чем [7,6]мы в итоге окажемся []).

ẹ                          Input into a list of digits
                       Ȯ   While we don't have a single digit number…
 ;I                  ⁱ⁾    …Iterate I times (I being unknown)…
   ⟨                ⟩      …The following fork:
               c           | Concatenate…
    ⟨         ⟩            | The output of the following fork:
     h       t             | | Take the head H and tail T of the number
      {     }              | | Then apply on [H,T]:
       ≥₁                  | | | H ≥ T
         +                 | | | Sum them
          tg               | | | Take the last digit (i.e. mod 10) and wrap it in a list
                {  }       | With the output of the following predicate:
                 bk        | | Remove the head and the tail of the number

Haskell, 70 64 60 байт

f(a:b)=b==""||a>=last b&&f(last(show$read[a]+read b):init b)

Ввод принимается в виде строки.

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

Изменить: -6 байт, используя хитрость @ Laikoni в использовании ||вместо отдельных охранников. Еще 4 байта благодаря @Laikoni.

Perl 5 , 64 байта

{local$_=pop;1while s/(.)(.*)(.)/$1<$3?'':(($1+$3)%10).$2/e;/./}

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

Python 2 , 75 67 байт

l=lambda n:n==n[0]or n[-1]<=n[0]*l(`int(n[0]+n[-1],11)%10`+n[1:-1])

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

Рекурсивный лямбда-подход. Принимает ввод в виде строки. Большое спасибо Денису за сохранение 8 байт!

Haskell , 69 64 байта

f n=read[show n!!0]#n
h#n=n<10||h>=mod n 10&&mod(h+n)10#div n 10

Попробуйте онлайн! Пример использования: f 2632доходность True.

Изменить: -5 байт, потому чтоmod (h + mod n 10) 10 = mod (h + n) 10

Рубин, 139 байт

->(a){a.length==1?(p true;exit):1;(a[0].to_i>=a[-1].to_i)?(a[0]=(a[-1].to_i+a[0].to_i).divmod(10)[1].to_s;a=a[0..-2];p b[a]):p(false);exit}

Попробуйте онлайн!(имеет дополнительный код для обработки ввода, так как это функция)

Ungolfed код:

->(a) do
    if a.length == 1
        p true
        exit
    if a[0].to_i >= a[-1].to_i
        a[0] = (a[-1].to_i + a[0].to_i).divmod(10)[1].to_s
        a = a[0..-2]
        p b[a]
    else
        p false
        exit
    end
end

Сетчатка 0.8.2 , 42 байта

\d
$*#;
^((#*).*;)\2;$
$2$1
}`#{10}

^#*;$

Попробуйте онлайн! Ссылка включает тестовые случаи. Объяснение:

\d
$*#;

Преобразовать цифры в одинарные и вставить разделители.

^((#*).*;)\2;$
$2$1

Если последняя цифра не больше первой, сложите их вместе.

#{10}

Уменьшите по модулю 10, если это необходимо.

}`

Повторяйте, пока последняя цифра не станет больше первой или пока не останется только одна цифра.

^#*;$

Проверьте, остается ли только одна цифра.

05AB1E , 26 25 24 байта

[DgD#\ÁD2£D`›i0qëSOθs¦¦«

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

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

[                 # Start an infinite loop
 D                #  Duplicate the top of the stack
                  #  (which is the input implicitly in the first iteration)
  gD              #  Take its length and duplicate it
    #             #  If its a single digit:
                  #   Stop the infinite loop
                  #   (and output the duplicated length of 1 (truthy) implicitly)
                  #  Else:
  \               #   Discard the duplicate length
   Á              #   Rotate the digits once towards the left
    D2£           #   Duplicate, and take the first two digits of the rotated number
       D`         #   Duplicate, and push the digits loose to the stack
         ›i       #   If the first digit is larger than the second digit:
           0      #    Push a 0 (falsey)
            q     #    Stop the program (and output 0 implicitly)
          ë       #   Else (first digit is smaller than or equal to the second digit):
           SO     #    Sum the two digits
             θ    #    Leave only the last digit of that sum
           s      #    Swap to take the rotated number
            ¦¦    #    Remove the first two digits
              «   #    Merge it together with the calculated new digit

C ++ (gcc) , 144 байта

bool f(std::string b){int c=b.length();while(c>1){if(b[0]<b[c-1])return 0;else{b[0]=(b[0]-48+b[c-1]-48)%10+48;b=b.substr(0,c-1);--c;}}return 1;}

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

В первый раз я пытаюсь что-то вроде этого, поэтому, если я отформатировал что-то неправильно, пожалуйста, дайте мне знать Я не на 100% уверен в правилах для таких вещей, как использование пространства имен для удаления 5 байтов "std ::", поэтому я оставил это.

Ungolfed:

bool hunger(std::string input)
{
    int count=input.length();
    while (count>1)
    {
        if (input[0]<input[count-1])                         //if at any point the head cannot eat the tail we can quit the loop
                                                             //comparisons can be done without switching from ascii
        {
            return false;
        }
        else
        {
             input[0]=(input[0]-48+input[count-1]-48)%10+48; //eating operation has to occur on integers so subtract 48 to convert from ASCII to a number
             input=input.substr(0,count-1);                  //get rid of the last number since it was eaten
             --count;
        }

    }
    return true;                                             //if the end of the loop is reached the number has eaten itself
}

C #, 114 байт

static bool L(string n){return n.Skip(1).Reverse().Select(x=>x%16).Aggregate(n[0]%16,(h,x)=>h>=x?(h+x)%10:-1)>=0;}

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

C (gcc) (с string.h) , 110 108 байт

c;f(char*b){c=strlen(b);if(!c)return 1;char*d=b+c-1;if(*b<*d)return 0;*b=(*b+*d-96)%10+48;*d=0;return f(b);}

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

Все еще относительно новый для PPCG, поэтому правильный синтаксис для связи библиотек как нового языка мне чужд. Также обратите внимание, что функция возвращает 0 или 1 для false / true, и для печати, которая приводит к stdout, требуется stdio. Если мы педантичны и упражнение требует результата, язык требует stdio .

Концептуально похож на ответ @ BenH, но в C, так что слава, где они должны (Добро пожаловать в PPCG, кстати), но с использованием рекурсии. Он также использует арифметику указателя массива, потому что грязный код короче, чем чистый код.

Функция является хвостовой рекурсивной, с условиями выхода, если первое число не может скушать последнее или длина равна 1, возвращая соответственно false или true. Эти значения можно найти, разыменовав указатель на C-String (который дает символ) в начале и конце строки, и выполнив сравнение с ними. Арифметика указателя делается, чтобы найти конец строки. наконец, последний символ «стирается», заменяя его нулевым терминатором (0).

Возможно, что арифметика модуля может быть сокращена на один или два байта, но я уже нуждаюсь в душе после этой манипуляции указателем.

Безголовая версия здесь

Обновление: сохранил два байта, заменив c == 1 на! C. По сути, это c == 0. Он будет работать дополнительное время и без необходимости удваивает себя перед удалением, но сохраняет два байта. Побочным эффектом является строка нулевой или нулевой длины, которая не вызовет бесконечной рекурсии (хотя мы не должны получать нулевые строки, так как в упражнении указаны положительные целые числа).

Powershell, 89 байт

"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(.\g(''+(+$m.1+$m.3)%10+$m.2)))

Важный! Скрипт вызывает себя рекурсивно. Так что сохраните скрипт какg.ps1 файл в текущем каталоге. Также вы можете вызвать переменную блока скрипта вместо файла скрипта (см. Тестовый скрипт ниже). Это звонки имеет одинаковую длину.

Примечание 1: скрипт использует ленивую оценку логических операторов -orи -and. Если "$args"-notmatch'(.)(.*)(.)'есть, Trueто правильное подвыражение -orне оценивается. Кроме того, если ($m=$Matches).1-ge$m.3есть, Falseто правильное подвыражение также -andне оценивается. Поэтому мы избегаем бесконечной рекурсии.

Примечание 2: Регулярное выражение '(.)(.*)(.)'не содержит начальный и конечный якоря, потому что выражение(.*) по умолчанию является жадным.

Тестовый скрипт

$g={
"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(&$g(''+(+$m.1+$m.3)%10+$m.2)))
}

@(
    ,(2632, $true)
    ,(92258, $true)
    ,(60282, $true)
    ,(38410, $true)
    ,(3210, $true)
    ,(2302, $true)
    ,(2742, $true)
    ,(8628, $true)
    ,(6793, $true)
    ,(1, $true)
    ,(2, $true)
    ,(10, $true)
    ,(100, $true)
    ,(55, $true)
    ,(121, $true)
    ,(6724, $false)
    ,(47, $false)
    ,(472, $false)
    ,(60247, $false)
    ,(33265, $false)
    ,(79350, $false)
    ,(83147, $false)
    ,(93101, $false)
    ,(57088, $false)
    ,(69513, $false)
    ,(62738, $false)
    ,(54754, $false)
    ,(23931, $false)
    ,(7164, $false)
    ,(5289, $false)
    ,(3435, $false)
    ,(3949, $false)
    ,(8630, $false)
    ,(5018, $false)
    ,(6715, $false)
    ,(340, $false)
    ,(2194, $false)
) | %{
    $n,$expected = $_
   #$result = .\g $n   # uncomment this line to call a script file g.ps1
    $result = &$g $n   # uncomment this line to call a script block variable $g
                       # the script block call and the script file call has same length
    "$($result-eq-$expected): $result <- $n"
}

Выход:

True: True <- 2632
True: True <- 92258
True: True <- 60282
True: True <- 38410
True: True <- 3210
True: True <- 2302
True: True <- 2742
True: True <- 8628
True: True <- 6793
True: True <- 1
True: True <- 2
True: True <- 10
True: True <- 100
True: True <- 55
True: True <- 121
True: False <- 6724
True: False <- 47
True: False <- 472
True: False <- 60247
True: False <- 33265
True: False <- 79350
True: False <- 83147
True: False <- 93101
True: False <- 57088
True: False <- 69513
True: False <- 62738
True: False <- 54754
True: False <- 23931
True: False <- 7164
True: False <- 5289
True: False <- 3435
True: False <- 3949
True: False <- 8630
True: False <- 5018
True: False <- 6715
True: False <- 340
True: False <- 2194

Powershell, 90 байт

Нет рекурсии. Отсутствие зависимости имени файла и имени блока скриптов.

for($s="$args";$s[1]-and$s-ge$s%10){$s=''+(2+$s[0]+$s)%10+($s|% S*g 1($s.Length-2))}!$s[1]

Powershell неявно преобразует правый операнд в тип левого операнда. Поэтому $s-ge$s%10вычисляет правый операнд $s%10как integerи сравнивает его как stringтип левого операнда string. И 2+$s[0]+$sпреобразует символ $s[0]и строку $sв integerпотому что левый операнд 2является целым числом.

$s|% S*g 1($s.Length-2)это ярлык для$s.Substring(1,($s.Length-2))

C # (интерактивный компилятор Visual C #) , 69 байт

x=>{for(int h=x[0],i=x.Length;i>1;)h=h<x[--i]?h/0:48+(h+x[i]-96)%10;}

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

Успех или неудача определяется наличием или отсутствием исключения . Ввод в форме строки.

Менее гольф ...

// x is the input as a string
x=>{
  // h is the head
  for(int h=x[0],
    // i is an index to the tail
    i=x.Length;
    // continue until the tail is at 0
    i>1;)
      // is head smaller larger than tail?
      h=h<x[--i]
        // throw an exception
        ?h/0
        // calculate the next head
        :48+(h+x[i]-96)%10;
}

Есть пара дополнительных байтов, чтобы иметь дело с преобразованием между символами и цифрами, но в целом это не сильно повлияло на размер.

Perl 5 -pF , 53 байта

$F[0]=($F[0]+pop@F)%10while$#F&&$F[0]>=$F[-1];$_=!$#F

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

Брахилог , 18 байт

ẹ⟨k{z₁{≥₁+t}ᵐ}t⟩ⁱȮ

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

Принимает три байта прочь решений Fatalize просто в силе недетерминистического superscriptless ⁱсуществующего в настоящее время, но теряет еще три, делая неопределенно Jelly вдохновленных вещей , z₁чтобы избежать использования c, gили даже h. (Также вдохновленный попыткой и неудачей использовать другую новую функцию: ʰметапредикат.)

                 Ȯ    A list of length 1
                ⁱ     can be obtained from repeatedly applying the following
ẹ                     to the list of the input's digits:
 ⟨k{         }t⟩      take the list without its last element paired with its last element,
    z₁                non-cycling zip that pair (pairing the first element of the list with
                      the last element and the remaining elements with nothing),
      {    }ᵐ         and for each resulting zipped pair or singleton list:
       ≥₁             it is non-increasing (trivially true of a singleton list);
          t           take the last digit of
         +            its sum.

PowerShell , 94 91 байт

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

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

Тестовый скрипт

function f($n){

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

Remove-Variable n
}
Write-Host True values:
@(2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121) |
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Write-Host False values:
@(6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194) | 
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Ungolfed код:

function f ($inVar){
    # While the Input exists, and the first character is greater than last
    while($inVar -and ($inVar[0] -ge $inVar[-1])){

        # Calculate the first integer -> ((+$n[0]+$n[-1]-96)%10)
        $summationChars = [int]$inVar[0]+ [int]$inVar[-1]
        # $summationChars adds the ascii values, not the integer literals. 
        $summationResult = $summationChars - 48*2
        $summationModulo = $summationResult % 10

        # Replace first character with the modulo
        $inVar = $inVar -replace "^.", $summationModulo

        # Remove last character
        $inVar = $inVar -replace ".$"
    }
    # Either it doesn't exist (Returns $True), or 
    # it exists since $inVar[0] < $inVar[-1] returning $False
    return !$inVar
}