Zahl, die sich selbst essen kann


30

Geben Sie bei einer positiven Ganzzahl einen Wahrheits- / Falschwert aus, um festzustellen, ob sich die Zahl selbst fressen kann.

Regeln

Ganz links ist der Kopf, ganz rechts der Schwanz

Wenn der Kopf größer oder gleich dem Schwanz ist, frisst der Kopf den Schwanz und der neue Kopf wird zu ihrer Summe.

Wenn ist, wird der Kopf durch .sum10summod10

sum=0 kann nicht ignoriert werden, die eingegebene Nummer wird jedoch niemals führende Nullen haben.

Beispiel:

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.

Wenn der Kopf zu irgendeinem Zeitpunkt den Schwanz nicht fressen kann, lautet die Antwort "Falsch".

number=6724
072
False (0<2)

Testfälle:

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]

Das ist Code-Golf, also gewinnt der kürzeste Code.


Können wir Eingaben als String annehmen?
Lirtosiast

@lirtosiast, ja, aber keine Ziffernliste.
Vedant Kandoi

14
Sie könnten als autokannibalistische Zahlen bezeichnet werden .
Arnauld

6
Was ist der Grund, warum wir keine Ziffernliste erstellen können? Dieses Problem behandelt sie bereits als Ziffernlisten. Das Erzwingen, dass sie Zahlen sind, bedeutet, dass Sie nur zusätzlichen Code anheften müssen, um sie in eine Liste zu konvertieren.
Wheat Wizard

1
Können zwei konsistente unterschiedliche Werte anstelle von Wahr / Falsch zurückgegeben werden?
Olivier Grégoire

Antworten:


7

JavaScript (ES6),  52 51  50 Byte

1 Byte dank @tsh gespeichert

Übernimmt die Eingabe als Zeichenfolge. Gibt einen Booleschen Wert zurück.

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

Probieren Sie es online!

Kommentiert

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


6

Jelly , 11 Bytes

Ṛṙ-µṖÄ%⁵:ḊẠ

Probieren Sie es online!

Wie es funktioniert

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

6

Perl 6 , 63 62 Bytes

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

Probieren Sie es online!

Erläuterung:

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

5

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

Probieren Sie es online!

Credits


Angesichts der Länge der Python-Antworten habe ich das Gefühl, etwas verpasst zu haben ... obwohl die Testfälle in Ordnung sind.
Olivier Grégoire

Ich glaube nicht, dass Sie etwas verpasst haben. Die Python-Antworten nehmen beide die Eingabe als Zeichenfolge und verwenden die Indizierung, und Sie nehmen die Eingabe als Ganzzahl und verwenden /10und %10in einer Schleife. Also gut gemacht, die Python-Antworten geschlagen; +1 von mir. :)
Kevin Cruijssen

1
Sie können ein Byte spielen, das r+=nach r=und ?1:0nach wechselt ?1:r.
Kevin Cruijssen

@ KevinCruijssen In der Tat ... die Python-Antworten sind suboptimal: Golfplätze in Kommentaren sind kürzer als diese Antwort. Danke auch für das gespeicherte Byte! ;-)
Olivier Grégoire

Sie können oder indem Sie mit beginnen und dabei 1 Byte speichern. 101r=1r&=h<n%10?0:r;return r;
Arnauld

4

Mathematica, 62 Bytes

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

Ruft zuerst IntegerDigitsden Eingang auf, um eine Liste seiner Ziffern zu erhalten, und wendet dann wiederholt die folgende Regel an:

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

Die Regel wird angewendet, bis das Muster nicht mehr übereinstimmt. In diesem Fall ist entweder nur noch eine Ziffer übrig (wahr) oder der Kopf ist kleiner als der Schwanz (falsch).

Anstatt aufzurufen Length[__]==1, können wir ein paar Bytes mit speichern 0(__)=={0}, alle Elemente in der Liste mit multiplizieren 0 und dann mit der Liste vergleichen {0}.


1
Falls Sie es nicht wussten, hat TIO jetzt Mathematica. Probieren Sie es online!
Dennis

4

Python 3 , 50 Bytes

Erste Zeile aus der Antwort von Black Owl Kai gestohlen .

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

Probieren Sie es online!

Die Ausgabe erfolgt über den Exit-Code. Fails (1) für falsche Eingaben und Ends (0) für wahrheitsgemäße Eingaben.


Können Sie erklären, warum p%10<k>qein NameError nicht ausgelöst wird, wenn p%10 >= k?
Black Owl Kai

1
@BlackOwlKai verkettete Vergleiche werden in Python träge ausgewertet. Dies bedeutet, sobald ein erster falscher Vergleich auftritt, wird die Kette nicht mehr ausgewertet. In diesem Fall p%10<k>qverhält es sich wie p%10<k and k>q.
Ovs

4

Python 2 , 105 82 81 Bytes

i,x=map(int,input()),1
for y in i[:0:-1]:
 if i[0]%10<y:x=0
 else:i[0]+=y
print x

Probieren Sie es online!

Vielen Dank für eine massive -23 von @ ØrjanJohansen

Vielen Dank an @VedantKandoi (und @ ØrjanJohansen) für einen weiteren -1


1
Sie können es formit einem umgekehrten Slice verwenden und auch %10nur beim Testen ausführen
Ørjan Johansen

1
Tauschen Sie die if-else-Bedingung aus if i[0]<i[-1]:x=0und dann else:..... @ ØrjanJohansen, auch in deiner Antwort.
Vedant Kandoi

@ ØrjanJohansen - Danke. Das ist gut cool.
ElPedro

Hey @VedantKandoi. Hört sich gut an, ist sich aber nicht sicher, was Sie meinen. Du hast mich darauf geschlagen. Können Sie bitte einen TIO hinzufügen? Wenn ich es versuche, funktioniert es für alle TrueFälle, aber nicht für alle False.
ElPedro

1
Ich denke, @VedantKandoi bedeutet das .
Ørjan Johansen

4

Brachylog , 23 Bytes

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

Probieren Sie es online!

Dies ist eine 1-Byte- Ersparnis gegenüber der Fatalize-Lösung . Dies verwendet einen rekursiven Ansatz anstelle eines iterativen

Erläuterung

ẹ                          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

3

APL (Dyalog Unicode) , 33 Byte SBCS

Anonyme implizite Präfixfunktion, die eine Zeichenfolge als Argument verwendet.

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

Probieren Sie es online!

⍎¨ bewerte jedes Zeichen (dies gibt uns eine Liste von Ziffern)

{} Wende das folgende "dfn" darauf an; ist das Argument (Ziffernliste):

  ⌽⍵ kehren Sie das Argument um

   wähle das erste Element (das ist der Schwanz)

  t← zuweisen t(für t ail)

  ⍵< Prüfen Sie für jede der Originalziffern, ob sie kleiner ist

   wähle das erste Richtig / Falsch

: wenn ja:

  0 falsch zurückgeben

 dann:

3:: Wenn von nun an ein Indexfehler (außerhalb der Grenzen) auftritt:

  1 return true

  ¯1↓⍵ Lass die letzte Ziffer fallen

   ergeben, dass (trennt 1und ¯1so werden sie nicht ein einziges Array bilden)

  t+@1 füge den Schwanz der ersten Ziffer (dem Kopf) hinzu

  10| mod-10

   rekursieren

Sobald wir eine einzelne Ziffer getroffen haben, ¯1↓wird dies zu einer leeren Liste und @1verursacht einen Indexfehler, da es keine erste Ziffer gibt, wodurch die Funktion true zurückgibt.



3

Brachylog , 24 Bytes

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

Probieren Sie es online!

Ich sollte das Standardverhalten so ändern , dass es eine unbekannte Anzahl von Iterationen durchläuft (derzeit wird standardmäßig 1 Iteration durchgeführt, was völlig nutzlos ist). Ich würde das dann nicht brauchen[…];I[…]⁾ , 3 Bytes einsparen

Erläuterung

Dieses Programm enthält eine hässliche Gabel in einer Gabel. Es gibt auch einige Klempnerarbeiten, die für die Bearbeitung von Ziffernlisten anstelle von Zahlen erforderlich sind (denn wenn wir Kopf und Schwanz entfernen , bleibt 76uns etwas übrig 0, was nicht im Gegensatz zu dem steht, [7,6]wo wir landen []).

ẹ                          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

Verwenden von Rekursion anstelle von Iteration und Ersetzen der zu verwendenden C-Fork ,Ich könnte 1 Byte entfernen. Probieren Sie es online aus!
Kroppeb

@Kroppeb Wirklich cool. Ich denke, du solltest deine eigene Antwort posten, weil sie sich erheblich von meiner unterscheidet!
Fatalize

3

Haskell, 70 64 60 Bytes

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

Die Eingabe wird als Zeichenfolge verwendet.

Probieren Sie es online!

Bearbeiten: -6 Bytes mit dem @ Laikoni-Trick , ||anstelle separater Wachen zu verwenden. Weitere -4 Bytes dank @Laikoni.


3
read[l b]kann nur read bdaran liegen, dass du sowieso nur die letzte ziffer ansiehst. Spart 4 weitere Bytes, indem Sie auch in-lining last: Probieren Sie es online!
Laikoni


2

Python 2 , 75 67 Bytes

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

Probieren Sie es online!

Rekursiver Lambda-Ansatz. Übernimmt die Eingabe als Zeichenfolge. Vielen Dank an Dennis für das Speichern von 8 Bytes!


2

Haskell , 69 64 Bytes

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

Probieren Sie es online! Anwendungsbeispiel: f 2632Erträge True.

Edit: -5 Bytes weilmod (h + mod n 10) 10 = mod (h + n) 10


netter Gebrauch von ||, der mir half, meine Antwort auch zu verkürzen. Vielen Dank!
nimi

2

Rubin, 139 Bytes

->(a){a.length==1?(p true;exit):1;(a[0].to_i>=a[-1].to_i)?(a[0]=(a[-1].to_i+a[0].to_i).divmod(10)[1].to_s;a=a[0..-2];p b[a]):p(false);exit}

Probieren Sie es online!(Verfügt über zusätzlichen Code zum Verarbeiten der Eingabe, da es sich um eine Funktion handelt.)

Ungolfed-Code:

->(a) do
    if a.length == 1
        p true
        exit
    if a[0].to_i >= a[-1].to_i
        a[0] = (a[-1].to_i + a[0].to_i).divmod(10)[1].to_s
        a = a[0..-2]
        p b[a]
    else
        p false
        exit
    end
end

1

Retina 0,8,2 , 42 Bytes

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

^#*;$

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

\d
$*#;

Konvertieren Sie die Ziffern in unäre Zeichen und fügen Sie Trennzeichen ein.

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

Wenn die letzte Ziffer nicht größer als die erste ist, addieren Sie sie.

#{10}

Modulo 10 ggf. reduzieren.

}`

Wiederholen, bis die letzte Ziffer größer als die erste ist oder nur noch eine Ziffer übrig ist.

^#*;$

Prüfen Sie, ob nur noch eine Ziffer übrig ist.


1

05AB1E , 26 25 24 Bytes

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

Kann wahrscheinlich ein bisschen mehr golfen werden. Es fühlt sich zu lang an, aber vielleicht ist die Herausforderung in Bezug auf Code komplexer als ich vorher gedacht habe.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

1

C ++ (gcc) , 144 Bytes

bool f(std::string b){int c=b.length();while(c>1){if(b[0]<b[c-1])return 0;else{b[0]=(b[0]-48+b[c-1]-48)%10+48;b=b.substr(0,c-1);--c;}}return 1;}

Probieren Sie es online!

Wenn ich zum ersten Mal so etwas versuche, lass es mich wissen, wenn ich etwas falsch formatiert habe. Ich bin nicht 100% sicher, welche Regeln für Dinge wie die Verwendung von Namespace zur Eliminierung der 5 Bytes "std ::" gelten, also habe ich es in gelassen.

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
}

1
Theoretisch braucht man auch #includeAussagen. Ich würde jedoch vorschlagen, im Subdialekt " std lib facilities" von C ++ mit #include "std_lib_facilities.h"vorangestelltem zu programmieren , was auch a bewirkt using namespace std;. Dieser Header wurde vom Autor der Sprachversion (letzte Version ist 2010) für Studenten geschrieben, die neu in C ++ sind.
Yakk

@Yakk Sofern Sie keinen Interpreter erstellen und veröffentlichen, der dies für Sie erledigt, müssen Sie immer noch das Include von std_lib_facilities.h zählen.
Dennis

@BenH Willkommen bei PPCG! Sie benötigen die Anzahl aller Includes, die zum Kompilieren Ihrer Funktion erforderlich sind. Die kürzeste mir bekannte Methode ist #import<string>. Probieren Sie es online!
Dennis

@ Tennis #!/usr/bin/shNewline gcc -include "std_lib_facilities.h" $@- Wenn ich einen C ++ - Kurs finde, der dieses Shell-Skript bereitstellt, würde das zählen?
Yakk

@Yakk Wusste nicht über diesen Schalter. Im Gegensatz zu # include-Anweisungen sind Befehlszeilenargumente frei, da sie im Wesentlichen eine neue Sprache sind . In C ++ (gcc)-include iostream sind dies tatsächlich 144 Bytes.
Dennis


1

C (gcc) (mit string.h) , 110 108 Bytes

c;f(char*b){c=strlen(b);if(!c)return 1;char*d=b+c-1;if(*b<*d)return 0;*b=(*b+*d-96)%10+48;*d=0;return f(b);}

Probieren Sie es online!

Da PPCG noch relativ neu ist, ist mir die korrekte Syntax zum Verknüpfen von Bibliotheken als neue Sprache fremd. Beachten Sie auch, dass die Funktion 0 oder 1 für false / true zurückgibt und dass für das Drucken des Ergebnisses in stdout stdio erforderlich ist. Wenn wir pedantisch sind und die Übung eine Ausgabe erfordert, erfordert die Sprache stdio das auch.

Konzeptuell ähnlich der Antwort von @ BenH, aber in C, also ein dickes Lob, wo sie fällig sind (Welcome to PPCG, btw), aber unter Verwendung von Rekursion. Es wird auch eine Arrayzeiger-Arithmetik verwendet, da der Dirty-Code kürzer als der Clean-Code ist.

Die Funktion ist rekursiv mit Endebedingungen, wenn die erste Zahl die letzte nicht essen kann oder die Länge 1 ist und false bzw. true zurückgibt. Diese Werte werden gefunden, indem ein Zeiger auf die C-Zeichenfolge (die ein Zeichen enthält) am Anfang und Ende der Zeichenfolge dereferenziert und mit diesen verglichen wird. Zeigerarithmetik wird durchgeführt, um das Ende der Zeichenkette zu finden. Schließlich wird das letzte Zeichen "gelöscht", indem es durch ein Null-Abschlusszeichen (0) ersetzt wird.

Es ist möglich, dass die Modularithmetik um ein oder zwei Bytes verkürzt wird, aber ich brauche nach dieser Zeigermanipulation bereits eine Dusche.

Ungolfed Version hier

Update: Zwei Bytes wurden gespeichert, indem c == 1 durch! C ersetzt wurde. Dies ist im Wesentlichen c == 0. Es wird eine zusätzliche Zeit ausgeführt und verdoppelt sich vor dem Löschen unnötigerweise, spart jedoch zwei Bytes. Ein Nebeneffekt ist, dass Zeichenfolgen mit der Länge Null keine unendliche Rekursion verursachen (obwohl wir keine Nullzeichenfolgen erhalten sollten, da in der Übung positive ganze Zahlen angegeben werden).


Sie brauchen keine Bibliotheken zu verknüpfen, gccwenn - obwohl Warnungen generiert gccwerden, Sie Ihren Code gerne ohne #includes kompilieren . Außerdem könnten Sie mit 4 Bytes sparen -DR=return. Schließlich sind die \0s in Ihrem Testcode nicht erforderlich, da die Zeichenfolge sie bereits implizit enthält.

1
Außerdem können Sie von einer Funktion zurückkehren, indem Sie der ersten Variablen b=case1?res1:case2?res2:res_else;if(case1)return res1;if(case2)return res2;return res_else;

Darüber hinaus können Sie einige zusätzliche Bytes verlieren, indem cSie Folgendes nicht verwenden : Sie können bestimmen, ob die Zeichenfolge eine Länge von 0 hat head-tail.


Wusste nicht, dass Sie in C ternäre (bedingte) Operatoren verwenden können. War das schon immer der Fall? Unabhängig davon, gut zu wissen; Ich werde sie in Zukunft verwenden. Prost
Andrew Baumher

1

Powershell, 89 Bytes

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

Wichtig! Das Skript ruft sich selbst rekursiv auf. Speichern Sie das Skript alsg.ps1 Datei im aktuellen Verzeichnis. Sie können auch eine Skriptblockvariable anstelle einer Skriptdatei aufrufen (siehe das Testskript unten). Dieser Anruf hat die gleiche Länge.

Anmerkung 1: Das Skript verwendet eine verzögerte Auswertung von logischen Operatoren -orund -and. Wenn "$args"-notmatch'(.)(.*)(.)'ist, Truedann wird der richtige Unterausdruck von -ornicht ausgewertet. Auch wenn ($m=$Matches).1-ge$m.3ist Falsedann der richtige Teilausdruck von -andwird auch nicht ausgewertet. So vermeiden wir eine unendliche Rekursion.

Anmerkung 2: Der reguläre Ausdruck '(.)(.*)(.)'enthält keine Start- und Endanker, da der Ausdruck(.*) standardmäßig gierig ist.

Skript testen

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

Ausgabe:

True: True <- 2632
True: True <- 92258
True: True <- 60282
True: True <- 38410
True: True <- 3210
True: True <- 2302
True: True <- 2742
True: True <- 8628
True: True <- 6793
True: True <- 1
True: True <- 2
True: True <- 10
True: True <- 100
True: True <- 55
True: True <- 121
True: False <- 6724
True: False <- 47
True: False <- 472
True: False <- 60247
True: False <- 33265
True: False <- 79350
True: False <- 83147
True: False <- 93101
True: False <- 57088
True: False <- 69513
True: False <- 62738
True: False <- 54754
True: False <- 23931
True: False <- 7164
True: False <- 5289
True: False <- 3435
True: False <- 3949
True: False <- 8630
True: False <- 5018
True: False <- 6715
True: False <- 340
True: False <- 2194

Powershell, 90 Bytes

Keine Rekursion. Keine Abhängigkeit vom Dateinamen und keine Abhängigkeit vom Skriptblocknamen.

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]

Eine PowerShell konvertiert implizit einen rechten Operanden in einen Typ eines linken Operanden. Daher $s-ge$s%10berechnet rechten Operanden $s%10wie integerund vergleichen Sie es als ein , stringweil Typ des linken Operanden ist string. Und 2+$s[0]+$swandelt ein Zeichen $s[0]und Zeichenfolge $sauf , integerweil linker Operand 2ganze Zahl ist.

$s|% S*g 1($s.Length-2)ist eine Abkürzung zu$s.Substring(1,($s.Length-2))


1

C # (Visual C # Interactive Compiler) , 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;}

Probieren Sie es online!

Erfolg oder Misserfolg hängen vom Vorhandensein oder Fehlen einer Ausnahme ab . Die Eingabe erfolgt in Form einer Zeichenfolge.

Weniger golfen ...

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

Es gibt ein paar zusätzliche Bytes für die Konvertierung zwischen Zeichen und Ziffern, aber insgesamt hat sich das nicht allzu stark auf die Größe ausgewirkt.



1

Brachylog , 18 Bytes

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

Probieren Sie es online!

Nimmt drei Bytes aus Fatalize Lösung nur durch nicht-deterministisch superscriptless bestehenden jetzt, verliert aber drei weitere indem vage Jelly inspirierte Dinge mit z₁zu vermeiden , mit c, goder sogar h. (Inspiriert durch den Versuch und das Scheitern, eine andere neue Funktion zu verwenden: das ʰMetapredikat.)

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

0

PowerShell , 94 91 Byte

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

Probieren Sie es online!


Skript testen

function f($n){

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

Remove-Variable n
}
Write-Host True values:
@(2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121) |
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Write-Host False values:
@(6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194) | 
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Ungolfed-Code:

function f ($inVar){
    # While the Input exists, and the first character is greater than last
    while($inVar -and ($inVar[0] -ge $inVar[-1])){

        # Calculate the first integer -> ((+$n[0]+$n[-1]-96)%10)
        $summationChars = [int]$inVar[0]+ [int]$inVar[-1]
        # $summationChars adds the ascii values, not the integer literals. 
        $summationResult = $summationChars - 48*2
        $summationModulo = $summationResult % 10

        # Replace first character with the modulo
        $inVar = $inVar -replace "^.", $summationModulo

        # Remove last character
        $inVar = $inVar -replace ".$"
    }
    # Either it doesn't exist (Returns $True), or 
    # it exists since $inVar[0] < $inVar[-1] returning $False
    return !$inVar
}

1
Sie sollten $n[0]Ihre forErklärung nicht einchecken müssen - nur das Einchecken $nsollte ausreichen.
AdmBorkBork

Sie können -6stattdessen verwenden, -96da es ausreicht,% 10
mazzy

Sie könnten return 7 Bytes entfernen und speichern
mazzy

und ich denke, dass Sie eine Parameterdeklaration zur Byteanzahl einschließen sollten. entweder param($n)oder function f($n).
mazzy

1
@mazzy Auf dem Poster stand in den Kommentaren, dass du Strings verwenden durftest, du durftest die Eingabe nur nicht als Liste von Zahlen / Strings geben. Ich interpretierte dies als ["1","2","3"]nicht gültige Eingabe, "123"ist es aber . Wenn @VedantKandoi ein Problem hat, kann ich es definitiv ändern!
KGlasier
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.