[Question]
  [
Given a positive integer, output a truthy/falsy value as to whether the number can eat itself.
### Rules
Leftmost is the head, rightmost is the tail
If the head is greater than or equal to the tail, the head eats the tail and the new head becomes their sum.
If \$sum \ge 10 \$ then the head is replaced by \$sum \mod 10\$.
\$sum=0\$ cannot be ignored, however the input number will never have any leading zeroes.
**Example:**
```
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.
```
If at any point the head cannot eat the tail, the answer will be False.
```
number=6724
072
False (0<2)
```
### Test Cases:
```
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]
```
This is **code-golf** so shortest code wins.
  
[Answer]
# JavaScript (ES6), ~~52 51~~ 50 bytes
*Saved 1 byte thanks to @tsh*
Takes input as a string. Returns a Boolean value.
```
f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]
```
[Try it online!](https://tio.run/##jU/NToZADLzzFOvBAPmAbNv91YAnfQJvKweCoJ8hiwH19bH7JSZ689DZdtLtzLwNX8M@buf3jzquz9NxzG1su9iFeA2yv5uLuqhjkH0dSyZOsdmX8zgVUNVQljdXMUB/jGvc12VqlvWlyMPj9jn1eXmbBYGGsBIeUbtKGImOJ3IKJD@YEEkyhVYxOoNpy3qqBDDJKFMxaM0NguizZl63@2F8LaJoO/FbeGbqJPK8LFk6@2PpKYaHYdl/XBmLqhLKpsKLr9QToWEZltes6AgS6Qkke9FWuuTNa2BzBi3xpJXVKkXgJf4HhgeNzvMpRXyJvPIpFaUAEi7ZIPEqBQev/h3n@AY "JavaScript (Node.js) – Try It Online")
### Commented
```
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
Ṛṙ-µṖÄ%⁵:ḊẠ
```
[Try it online!](https://tio.run/##HU67jUIxEMyvCieXGcn784cGrgggvATRACEICYkCTjoiCrgUiUcIlZhGfLNI3tHOaGc86@/NZjtGn859@p09rn36eR4@X7vrvN9O/X4Zz@Nr/4cXvsZYcBaOoTFbjSEnrmBSlVIUBgSWBIWLAmtmPypNYiCIwOQDMMPCtIph@bHIhTUGLT78TvVdhDOu4DYYqpCLTSghykqqHt2MkJ25CJhpMfUGOIKPMohxbYhSQZI0bV5K/P9E72rkunpvarr6Bw "Jelly – Try It Online")
### How it works
```
Ṛṙ-µṖÄ%⁵:ḊẠ  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.
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~63~~ 62 bytes
```
{!grep {.[*-1]>.[0]},(.comb,{.[0,*-1].sum%10,|.[1..*-2]}...1)}
```
[Try it online!](https://tio.run/##LY7NbsJADITvfQr3AKJosdb2/go1fZAoB6gClwQQiAOiefbUpj145BnZn@bSX4c0jw9YHuAT5uf78dpf4IntekNdg63vJrfC7/O4dxp6ZzHe7uOCvPvBlhDXG@4mRKSPab7tHvDVchJ2UJljcZA8F3VSgn4IqwCL14RzUC2J7ShXcUAaqnob3zUNLg@4G4bt2x82ZQ4OQrbhF9h2EU7RgQKiPhYhC6uQV1rMvhi9RlJ84izqYsgxWAk90j9KaiKXqqggSpIaqvUSxUVPr3ZkebDqVMN/s9P51G/nXw "Perl 6 – Try It Online")
### Explanation:
```
{                                                            } # 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?
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 83 bytes
```
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;}
```
[Try it online!](https://tio.run/##rVFNT@MwEL33V4yQKiVsyPoziRtSzhyQkDgiDqZNiLupUzlOEary28s4BYkDxz147Deeee95vNNHfbPb/jub/aF3HnaI09GbLm1Gu/Gmt@l1udh0ehjgQRsLpwXAYXztzAYGrz1ux95sYY930ZN3xr49v4B2b0M8lwLcW//o6q3ZaF9DAxWc7c36ZKwHV5GkrWz53pqujtq1itu/FSVl07uotGtVtlXU/rHxkpLEhpvYVe2tRXhHV650tR@dBXdLy@lczlrIiurejb79QKUTsIyzBBRjskggI6xAxAuBhJxhAMYJZlguMBYZC0W54glQTGIkYWGQEg@MwvRTptHdcFHJciYSEHlYbNYJZ85Zhn3IJ5Gi4DQkFacEyWVOiiCmJEW1jOUckRS5FMETFmEfzRBIViikEhyZuBIq2OTBEaGzWRryIryEKvHtDwcIUZjwUXdjvfoayPeHADx9DL7ep/3o0wP@mG@iq6XcrmD5urRXyaUrgSb19eCjGcXxhXn6lX@exP@inxbT@RM "Java (JDK) – Try It Online")
## Credits
* -1 byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
## Mathematica, 62 bytes
```
0(IntegerDigits@#//.{a_,r___,b_}/;a>=b:>{Mod[a+b,10],r})=={0}&
```
First calls `IntegerDigits` on the input to get a list of its digits,
then repeatedly applies the following rule:
```
{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 *)
```
The rule is applied until the pattern no longer matches,
in which case either there is only one digit left (truthy)
or the head is less than the tail (falsy).
Instead of calling `Length[__]==1`,
we can save a few bytes with `0(__)=={0}`,
multiplying all elements in the list by `0`
and then comparing with the list `{0}`.
[Answer]
# [Python 3](https://docs.python.org/3/), 50 bytes
First line stolen from [Black Owl Kai's answer](https://codegolf.stackexchange.com/a/177133/64121).
```
p,*s=map(int,input())
while s:*s,k=s;p%10<k>q;p+=k
```
[Try it online!](https://tio.run/##TY7BboMwEETv@xVcqkDKwbtrY5uU3pJje@kP0NRSEAm4hqjJ19Ol6iGSZXtnnmcc7/NpHHg5jl@h2Ww2Syy3U3NpY94Nc9kN8TrnRQE/p@4csqneTmXfTLv4hOqlf/3exeemX@TZP/CRrqGGLJvTfT2yLNzCMV@zi78xJknNV2qdw@0Y4py9tZewT2lM9QNzaM/TI7R/Pzwwnym0/UIVE3gi46BS5AjYaVTAJBuxIiCrCVxF4lvPgEAgFioFxgASikwatJVFa4TcmKkyILRR4BhF8YwKwVjlJMYbZKjIsgOjrdHSIz5YrDQYch5YswH22ksvS4/CtRxF0/Ip9PoX "Python 3 – Try It Online")
Output is via exit code. Fails (1) for falsy inputs and finishes (0) for truthy inputs.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~105~~ ~~82~~ 81 bytes
```
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
```
[Try it online!](https://tio.run/##VY/PTsMwDMbveYqoEuoGRYrt/K3olSfgBjtMIxOVoK3KJrVPX2IPDlzy5fNn/@JM6@VjHHA7je9Zd7qu661vlu7rOO364dL0w3S97Pb7BtR5nPWq@0H3r61pH@HQKt2fizOHOzBPa7t0Run8@Z1brj10q5rmwtDLVqi/9/plvuZa5SWftDx5r4H@srfh@VjG/8eISm0VesJKVQnRxaLeYGRP0YJhRREkw1UMliV6lN6QqAhwwGrkMJKgLWKDHHjjiiNC74qWUcedkUDqicAwyAUThZ0cMNxjIPbOBmdlkdLJ8@DZOoyJqZYYSskmWY8Y7QzctgTJrPwDkq1@AA "Python 2 – Try It Online")
Many thanks for a massive -23 from @ØrjanJohansen 
Thanks to @VedantKandoi (and @ØrjanJohansen) for another -1
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 23 bytes
```
ẹ{bkK&⟨h{≥₁+tg}t⟩,K↰|Ȯ}
```
[Try it online!](https://tio.run/##LU@7TgMxEPwVx8U1uLB3/eQDaNJScboiQVFOIlKkcChClyuIECIdf5AKAQ2ioSBfwG@cf@TYDSl2NDsaz46nq8l1fb9YzmFo6/6wK5p2Lc@FXBejNj995e1jfn6Tl6u7mdwwu5gsbmeyG5G1679fWJInPvSHn3Z6My7y/r1u8@41bx/OmnnX5P2HGlPY5vezG4ay/I9TJXgEJRKAi0p4DZE2jNZohUAgADUpECxh9MCmkFAJQyKh5iFwjgiYqlKiPPUj5gNYJWzggWM8c0TwZKcYRy8jGhYTGk2ZLujIN5IzdMRDQNqcDc5yFTLRO@NpcRATRVmkJEw2cTvkItocOxrWLX/AJFtV1XD1Bw "Brachylog – Try It Online")
This is a 1 byte save over [Fatalize's solution](https://codegolf.stackexchange.com/a/177139/81957).
This uses a recursive approach instead of a iterative
### Explanation
```
ẹ                          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
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 33 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function taking a string as argument.
```
{⊃⍵<t←⊃⌽⍵:0⋄3::1⋄∇10|t+@1⊢¯1↓⍵}⍎¨
```
[Try it online!](https://tio.run/##JU@7TgNBDOz5CrotENLa3ucpBRINqZAIPxAJhSYSKdIgQgU6UOBOIMQPUKVLRUlzn@IfOWynmdmxPfbsfLU8vbmfL@9ux/GBt0/c/U7W3H7o8/1PVOP57ZmaBoT49QX8Zn1yBrz9GfbA7ZdMPHLXD7txoa6u5/57einuYU/cfoqaXZ0LXl9MZ@Ni2DlMhO7YVcRYhJPHoppKAK@MRkheq5iDUklos7mSEGhD2RsoxqhPBHekJ1LGIDpkAzxcMUWESUdlUVRfIbB6JfC6NmZf7FKNoKcSZlIdQ47BYsmk@iGpjFiqbg2kS6mGamHJInk4ZAbrBfsV1OD@AQ "APL (Dyalog Unicode) – Try It Online")
`⍎¨` evaluate each character (this gives us a list of digits)
`{`…`}` apply the following "dfn" to that; `⍵` is the argument (list of digits):
  `⌽⍵` reverse the argument
  `⊃` pick the first element (this is the tail)
  `t←` assign to `t` (for **t**ail)
  `⍵<` for each of the original digits, see if it is less than that
  `⊃` pick the first true/false
 `:` if so:
  `0` return false
 `⋄` then:
 `3::` if from now on, an index error (out of bounds) happens:
  `1` return true
  `¯1↓⍵` drop the last digit
  `⊢` yield that (separates `1` and `¯1` so they won't form a single array)
  `t+@1` add the tail to the first digit (the head)
  `10|` mod-10
  `∇` recurse
Once we hit a single digit, `¯1↓` will make that an empty list, and `@1` will cause an index error as there is no first digit, causing the function to return true.
[Answer]
# [Python 3](https://docs.python.org/3/), 77 bytes
```
p,*s=map(int,input())
print(all(n<=sum(s[i+1:],p)%10for i,n in enumerate(s)))
```
[Try it online!](https://tio.run/##FY5BT8MwDIXP86/oBS2BHmI7aZKJHceVCzfEoYygVWxplLaC/friSpZlv2e9z@U@X8bM63n8Ssf9fr@W9nE63vqihjy3Qy7LrLSGUmVV/fWq8vNxWm5qeh@e8PDRFv2A5nuszdDmZshNysst1X5OatJar5IIv5fhmpq3uqQD7OZ6l75Lf@msNqYGmc@pzM3p9eVU61g3@7Om/meljgkikQvQGQoEHCwaYJJGbAjIW4LQkfg@MiAQiIXGgHOAhCKTBeulaIuQiZk6B3LtDARGUSKjQXDeBImJDhk68hzAWe@scMQHj50FRyECW3bA0UbhsnAMbnAUzcpTGO0/ "Python 3 – Try It Online")
---
And my old solution with a recursive approach
# [Python 3](https://docs.python.org/3/), 90 bytes
```
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]))
```
[Try it online!](https://tio.run/##bU/LTsMwEDyTr/AFKVaN5N31M6L8SJVDKIkaKSRV6kP4@rDbCsGBw452xvbM@PpVLstM@z4cp@7z/aNTm@mOtsG3qZ/rTY@D@lmXtR7nUm8n2@pDp5/Bvj74C7S6n269Gpg0zEx3@D3R@7CsqpzVOKsTBkKjMqJPRgWLiRklB9YQMigkywpGx5gCyqWYyShgkdHKMHjPC0LbVE/XVaKG@lbWupy11tVD0VX1JzdEdEa5KIP3ZNmJMLATJ3g2TQQiZgLLcT7aJPHZA@cHjMTMu@idtORL/A4CE48ps5UjdqLsshQn6WjhXh9Ed/I3yO7fxvs3 "Python 3 – Try It Online")
Takes input as a string.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 24 bytes
```
ẹ;I⟨⟨h{≥₁+tg}t⟩c{bk}⟩ⁱ⁾Ȯ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@Gundaej@avAKKM6kedSx81NWqXpNeWPJq/Mrk6KbsWSD9q3Piocd@Jdf//G1uYGBr8BwA "Brachylog – Try It Online")
I should change `ⁱ`'s default behaviour so that it iterates an unknown number of times (currently, it iterates 1 time by default which is completely useless). I then wouldn't need the `[…];I[…]⁾`, saving 3 bytes
### Explanation
This program contains an ugly fork inside a fork. There is also some plumbing needed to work on lists of digits instead of numbers (because if we remove the head and tail of `76` we are left with `0`, which doesn't work contrary to `[7,6]` where we end up with `[]`).
```
ẹ                          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
```
[Answer]
## Haskell, ~~70~~ ~~64~~ 60 bytes
```
f(a:b)=b==""||a>=last b&&f(last(show$read[a]+read b):init b)
```
Input is taken as a string.
[Try it online!](https://tio.run/##dY5bisJQDIbfXUUQkZYJcnI5N6GzEenDKVos1ipWmBf3XtMFDIQk5E/@fNcy3y7juCx9VY5d3XRNs91@PuW3Gcv8hm6/76u1q@br42/3upTzqbQ/a4WuPg7TYDv1ci/DBA2cHxsAeL6G6Q07uJcnVP1hPazhxEEYM7NPGBwnRklKDoUtsThGjsqYApsesyAho0nkHHqPxNT@7x0iK2q04NXcOhEOHs3HO0xCNslCjtBHl@xB9iQYOEpCr9GrEZiOkYKi55RRVDxK1mxEYgSOViyymRouZW03yxc "Haskell – Try It Online")
Edit: -6 bytes by using [@Laikoni's trick](https://codegolf.stackexchange.com/a/177198/34531) of using `||` instead of separate guards. Another -4 bytes thanks to @Laikoni.
[Answer]
# [Perl 5](https://www.perl.org/), 64 bytes
```
{local$_=pop;1while s/(.)(.*)(.)/$1<$3?'':(($1+$3)%10).$2/e;/./}
```
[Try it online!](https://tio.run/##RU/tSgNBDPzvU6RlpXe63G2SzX54io9SWlm1eNCjRxURn/3MloI/MiRDMjOZymmU5TwX@JQO3XAzn/dQlp/x@LIbzfZpOk4Dfr0fxgJz33Rt091ptb3BR8PPm81D0xi8N9zeoms7Q30Z@q7/XebdN6yPH4BrOLzC6u1UplVpzLa1QIHJQiaSZCE4Sjpx8ugskwIQO2UoesUUqC7FzBZQSUVXS0FEG0JNfLWifyu4WoVI3oKPtehiVntmCnqsoqI6ibGSmdGpg0SXqmMWVMtAkXUSH8XXYLqkdxh0EEpZpTyrEmefa1ausRxeEmPlfX0Hsx@WPw "Perl 5 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/), ~~75~~ 67 bytes
```
l=lambda n:n==n[0]or n[-1]<=n[0]*l(`int(n[0]+n[-1],11)%10`+n[1:-1])
```
**[Try it online!](https://tio.run/##fVBNS8RADL3vrwgFoXUrTJL5LO7VX@CtFlrXFRfq7NLWg7@@JmVvogMJeW8yyXtz/V4@LpnWdTyMw@fr2wC5yYdDbk13mSC3D9g9buh@LPtzXkqt9xtfI1Z3aHpB2Aiu1uskHVC85Ofp6wTLaV7gOMynuSl27zoNzhla8kw1JCIXa/CGoiCOFk3NJAmIjTAUrOToSZtC4hpQSMlGQ5JzUhB2Ddy2gpwC9jAvUylac19Vu9tV8at4Gsb5T4U@kK3BBg3aNGrNTF52ihYn6yOjkonRiDAXTFShyaEo9RRYkLPBWfUjTfIOvQBHMckoyzKJk01qkdWNwc0oKm/1FzDZf72t6w8)**
Recursive lambda approach. Takes input as a string. Many thanks to Dennis for saving 8 bytes!
[Answer]
# [Haskell](https://www.haskell.org/), ~~69~~ 64 bytes
```
f n=read[show n!!0]#n
h#n=n<10||h>=mod n 10&&mod(h+n)10#div n 10
```
[Try it online!](https://tio.run/##ZU/LasNADLznKxRcQkv3oMc@oe6PBB8MTrBpvA5JSS75d1fytQcN0iDNjMb@/nO6XNb1DLW9nfrheB@XJ9T9Hrum7samtvWL8PUav9t5GaAC4eGg3fv4WT8Im2F6bOQ691OFFoYFdnC9TfUX3mDur3CGI0dhB4U5ZAcROesk2RM6YQVgQWU4ecUc2ZZSEQekpCJaKYSgDVP3Tz8m9g58suLNwXoRjnqhSkGPs5CRRQhVNiTMZlMCqU/kJDoFn4K3NLqkdxR1CJyLSnlRJSm@WECxLEhbTDLe2w9UfLf@AQ "Haskell – Try It Online") Example usage: `f 2632` yields `True`.
*Edit:* -5 bytes because `mod (h + mod n 10) 10 = mod (h + n) 10`
[Answer]
# Ruby, 139 bytes
```
->(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}
```
[Try it online!](https://tio.run/##RY3RCoIwGIXvfQov9xMbm0EXjumDDInfXDpQN9yMInr2VQp1d/jOdzjL2j5SahWtCMIT2WjmPg5KiZr4PC6rkeZuI5RCEtS8YdGdbaVQU7FnqDeuyB8dfiKwzt4m1xHBQe9tkPhZc8Zo0UiftxobKD254hgMbF@vLEPVmxjYZXCTz75KSsXpWLwB "Ruby – Try It Online") (has some extra code to process input, since it's a function)
Ungolfed code:
```
->(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
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 42 bytes
```
\d
$*#;
^((#*).*;)\2;$
$2$1
}`#{10}
^#*;$
```
[Try it online!](https://tio.run/##FY49CgJRDIT7ucY@Yd1CkknyftgDeAkRBS1sLMROPPsaIYQwE@ab1/39eF633TwfL9vphrJMK87zPC37w7LuT1wLCovie5k@Kl/gPC1r2TZWIwYZHVXYCeuuAmMumhBsTvTK9NswKIi0VAQRUGrKdHjL4T8iLzPWQH6HoJumMkxFEU16xoxQQ2WzjvAWnpz00bQ6gn3A3AI2fCTXkiP6h2tqnqV0@A8 "Retina 0.8.2 – Try It Online") Link include test cases. Explanation:
```
\d
$*#;
```
Convert the digits to unary and insert separators.
```
^((#*).*;)\2;$
$2$1
```
If the last digit is not greater than the first then add them together.
```
#{10}
```
Reduce modulo 10 if appropriate.
```
}`
```
Repeat until the last digit is greater than the first or there is only one digit left.
```
^#*;$
```
Test whether there is only one digit left.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~26~~ ~~25~~ 24 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
[DgD#\ÁD2£D`›i0qëSOθs¦¦«
```
Can probably be golfed a bit more.. It feels overly long, but maybe the challenge is in terms of code more complex than I thought beforehand.
[Try it online](https://tio.run/##yy9OTMpM/f8/2iXdRTnmcKOL0aHFLgmPGnZlGhQeXh3sf25H8aFlQLj6/39TUwA) or [verify all test cases](https://tio.run/##HU47ikJBELzKoOkE07/5RCYvNzAR3AUVRIw2EBZeIGjiAbzCwiZeQDbUfA/hRZ7VMnTRXVNV3V/71Xq3Gb77ySg8z5cwmvTDott244/HqeP7T7d8Hv92aT5@XGfT/9v@/ot3HQ6HOCw4C8fQmK3GkBNXTFKVUhQGBJYEhosCa2YXlSYxEEhg8gKYoWHyX9YYtHjxO9F7Ec5QwGkQVyEnm1CCw0qqHtuMkJu5CCbTYurbIYKPMgbj2hClgiRp2vwg8d2J3meR8@o3U9PPFw).
**Explanation:**
```
[                 # 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
```
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 144 bytes
```
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;}
```
[Try it online!](https://tio.run/##TY7BasMwEETv@gqRUpBIVGRIicnK/pGQg7SWHYEiG0umB@Nvd2U3kO5pmbc7MzgMokNcP1xAPzWWKtfHNFr9rAlZTd972rKYmus1qy501PDZhUSxMl/ehi49GIefh/OWYV1k1jJzk3dlbiiKOx9tmsZAJVgf7byRaufiXB7/TvLGPwt5PJdgsmecTA5i8pQZByEQluVlUsCybtFP7QLjZCY0z/9qmlb08H2RZXmAHe71dWzaqmWaw/sB@ykptRGldsGGxgNZ1l8 "C++ (gcc) – Try It Online")
First time I'm trying something like this so if I formatted something wrong please let me know. I'm not 100% sure on the rules for stuff like using namespace to eliminate the 5 bytes "std::" so I left it in.
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
}
```
[Answer]
# C#, 114 bytes
```
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;}
```
[Try it online](https://tio.run/##TU9dS8MwFH1uf8VlOEhwC22VCpZWxNcKYh/2MPYQ4zUNdokmWamU/vaYwR4G9@Hc88HhCLcVxmI4OaUldH/O47FKrz/WKv1bpWLgzsGbNdLyI8zBee6VgA9jBmiJ8/ac0HS26E9Wg2bdt/ohOWXvOKJ1SCjrcEDhyVQ30zovKXuW0qLkHoneZ4dIbUi/mWjd9E09PZH@dqLrPHvc5rSps2oJyaVzNOoTXrnSl9r9AbiVjsKcJslXXMNFT0ZuzywofSUmL0Y7MyDbWeUxDkNys5qjvkDdwNySCOmyolX0Lmm8JYSivCtCmRX3D/8)
[Answer]
# [C (gcc)](https://gcc.gnu.org/) *(with string.h)*, ~~110~~ 108 bytes
```
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);}
```
[Try it online!](https://tio.run/##hY7RboMgGEav61MwGxPAuaDbWjtKH2K36y7gRyyJo43iVdNnt2Bnsrtd8p2T8wNFCzCtrYNu1A3aD17b88vpkPydeuvauE3ADYaT7KkiVxABdI3DinBr8BOQvvFj71DJZ0ULlUNRRkbVnuoFM06VCFNOdbHbkKxk@VvNg874r2Fi8jZZ59GPtA6T5JqsYhPJr5J9I4HS9y2r6yNLebKKmhy0EQZLEt6X8FtvcPrZDGPnP1Bmjy59npWI545aOtXmtXpkIg/LfPu/yG26Aw "C (gcc) – Try It Online")
Still relatively new to PPCG, so the correct syntax for linking libraries as a new language is foreign to me. Also note that the function returns 0 or 1 for false/true, and printing that result to stdout does require stdio. If we're being pedantic and the exercise requires output, the language requires *stdio* that as well. 
Conceptually similar to @BenH's answer, but in C, so kudos where they are due (Welcome to PPCG, btw), but using recursion. It also uses array pointer arithmetic, because dirty code is shorter than clean code. 
The function is tail recursive, with exit conditions if the first number can't eat the last or the length is 1, returning false or true, respectively. These values are found by dereferencing a pointer to the C-String (which gives a char) at the beginning and end of the string, and doing the comparisons on them. pointer arithmetic is done to find the end of the string. finally, the last char is "erased" by replacing it with a null terminator (0). 
It's possible that the modulus arithmetic could be shortened by a byte or two, but I already need a shower after that pointer manipulation.
[Ungolfed Version Here](https://tio.run/##hY/NTsMwEITP8VOsgirZLkFOoSXQmofgSnvwT9xaSg1KnBPKs4e1AxKcOHrmm9mxqc7GzDc@mG60LRyGaP373eWF/JZ6H85Jm32I4Ki5qJ5rRj5JkQQjAZGuDVSzPUoISFkzUqBf9G0c@wA1GhMpUhI4WJCg16aqMw6UazgAtwz@ZMSSQVNmZI0IVE87Bqta4OuhQYCnrkR@h1weMeWlV@UDzTPzXfVWixPS5fZRNM1RlPtlvxqsk46qNP4DvxodLV/bYeziM6z8MZS3GUl27tE/PZvd/WapST4qy/F/Sqb5Cw "Ungolfed Version Here")
Update: Saved two bytes by replacing c==1 with !c. This is essentially c == 0. It will run an additional time, and will needlessly double itself before deleting itself, but saves two bytes. A side effect is null or zero length strings won't cause infinite recursion (though we shouldn't get null strings as the exercise says positive integers). 
[Answer]
# Powershell, 89 bytes
```
"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(.\g(''+(+$m.1+$m.3)%10+$m.2)))
```
Important! The script calls itself recursively. So save the script as `g.ps1` file in the current directory. Also you can call a script block variable instead script file (see the test script below). That calls has same length.
Note 1: The script uses a lazy evaluation of logic operators `-or` and `-and`. If `"$args"-notmatch'(.)(.*)(.)'` is `True` then the right subexpression of `-or` is not evaluated. Also if `($m=$Matches).1-ge$m.3` is `False` then the right subexpression of `-and` is not evaluated too. So we avoid infinite recursion.
Note 2: The regular expression `'(.)(.*)(.)'` does not contain start and end anchors because the expression `(.*)` is greedy by default.
## Test script
```
$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"
}
```
Output:
```
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 bytes
No recursion. No file name dependency and no script block name dependency.
```
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]
```
A Powershell implicitly converts a right operand to a type of a left operand. Therefore, `$s-ge$s%10` calculates right operand `$s%10` as `integer` and compare it as a `string` because type of the left operand is `string`. And `2+$s[0]+$s` converts a char `$s[0]` and string `$s` to `integer` because left operand `2` is integer.
`$s|% S*g 1($s.Length-2)` is a [shortcut](https://codegolf.stackexchange.com/a/111526/80745) to `$s.Substring(1,($s.Length-2))`
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 69 bytes
```
x=>{for(int h=x[0],i=x.Length;i>1;)h=h<x[--i]?h/0:48+(h+x[i]-96)%10;}
```
[Try it online!](https://tio.run/##TVFLa4NAEL77K4ZAQYmm@9TdGFNKr7m10IN4SEWzC0FBt9QQ/O121pbSwww7s/M9drYek3q0y3PtbN8dRjfY7nKEFoplKo73th9C2zkwxVSSKrbFtDs13cWZ3B5pHpnCHKYySWz1ZB7JXqhtaLZTaatEp9EDJfm85EGABGUFbvh05gYFdM1XWQV3lnIWg2ZMqhhSwhRWXAlKYs4wAeMEOywTmFXK/FCmeQwUm5iJD0xS4oHR@U@nPV/HfzJpxkQMIvPBViF/5pylCERCiRyKU9/UnBJklxlRXk1LinIpyzhWUmRSeFM4hDiaYiGZ0kglODJxLbT3yb0lQle31PeFfwrVwhvEbTbn2sC6Ugu2@13K7qXv6rMLV@tRBPcA4KPvrzAUONDkWLrhtrYB2tDu3vrX9aPCKPKXMyAaeX8GhsLzrKgZ432wrjnZrgntdrOHzXZAzLx8Aw "C# (Visual C# Interactive Compiler) – Try It Online")
Success or failure is determined by [presence or absence of an exception](https://codegolf.meta.stackexchange.com/a/11908/8340). Input is in the form of a string.
Less golfed...
```
// 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;
}
```
There are a couple extra bytes to deal with converting between characters and digits, but overall that didn't affect the size too much.
[Answer]
# [Perl 5](https://www.perl.org/) `-pF`, 53 bytes
```
$F[0]=($F[0]+pop@F)%10while$#F&&$F[0]>=$F[-1];$_=!$#F
```
[Try it online!](https://tio.run/##K0gtyjH9/1/FLdog1lYDTGkX5Bc4uGmqGhqUZ2TmpKoou6mpgSXsbIGUrmGstUq8rSJQ@P9/U9N/@QUlmfl5xf91C9wA "Perl 5 – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 18 bytes
```
ẹ⟨k{z₁{≥₁+t}ᵐ}t⟩ⁱȮ
```
[Try it online!](https://tio.run/##HU47TgNBDL3KaFpGaMb2/CoOglIsUfiIKJFgpBVZbZEgoaTjBqkQoUFQUJATcI2diyx2Cj/bz8/PvnpoprdP8@UNjF2r1bRZ6Paiqy9fdfNctwe9WBbd9nX7rtWsKequPM7m1@d6OO764ed1HI6/dX@471Z1s@7q7o3TWZFJX@r@o66//z7H8RICglEZwCejgoXEHSZy1iAwKEDLDERiTAFEFDMa5ZhktBIM3nMBTqZARlGUgJOj1IgQWMGbnsUJnZAZneUNH20S2@wd@waIyJ2n6Emus4j3XODGQ8psRchOmCnLQyi3rTu95YQn@dllmvwD "Brachylog – Try It Online")
Takes three bytes off Fatalize's solution just by virtue of non-deterministic superscriptless `ⁱ` existing now, but loses another three by doing vaguely Jelly-inspired things with `z₁` to avoid using `c`, `g`, or even `h`. (Also inspired by trying, and failing, to use a different new feature: the `ʰ` metapredicate.)
```
                 Ȯ    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.
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~94~~ 91 bytes
```
for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n
```
[Try it online!](https://tio.run/##rVDLTsMwELznK5bIVWOaVH4nBiFxQhw4QQUHVKpQ3IcUnMpNy6H028u6SKi9c/B4H@P1zK7aLxfWC9c0h9nGT7tl62GWEU93yWHWhuya@KL2H8S/snExd3gXfEx3xN9gI7hVU09d@jZM8ywbHEmDX0phDe1xRv84Q5Lug@s2wcMF8YdH99luXfFch2X93jjwyT5JXsKyc8V9u@5gFDYOtnWzceur5DYTRoocrBC6ysEwUWEmK8VZLgUCCMmwIkqFWBkRSaWVOXAsIrJ4ELTGQHAK39CDHZz8lwKQCZCsD/3LzBRkMhy1T11Y@nlGhw/Oz7sFpdifQeHhrEtTOJd@VzfrU@2mFCoHVcYjjupjLKUwqAZVahRWSR6LVnKGknXJqmjBao4ejCglZlqVWkWnSMJ33GCiRWVxlJI4SVplo3kZfTJ@XAGPdRX3w636d9eHHw "PowerShell – Try It Online")
---
## Test Script
```
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 code:
```
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
}
```
]