Bei zwei positiven ganzen Zahlen p und q müssen Sie das Array A zurückgeben, das mit dem folgenden Algorithmus erstellt wurde:

1. Beginnen Sie mit A = [p, q] und d = 2
2. Fügen Sie für jedes Paar (x, y) zusammenhängender Zahlen in A, dessen Summe durch d teilbar ist, (x + y) / d zwischen x und y ein .
3. Wenn mindestens ein passendes Paar gefunden wurde, erhöhen Sie d und fahren Sie mit Schritt 2 fort. Andernfalls stoppen Sie und kehren Sie zu A zurück .

Beispiel

Unten ist das Detail des Prozesses für p = 1 und q = 21 .

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

Daher die erwartete Ausgabe: [1, 1, 4, 3, 11, 8, 21]

Erläuterungen und Regeln

• Die Ein- und Ausgabe kann in jedem vernünftigen Format erfolgen. Die ganzen Zahlen p und q sind garantiert größer als 0. Wenn das hilft, können Sie annehmen, dass q ≥ p ist .
• Der 2. Schritt des Algorithmus sollte nicht rekursiv auf Elemente angewendet werden, die gerade in derselben Iteration eingefügt wurden. Zum Beispiel sollte A = [1, 1] und d = 2 zu [1, 1, 1] führen (keine unendliche Liste von Einsen).
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Testfälle

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

Wenn Sie Ihren Code in einem etwas größeren Testfall testen möchten, finden Sie hier die erwartete Ausgabe für:

• p = 12096 (2 ⁶ * 3 ³ * 7)
• q = 24192 (2 ⁷ * 3 ³ * 7)

05AB1E , 28 19 18 Bytes

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

Probieren Sie es online!

eh, kann definitiv hardcore verbessert werden. arbeitet immer noch an der Umgestaltung.

Wahrscheinlich so gut, wie ich es verstehe.

-1 Danke an, wer sonst noch, Emigna! Für den Hinweis funktionierte Swap besser als die Register.

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

Debug-Dump für [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

Probieren Sie es online mit Debug!

Mathematica, 72 64 59 58 Bytes

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

Probieren Sie es online!

Wie es funktioniert

Wir nehmen die Eingabe als Liste {p,q}. Der Iterationsschritt wird wie folgt umformuliert:

1. Fügen Sie (a+b)/dzwischen jeweils zwei Elementen ein aund b: (x+{##2,}&@@x)berechnet die Folge von a+b's mit einem a+Nullam Ende. Wir teilen durch dund Rifflefügen jeweils (a+b)/dzwischen aund ein b. Zuwachsd .
2. Wählen Sie die IntegerElemente der resultierenden Liste aus. (Dies wird auch von der Nulleingeführten los {##2,}.)

Dies wird wiederholt, bis sich das Ergebnis nicht mehr ändert (was nur passieren kann, weil wir alle neuen Elemente entfernt haben, weil keine von ihnen Ganzzahlen waren).

-8 Bytes dank @MartinEnder von using //.anstatt FixedPoint(und von der Eingabe als Liste).

-6 mehr, weil ListConvolveeigentlich nicht so toll ist

Ruby , 80 Bytes

->a,d=2{*b=a[0];a.each_cons 2{|x,y|z=x+y;b+=z%d>0?[y]:[z/d,y]};b==a ?a:f[b,d+1]}

Probieren Sie es online!

Rekursive Funktion, fdie Eingaben als Array verwendet [p, q].

Haskell, 85 81 Bytes

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

Probieren Sie es online!

Die Eingabe wird als Liste übernommen, z [1,2] .

Edit: -4 Bytes dank @Laikoni.

Python 2 , 112 110 108 105 103 Bytes

^{-2 Bytes dank Jonathan Frech
-5 Bytes dank Erik the Outgolfer}

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

Probieren Sie es online!

Python 2 , 98 Bytes

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

Aufrufen als f([p,q]). Probieren Sie es online!

Jonathan Allan sparte 12 Bytes. Vielen Dank ~!

Erläuterung

fist eine rekursive Funktion: f(A, B, d)Wertet aus f(next_A, A, d+1), es sei denn A == B, in diesem Fall wird zurückgegeben A. (Dies wird gehandhabt von A*(A==B)or …: wenn A ≠ B A*(A==B)die leere Liste ist, die falsch ist, wird der …Teil ausgewertet; wenn A = B dann A*(A==B)ist A, was nicht leer und somit wahr ist, wird er zurückgegeben.)

next_A wird berechnet als:

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

Dies lässt sich am besten anhand eines Beispiels erklären. Wenn zB d = 5 und A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]

Python 2 , 111 Bytes

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

Probieren Sie es online!

-8 danke an Rod .
-2 danke an Lynn .

Schale , 22 Bytes

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

Nimmt eine Liste mit 2 Elementen auf, gibt eine Liste mit ganzen Zahlen und Gleitkommazahlen zurück. Probieren Sie es online!

Erläuterung

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.

Perl 5 , 92 + 1 (-a ) = 93 Bytes

do{$c=0;@n=shift@F;$.++;push@n,($t=$_+$n[-1])%$.?$_:($c=$t/$.,$_)for@F;@F=@n}while$c;say"@F"

Probieren Sie es online!

Netzhaut , 111 Bytes

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

Probieren Sie es online!

Nimmt die Eingabe als durch Leerzeichen getrennte Zahlen. Ganz naiv folgt der gegebene Algorithmus, wobei die einzige bemerkenswerte Technik darin besteht, ein Markersymbol zu verwenden,a , um festzustellen, wann eine der Zahlen erhalten geblieben ist. Dies wird verwendet, um mit den etwas eingeschränkten Schleifenfunktionen von Retina zu arbeiten, die es Ihnen nur ermöglichen, eine Schleife zu erstellen, bis eine Reihe von Stufen den Eingang zu diesen Stufen insgesamt nicht mehr ändert.

Erläuterung:

Dies wird dasselbe Beispiel wie in der Frage verwenden.

\d+
$*1;

Wir ändern das Eingabearray von Zahlen in ein durch Semikolons getrenntes unäres Array, also hätten wir:

1; 111111111111111111111;

^
11@

Schreiben Sie dam Anfang in unseren Code und geben Sie uns:

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

Das ist etwas komplizierter. {Startet eine Gruppe von Stufen, die ausgeführt werden, bis sie einen festen Punkt erreichen. Zeigt dann an, +dass diese Stufe selbst bis zu einem festen Punkt ausgeführt werden soll. Diese Stufe fügt jedes Paar benachbarter Zahlen hinzu, fügt sie jedoch ohne das zusätzliche Semikolon ein. Jetzt hätten wir:

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

Die andere schwierige Phase, diese, akkumuliert unseren Divisor in der ersten Erfassungsgruppe und ersetzt eine beliebige Nummer in unserer Liste ohne nachfolgendes Semikolon durch diese durch dividierte Nummer d. Wir fügen adiesen Zahlen auch ein Anführungszeichen hinzu, um anzuzeigen, dass etwas beibehalten wurde, und um anzuzeigen, dass ;es dauerhaft Teil des Arrays sein sollte. Jetzt hätten wir:

11@1; a11111111111; 111111111111111111111;

 1+ 

Dadurch werden Zahlen gelöscht, ddie vor dieser Runde weder durch noch im Array teilbar waren . Dies ändert sich in unserem Beispiel nicht.

.*a
1&$

Dies stimmt vom Anfang der Zeichenfolge bis zum letzten Buchstaben ain der Eingabe gierig überein . Dies bedeutet, dass es höchstens eine Übereinstimmung geben kann. Wenn wir Änderungen vorgenommen haben, fügen wir eine hinzu d, andernfalls lassen wir sie unverändert , damit wir die Schleife verlassen können.

111@1; a11111111111; 111111111111111111111;

)`a

Das )schließt die Schleife, mit der begonnen wurde {(nicht in Frage stellen!), Und ansonsten entfernt diese Stufe nur die Markierungen, die wir zuvor gesetzt haben. Da dies das Ende der Schleife ist, würden wir die obigen Schritte viele Male wiederholen, aber ich werde einfach so weitermachen, als hätte ich die Schleife vergessen, da dies das Beispiel kontinuierlicher macht.

111@1; 11111111111; 111111111111111111111;

1+@

Diese Stufe entfernt sich von unserer Ausgabe:

1; 11111111111; 111111111111111111111;

1+
$.&

Diese Stufe ersetzt die unären Zahlen durch Dezimalzahlen:

1; 11; 21;

;

In der letzten Phase werden die Semikolons entfernt:

1 11 21

Das Überspringen der Schleife führt hier natürlich zu einem falschen Ergebnis, aber das ist hoffentlich nicht zu verwirrend.

JavaScript (ES6), 89 87 82 Byte

Vielen Dank an @Arnauld für -2 Bytes und für das Sparen von 5 weiteren Bytes.

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

Übernimmt die Eingabe als Array: f([p,q]) .

Testfälle

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

Röda , 90 Bytes

f a,d=2{A=[a()|slide 2|[_,(_1+_)/d]if[(_1+_2)%d=0]else[_1]]+a[-1]f A,d=d+1 if[a!=A]else A}

Probieren Sie es online!

Java 8, 180 Bytes

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

Erläuterung:

Probieren Sie es hier aus.

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method

C # 280 Bytes

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

Erster Versuch mit Codegolf, das ist das ganze Programm. Probier es aus

Versuch 2, 159 Bytes

Entfernen des Gerüsts, da die Aufgabe darin besteht, eine Funktion bereitzustellen, die ein Zahlenpaar annehmen kann (ein Array funktioniert) und ein Array zurückgibt. Da ein Func <int [], int []> F verwendet werden kann, um die Anforderungen zu erfüllen, definieren Sie einfach F :

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

Testen Sie hier das vollständige Programm

Dies könnte kleiner sein, wenn eine generische Liste als gültige Ausgabe betrachtet wird (löschen Sie das .ToArray (), um 10 Bytes zu sparen).

Wenn die Eingabe auch geändert werden kann, muss durch die Übergabe einer Liste <int> anstelle eines Arrays die Ausgabe nicht mehr initialisiert werden (bei 126 Byte).

In diesem Fall muss es keinen Rückgabewert geben. Die Verwendung einer Aktion entfernt stattdessen die 9 Bytes, die von der return-Anweisung verwendet werden.

Jelly , 19 Bytes

®‘©‘÷@+2\⁸żFfṀR$µÐL

Probieren Sie es online!