给定一个正整数，请输出一个真/假值，以表明该数字是否可以吞噬自己。

规则

最左边是头，最右边是尾

如果头部大于或等于尾巴，则头部吃掉尾巴，新的头部成为它们的总和。

如果$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.

如果头部在任何时候都不能吃掉尾巴，那么答案将是False。

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字节

@tsh节省了1个字节

将输入作为字符串。返回一个布尔值。

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字节感谢Kevin Cruijssen

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个字节

第一行从Black Owl Kai的答案中被盗。

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

在线尝试！

非常感谢@ØrjanJohansen提出的-23

感谢@VedantKandoi（和@ØrjanJohansen）再获得-1

Brachylog，23个字节

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

在线尝试！

这比Fatalize的解决方案节省了1个字节。这使用递归方法而不是迭代方法

说明

ẹ                          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（用于吨 AIL）

  ⍵< 对于每个原始数字，请查看是否小于该数字

  ⊃ 选择第一个对/错

 : 如果是这样的话：

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

在线尝试！

将输入作为字符串。

Brachylog，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的伎俩使用的||，而不是单独的警卫。感谢@Laikoni，另一个-4字节。

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

在线尝试！

递归lambda方法。将输入作为字符串。非常感谢Dennis节省了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 2632yields True。

编辑： -5个字节，因为mod (h + mod n 10) 10 = mod (h + n) 10

Ruby，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}

在线尝试！（因为它是一个函数，所以有一些额外的代码来处理输入）

取消程式码：

->(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;}

在线尝试！

第一次尝试这种方法时，如果格式化错误，请告诉我。我不确定使用诸如使用命名空间来消除5个字节的“ std ::”之类的规则，所以我将其保留了下来。

取消高尔夫：

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来说，它还是一个相对较新的东西，因此，将库链接为一种新语言的正确语法对我来说是陌生的。还要注意，该函数为false / true返回0或1，并且将结果打印到stdout确实需要stdio。如果我们正在做学步，而练习需要输出，那么语言也需要stdio。

从概念上讲，它类似于@BenH的答案，但在C语言中，应使用它们的荣誉（欢迎使用PPCG，顺便说一句），但使用递归。它还使用数组指针算法，因为脏代码比干净代码短。

该函数是尾部递归，如果第一个数字不能吃完最后一个或长度为1，则退出条件，分别返回false或true。通过在字符串的开头和结尾解引用指向C字符串的指针（给出一个字符）并进行比较，可以找到这些值。完成指针算术以找到字符串的结尾。最后，最后一个字符通过用空终止符（0）替换来“擦除”。

模运算可能会缩短一到两个字节，但是在指针操作之后我已经需要淋浴了。

这里的非高尔夫版本

更新：通过将c == 1替换为！c，节省了两个字节。本质上，这是c ==0。它将运行额外的时间，并且在删除自身之前会不必要地使其自身加倍，但是会节省两个字节。副作用是null或零长度的字符串不会引起无限递归（尽管我们不应该像练习中所说的那样使用null字符串表示正整数）。

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将char $s[0]和string 转换为$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 -pF 5，53个字节

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

在线尝试！

Brachylog，18个字节

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

在线尝试！

起飞Fatalize的解决方案三个字节仅仅凭借非确定性superscriptless的ⁱ目前现有的，但如果用做隐约果冻风格的东西失去了另外三个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())" }

取消程式码：

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
}