Dato un numero intero positivo, genera un valore di verità / falsità sul fatto che il numero possa mangiare da solo.

Regole

L'estrema sinistra è la testa, l'estrema destra è la coda

Se la testa è maggiore o uguale alla coda, la testa mangia la coda e la nuova testa diventa la loro somma.

Se $sum \ge 10$ poi la testa è sostituita dalla .$sum \mod 10$

$sum=0$ non può essere ignorato, tuttavia il numero di input non avrà mai zero iniziali.

Esempio:

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.

Se in qualsiasi momento la testa non riesce a mangiare la coda, la risposta sarà falsa.

number=6724
072
False (0<2)

Casi test:

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]

Questo è code-golf, quindi vince il codice più breve.

JavaScript (ES6),  52 51  50 byte

Salvato 1 byte grazie a @tsh

Accetta l'input come stringa. Restituisce un valore booleano.

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

Provalo online!

Commentate

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

Gelatina , 11 byte

Ṛṙ-µṖÄ%⁵:ḊẠ

Provalo online!

Come funziona

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

Provalo online!

Spiegazione:

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

Provalo online!

Crediti

• -1 byte grazie a Kevin Cruijssen

Mathematica, 62 byte

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

Prima chiama IntegerDigitsl'input per ottenere un elenco delle sue cifre, quindi applica ripetutamente la seguente regola:

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

La regola viene applicata fino a quando il modello non corrisponde più, nel qual caso è rimasta solo una cifra (verità) o la testa è inferiore alla coda (falsa).

Invece di chiamare Length[__]==1, possiamo salvare alcuni byte con 0(__)=={0}, moltiplicando tutti gli elementi nell'elenco 0 e confrontandoli con l'elenco {0}.

Python 3 , 50 byte

Prima riga rubata dalla risposta di Black Owl Kai .

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

Provalo online!

L'uscita è tramite il codice di uscita. Errore (1) per input falsi e finish (0) per input true.

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

Provalo online!

Mille grazie per il massiccio -23 di @ ØrjanJohansen

Grazie a @VedantKandoi (e @ ØrjanJohansen) per un altro -1

Brachylog , 23 byte

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

Provalo online!

Si tratta di un salvataggio di 1 byte sulla soluzione di Fatalize . Questo utilizza un approccio ricorsivo anziché un iterativo

Spiegazione

ẹ                          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) , ^{SBCS da} 33 byte

Funzione di prefisso tacito anonimo che accetta una stringa come argomento.

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

Provalo online!

⍎¨ valuta ogni personaggio (questo ci dà un elenco di cifre)

{... } applica il seguente "dfn" a quello; ⍵è l'argomento (elenco di cifre):

  ⌽⍵ invertire l'argomento

  ⊃ scegli il primo elemento (questa è la coda)

  t← assegnare t(per t ail)

  ⍵< per ciascuna delle cifre originali, vedere se è inferiore a quello

  ⊃ scegli il primo vero / falso

 : se è così:

  0 restituire false

 ⋄ poi:

 3:: se d'ora in poi, si verifica un errore di indice (fuori limite):

  1 ritorna vero

  ¯1↓⍵ rilascia l'ultima cifra

  ⊢ rendilo (separa 1e ¯1quindi non formano un singolo array)

  t+@1 aggiungi la coda alla prima cifra (la testa)

  10| mod-10

  ∇ ricorso

Una volta che colpiamo una singola cifra, ¯1↓creeremo un elenco vuoto e @1causeremo un errore di indice in quanto non vi è alcuna prima cifra, facendo sì che la funzione ritorni vera.

Python 3 , 77 byte

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

Provalo online!

E la mia vecchia soluzione con un approccio ricorsivo

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

Provalo online!

Accetta l'input come stringa.

Brachylog , 24 byte

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

Provalo online!

Dovrei cambiare ⁱil comportamento predefinito in modo che iteri un numero sconosciuto di volte (attualmente, iterera 1 volta di default che è completamente inutile). Quindi non avrei bisogno di […];I[…]⁾, risparmiando 3 byte

Spiegazione

Questo programma contiene una brutta forchetta dentro una forchetta. Ci sono anche alcuni impianti idraulici necessari per lavorare su elenchi di cifre anziché numeri (perché se rimuoviamo la testa e la coda di 76cui siamo rimasti 0, il che non funziona in contrasto con [7,6]dove finiamo []).

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

L'input è preso come una stringa.

Provalo online!

Modifica: -6 byte usando il trucco di @ Laikoni di usare ||invece di protezioni separate. Altri -4 byte grazie a @Laikoni.

Perl 5 , 64 byte

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

Provalo online!

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

Provalo online!

Approccio lambda ricorsivo. Accetta l'input come stringa. Mille grazie a Dennis per aver salvato 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

Provalo online!Esempio di utilizzo: f 2632rese True.

Modifica: -5 byte perchémod (h + mod n 10) 10 = mod (h + n) 10

Rubino, 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}

Provalo online!(ha del codice aggiuntivo per elaborare l'input, poiché è una funzione)

Codice non golfato:

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

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

^#*;$

Provalo online! Il link include casi di test. Spiegazione:

\d
$*#;

Converti le cifre in unario e inserisci separatori.

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

Se l'ultima cifra non è maggiore della prima, aggiungile insieme.

#{10}

Ridurre il modulo 10 se appropriato.

}`

Ripetere l'operazione fino a quando l'ultima cifra è maggiore della prima o rimane solo una cifra.

^#*;$

Verifica se è rimasta solo una cifra.

05AB1E , 26 25 24 byte

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

Probabilmente si può giocare a golf un po 'di più .. Sembra troppo lungo, ma forse la sfida è in termini di codice più complesso di quanto pensassi prima.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Provalo online!

La prima volta che sto provando qualcosa del genere, quindi se ho formattato qualcosa di sbagliato per favore fatemelo sapere. Non sono sicuro al 100% delle regole per cose come l'uso dello spazio dei nomi per eliminare i 5 byte "std ::", quindi l'ho lasciato.

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

Provalo online

C (gcc) (con stringa.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);}

Provalo online!

Ancora relativamente nuovo in PPCG, quindi la sintassi corretta per il collegamento di librerie come nuova lingua mi è estranea. Si noti inoltre che la funzione restituisce 0 o 1 per false / true e la stampa che risulta su stdout richiede stdio. Se siamo pedanti e l'esercizio richiede risultati, la lingua richiede stdio .

Concettualmente simile alla risposta di @ BenH, ma in C, quindi complimenti dove sono dovuti (Benvenuti in PPCG, a proposito), ma usando la ricorsione. Utilizza anche l'aritmetica del puntatore di array, poiché il codice sporco è più corto del codice pulito.

La funzione è ricorsiva alla coda, con condizioni di uscita se il primo numero non può mangiare l'ultimo o la lunghezza è 1, restituendo rispettivamente falso o vero. Questi valori si trovano dereferenziando un puntatore alla C-String (che dà un carattere) all'inizio e alla fine della stringa e facendo i confronti su di essi. l'aritmetica del puntatore viene eseguita per trovare la fine della stringa. infine, l'ultimo carattere viene "cancellato" sostituendolo con un terminatore null (0).

È possibile che l'aritmetica del modulo possa essere accorciata di uno o due byte, ma ho già bisogno di una doccia dopo quella manipolazione del puntatore.

Versione Ungolfed qui

Aggiornamento: salvato due byte sostituendo c == 1 con! C. Questo è essenzialmente c == 0. Verrà eseguito un ulteriore tempo e inutilmente raddoppierà se stesso prima di eliminare se stesso, ma salva due byte. Un effetto collaterale è che le stringhe nulle o nulle non causeranno una ricorsione infinita (anche se non dovremmo ottenere le stringhe nulle poiché l'esercizio dice numeri interi positivi).

Powershell, 89 byte

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

Importante! Lo script si chiama ricorsivamente. Quindi salva lo script comeg.ps1 file nella directory corrente. Inoltre è possibile chiamare una variabile di blocco di script anziché il file di script (vedere lo script di prova di seguito). Quella chiamata ha la stessa lunghezza.

Nota 1: lo script utilizza una valutazione pigra degli operatori logici -ore -and. Se "$args"-notmatch'(.)(.*)(.)'è Trueallora la giusta sottoespressione di -ornon viene valutata. Anche se ($m=$Matches).1-ge$m.3è Falsepoi il diritto di sottoespressione -andnon viene analizzato anche. Quindi evitiamo la ricorsione infinita.

Nota 2: L'espressione regolare '(.)(.*)(.)'non contiene ancore di inizio e fine perché l'espressione (.*)è avida per impostazione predefinita.

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

Produzione:

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

Nessuna ricorsione. Nessuna dipendenza dal nome del file e nessuna dipendenza dal nome del blocco di script.

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]

Un Powershell converte implicitamente un operando di destra in un tipo di operando di sinistra. Pertanto, $s-ge$s%10calcola l'operando di destra $s%10come integere lo confronta come un stringtipo perché dell'operando di sinistra è string. E 2+$s[0]+$sconverte un carattere $s[0]e una stringa $sin integerperché l'operando di sinistra 2è intero.

$s|% S*g 1($s.Length-2)è una scorciatoia per$s.Substring(1,($s.Length-2))

C # (compilatore interattivo 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;}

Provalo online!

L'esito positivo o negativo è determinato dalla presenza o dall'assenza di un'eccezione . L'input ha la forma di una stringa.

Meno golf ...

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

Ci sono un paio di byte extra per gestire la conversione tra caratteri e cifre, ma nel complesso ciò non ha influito troppo sulle dimensioni.

Perl 5 -pF , 53 byte

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

Provalo online!

Brachylog , 18 byte

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

Provalo online!

Prende tre byte fuori la soluzione di Fatalize proprio in virtù della superscriptless non deterministica ⁱesistente ora, ma perde altri tre facendo le cose vagamente Gelatina di ispirazione con z₁Per evitare di utilizzare c, go addirittura h. (Ispirato anche dal tentativo e dall'impossibilità di utilizzare una nuova funzionalità diversa: il ʰmetapredicato.)

                 Ȯ    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

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

Codice non golfato:

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
}