Biorąc pod uwagę tablicę liczb całkowitych nieujemnych, Twoim zadaniem jest zachowanie tylko niektórych jego elementów, jak opisano poniżej.

• Powiedzmy, że tablica jest [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Najpierw uzyskać pierwszy element tablicy n. Zatrzymaj pierwsze nelementy i odrzuć następny (odrzuć n+1th). Nowa tablica to [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Następnie łapiesz element po usuniętym i robisz dokładnie to samo. Ponownie stosujemy ten proces[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Powtarzasz ten proces, dopóki nie dojdziesz poza granice tablicy / nie ma już elementów w tablicy. Zatrzymujemy się, ponieważ 11jest większa niż długość tablicy.

• Teraz powinieneś wypisać wynik.

Dane wejściowe / wyjściowe można przyjmować / dostarczać w dowolnej standardowej formie. Tablica nigdy nie będzie pusta i będzie zawierać tylko nieujemne liczby całkowite. Wszystkie standardowe luki są zabronione.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach!

Przypadki testowe

Wejście -> Wyjście

[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, 2]

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

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

* Ostatni przypadek testowy dotyczy 0, więc postanowiłem opublikować proces, aby był bardziej przejrzysty:

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

^{( Inspirowane przez to wyzwanie przez Erik Outgolfer )}

Pyth, 18 bajtów

#IgZlQB .(Q=Z@QZ)Q

Wypróbuj tutaj.

JavaScript (ES6), 45 bajtów

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

Przypadki testowe

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 bajtów

g.pure.(0:)to anonimowa funkcja pobierająca i zwracająca listę Ints, użyj jako (g.pure.(0:))[1,2,3,4,5].

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

Wypróbuj online!

Jak to działa

• Funkcja gprzyjmuje argument krotki reprezentujący podzieloną listę. ato lista początkowych elementów przechowywana w poprzednim kroku, _to element, który należy odrzucić, bto następny element, który zostanie użyty jako długość, i cpozostałe elementy.
  • Jeśli w drugiej części krotki jest wystarczająca liczba elementów, aby wybrać a b, następuje nowy podział i następuje on gponownie. W przeciwnym razie zatrzymuje się aw wyniku.
• Anonimowa funkcja g.pure.(0:)rozpoczyna wszystko od wywołania gz krotką ([],0:l), w której lznajduje się dane wejściowe, i 0zostaje natychmiast odrzucona przez g.
  • puretutaj używa Applicativeinstancji krotek (binarnych), a typ wyniku ([Int],[Int])wygodnie umieszcza argument jako drugi element w krotce z []pierwszym elementem.

Python 3 , 59 bajtów

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

Wypróbuj online!

Haskell , 51 bajtów

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

Wypróbuj online! Przykładowe zastosowania: f [1,2,3,4,5].

Java 8, 68 bajtów

Ta lambda akceptuje zmienną List<Integer>(obsługuje remove(int)np ArrayList.). Wyjście jest zmutowanym wejściem. Przypisz do 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);}

Wypróbuj online

Przepływ sterowania tym problemem jest bardzo denerwujący. Każdą iterację musimy usunąć element i ustawić element w następnej pozycji, a obie te operacje wymagają sprawdzenia zasięgu (i każda z nich może wyzwalać zakończenie programu). Jedną strategią jest przeprowadzanie obu operacji w jednej iteracji w pętli, z aktualizacją indeksu strzeżoną przez własną kontrolę zasięgu. Inną strategią, która okazała się krótsza, jest naprzemienne wykonywanie operacji w każdej pętli, co robi to rozwiązanie.

APL (Dyalog Classic) , 32 bajty

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

Wyjaśnienie

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

Wypróbuj online!

Perl 5 , 38 + 1 (-a) = 39 bajtów

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

Wypróbuj online!

Haskell, 99 bajtów (88 bez wcięcia)

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 bajtów

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

<C-?>odpowiada Control + ?, a <Esc>do Escapeoczywiście. Każdy z nich liczy się dla 1 bajtu (patrz meta ).

Wejście

Plik wejściowy powinien zawierać 1 liczbę całkowitą na linię + 1 pustą linię na końcu, przykład:

1
2
3
4
5
⁣

Widzimy każdy wiersz pliku wejściowego jako element tablicy, na przykład 1 :: 2 :: 3 :: 4 :: 5 :: []jak w niektórych językach (na przykład caml).

Uruchomić

Możesz uruchomić vi za pomocą następującego polecenia i wpisać rozwiązanie skok po skoku:

vi -u NONE input

Możesz także użyć tej jednowierszowej:

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

Powinno to wygenerować plik outputz poprawnym wynikiem z pliku wejściowego input.

Objaśnienia

Aby wprowadzić rozwiązanie, najpierw przedstawię 19-bajtowe rozwiązanie działające tylko dla tablic bez 0. To rozwiązanie wykorzystuje rekurencyjne makro, używane z niewielką modyfikacją w ostatecznym rozwiązaniu:

Yqa@0ddYgg@aquggY@a

Wyjaśnienie częściowego rozwiązania

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

Sztuczka polega na tym, aby użyć "0rejestru do przechowywania bieżącej liczby całkowitej (i podziału linii, bardzo ważne). Dlatego polecenie @0pozwala przeskakiwać nlinie (wywołać nwartość "0). Jeśli skok przekroczy liczbę linii w pliku, makro nie powiedzie się, więc program zatrzyma się (poza granicami tablicy, zgodnie z wymaganiami).

Ale to rozwiązanie nie działa, jeśli dane wejściowe zawierają 0. Rzeczywiście, jeśli "0wartość rejestru jest równa 0, @0przeskoczy o jedną linię (z powodu podziału linii), a nie 0tak, jak nam się podobało. Zatem następne polecenie ( dd) nie usunie 0-tej liczby całkowitej, ale 1-szą (niepoprawną).

Prawidłowym rozwiązaniem tego problemu 0jest zawsze zwiększanie liczby całkowitej przed jej wyrwaniem i zmniejszanie tuż po niej. Zatem @0polecenie przeskoczy o n+1linie ( nto bieżąca liczba całkowita, która została zwiększona). kPolecenia jest wtedy konieczne, aby przejść do wiersza n(poprzednia linia). Korzystając z tej sztuczki, potrzebna jest pusta linia na końcu pliku wejściowego, aby uniknąć przeskakiwania poza tablicę (a tym samym zakończenie programu), ponieważ teraz zawsze przeskakujemy n+1linie, przed przejściem do poprzedniej linii.

Wyjaśnienie ostatecznego rozwiązania

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)

Zapisanie zawartości makra w pliku przed zarejestrowaniem pozwala zaoszczędzić kilka bajtów:

• unika zapisywania qa...qi cofania wszystkich zmian po rejestracji
• unika :let @a="...")

Edycje

# 1

• napisz zawartość makra w pierwszym wierszu (zamiast w ostatnim wierszu)
• zmień wejście (1 pusty wiersz na końcu)
• dodaj linijkę do testowania w wierszu poleceń

Pyth, 32 bajty

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

Wypróbuj online

C # (.NET Core) , 74 bajty

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

Wypróbuj online!

To pobiera listę ints i modyfikuje ją. Widziałem niektóre odpowiedzi Java, które omijają import, używając w pełni kwalifikowanej nazwy w definicji argumentu Lambda. Jeśli nie jest to dozwolone, mogę usunąć tę odpowiedź.

R , 64 53 bajtów

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

Funkcja rekurencyjna. Ma jedno obowiązkowe wejście, alistę do pominięcia. ijest indeksem liczby rzeczy do przeskoczenia (domyślnie to 1) i djest indeksem następnego elementu po usunięciu wymaganej wartości, który jest również indeksem elementu do usunięcia. Zwraca numeric(0)pusty wektor dla pustego wyjścia.

Wypróbuj online!

Nie golfowany:

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