Der PPCG-Benutzer und gewählte Mod @Dennis war der zweite Benutzer, der mehr als 100.000 Wiederholungen verdiente!

Dies ist eine völlig originelle Idee, die ich von niemand anderem bekommen habe , aber lasst uns eine Herausforderung basierend auf seiner Benutzer-ID 12012als Tribut machen!

Wenn Sie es sich ansehen, werden Sie feststellen, dass es zwei unterschiedliche "Abschnitte" zu seiner ID gibt.

12

und

012

Beide Abschnitte ergeben eine 3. Das ist eine ziemlich interessante Eigenschaft.

Definieren wir eine "Dennis 2.0-Zahl" als eine positive Ganzzahl, bei der jede maximale Folge von streng ansteigenden Ziffern dieselbe Zahl ergibt. Zum Beispiel,

123

ist eine Dennis 2.0-Zahl, weil es nur eine maximale Unterliste mit streng aufsteigenden Ziffern gibt, und sie summiert sich auf 6. Zusätzlich ist 2.846.145 auch eine Dennis 2.0-Zahl, weil die drei maximalen Unterlisten mit aufsteigenden Ziffern, nämlich

28
46
145

Alles in allem 10. Zusätzlich Zahlen , die nur die gleiche Ziffer wiederholen muss Dennis 2.0 Zahlen sein , weil zum Beispiel 777kann in gebrochen werden

7
7
7

die eindeutig alle auf sieben summieren.

Eine Zahl wie 42ist keine Dennis 2.0-Zahl, da sie in zwei Teile zerlegt ist

4
2

die eindeutig nicht die gleiche Zahl ergeben.

Die Herausforderung

Sie müssen ein Programm oder eine Funktion schreiben, um festzustellen, ob eine bestimmte Nummer eine Dennis 2.0-Nummer ist oder nicht. Sie können Eingaben und Ausgaben in jedem vernünftigen Eingabeformat vornehmen, z. B. als Zeichenfolge, als Zahl, aus einer Datei, Funktionsargumenten / Rückgabe, von STDIN / STDOUT usw., und dann einen Wahrheitswert zurückgeben, wenn diese Zahl Dennis 2.0 ist Zahl und ein falscher Wert, wenn dies nicht der Fall ist. Als Referenz ist hier jede Dennis 2.0-Nummer bis zu 1.000:

1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19
22
23
24
25
26
27
28
29
33
34
35
36
37
38
39
44
45
46
47
48
49
55
56
57
58
59
66
67
68
69
77
78
79
88
89
99
101
111
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
202
222
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289
303
312
333
345
346
347
348
349
356
357
358
359
367
368
369
378
379
389
404
413
444
456
457
458
459
467
468
469
478
479
489
505
514
523
555
567
568
569
578
579
589
606
615
624
666
678
679
689
707
716
725
734
777
789
808
817
826
835
888
909
918
927
936
945
999

Es gelten Standardlücken und die kürzeste Antwort, gemessen in Bytes, gewinnt!

Jelly, 13-12 Bytes

1 Byte dank @Dennis.

DIṠ’0;œṗDS€E

Probieren Sie es online!

Erläuterung

DIṠ’0;œṗDS€E    Main link. Argument: N
D               Convert N to its digits.
 I              Find the differences between the elements.
  Ṡ             Find the sign of each difference. This yields 1 for locations where the
                list is strictly increasing and 0 or -1 elsewhere.
   ’            Decrement. This yields 0 for locations where the list is strictly
                increasing and -1 or -2 elsewhere.
    0;          Prepend a 0.
        D       Get another list of digits.
      œṗ        Split the list of digits at truthy positions, i.e. the -1s and -2s.
         S€     Sum each sublist.
           E    Check if all values are equal.

JavaScript (ES6), 72-70 Byte

Nimmt einen String als Eingabe. Gibt entweder false oder einen Wahrheitswert zurück (der eine Zahl sein kann).

Es wird ein regulärer Ausdruck verwendet, um eine Eingabezeichenfolge wie folgt umzuwandeln "2846145":

"(a=2+8)&&(a==4+6)&&(a==1+4+5)"

Ruft dann eval()diesen Ausdruck auf.

let f =

n=>eval(n.replace(/./g,(v,i)=>(v>n[i-1]?'+':i?')&&(a==':'(a=')+v)+')')

console.log(f("101"));
console.log(f("102"));
console.log(f("777"));
console.log(f("2846145"));

Python, 50 Bytes

r='0'
for d in input():r=d+'=+'[r<d]*2+r
1/eval(r)

Erwartet input(), zu einer Zeichenfolge ausgewertet zu werden, sodass die Eingabe umgebende Anführungszeichen in Python 2 benötigt. Die Ausgabe erfolgt über den Exit-Code , wobei 0 Erfolg (wahr) und 1 Fehler (falsch) angibt.

Teste es auf Ideone .

Wie es funktioniert

Wir initialisieren r mit der Zeichenfolge 0 und iterieren über alle Ziffern d in der Eingabe.

• Wenn d größer als die erste Ziffer von r ist (anfangs 0 , dann gleich dem vorherigen Wert von d ), wird es r<dzu True ausgewertet und '=+'[r<d]*2ergibt ++.

• Wenn d kleiner als die erste Ziffer von r ist , '=+'[r<d]*2ergibt sich ==.

• Wenn d gleich der ersten Ziffer von r ist , ist r länger als die Singleton-Zeichenfolge d und '=+'[r<d]*2ergibt erneut ==.

In allen Fällen werden die Ziffer d und die beiden generierten Zeichen vor r gesetzt .

Wenn alle eingegebenen Ziffern verarbeitet wurden, wird eval(r)der generierte Ausdruck ausgewertet.

• Wenn die Eingabe aus einer einzelnen, streng ansteigenden Folge von (positiven) Ziffern besteht, wird der Ausdruck zu ihrer Summe ausgewertet.

  Beispielsweise ergibt die Ganzzahl 12345 den Ausdruck 5++4++3++2++1++0, der bei der Auswertung 15 ergibt . Beachten Sie, dass jede Sekunde + ein unärgerliches Plus ist, sodass das Ergebnis davon nicht beeinflusst wird. Die Division von 1 durch 15 ist gültig (das Ergebnis ist nicht wichtig). Das Programm wird normal beendet.

• Wenn die Eingabe aus zwei streng aufsteigenden Ziffernfolgen besteht, besteht der Ausdruck aus einem einfachen Vergleich.

  Beispielsweise ergibt die Ganzzahl 12012 den Ausdruck 2++1++0==2++1++0, der bei der Auswertung True ergibt , da beide Terme die Summe 3 haben . Die Division von 1 durch True ( 1 ) ist gültig (das Ergebnis ist nicht wichtig). Das Programm wird normal beendet.

  Andererseits ergibt die Ganzzahl 12366 den Ausdruck 6==6++3++2++1++0, der bei der Auswertung Falsch ergibt , da die Terme die Summen 6 und 12 haben . Dividieren 1 durch Falsch ( 0 ) stellt einen Zerodivisionerror ; Das Programm wird mit einem Fehler beendet.

• Wenn die Eingabe aus drei oder mehr streng aufsteigenden Ziffernfolgen besteht, besteht der Ausdruck aus einem verketteten Vergleich , der nur dann True zurückgibt, wenn alle beteiligten Vergleiche True zurückgeben .

  Beispielsweise ergibt die Ganzzahl 94536 den Ausdruck 6++3==5++4==9++0, der bei der Auswertung True ergibt , da alle Terme die Summe 9 haben . Wie zuvor wird das Programm normal beendet.

  Andererseits ergibt die Ganzzahl 17263 den Ausdruck 3==6++2==7++1++0, der bei der Auswertung Falsch ergibt , da die Terme die Summen 3 , 8 und 8 haben . Nach wie vor wird das Programm mit einem Fehler beendet.

Brachylog , 13 Bytes

~c@e:{<+}a!#=

Probieren Sie es online!

Erläuterung

~c               Find a list of integers which when concatenated result in the Input
  @e             Split the integers into lists of digits
    :{<+}a       Each list of digit is stricly increasing, and compute its sum
          !      Discard all other choice points (prevents backtracking for smaller sublists)
           #=    All sums must be equal

~c wird zuerst mit den größten Unterlisten vereinigt.

Pyke, 18 Bytes

mb$1m>0R+fMbms}lt!

Probieren Sie es hier aus!

mb                 -         map(int, input)
  $                -        delta(^)
   1m>             -       map(^, 1>i)
      0R+          -      [0]+^
         f         -     input.split_at(^) 
          Mb       -    deep_map(int, ^)
            ms     -   map(sum, ^)
              }    -  uniquify(^)
               lt! - len(^) == 1

PowerShell v2 +, 100 64 61 Bytes

-join([char[]]$args[0]|%{("+$_","-eq$_")[$_-le$i];$i=$_})|iex

Ein buchstäblicher Einzeiler, da dies alles eine Pipeline ist. Übernimmt die Eingabe als Zeichenfolge $args[0]. Schleifen durch sie als char-array, jede Iteration entweder das aktuelle Element mit einer Platzierung +oder -eqvor ihm auf die Rohrleitung basierend darauf , ob der aktuelle Wert -less-als-oder - eQual auf den vorherigen Wert $i. Diese Saiten sind -joined zusammen und Ausleiten iex(kurz für Invoke-Expressionund ähnlich wie evalz. B. für die Eingabe 2846145wird dieser als ausgewertet werden +2+8-eq4+6-eq1+4+5, das ist True.

Dieser Boolesche Wert verbleibt in der Pipeline und True/ oder Falsewird implizit bei Programmabschluss geschrieben.

Hinweis: Bei der Eingabe mit einer Ziffer verbleibt die resultierende Ziffer in der Pipeline. Dies ist ein wahrer Wert in PowerShell.

Beispiele

PS C:\Tools\Scripts\golfing> 2846145,681,777,12366,2|%{"$_ -> "+(.\dennis-number-20.ps1 "$_")}
2846145 -> True
681 -> False
777 -> True
12366 -> False
2 -> 2

GNU sed 217 oder 115

Beide enthalten +1 für -r

217

s/./&,/g;s/^/,/g;:;s,0,,;s,2,11,;s,3,21,;s,4,31,;s,5,41,;s,6,51,
s,7,61,;s,8,71,;s,9,81,;t;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

Übernimmt die Eingabe in normaler Dezimalzahl

Probieren Sie es online!

115

s/^|$/,/g;:;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

Nimmt die Eingabe als kommagetrennte Liste der Ziffern in Unary an. zB 123wäre1,11,111

Probieren Sie es online!

Perl, 38 + 3 ( -p) = 41 Bytes

-9 Bytes dank @Ton Hospel !

s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/

Da es eine gibt $', muss sich der Code in einer Datei befinden, um ausgeführt zu werden. So -pzählt für 3 Byte. Gibt 1 aus, wenn die Nummer eine Dennis 2.0-Nummer ist, oder andernfalls eine leere Zeichenfolge:

$ cat dennis_numbers.pl
s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/
$ perl -p dennis_numbers.pl <<< "1
10
12315
12314"

JavaScript (ES6), 66 65 63 Bytes

2 Bytes gespart dank @ edc65

x=>[...x,p=t=z=0].every(c=>p>=(t+=+p,p=c)?(z?z==t:z=t)+(t=0):1)

Übernimmt die Eingabe als Zeichenfolge. Alte Version (funktioniert nur in Firefox 30+):

x=>[for(c of(p=t=0,x))if(p>=(t+=+p,p=c))t+(t=0)].every(q=>q==+p+t)

Mathematica, 38 Bytes

Equal@@Tr/@IntegerDigits@#~Split~Less&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt Trueoder Falseals Ausgabe zurück.

Brachylog 2, 10 Bytes, Sprachnachstellung

ẹ~c<₁ᵐ!+ᵐ=

Probieren Sie es online!

Dies ist im Grunde derselbe Algorithmus wie die Antwort von @ Fatalize (die ich erst gesehen habe, nachdem ich dies geschrieben hatte), aber er wurde etwas umgestellt, um es unter der Syntax von Brachylog 2 golfiger zu machen.

Es ist ein vollständiges Programm, das zurückkehrt, false.wenn es keine Dennis 2.0-Nummer ist oder truewenn es eine ist.

Erläuterung

ẹ~c<₁ᵐ!+ᵐ=
ẹ           Interpret the input number as a list of digits
      !     Find the first (in default order)
 ~c           partition of the digits
   <₁ᵐ        such that each is in strictly increasing order
         =  Assert that the following are all equal:
       +ᵐ     the sums of each partition

Wie bei einem vollständigen Brachylog-Programm üblich, erhalten wir, wenn alle Behauptungen gleichzeitig erfüllt werden können, eine echte Rendite, ansonsten eine falsche. Die Standardreihenfolge für ~cPartitionen mit weniger, mehr Elemente zuerst zu sortieren ist, und in Prolog (also Brachylog), die durch das erste Prädikat im Programm (unter Verwendung des zweiten als Tie - Break definiert die Standardreihenfolge, und so weiter, hier ~cdominiert, weil ẹdeterministisch ist und somit nichts zu ordnen hat).

MATL, 24 23 20 18 16 Bytes

Tjdl<vYsG!UlXQ&=

Gibt eine truthy von Falsey Matrix

Probieren Sie es online!

Auch Glückwunsch @Dennis!

Erläuterung

T       % Push a literal TRUE to the stack
        %   STACK: {1}
j       % Explicitly grab the input as a string
        %   STACK: {1, '2846145'}
d       % Compute the difference between successive ASCII codes
        %   STACK: {1, [6 -4 2 -5 3 1]}
l<      % Find where that difference is less than 1
        %   STACK: {1, [0 1 0 1 0 0]}
v       % Prepend the TRUE value we pushed previously
        %   STACK: {[1 0 1 0 1 0 0]}
Ys      % Compute the cumulative sum. This assigns a unique integer label to
        % each set of increasing numbers
        %   STACK: {[1 1 2 2 3 3 3]}
G!U     % Grab the input as numeric digits
        %   STACK: {[1 1 2 2 3 3 3], [2 8 4 6 1 4 5]}
lXQ     % Compute the sum of each group of increasing digits
        %   STACK: {[10 10 10]}
&=      % Computes element-wise equality (automatically broadcasts). A
        % truthy value in MATL is a matrix of all ones which is only the case
        % when all elements are equal:
        %   STACK: {[1 1 1
        %            1 1 1
        %            1 1 1]}
        % Implicitly display the result

PHP, 108 105 92 Bytes

$p=-1;foreach(str_split("$argv[1].")as$d)$p>=$d?$r&&$s-$r?die(1):($r=$s)&$s=$p=$d:$s+=$p=$d;

Nimmt Eingaben von Argumenten, beendet mit 0für Dennis-2.0-Nummer, mit 1else.

Nervenzusammenbruch

$p=-1;                              // init $p(revious digit) to -1
foreach(str_split("$argv[1].")as$d) // loop $d(igit) through input characters
                                    // (plus a dot, to catch the final sum)
    $p>=$d                              // if not ascending:
        ?$r                             // do we have a sum remembered 
        &&$s-$r                         // and does it differ from the current sum?
                ?die(1)                     // then exit with failure
                :($r=$s)&$s=$p=$d           // remember sum, set sum to digit, remember digit
        :$s+=$p=$d                      // ascending: increase sum, remember digit
    ;
// 

05AB1E , 18 Bytes

SD¥X‹X¸«DgL*ꥣOÙg

Erläuterung

N = 12012 als Beispiel verwendet.

                    # implicit input N = 12012
S                   # split input number to list of digits  
                    # STACK: [1,2,0,1,2]
 D                  # duplicate
                    # STACK: [1,2,0,1,2], [1,2,0,1,2]
  ¥                 # reduce by subtraction
                    # STACK: [1,2,0,1,2], [1,-2,1,1]
   X‹               # is less than 1
                    # STACK: [1,2,0,1,2], [0,1,0,0]
     X¸«            # append 1
                    # STACK: [1,2,0,1,2], [0,1,0,0,1]
        DgL*        # multiply by index (1-indexed)
                    # STACK: [1,2,0,1,2], [0,2,0,0,5]
            ê       # sorted unique
                    # STACK: [1,2,0,1,2], [0,2,5]
             ¥      # reduce by subtraction
                    # STACK: [1,2,0,1,2], [2,3]
              £     # split into chunks
                    # STACK: [[1,2],[0,1,2]]
               O    # sum each
                    # STACK: [3,3]
                Ù   # unique
                    # STACK: [3]
                 g  # length, 1 is true in 05AB1E
                    # STACK: 1

Probieren Sie es online!

Ruby 2.3, 56 Bytes

p !gets.chars.chunk_while(&:<).map{|a|eval a*?+}.uniq[1]

Mit ziemlicher Sicherheit nicht die golferischste Art, dies zu tun, aber es zeigt einige nette Sprachmerkmale.

(Nicht Newline-tolerant, also laufe wie ruby dennis2.rb <<< '12012')

PHP, 144 Bytes

<?php preg_match_all("/0?1?2?3?4?5?6?7?8?9?/",$argv[1],$n);foreach($n[0]as$i)if(strlen($i)&&($a=array_sum(str_split($i)))!=$s=$s??$a)die;echo 1;

Ich bin sicher, es gibt einen viel clevereren (und kürzeren) Weg, dies zu tun, aber es wird vorerst reichen.

Python 2, 69 Bytes

Übernimmt die Eingabe als Zeichenfolge.

lambda I:len(set(eval(reduce(lambda x,y:x+',+'[y>x[-1]]+y,I+' '))))<2

Erläuterung:

Ex 1201212012

Konvertiert in Liste der Summen:

1+2,0+1+2,1+2,0+1+2,

Berechnet und konvertiert zu setzen.

set([3])

Wenn die Länge des Satzes 1 ist, sind alle Summen gleich.

JavaScript (ES6), 58

s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

Anwendung meines selten nützlichen Trinkgeldes https://codegolf.stackexchange.com/a/49967/21348

Es scannt den String char, indem es den Lauf aufsteigender Zeichen identifiziert und am Ende jedes Rums prüft, ob die Summe immer gleich ist

• c: aktuelles Zeichen
• p: vorheriges Zeichen
• z: laufende Summe, am Ende eines Laufs wird verglichen mit ...
• x: Summe zum Vergleich, wird beim ersten Durchlauf einfach gleich z gesetzt

Prüfung

f=
s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

function run()
{
  var i=I.value
  O.textContent = i + ' -> ' + f(i)
}

run()

test=`1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 22 23 24 25 26 27 28 29 33 34 35 36 37 38 39 44 45 46 47 48 49 55 56 57 58 59 66 67 68 69 77 78 79 88 89 99 101 111 123 124 125 126 127 128 129 134 135 136 137 138 139 145 146 147 148 149 156 157 158 159 167 168 169 178 179 189 202 222 234 235 236 237 238 239 245 246 247 248 249 256 257 258 259 267 268 269 278 279 289 303 312 333 345 346 347 348 349 356 357 358 359 367 368 369 378 379 389 404 413 444 456 457 458 459 467 468 469 478 479 489 505 514 523 555 567 568 569 578 579 589 606 615 624 666 678 679 689 707 716 725 734 777 789 808 817 826 835 888 909 918 927 936 945 999`.split` `

numerr=0
for(i=1; i<1000; i++)
{
  v = i + '';
  r = f(v);
  ok = r == (test.indexOf(v) >= 0)
  if (!ok) console.log('Error',++numerr, v)
}  
if(!numerr) console.log('All test 1..999 ok')

<input id=I value=612324 type=number oninput='run()'>
<pre id=O>

Pyth , 20 Bytes

Zwei Versionen

!t{sMcJjQThMx1<R0.+J
LS{b!t{sMhyI#I#./jQT

Probieren Sie das erste online aus!

Probieren Sie den zweiten online aus!

Rubin, 117 105 85 Bytes

# original (117):
j,k=0,?0;"#{i}".chars.group_by{|n|n>k||j=j+1;k=n;j}.values.map{|a|a.map(&:to_i).reduce(&:+)}.reduce{|m,n|n==m ?m:nil}

# inspired by PHP regexp approach (105):
"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.reduce{|m,n|!n||n==m ?m:nil}

# some number comparison simplification (85):
!"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.uniq[1]

Dies würde die ganze Zahl dieser Dennis-Nummer oder, nilfalls nicht, eine Dennis-Nummer zurückgeben. Alle ganzen Zahlen werden auch in Ruby als wahr und nilals falsch betrachtet. iist die Ganzzahl, die geprüft wird.

Die dritte Version gibt tatsächlich trueund zurück false.

PS getestet, um 172 Ganzzahlen von 1 bis 1000 wie in der Antwort zurückzugeben.

APL, 23 Bytes

{1=≢∪+/↑N⊂⍨1,2>/N←⍎¨⍕⍵}

Erläuterung:

• N←⍎¨⍕⍵: die einzelnen Ziffern in der Eingabe erhalten, speichern in N
• N⊂⍨1,2>/N: finden Sie die Unterlisten der streng steigenden Zahlen in N
• +/↑: summiere jede Unterliste
• 1=≢∪: Überprüfen Sie, ob die resultierende Liste nur ein einziges Element enthält

Add ++ , 109 Bytes

D,g,@@#,BF1_B
D,k,@@#,bR$d@$!Q@BFB
D,f,@,BDdVÑ_€?1€_0b]$+€?dbLRBcB*BZB]GbL1+b]+qG€gd€bLÑ_0b]$+BcB]£k€¦+Ñ=1$ª=

Probieren Sie es online!

Wie es funktioniert

Wir definieren unsere 3 Funktionen, $f$, $g$ und $k$. $f$ ist die Hauptfunktion, die die Eingabe in die richtige Ausgabe umwandelt.

$f(x)$

Zuerst konvertieren wir die Eingabe $x$in eine Liste von Ziffern, dann nehmen Sie die Vorwärtsschritte. Als nächstes nehmen wir das Vorzeichen jedes Inkrements. Dies ergibt bei zunehmenden Teilfolgen eine Teilfolge von$1$für gleiche Teilfolgen, wie z $[4, 4, 4]$, Dies ergibt $0$s und für abnehmende Abschnitte, $-1$ist zurück gekommen. Wir nehmen dann das Komplement von jedem dieser Zeichen, um uns umzudrehen$1$in einen falschen Wert und alles andere in einen wahren Wert. Nächster,$0$wird diesem Array vorangestellt, und wir nehmen das Vorzeichen jedes Elements erneut. Dies ergibt ein Array,$A$, von $0$ und $1$, wobei das erste Element immer ist $0$.

Wir geben dann den Bereich $[1, 2, ... length(A)]$ und entfernen Sie die entsprechenden Elemente $0$ im $A$. Dies lässt uns mit einem zweiten Array,$A'$. Wir tippen dann die Anzahl der Ziffern in die Eingabe, addieren eine und hängen diese Zahl an$A'$. Wir deduplizieren dann$A'$, um ein neues Array zu ergeben, $A''$.

Als nächstes verwenden wir die $g$Hilfsfunktion. Wie$g$ist dyadisch (benötigt 2 Argumente) und verhält sich in Verbindung mit jedem Operator etwas anders €. Dyadische Funktionen holen einen Wert aus dem Stapel und binden diesen Wert als ihr rechtes Argument, um eine partielle monadische Funktion zu erzeugen. Diese Teilfunktion wird dann auf jedes Element im Argument abgebildet. Das gebundene rechte Argument sind hier die Ziffern der Eingabe, und die Teilfunktion wird abgebildet$A''$.

$g(x, y)$

Schauen wir uns nur eine Iteration von an $g(x, y)$ wo $x := [1, 2, 0, 1, 2]$ und $y = 3$. Beachten Sie, dass$3$ ist der erste Index in $A''$ Woher die Schilder? $A$ entsprach mit $1$, eher, als $0$. In der Tat, für$x = 12012$, wir können das sehen $A'' = [3, 6]$. $3$ ist der einzige Index ungleich Null in $A$, und $6$ ist die Länge von $x$ Plus eins.

So für $g([1, 2, 0, 1, 2], 3)$Folgendes passiert: Zuerst tauschen wir die beiden Argumente aus, sodass der Stapel die Ziffern unter dem Index enthält. Wir reduzieren dann das Array und den Index. Bisher sieht der Stapel so aus [1 2 0 1 2 2]. Wir führen dann den Kopf Befehl. Wir ziehen den Index vom oberen Ende des Stapels und nehmen so viele Zeichen vom unteren Ende des Stapels. Dies ergibt$[1, 2]$, die dann von zurückgegeben wird $g$.

Damit, $g(x, y)$ wird über jedes Element abgebildet $y \in A''$, der eine Reihe von Präfixen der Eingabe mit unterschiedlicher Länge zurückgibt. Dieser Teil könnte etwas verwirrend werden, daher werden wir ihn anhand der Beispieleingabe von bearbeiten$x := 12012$. Nach der Kartierung von$g$sieht der Stack momentan so aus

[[[1 2] [1 2 0 1 2]]]

Wir verschieben dann ein Array, das die Länge jedes Arrays enthält, in das oberste Element oder in diesem Fall in das Array $[2, 5]$. Dies ist das gleiche wie$A'' - 1$, wenn die $-$Operatorzuordnungen, aber es werden mehr Bytes benötigt, um diese Beziehung zu verwenden. Als nächstes werden die Vorwärtsdifferenzen der Längen genommen und$0$ wird vorangestellt und ergibt in diesem Beispiel $[0, 3]$. Dieses neue Array wird dann mit den Ergebnissen von komprimiert$g$ erschaffen $B$und der Starmap- Operator wird über jedes Paar gefahren.

$k(x, n)$

Der Starmap- Operator verwendet die Funktion$k$als Argument und arbeitet mit einer dyadischen Funktion und einem verschachtelten Array. Das Array muss aus Paaren bestehen, z$[[1, 2], [3, 4], [5, 6]]$und die dyadische Funktion wird über jedes Paar abgebildet, wobei jedes Element der Paare das linke bzw. rechte Argument ist.

Hier ist unser Beispiel für ein verschachteltes Array $[[[1, 2], 0], [[1, 2, 0, 1, 2], 3]]$ und unsere Funktion ist $k$. Wir werden uns einfach darauf konzentrieren$k([1, 2, 0, 1, 2], 3)$ zur Zeit.

$k(x, n)$ beginnt, ähnlich wie $g$durch Vertauschen der beiden Argumente, sodass das Array die oberste Position im Stapel einnimmt. Wir kehren dann das Array um und tauschen die Argumente zurück. Jetzt,$n = 0$Wenn Sie das Array unverändert lassen möchten, duplizieren Sie die Ganzzahl und drehen Sie die oberen drei Argumente, sodass der Stapel das Format hat $[n, x, n]$. Als nächstes geben wir das Array if zurück$n = 0$. Andernfalls wird das Element top verworfen und der Stapel wird so angeordnet, wie er war, dh mit dem umgekehrten Array unten und der Ganzzahl oben, oder in unserem Beispiel:$[[2, 1, 0, 1, 2], 3]$. Dann machen wir den Stapel flach und nehmen den ersten$n$ Elemente von $x$. Diese Elemente werden dann zurückgegeben und ersetzt$x$ im $B$.

Für unsere Eingabe wird dies zurückgegeben $[0, 1, 2]$. (Genau genommen kehrt es zurück$[2, 1, 0]$, aber die Reihenfolge spielt für den Rest des Programms keine Rolle).

Nach $k(x, n)$ wird über jedes Paar abgebildet $(x, n) \in B$Wir nehmen die Summe jedes Paares und überprüfen dann, ob jedes Element gleich ist, indem wir behaupten, dass jedes benachbarte Paar gleich ist, und dann behaupten, dass jeder dieser Gleichheitstests ergibt $1$(ein wahrer Wert). Schließlich wird dieses Ergebnis zurückgegeben.