Nombre qui peut se manger

30

Étant donné un entier positif, affichez une valeur de vérité / fausse indiquant si le nombre peut se manger lui-même.

Règles

Le plus à gauche est la tête, le plus à droite est la queue

Si la tête est supérieure ou égale à la queue, la tête mange la queue et la nouvelle tête devient leur somme.

Si la tête est remplacée par .sum10summod10

sum=0 ne peut pas être ignoré, mais le numéro d'entrée n'aura jamais de zéros en tête.

Exemple:

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.

Si à un moment donné la tête ne peut pas manger la queue, la réponse sera Faux.

number=6724
072
False (0<2)

Cas de 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]

C'est le code-golf donc le code le plus court gagne.

Vedant Kandoi
la source
Pouvons-nous prendre l'entrée comme une chaîne?
lirtosiast
@lirtosiast, oui, mais pas une liste de chiffres.
Vedant Kandoi
14
On pourrait les appeler des nombres autocannibalistiques .
Arnauld
6
Quelle est la raison pour laquelle nous ne pouvons pas prendre comme liste de chiffres? Ce problème les traite déjà comme s'il s'agissait de listes de chiffres. Les forcer à être des nombres signifie que vous n'avez qu'à épingler du code supplémentaire pour les convertir en liste.
Wheat Wizard
1
Peut-on renvoyer deux valeurs distinctes cohérentes au lieu de vérité / fausse?
Olivier Grégoire

Réponses:

7

JavaScript (ES6),  52 51  50 octets

1 octet enregistré grâce à @tsh

Prend l'entrée sous forme de chaîne. Renvoie une valeur booléenne.

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

Essayez-le en ligne!

Commenté

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
Arnauld
la source
6

Gelée , 11 octets

Ṛṙ-µṖÄ%⁵:ḊẠ

Essayez-le en ligne!

Comment ça marche

Ṛṙ-µṖÄ%⁵:ḊẠ  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.
Dennis
la source
6

Perl 6 , 63 62 octets

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

Essayez-le en ligne!

Explication:

{                                                            } # 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?
Jo King
la source
5

Java (JDK) , 83 octets

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

Essayez-le en ligne!

Crédits

Olivier Grégoire
la source
Compte tenu de la longueur des réponses Python, j'ai l'impression d'avoir raté quelque chose ... bien que les cas de test soient corrects.
Olivier Grégoire
Je ne pense pas que vous ayez raté quelque chose. Les réponses Python prennent à la fois l'entrée comme chaîne et utilisent l'indexation, et vous prenez l'entrée comme entier et utilisez /10et %10dans une boucle. Si bien fait de battre les réponses Python; +1 de moi. :)
Kevin Cruijssen
1
Vous pouvez jouer au golf un octet en changeant r+=vers r=et ?1:0vers ?1:r.
Kevin Cruijssen
@KevinCruijssen En effet ... les réponses Python sont sous-optimales: les golfs dans les commentaires sont plus courts que cette réponse. Merci aussi pour l'octet enregistré! ;-)
Olivier Grégoire
01r=1r&=h<n%10?0:r;return r;
4

Mathematica, 62 octets

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

Appelle d'abord IntegerDigitsl'entrée pour obtenir une liste de ses chiffres, puis applique à plusieurs reprises la règle suivante:

{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 règle est appliquée jusqu'à ce que le motif ne corresponde plus, auquel cas il ne reste qu'un seul chiffre (véridique) ou la tête est inférieure à la queue (fausse).

Au lieu d'appeler Length[__]==1, nous pouvons enregistrer quelques octets avec 0(__)=={0}, en multipliant tous les éléments de la liste par 0 puis en comparant avec la liste {0}.

Poignée de porte
la source
1
Au cas où vous ne le sauriez pas, TIO a maintenant Mathematica. Essayez-le en ligne!
Dennis
4

Python 3 , 50 octets

Première ligne volée à la réponse de Black Owl Kai .

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

Essayez-le en ligne!

La sortie se fait via un code de sortie. Échoue (1) pour les entrées fausses et termine (0) pour les entrées véridiques.

ovs
la source
Pouvez-vous expliquer pourquoi p%10<k>qne lance pas une erreur de nom si p%10 >= k?
Black Owl Kai
1
Les comparaisons chaînées @BlackOwlKai sont évaluées paresseusement en Python. Cela signifie que dès qu'une première fausse comparaison apparaît, la chaîne ne sera plus évaluée. Dans ce cas, p%10<k>qfait la même chose que p%10<k and k>q.
ovs
4

Python 2 , 105 82 81 octets

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

Essayez-le en ligne!

Merci beaucoup pour un énorme -23 de @ ØrjanJohansen

Merci à @VedantKandoi (et @ ØrjanJohansen) pour encore -1

ElPedro
la source
1
Vous pouvez l'utiliser foravec une tranche inversée, et faire le %10seul lors des tests: essayez-le en ligne!
Ørjan Johansen
1
Inversez la condition if-else, if i[0]<i[-1]:x=0puis else:..... @ ØrjanJohansen, dans votre réponse aussi.
Vedant Kandoi
@ ØrjanJohansen - Merci. C'est bien cool.
ElPedro
Salut @VedantKandoi. Sonne bien mais ne savez pas exactement ce que vous voulez dire. Vous m'avez battu sur celui-là. Pouvez-vous ajouter un TIO s'il vous plaît? Lorsque j'essaie, cela fonctionne pour tous les Truecas, mais pas pour tous False.
ElPedro
1
Je pense que @VedantKandoi signifie cela .
Ørjan Johansen
4

Brachylog , 23 octets

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

Essayez-le en ligne!

Il s'agit d'une sauvegarde de 1 octet sur la solution de Fatalize . Cela utilise une approche récursive au lieu d'une approche itérative

Explication

ẹ                          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
Kroppeb
la source
3

APL (Dyalog Unicode) , 33 octets SBCS

Fonction de préfixe tacite anonyme prenant une chaîne en argument.

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

Essayez-le en ligne!

⍎¨ évaluer chaque caractère (cela nous donne une liste de chiffres)

{} Appliquer le "dfn" suivant à cela; est l'argument (liste des chiffres):

  ⌽⍵ inverser l'argument

   choisissez le premier élément (c'est la queue)

  t← affecter à t(pour t tous)

  ⍵< pour chacun des chiffres d'origine, voyez s'il est inférieur à celui

   choisir le premier vrai / faux

: si c'est le cas:

  0 retourner faux

 puis:

3:: si désormais, une erreur d'index (hors limites) se produit:

  1 retourner vrai

  ¯1↓⍵ laisser tomber le dernier chiffre

   produire cela (sépare 1et ¯1donc ils ne formeront pas un seul tableau)

  t+@1 ajouter la queue au premier chiffre (la tête)

  10| mod-10

   recurse

Une fois que nous avons atteint un seul chiffre, ¯1↓cela en fera une liste vide et @1provoquera une erreur d'index car il n'y a pas de premier chiffre, ce qui provoquera le retour de la fonction à true.

Adam
la source
3

Python 3 , 77 octets

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

Essayez-le en ligne!


Et mon ancienne solution avec une approche récursive

Python 3 , 90 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne.

Chouette noire Kai
la source
3

Brachylog , 24 octets

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

Essayez-le en ligne!

Je devrais changer le comportement par défaut de sorte qu'il répète un nombre inconnu de fois (actuellement, il réitère 1 fois par défaut, ce qui est complètement inutile). Je n'aurais alors pas besoin du[…];I[…]⁾ , économisant 3 octets

Explication

Ce programme contient une fourchette laide à l'intérieur d'une fourchette. Il y a aussi de la plomberie nécessaire pour travailler sur des listes de chiffres au lieu de chiffres (parce que si nous retirons la tête et la queue de 76nous nous retrouvons avec 0, ce qui ne fonctionne pas contrairement à l' [7,6]endroit où nous nous retrouvons []).

ẹ                          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
Fatalize
la source
En utilisant la récursivité au lieu de l'itération et en remplaçant le c-fork à utiliser à la ,place, je pourrais supprimer 1 octet Essayez-le en ligne!
Kroppeb
@Kroppeb Vraiment cool. Je pense que vous devriez poster votre propre réponse, car elle est très différente de la mienne!
Fatalize
3

Haskell, 70 64 60 octets

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

L'entrée est considérée comme une chaîne.

Essayez-le en ligne!

Edit: -6 octets en utilisant l'astuce de @ Laikoni d'utiliser ||au lieu de gardes séparés. Encore -4 octets grâce à @Laikoni.

nimi
la source
3
read[l b]peut être juste read bparce que vous ne regardez de toute façon que le dernier chiffre. Enregistre 4 octets de plus en étant également en lignelast : essayez-le en ligne!
Laikoni
2

Python 2 , 75 67 octets

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

Essayez-le en ligne!

Approche lambda récursive. Prend l'entrée sous forme de chaîne. Un grand merci à Dennis pour avoir économisé 8 octets!

ArBo
la source
2

Haskell , 69 64 octets

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

Essayez-le en ligne! Exemple d'utilisation: f 2632rendements True.

Modifier: -5 octets carmod (h + mod n 10) 10 = mod (h + n) 10

Laikoni
la source
bon usage de ||, ce qui m'a également permis de raccourcir ma réponse. Merci!
nimi
2

Rubis, 139 octets

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

Essayez-le en ligne! (a du code supplémentaire pour traiter l'entrée, car c'est une fonction)

Code non golfé:

->(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
CG One Handed
la source
1

Retina 0.8.2 , 42 octets

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

^#*;$

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

\d
$*#;

Convertissez les chiffres en unaires et insérez des séparateurs.

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

Si le dernier chiffre n'est pas supérieur au premier, ajoutez-les ensemble.

#{10}

Réduisez le modulo 10 si nécessaire.

}`

Répétez jusqu'à ce que le dernier chiffre soit supérieur au premier ou qu'il ne reste qu'un seul chiffre.

^#*;$

Testez s'il ne reste qu'un seul chiffre.

Neil
la source
1

05AB1E , 26 25 24 octets

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

Peut probablement être joué un peu plus .. Cela semble trop long, mais peut-être que le défi est en termes de code plus complexe que je ne le pensais auparavant.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

[                 # 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
Kevin Cruijssen
la source
1

C ++ (gcc) , 144 octets

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

Essayez-le en ligne!

La première fois que j'essaie quelque chose comme ça, donc si j'ai formaté quelque chose de mal, faites le moi savoir. Je ne suis pas sûr à 100% des règles pour des choses comme utiliser l'espace de noms pour éliminer les 5 octets "std ::" alors je l'ai laissé.

Non golfé:

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
}
Ben H
la source
1
En théorie, vous avez également besoin de #includedéclarations. Cependant, je proposerais la programmation dans la sous-dialecte std lib facilities de C ++ avec #include "std_lib_facilities.h"prepended, qui fait aussi a using namespace std;. Cet en-tête a été écrit par l'auteur du chemin du langage (la dernière version est 2010) pour les étudiants débutants en C ++.
Yakk
@Yakk Sauf si vous créez et publiez un interprète qui le fait pour vous, vous devez toujours compter l'inclusion de std_lib_facilities.h.
Dennis
@BenH Bienvenue chez PPCG! Vous avez besoin du nombre de tous les éléments nécessaires pour compiler votre fonction. La méthode la plus courte que je connaisse est #import<string>. Essayez-le en ligne!
Dennis
@Dennis #!/usr/bin/shnouvelle ligne gcc -include "std_lib_facilities.h" $@- si je trouve un cours de C ++ qui prévoit que script shell, serait - ce nombre?
Yakk
@Yakk Ne connaissait pas cet interrupteur. Contrairement aux instructions #include, les arguments de ligne de commande sont gratuits car ils sont essentiellement un nouveau langage . En C ++ (gcc)-include iostream , c'est en effet 144 octets.
Dennis
1

C #, 114 octets

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

Essayez-le en ligne

gwell
la source
1

C (gcc) (avec string.h) , 110 108 octets

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

Essayez-le en ligne!

Encore relativement nouveau pour PPCG, la syntaxe correcte pour lier les bibliothèques en tant que nouvelle langue m'est étrangère. Notez également que la fonction renvoie 0 ou 1 pour false / true, et l'impression qui en résulte sur stdout nécessite stdio. Si nous sommes pédant et que l'exercice nécessite une sortie, le langage nécessite également stdio .

Conceptuellement similaire à la réponse de @ BenH, mais en C, donc bravo où ils sont dus (Bienvenue dans PPCG, btw), mais en utilisant la récursivité. Il utilise également l'arithmétique du pointeur de tableau, car le code sale est plus court que le code propre.

La fonction est récursive de queue, avec des conditions de sortie si le premier nombre ne peut pas manger le dernier ou si la longueur est 1, retournant respectivement faux ou vrai. Ces valeurs sont trouvées en déréférençant un pointeur sur la chaîne C (qui donne un caractère) au début et à la fin de la chaîne, et en effectuant les comparaisons sur elles. l'arithmétique du pointeur est effectuée pour trouver la fin de la chaîne. enfin, le dernier caractère est "effacé" en le remplaçant par un terminateur nul (0).

Il est possible que l'arithmétique du module soit raccourcie d'un octet ou deux, mais j'ai déjà besoin d'une douche après cette manipulation du pointeur.

Version non golfée ici

Mise à jour: enregistré deux octets en remplaçant c == 1 par! C. Il s'agit essentiellement de c == 0. Il s'exécutera un temps supplémentaire et se doublera inutilement avant de se supprimer, mais économisera deux octets. Un effet secondaire est que les chaînes de longueur nulle ou nulle ne causeront pas de récursion infinie (bien que nous ne devrions pas obtenir de chaînes nulles car l'exercice dit des entiers positifs).

Andrew Baumher
la source
Vous n'avez pas besoin de lier les bibliothèques dans le cas de gcc- bien que des avertissements soient générés, ils gccseront heureux de compiler votre code sans #includes. Vous pouvez également enregistrer 4 octets avec -DR=return. Enfin, dans votre code de test, les \0s ne sont pas nécessaires, car la chaîne les inclut déjà implicitement.
1
De plus, vous pouvez revenir d'une fonction en affectant à la première variable: b=case1?res1:case2?res2:res_else; est la même queif(case1)return res1;if(case2)return res2;return res_else;
Encore plus loin, vous pouvez perdre quelques octets supplémentaires en n'utilisant pas c : vous pouvez déterminer si la chaîne est de longueur nulle head-tail.
Je ne savais pas que vous pouviez utiliser des opérateurs ternaires (conditionnels) en C. Cela a-t-il toujours été le cas? Quoi qu'il en soit, bon à savoir; Je les utiliserai à l'avenir. Vive
Andrew Baumher
1

Powershell, 89 octets

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

Important! Le script s'appelle récursivement. Enregistrez donc le script en tant que g.ps1fichier dans le répertoire courant. Vous pouvez également appeler une variable de bloc de script à la place d'un fichier de script (voir le script de test ci-dessous). Ces appels ont la même durée.

Remarque 1: le script utilise une évaluation paresseuse des opérateurs logiques -oret -and. Si "$args"-notmatch'(.)(.*)(.)'est Truealors la bonne sous-expression de -orn'est pas évaluée. Aussi si ($m=$Matches).1-ge$m.3estFalse alors la bonne sous-expression de -andn'est pas évaluée non plus. Nous évitons donc la récursion infinie.

Remarque 2: L'expression régulière '(.)(.*)(.)'ne contient pas d'ancres de début et de fin car l'expression(.*) est gourmande par défaut.

Script de test

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

Sortie:

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 octets

Pas de récursivité. Aucune dépendance de nom de fichier et aucune dépendance de nom de bloc de 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 convertit implicitement un opérande droit en un type d'opérande gauche. Par conséquent, $s-ge$s%10calcule l'opérande droit $s%10comme integeret le compare comme un stringcar le type de l'opérande gauche eststring . Et 2+$s[0]+$sconvertit un $s[0]caractère et une chaîne $sen integercar opérande gauche2 est un entier.

$s|% S*g 1($s.Length-2)est un raccourci vers$s.Substring(1,($s.Length-2))

mazzy
la source
1

C # (compilateur interactif Visual C #) , 69 octets

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

Essayez-le en ligne!

Le succès ou l'échec est déterminé par présence ou l'absence d'une exception . L'entrée se présente sous la forme d'une chaîne.

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

Il y a quelques octets supplémentaires pour gérer la conversion entre les caractères et les chiffres, mais dans l'ensemble, cela n'a pas trop affecté la taille.

dana
la source
1

Brachylog , 18 octets

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

Essayez-le en ligne!

Prend trois octets au large de la solution de Fatalize juste en vertu de superscriptless non-déterministe existant maintenant, mais perd trois autres en faisant vaguement les choses Jelly inspirés avec z₁d'éviter d' utiliser c, gou même h. (Également inspiré en essayant, et en échouant, d'utiliser une nouvelle fonctionnalité différente: le ʰmétaprédicat.)

                 Ȯ    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.
Chaîne indépendante
la source
0

PowerShell , 94 91 octets

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

Essayez-le en ligne!


Script de test

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

Code non golfé:

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
}
KGlasier
la source
1
Vous ne devriez pas avoir besoin de vérifier $n[0]votre forrelevé - il suffit de vérifier $n.
AdmBorkBork
Vous pourriez utiliser à la -6place -96car il suffit de calculer% 10
mazzy
vous pouvez supprimer return et enregistrer 7 octets
mazzy
et je pense que vous devriez inclure une déclaration de paramètre au nombre d'octets. soit param($n)ou function f($n).
mazzy
1
@mazzy L'affiche a déclaré dans les commentaires que vous étiez autorisé à utiliser des chaînes, vous n'étiez tout simplement pas autorisé à donner l'entrée sous forme de liste de nombres / chaînes. J'ai interprété cela comme ["1","2","3"]une entrée non valide mais l' "123"est. si @VedantKandoi a un problème avec ça, je peux certainement le changer!
KGlasier