Olumlu bir tamsayı verildiğinde, sayının kendisini yiyip yiyemeyeceğine dair bir aşırılık / sahtekarlık değeri üretin.

kurallar

En soldaki kafa, en soldaki kuyruk

Kafa kuyruğundan büyük veya ona eşitse, kafa kuyruğu yer ve yeni kafa toplamı olur.

Eğer sonra kafa ile değiştirildiği .$sum \ge 10$$sum \mod 10$

$sum=0$ yoksayılamaz, ancak giriş numarası hiçbir zaman baştaki sıfırlara sahip olmaz.

Örnek:

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.

Herhangi bir noktada baş kuyruğu yiyemiyorsa, cevap Yanlış olacaktır.

number=6724
072
False (0<2)

Test Durumları:

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]

Bu kod golf yani en kısa kod kazanır.

JavaScript (ES6),  52  5150 bayt

@Tsh sayesinde 1 bayt kaydedildi

Bir dize olarak girdi alır. Bir Boolean değeri döndürür.

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

Çevrimiçi deneyin!

Yorumlananlar

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

Jöle , 11 bayt

Ṛṙ-µṖÄ%⁵:ḊẠ

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Kredi

• Kevin Cruijssen sayesinde -1 bayt

Mathematica, 62 bayt

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

İlk IntegerDigitsönce girdiyi hanelerin bir listesini almak için çağırır , ardından tekrar tekrar aşağıdaki kuralı uygular:

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

Kural, örüntü artık uyuşmayana kadar uygulanır; bu durumda ya sadece bir basamak kaldı (truthy) ya da baş kuyruktan daha az (sahte).

Arama yapmak yerine Length[__]==1birkaç bayttan tasarruf edebiliriz 0(__)=={0}, listedeki tüm elemanları çarparak 0 ve sonra listeyle karşılaştırabiliriz {0}.

Python 3 , 50 bayt

İlk satır Black Owl Kai'nin cevabından çalındı .

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

Çevrimiçi deneyin!

Çıkış, çıkış kodu üzerinden yapılır. Sahte girdiler için başarısız (1) ve gerçeğe uygun girdiler için bitirir (0).

Python 2 , 105 82 81 bayt

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

Çevrimiçi deneyin!

@ ØrjanJohansen'den büyük -23 için çok teşekkürler

@VedantKandoi (ve @ ØrjanJohansen) 'e bir başkası için teşekkürler

Brachylog , 23 bayt

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

Çevrimiçi deneyin!

Bu, Fatalize'in çözümüne göre 1 baytlık bir tasarruftur . Bu, yinelemeli yerine özyinelemeli bir yaklaşım kullanır

açıklama

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

Bir dize argüman alarak anonim tacit önek işlevi.

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

Çevrimiçi deneyin!

⍎¨ her karakteri değerlendirin (bu bize rakamların bir listesini verir)

{… } Aşağıdaki "dfn" yi uygulayın; ⍵argüman (rakamların listesi):

  ⌽⍵ argümanı tersine çevir

  ⊃ ilk elemanı seç (bu kuyruk)

  t← atamak tiçin ( t ail)

  ⍵< Orijinal rakamların her biri için, ondan daha az olup olmadığına bakın.

  ⊃ ilk doğru / yanlışı seç

 : Öyleyse:

  0 yanlış dönüş

 ⋄ sonra:

 3:: şu andan itibaren, bir dizin hatası (sınırların dışında) gerçekleşir:

  1 gerçek dönüş

  ¯1↓⍵ son rakamı bırak

  ⊢ verim (ayırır 1ve ¯1böylece tek bir dizi oluşturmazlar)

  t+@1 kuyruğu ilk haneye ekleyin (kafa)

  10| Mod-10

  ∇ recurse

Tek bir basamağa çarptığımızda, ¯1↓bu boş bir liste oluşturur ve @1ilk basamak olmadığından indeks hatasına neden olur ve bu da fonksiyonun doğru dönmesine neden olur.

Python 3 , 77 bayt

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

Çevrimiçi deneyin!

Özyinelemeli bir yaklaşımla eski çözümüm

Python 3 , 90 bayt

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

Çevrimiçi deneyin!

Bir dize olarak girdi alır.

Brachylog , 24 bayt

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

Çevrimiçi deneyin!

ⁱVarsayılan davranışını, bilinmeyen sayıda yinelemek için değiştirmeliyim (şu anda, varsayılan olarak 1 kez yinelenen, tamamen işe yaramaz). O zaman ihtiyacım olmaz[…];I[…]⁾ , 3 byte tasarruf

açıklama

Bu program bir çatalı içinde çirkin bir çatal içerir. Yerine sayıların basamak listelerinde çalışmaları için gerekli bazı sıhhi tesisat da vardır (çünkü baş ve kuyruk kaldırırsanız 76kalır biz 0hilafına hiçbir iş yapmaz, [7,6]biz ile bitirmek nerede []).

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

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

Giriş bir dize olarak alınır.

Çevrimiçi deneyin!

Düzenleme: -6 bayt @ Laikoni'nin|| ayrı korumalar yerine kullanma hilesini kullanarak . @Likonik sayesinde bir başka -4 bayt daha.

Perl 5 , 64 bayt

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

Çevrimiçi deneyin!

Python 2 , 75 67 bayt

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

Çevrimiçi deneyin!

Özyinelemeli lambda yaklaşımı. Bir dize olarak girdi alır. 8 baytı kurtardığı için Dennis'e çok teşekkürler!

Haskell , 69 64 bayt

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

Çevrimiçi deneyin! Örnek kullanım: f 2632verimTrue .

Düzenleme: -5 bayt çünkümod (h + mod n 10) 10 = mod (h + n) 10

Ruby, 139 bayt

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

Çevrimiçi deneyin!(işlevi işlediğinden, girişi işlemek için bazı ekstra kodlar vardır)

Ungolfed kod:

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

Retina 0.8.2 , 42 bayt

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

^#*;$

Çevrimiçi deneyin! Bağlantı, test durumlarını içerir. Açıklama:

\d
$*#;

Rakamları birliğe dönüştürün ve ayırıcıları yerleştirin.

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

Son hane birinciden büyük değilse, bunları bir araya getirin.

#{10}

Uygunsa, modulo 10'u azaltın.

}`

Son hane birinciden büyük olana kadar tekrar edin veya yalnızca bir hane kaldı.

^#*;$

Yalnızca bir basamak kaldı mı test edin.

05AB1E , 26 25 24 bayt

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

Muhtemelen biraz daha fazla golf oynayabilir .. Aşırı derecede uzun hissettiriyor, ama belki de zorluk daha önce düşündüğümden daha karmaşık kodlar açısından.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

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

Çevrimiçi deneyin!

İlk kez böyle bir şey deniyorum, bu yüzden yanlış bir şey formatladıysam lütfen bana bildirin. 5 bayt "std ::" 'yi silmek için isim alanını kullanma gibi kuralların% 100 olduğundan emin değilim.

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 bayt

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

Çevrimiçi deneyin

C (gcc) (string.h ile) , 110 108 bayt

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

Çevrimiçi deneyin!

Yine de PPCG için nispeten yeni, bu nedenle kütüphaneleri yeni bir dil olarak bağlamak için doğru sözdizimi bana yabancı. Ayrıca, fonksiyonun false / true için 0 veya 1 döndürdüğünü ve stdout ile sonuçlanan yazdırmanın stdio gerektirdiğini unutmayın. Eğer bilgiçlik yapıyorsak ve alıştırma çıktı gerektiriyorsa, dil stdio gerektirir. de .

Kavramsal olarak @ BenH'nin cevabına benzer, fakat C’de, oldukları yerde şeref duyuyorlar (PPCG’ye Hoşgeldiniz, btw), ancak özyinelemeyi kullanıyorlar. Ayrıca, kirli işaret, temiz koddan daha kısa olduğundan, dizi işaretçisi aritmetiği kullanır.

İşlev, özyinelemelidir, eğer ilk sayı en son yiyemezse çıkış koşulları ile birlikte veya uzunluk 1, sırasıyla yanlış veya doğru döndürülür. Bu değerler dizgenin başında ve sonunda C-String'e (karakter veren bir karakter) bir işaretçi bırakılarak ve bunlar üzerinde karşılaştırmalar yaparak bulunur. işaretçi aritmetik dizenin sonunu bulmak için yapılır. Son olarak, son karakter boş bir sonlandırıcıyla (0) değiştirilerek "silinir".

Modül aritmetiğinin bir bayt veya iki kısaltılması mümkün olabilir, ancak bu işaretçi manipülasyonundan sonra zaten bir duşa ihtiyacım var.

Burada Ungolfed Sürümü

Güncelleme: c == 1 yerine! C ile iki bayt kaydedildi. Bu aslında c == 0 'dır. Ek bir süre çalışacak ve kendisini silmeden önce gereksiz yere iki katına çıkacak, ancak iki bayttan tasarruf edecek. Yan etkisi boş veya sıfır uzunluklu dizeler sonsuz yinelemeye neden olmaz (egzersiz pozitif pozitif tamsayıların söylediği gibi boş dizgiler alamamamız gerekir).

Powershell, 89 bayt

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

Önemli! Senaryo kendini tekrarlı olarak çağırır. Yani betiği farklı kaydetg.ps1 dosyasını geçerli dizine dosya . Ayrıca komut dosyası yerine komut dosyası blok değişkeni de çağırabilirsiniz (aşağıdaki test komut dosyasına bakın). Bu çağrıların uzunluğu aynı.

Not 1: Betik, mantık operatörlerinin tembel bir değerlendirmesini kullanır -orve -and. Öyleyse "$args"-notmatch'(.)(.*)(.)', Truesağ alt ifadesi -ordeğerlendirilmez. Ayrıca eğer ($m=$Matches).1-ge$m.3olduğunu Falsedaha sonra sağ alt ifade -andde değerlendirilmez. Böylece sonsuz özyinelemeden kaçınırız.

Not 2: Normal ifade '(.)(.*)(.)', ifade nedeniyle başlangıç ​​ve bitiş çapalarını içermez(.*) varsayılan olarak açgözlü .

Test komut dosyası

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

Çıktı:

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 bayt

Özyineleme yok. Dosya adı bağımlılığı ve komut dosyası bloğu adı bağımlılığı yok.

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]

Bir Powershell, bir sağ işleneni örtülü olarak bir sol işlenenin türüne dönüştürür. Bu nedenle, $s-ge$s%10doğru işleneni hesaplar$s%10 olarak integerve bir olarak karşılaştırmak stringsol işlenen türüdür çünkü string. Ve 2+$s[0]+$sbir char dönüştürür $s[0]ve dizeyi $siçin integersol işlenen çünkü 2tam sayıdır.

$s|% S*g 1($s.Length-2)Bir olan kısayol için$s.Substring(1,($s.Length-2))

C # (Visual C # Etkileşimli Derleyici) , 69 bayt

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

Çevrimiçi deneyin!

Başarı veya başarısızlık bir istisna bulunmaması veya bulunmamasıyla . Giriş bir dize şeklindedir.

Daha az golf oynadım ...

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

Karakterler ve rakamlar arasında dönüştürme yapmak için ek birkaç bayt vardır, ancak genel olarak boyutu çok fazla etkilememiştir.

Perl 5 -pF , 53 bayt

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

Çevrimiçi deneyin!

Brachylog , 18 bayt

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

Çevrimiçi deneyin!

Sadece olmayan deterministik superscriptless sayesinde Fatalize çözümüyle kapalı üç bayt Alır ⁱşimdi mevcut, fakat belli belirsiz Jöle esinlenen şeyleri yaparak başka bir üç kaybeder z₁kullanarak kaçınmak için c, ghatta h. (Ayrıca farklı bir yeni özellik kullanmak için denemek ve başarısız ʰolmaktan ilham alındı: metapredik.)

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

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

Çevrimiçi deneyin!

Test Komut Dosyası

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 kod:

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
}