Cho một số nguyên dương, đưa ra một giá trị trung thực / sai lệch về việc liệu số đó có thể tự ăn hay không.

Quy tắc

Bên trái là đầu, ngoài cùng bên phải là đuôi

Nếu đầu lớn hơn hoặc bằng đuôi, đầu ăn đuôi và đầu mới trở thành tổng của chúng.

Nếu $sum \ge 10$ thì người đứng đầu được thay thế bằng $sum \mod 10$ .

$sum=0$ không thể bị bỏ qua, tuy nhiên số đầu vào sẽ không bao giờ có bất kỳ số 0 đứng đầu nào.

Thí dụ:

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.

Nếu tại bất kỳ thời điểm nào, đầu không thể ăn đuôi, câu trả lời sẽ là Sai.

number=6724
072
False (0<2)

Các trường hợp thử nghiệm:

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]

Đây là mã golf nên mã ngắn nhất sẽ thắng.

JavaScript (ES6),  52 51  50 byte

Đã lưu 1 byte nhờ @tsh

Đưa đầu vào dưới dạng một chuỗi. Trả về giá trị Boolean.

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

Hãy thử trực tuyến!

Đã bình luận

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

Thạch , 11 byte

Ṛṙ-µṖÄ%⁵:ḊẠ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṛṙ-µṖÄ%⁵:ḊẠ  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 byte

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

Hãy thử trực tuyến!

Giải trình:

{                                                            } # 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 byte

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

Hãy thử trực tuyến!

Tín dụng

• -1 byte nhờ Kevin Cruijssen

Toán học, 62 byte

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

Đầu tiên gọi IntegerDigitsvào đầu vào để có được danh sách các chữ số của nó, sau đó liên tục áp dụng quy tắc sau:

{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 *)

Quy tắc được áp dụng cho đến khi mẫu không còn phù hợp, trong trường hợp đó chỉ còn lại một chữ số (trung thực) hoặc đầu nhỏ hơn đuôi (giả).

Thay vì gọi Length[__]==1, chúng ta có thể lưu một vài byte với 0(__)=={0}, nhân tất cả các thành phần trong danh sách 0 và sau đó so sánh với danh sách {0}.

Python 3 , 50 byte

Dòng đầu tiên bị đánh cắp từ câu trả lời của Black Owl Kai .

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

Hãy thử trực tuyến!

Đầu ra là thông qua mã thoát. Thất bại (1) cho đầu vào sai và kết thúc (0) cho đầu vào trung thực.

Python 2 , 105 82 81 byte

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

Hãy thử trực tuyến!

Rất cám ơn về số lượng lớn -23 từ @ janrjanJohansen

Cảm ơn @VedantKandoi (và @ rjanJohansen) cho -1 khác

Brachylog , 23 byte

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

Hãy thử trực tuyến!

Đây là tiết kiệm 1 byte so với giải pháp của Fatalize . Điều này sử dụng một cách tiếp cận đệ quy thay vì lặp đi lặp lại

Giải trình

ẹ                          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 byte ^SBCS

Hàm tiền tố ẩn danh lấy một chuỗi làm đối số.

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

Hãy thử trực tuyến!

⍎¨ đánh giá từng ký tự (điều này cung cấp cho chúng tôi danh sách các chữ số)

{... } áp dụng sau "DFN" để đó; ⍵là đối số (danh sách các chữ số):

  ⌽⍵ đảo ngược lập luận

  ⊃ chọn phần tử đầu tiên (đây là phần đuôi)

  t← gán cho t(cho t ail)

  ⍵< đối với mỗi chữ số ban đầu, hãy xem nếu nó nhỏ hơn số đó

  ⊃ chọn đúng / sai đầu tiên

 : nếu vậy:

  0 trả lại sai

 ⋄ sau đó:

 3:: nếu kể từ bây giờ, một lỗi chỉ mục (ngoài giới hạn) xảy ra:

  1 trở về đúng

  ¯1↓⍵ bỏ chữ số cuối

  ⊢ mang lại điều đó (tách ra 1và ¯1do đó chúng sẽ không tạo thành một mảng duy nhất)

  t+@1 thêm đuôi vào chữ số đầu tiên (đầu)

  10| mod-10

  ∇ tái diễn

Khi chúng ta nhấn một chữ số, ¯1↓sẽ tạo một danh sách trống và @1sẽ gây ra lỗi chỉ mục vì không có chữ số đầu tiên, khiến hàm trả về đúng.

Python 3 , 77 byte

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

Hãy thử trực tuyến!

Và giải pháp cũ của tôi với cách tiếp cận đệ quy

Python 3 , 90 byte

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi.

Brachylog , 24 byte

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

Hãy thử trực tuyến!

Tôi nên thay đổi ⁱhành vi mặc định của nó để nó lặp lại một số lần không xác định (hiện tại, nó lặp lại 1 lần theo mặc định là hoàn toàn vô dụng). Sau đó tôi sẽ không cần […];I[…]⁾, tiết kiệm 3 byte

Giải trình

Chương trình này chứa một ngã ba xấu xí bên trong một ngã ba. Ngoài ra còn có một số hệ thống ống nước cần thiết để làm việc trên danh sách các chữ số thay vì số (bởi vì nếu chúng ta loại bỏ phần đầu và đuôi của 76chúng ta 0, chúng không hoạt động trái với [7,6]nơi chúng ta kết thúc []).

ẹ                          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 byte

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

Đầu vào được lấy dưới dạng một chuỗi.

Hãy thử trực tuyến!

Chỉnh sửa: -6 byte bằng cách sử dụng thủ thuật sử dụng của @ Laikoni|| thay vì các bộ bảo vệ riêng biệt. Một -4 byte khác nhờ @Laikoni.

Perl 5 , 64 byte

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

Hãy thử trực tuyến!

Python 2 , 75 67 byte

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

Hãy thử trực tuyến!

Phương pháp đệ quy lambda. Đưa đầu vào dưới dạng một chuỗi. Rất cám ơn Dennis vì đã tiết kiệm được 8 byte!

Haskell , 69 64 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng: f 2632sản lượng True.

Chỉnh sửa: -5 byte vìmod (h + mod n 10) 10 = mod (h + n) 10

Ruby, 139 byte

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

Hãy thử trực tuyến! (có một số mã bổ sung để xử lý đầu vào, vì đó là một chức năng)

Mã bị đánh cắp:

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

Võng mạc 0.8.2 , 42 byte

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

^#*;$

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\d
$*#;

Chuyển đổi các chữ số thành unary và chèn dấu phân cách.

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

Nếu chữ số cuối cùng không lớn hơn chữ số đầu tiên thì hãy cộng chúng lại với nhau.

#{10}

Giảm modulo 10 nếu thích hợp.

}`

Lặp lại cho đến khi chữ số cuối cùng lớn hơn chữ số đầu tiên hoặc chỉ còn lại một chữ số.

^#*;$

Kiểm tra xem chỉ còn lại một chữ số.

05AB1E , 26 25 24 byte

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

Có lẽ có thể chơi golf nhiều hơn một chút .. Nó cảm thấy quá dài, nhưng có lẽ thách thức về mặt mã phức tạp hơn tôi nghĩ trước đó.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

[                 # 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 byte

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

Hãy thử trực tuyến!

Lần đầu tiên tôi đang thử một cái gì đó như thế này vì vậy nếu tôi định dạng một cái gì đó sai xin vui lòng cho tôi biết. Tôi không chắc chắn 100% về các quy tắc cho các công cụ như sử dụng không gian tên để loại bỏ 5 byte "std ::" vì vậy tôi đã bỏ nó vào.

Ung dung:

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 byte

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

Dùng thử trực tuyến

C (gcc) (với chuỗi.h) , 110 108 byte

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

Hãy thử trực tuyến!

Vẫn còn tương đối mới với PPCG, vì vậy cú pháp chính xác để liên kết các thư viện như một ngôn ngữ mới là xa lạ với tôi. Cũng lưu ý rằng hàm trả về 0 hoặc 1 cho sai / đúng và việc in kết quả ra thiết bị xuất chuẩn không yêu cầu tiêu chuẩn. Nếu chúng ta là người phạm tội và bài tập yêu cầu đầu ra, ngôn ngữ cũng yêu cầu stdio .

Về mặt khái niệm tương tự như câu trả lời của @ BenH, nhưng trong C, vì vậy họ sẽ đến hạn (Chào mừng bạn đến với PPCG, btw), nhưng sử dụng đệ quy. Nó cũng sử dụng số học con trỏ mảng, vì mã bẩn ngắn hơn mã sạch.

Hàm này là đệ quy đuôi, với các điều kiện thoát nếu số đầu tiên không thể ăn cuối cùng hoặc độ dài là 1, trả về sai hoặc đúng tương ứng. Các giá trị này được tìm thấy bằng cách hủy bỏ một con trỏ tới Chuỗi C (cung cấp char) ở đầu và cuối chuỗi và thực hiện so sánh trên chúng. số học con trỏ được thực hiện để tìm kết thúc chuỗi. cuối cùng, char cuối cùng bị "xóa" bằng cách thay thế nó bằng một terminator null (0).

Có thể số học mô đun có thể rút ngắn một hoặc hai byte, nhưng tôi đã cần một vòi hoa sen sau thao tác con trỏ đó.

Phiên bản Ungolfed Tại đây

Cập nhật: Đã lưu hai byte bằng cách thay thế c == 1 bằng! C. Điều này về cơ bản là c == 0. Nó sẽ chạy thêm một thời gian và sẽ không cần gấp đôi chính nó trước khi xóa chính nó, nhưng tiết kiệm hai byte. Một tác dụng phụ là các chuỗi có độ dài bằng 0 hoặc bằng 0 sẽ không gây ra đệ quy vô hạn (mặc dù chúng ta không nên nhận các chuỗi rỗng vì bài tập cho biết các số nguyên dương).

Powershell, 89 byte

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

Quan trọng! Kịch bản gọi chính nó đệ quy. Vì vậy, tiết kiệm kịch bản như g.ps1tập tin trong thư mục hiện hành. Ngoài ra, bạn có thể gọi một biến khối tập lệnh thay vì tập tin tập lệnh (xem tập lệnh kiểm tra bên dưới). Các cuộc gọi đó có cùng độ dài.

Lưu ý 1: Kịch bản sử dụng đánh giá lười biếng các toán tử logic -orvà -and. Nếu "$args"-notmatch'(.)(.*)(.)'là Truethì sự phụ thuộc đúng của -orkhông được đánh giá. Ngoài ra nếu ($m=$Matches).1-ge$m.3là Falsethì sự phụ thuộc đúng của -andkhông được đánh giá quá. Vì vậy, chúng tôi tránh đệ quy vô hạn.

Lưu ý 2: Biểu thức chính quy '(.)(.*)(.)'không chứa neo bắt đầu và kết thúc vì biểu thức (.*)mặc định là tham lam.

Kịch bản kiểm tra

$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"
}

Đầu ra:

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 byte

Không đệ quy. Không phụ thuộc tên tệp và không phụ thuộc tên khối tập lệnh.

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]

Một Powershell ngầm chuyển đổi một toán hạng bên phải thành một loại toán hạng bên trái. Do đó, $s-ge$s%10tính toán toán hạng phải $s%10như integervà so sánh nó như một stringvì kiểu của toán hạng bên trái là string. Và 2+$s[0]+$schuyển đổi một char $s[0]và chuỗi $sthành integerbởi vì toán hạng bên trái 2là số nguyên.

$s|% S*g 1($s.Length-2)là một lối tắt đến$s.Substring(1,($s.Length-2))

C # (Trình biên dịch tương tác Visual C #) , 69 byte

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

Hãy thử trực tuyến!

Thành công hay thất bại được xác định bởi sự hiện diện hay vắng mặt của một ngoại lệ . Đầu vào ở dạng chuỗi.

Ít chơi gôn hơn ...

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

Có thêm một vài byte để xử lý việc chuyển đổi giữa các ký tự và chữ số, nhưng về tổng thể, điều đó không ảnh hưởng đến kích thước quá nhiều.

Perl 5 -pF , 53 byte

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

Hãy thử trực tuyến!

Brachylog , 18 byte

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

Hãy thử trực tuyến!

Mất ba byte ra giải pháp Fatalize của chỉ nhờ superscriptless không xác định ⁱhiện nay, nhưng mất thêm ba bằng cách thực hiện điều mơ hồ Jelly lấy cảm hứng từ với z₁để tránh sử dụng c, ghoặc thậm chí h. (Cũng được truyền cảm hứng bằng cách thử và thất bại, để sử dụng một tính năng mới khác: ʰsiêu hình.)

                 Ȯ    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 byte

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

Hãy thử trực tuyến!

Kiểm tra tập lệnh

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())" }

Mã bị đánh cắp:

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
}