Bei einem Array nicht negativer Ganzzahlen besteht Ihre Aufgabe darin, nur bestimmte Elemente davon beizubehalten, wie im Folgenden beschrieben.

• Angenommen, das Array ist [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Zuerst sollten Sie das erste Element des Arrays n. Behalten Sie die ersten nElemente und werfen Sie das nächste weg (werfen Sie das n+1th weg). Das neue Array ist [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Dann greifen Sie zu dem Element, das dem entfernten folgt, und tun genau dasselbe. Wenn wir den Prozess erneut anwenden, erhalten wir[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Sie wiederholen den Vorgang, bis Sie außerhalb der Grenzen des Arrays ankommen bzw. keine Elemente mehr im Array vorhanden sind. Wir hören auf, weil 11höher als die Länge des Arrays ist.

• Nun sollten Sie das Ergebnis ausgeben.

Die Eingabe / Ausgabe kann in jeder Standardform erfolgen. Das Array wird niemals leer sein und nur nicht negative ganze Zahlen enthalten. Alle Standardlücken sind verboten.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Testfälle

Eingabe -> Ausgabe

[1, 2, 3, 4, 5] -> [1, 3, 4]

[6, 1, 0, 5, 6] -> [6, 1, 0, 5, 6]

[1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1] -> [1, 2, 11, 5, 2, 0, 13, 10, 1]

[2, 2, 2, 2, 2] -> [2, 2]

[1, 2, 3, 1, 2, 3, 1, 2, 3] -> [1, 2]

[3, 1, 2, 4, 0] -> [] *

* Der letzte Testfall beinhaltet 0, also habe ich beschlossen, den Prozess so zu posten, dass er klarer ist:

[3, 1, 2, 4, 0] --> [3, 1, 2, 0] --> [1, 2, 0] --> [1, 0] --> [0] --> [] )

^{( Inspiriert von dieser Herausforderung von Erik dem Outgolfer )}

Pyth, 18 Bytes

#IgZlQB .(Q=Z@QZ)Q

Probieren Sie es hier aus.

JavaScript (ES6), 45 Byte

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

Testfälle

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

console.log(JSON.stringify(f([1, 2, 3, 4, 5]))) // --> [1, 3, 4]
console.log(JSON.stringify(f([6, 1, 0, 5, 6]))) // --> [6, 1, 0, 5, 6]
console.log(JSON.stringify(f([1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]))) // --> [1, 2, 11, 5, 2, 0, 13, 10, 1]
console.log(JSON.stringify(f([2, 2, 2, 2, 2, 2]))) // --> [2, 2]
console.log(JSON.stringify(f([1, 2, 3, 1, 2, 3, 1, 2, 3]))) // -> [1, 2]
console.log(JSON.stringify(f([3, 1, 2, 4, 0]))) // --> []

Haskell , 50 Bytes

g.pure.(0:)ist eine anonyme Funktion, die eine Liste von Ints aufnimmt und zurückgibt (g.pure.(0:))[1,2,3,4,5].

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

Probieren Sie es online!

Wie es funktioniert

• Die Funktion verwendet gein Tupelargument, das eine geteilte Liste darstellt. aist die Liste der Anfangselemente, die im vorherigen Schritt _gespeichert wurde, bist das zu verwerfende Element , ist das nächste als Länge zu verwendende Element und csind die verbleibenden Elemente.
  • Wenn im zweiten Teil des Tupels genügend Elemente vorhanden sind, um a auszuwählen b, wird eine neue Aufteilung durchgeführt und es wird eine gRekursion durchgeführt. Ansonsten stoppt es mit adem Ergebnis.
• Die anonyme Funktion g.pure.(0:)startet alles, indem sie gmit dem Tupel aufruft ([],0:l), wo lsich die Eingabe befindet und 0von sofort verworfen wird g.
  • pureHier wird die ApplicativeInstanz für (binäre) Tupel verwendet, und mit dem Ergebnistyp wird ([Int],[Int])das Argument bequem als zweites Element in ein Tupel mit []als erstem Element eingefügt.

Python 3 , 59 Bytes

f=lambda a,i=0:f(a[:a[i]]+a[a[i]+1:],a[i])if i<len(a)else a

Probieren Sie es online!

Haskell , 51 Bytes

f s=s%s
s%(n:_)|(x,_:z)<-splitAt n s=(x++z)%z
s%_=s

Probieren Sie es online! Beispiel Nutzung: f [1,2,3,4,5].

Java 8, 68 Bytes

Dieses Lambda akzeptiert eine veränderbare List<Integer>(unterstützt remove(int)zB ArrayList). Ausgang ist mutierter Eingang. Zuweisen zu Consumer<List<Integer>>.

l->{for(int i=0,f=0;i<l.size();f^=1)i=f>0?l.remove(i)*0+i:l.get(i);}

Probieren Sie es online

Der Kontrollfluss für dieses Problem ist sehr ärgerlich. Bei jeder Iteration müssen wir ein Element entfernen und das Element an der nächsten Position abrufen. Beide Operationen erfordern eine Bereichsprüfung (und beide können die Programmbeendigung auslösen). Eine Strategie besteht darin, beide Operationen in einer einzigen Schleifeniteration auszuführen, wobei die Indexaktualisierung durch eine eigene Bereichsprüfung geschützt wird. Eine andere Strategie, die sich als kürzer herausgestellt hat, besteht darin, bei jeder Schleifeniteration zwischen den Operationen zu wechseln. Dies ist die Aufgabe dieser Lösung.

APL (Dyalog Classic) , 32 Byte

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

Erläuterung

1∘{                             } bind 1 as starting left argument (⍺)
                             ⍳≢⍵  generate indexes for right argument (⍵)
                   (n←1+⍺⊃⍵)      n is 1+item at position ⍺ 
              w←⍵/⍨         ≠     w is ⍵ with item at n removed
   n∇⍣(n≤≢w)⊢                     recurse with n as left and w as right arg if n <= length of w

Probieren Sie es online!

Perl 5 , 38 + 1 (-a) = 39 Bytes

splice@F,$p=$F[$p],1while$p<@F;say"@F"

Probieren Sie es online!

Haskell, 99 Bytes (88 ohne Einrückung)

f x y
 |y>=l=f x$l-1
 |e>=l=x
 |True=f (take e x ++ drop (1+e) x) e
 where e=x!!y
       l=length x

VI, 31-25 Bytes

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?> entspricht Control + ? , und <Esc>zu Escapeoffensichtlich. Diese zählen jeweils 1 Byte (siehe Meta ).

Eingang

Die Eingabedatei sollte 1 Ganzzahl pro Zeile + 1 Leerzeile am Ende enthalten. Beispiel:

1
2
3
4
5
⁣

Wir können jede Zeile der Eingabedatei als Array-Element 1 :: 2 :: 3 :: 4 :: 5 :: []anzeigen, z. B. in einigen Sprachen (z. B. caml).

Starten

Sie können vi mit dem folgenden Befehl starten und die Lösung Strich für Strich eingeben:

vi -u NONE input

Sie können auch diesen Einzeiler verwenden:

vi -u NONE -c ':exec "norm O@0kdd\<C-v>\<C-a>Y\<C-v>\<C-x>gg@a\<Esc>\"add\<C-a>Y\<C-x>@a"' -c ":w output" -c ':q' input

Dies sollte eine Datei outputmit dem richtigen Ergebnis aus einer Eingabedatei erzeugeninput .

Erklärungen

Um die Lösung vorzustellen, stelle ich zunächst eine 19-Byte-Lösung vor, die nur für Arrays ohne 0 funktioniert. Diese Lösung verwendet ein rekursives Makro, das in der endgültigen Lösung nur geringfügig geändert wurde:

Yqa@0ddYgg@aquggY@a

Erklärung einer Teillösung

Y                       # yank first line (first integer + line break) to "0 register
 qa                     # start recording a macro ("a register)
   @0                   # jump n lines, where n is the content of the "0 register
     dd                 # delete the current line (n+1th line)
       Y                # yank current line (integer after the previously deleted line)
        gg              # go back to the first line
          @a            # recurse on macro "a"
            q           # finish recording the macro
             u          # cancel modifications done by the execution of the macro
              gg        # go back to the first line
                Y@a     # apply the recorded macro with first parameter equal to the first integer

Der Trick dabei ist, das "0Register zum Speichern der aktuellen Ganzzahl (und des Zeilenumbruchs, sehr wichtig) zu verwenden. Daher @0erlaubt der Befehl , nZeilen zu springen ( nden Wert von aufzurufen "0). Wenn der Sprung die Anzahl der Zeilen in der Datei überschreitet, schlägt das Makro fehl, und das Programm stoppt (je nach Bedarf außerhalb der Array-Grenzen).

Diese Lösung funktioniert aber nicht, wenn die Eingabe enthält 0. Tatsächlich springt , wenn der "0Registerwert gleich ist 0, @0eine Zeile (aufgrund des Zeilenumbruchs), nicht so, 0wie wir es wollten. Der nächste Befehl ( dd) löscht also nicht die 0. Ganzzahl, sondern die 1. (nicht korrekt).

Eine gültige Lösung für dieses 0Problem besteht darin, die Ganzzahl vor dem Ziehen immer zu erhöhen und unmittelbar danach zu dekrementieren. Somit @0springt der Befehl über n+1Zeilen ( nist die aktuelle Ganzzahl, die inkrementiert wurde). Es kist dann ein Befehl erforderlich, um in die Zeile n(vorherige Zeile) zu wechseln. Mit diesem Trick wird eine leere Zeile am Ende der Eingabedatei benötigt, um zu vermeiden, dass das Array verlassen wird (wodurch das Programm beendet wird), da wir jetzt immer n+1Zeilen springen , bevor wir zur vorherigen Zeile springen.

Erläuterung der endgültigen Lösung

O                                                       # insert a new line at the beginning of the file, enter insert mode to write the macro content
 @0                                                     # jump n lines                                                       
   k                                                    # go to the previous line
    dd                                                  # delete this line
      <C-v><C-a>                                        # type Control+A (C-v is needed because we are in insert mode) to increment the current integer
                Y                                       # yank the incremented integer
                 <C-v><C-x>                             # decrement the current integer
                           gg                           # go to the first line
                             @a                         # recurse on macro "a"
                               <Esc>                    # exit insert mode : at this step, the first line of the file contains the macro content @0kdd^AY^Xgg@a
                                    "add                # copy @0kdd^AY^Xgg@a line to the register "a and delete the line
                                        <C-a>           # increment the first integer
                                             Y          # yank it (into "0)
                                              <C-x>     # decrement the first integer
                                                   @a   # apply macro in a" (initial @0 will jump n+1 lines, since we incremented the first integer before calling the macro)

Wenn Sie den Makro-Inhalt vor der Registrierung in die Datei schreiben, können Sie einige Bytes sparen:

• vermeidet das Schreiben qa...qund Rückgängigmachen aller Änderungen nach der Registrierung
• vermeidet :let @a="...")

Bearbeitungen

# 1

• Schreiben Sie den Makro-Inhalt in die erste Zeile (anstelle der letzten Zeile)
• Eingabe ändern (1 Leerzeile am Ende)
• Fügen Sie einen Einzeiler hinzu, um ihn in der Befehlszeile zu testen

Pyth, 32 Bytes

VlQIgNlQBK@QNI!K=QYBIgKlQB.(QK;Q

Probieren Sie es online aus

C # (.NET Core) , 74 Byte

n=>{for(int i=n[0];i<n.Count;){n.RemoveAt(i);i=i<n.Count?n[i]:n.Count+1;}}

Probieren Sie es online!

Dies nimmt eine Liste von Ints auf und ändert sie. Ich habe einige Java-Antworten gesehen, die Importe umgehen, indem sie den vollständig qualifizierten Namen in der Lambda-Argumentdefinition verwenden. Wenn dies nicht erlaubt ist, kann ich diese Antwort entfernen.

R , 64 53 Bytes

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

Rekursive Funktion. Hat man einen Pflichteintrag, akann die Liste übersprungen werden. iist der Index für die Anzahl der zu überspringenden Elemente (standardmäßig 1) und dder Index für das nächste Element, nachdem der erforderliche Wert entfernt wurde. Dies ist auch der Index für das zu entfernende Element. Gibt numeric(0)einen leeren Vektor für eine leere Ausgabe zurück.

Probieren Sie es online!

Ungolfed:

f <- function(a, i = 1, d = a[i] + 1) {
  if(is.na(d)) {   # d is NA if and only if a[i] is out of bounds
    a
  } else {
    f( a[-d], d, a[d] + 1 )   # a[-d] is a with the item at index d removed
  }
}