Pomiń jak królik!


41

Biorąc pod uwagę listę liczb całkowitych nieujemnych w dowolnym rozsądnym formacie, iteruj ją, pomijając tyle elementów, ile mówi każda liczba całkowita, na którą wkraczasz.


Oto działający przykład:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done

Kolejny działający przykład, nie tak jednakowo-deltowy:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done

Przykład poza zakresem:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds)

Zasady

  • Nie możesz używać nudnego oszustwa wśród tych , które sprawiają, że wyzwanie jest nudne i nieciekawe.
  • Powinieneś tylko zwrócić / wydrukować wynik końcowy. Dane wyjściowe STDERR są ignorowane.
  • Nie możesz otrzymać danych wejściowych jako ciąg cyfr w żadnej bazie (np. „0102513162” w pierwszym przypadku).
  • Do wprowadzania danych należy stosować kolejność od lewej do prawej.
  • Podobnie jak w sprawdzonych przykładach, jeśli wyjdziesz poza granice, wykonanie kończy się tak, jakby było inaczej.
  • Powinieneś użyć 0do pominięcia 0 elementów.
  • Biorąc pod uwagę pustą listę ( []) jako dane wejściowe, powinieneś powrócić [].

Przypadki testowe

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4]

To jest , więc wygrywa najkrótsza odpowiedź!


1
Czy mogę mieć końcowe zera w mojej tablicy? zaoszczędzi mi ~ 18 bajtów
Roman Gräf

@EriktheOutgolfer Czy możemy wyprowadzić tablicę ciągów i mieć końcowe puste ciągi?
TheLethalCoder

1
@TheLethalCoder Przepraszam, że powiedziałbym nie, ponieważ to nie jest rozsądne imo ... nie możesz po prostu usunąć końcowych ""s?
Erik the Outgolfer

2
@ RomanGräf Przepraszamy, ale nie, to byłoby zbyt dwuznaczne, ponieważ są przypadki, w których powinieneś mieć końcowe 0s na wyjściu.
Erik the Outgolfer

Odpowiedzi:



13

Python 2 , 49 44 * 41 bajtów

Przekreślone 44 jest nadal regularne 44 :(

* -3 dzięki tylko @ ASCII .

l=input()
while l:print l[0];l=l[l[0]+1:]

Wypróbuj online!

Drukuje wyniki oddzielone znakiem nowej linii, ponieważ OP jest dozwolony na czacie. Nie sądzę, że może stać się krótszy jako nierekurencyjny pełny program .


Jak to działa?

  • l=input() - Czyta listę ze standardowego wejścia.

  • while l: - Nadużywa faktu, że puste listy są w Pythonie fałszywe, zapętla się, dopóki lista nie będzie pusta.

  • print l[0]; - Drukuje pierwszy element listy.

  • l=l[l[0]+1:]- „Pomija jak królik” - przycina pierwszy l[0]+1z listy.

Weźmy przykład

Biorąc pod uwagę listę [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]jako wejściowych, wykonuje kod następujący (zgodnie z wyjaśnieniem powyżej) - Drukuje pierwszy element tablicy: 5, wykończenia pierwszych 6: [2, 1, 2, 1, 0, 0]. Następnie wydrukować 2i wykończenia pierwszy 3: [1,0,0]. Podobnie, produkujemy 1, przycinamy pierwsze 2 i otrzymujemy [0]. Oczywiście 0jest drukowany i program się kończy.




9

JavaScript (ES6), 42 39 35 bajtów

a=>a.map((n,i)=>a.splice(i+1,n))&&a

let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4]

Stare rozwiązanie 39 bajtów

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

-3 bajty dzięki @ThePirateBay


39 bajtówa=>a.map(n=>i--||r.push(i=n),r=i=[])&&r


8

Mathematica, 46 44 bajtów

SequenceCases[#,{x_,y___}/;Tr[1^{y}]<=x:>x]&

Alternatywy:

SequenceCases[#,{x_,y___}/;x>=Length@!y:>x]&
SequenceCases[#,l:{x_,___}/;x>Tr[1^l]-2:>x]&

7

C #, 68 bajtów

a=>{for(int i=0;i<a.Count;i+=a[i]+1)System.Console.Write(a[i]+" ");}

Wypróbuj online!

Wersja pełna / sformatowana:

namespace System
{
    class P
    {
        static void Main()
        {
            Action<Collections.Generic.List<int>> f = a =>
            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List<int>() { });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
}

Zwracanie listy jest dłuższe i wynosi 107 bajtów.

a=>{var l=new System.Collections.Generic.List<int>();for(int i=0;i<a.Count;i+=a[i]+1)l.Add(a[i]);return l;}

2
Dlaczego ktoś głosował za tym?
TheLethalCoder

Aby zaokrąglić wynik i zrobić idealne 5 000?
Thomas Ayoub,

@ThomasAyoub Możemy tylko założyć, że był to ktoś z OCD tak.
TheLethalCoder

6

Łuska , 8 6 bajtów

←TU¡Γ↓

Wypróbuj online!

-2 bajty (i zupełnie nowy pomysł na rozwiązanie) dzięki Leo!

Wyjaśnienie

Używam funkcji dopasowania wzorca listy Γ. Zajmuje funkcji foraz listę z głową xi ogonem xs, i odnosi się fdo xa xs. Jeśli lista jest pusta, Γzwraca wartość domyślną zgodną z jej typem, w tym przypadku pustą listą. Uważamy fsię za , który odrzuca xelementy xs. Ta funkcja jest następnie iterowana, a powstałe elementy są gromadzone na liście.

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4]

Możesz upuścić domyślną wartość ø, a wszystko będzie nadal magicznie działać :)
Leo


@Leo O wow, to sprytne!
Zgarb

Dlaczego to zrobiłeś?
Erik the Outgolfer

@ErikTheOutgolfer To był błąd (rozmawiam przez telefon i najwyraźniej popchnąłem coś przez przypadek). Próbuję to cofnąć ...
Zgarb,


5

Pyth, 22 bajtów

VQ aY.(Q0VeY .x.(Q0 ;Y

Usunięto bezużyteczny bajt


Widzę tam 23 bajty.
Erik the Outgolfer,

Typo :) przepraszam ...
Dave

3
Nie jestem pewien, dlaczego masz głos negatywny. Istnieje możliwość, że podczas edytowania poprawiania odpowiedzi wywołało to „automatyczne głosowanie w dół”. Przyczyny tego automatycznego przegłosowania są mylące i okropne, ale dzieje się tak, jeśli system uważa twoją odpowiedź za „niską jakość” w oparciu o heurystykę. Możliwe jest również, że ktoś nie polubił twojej odpowiedzi, ale nie widzę w tej chwili nic złego, więc nie jestem pewien, dlaczego tak jest.
Wheat Wizard

Cieszę się, że używasz Pytha!
isaacg


3

Siatkówka , 36 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$

Wejścia i wyjścia są oddzielone od linii za pomocą końcowego linii.

Wypróbuj online! (Używa przecinków zamiast linii, aby umożliwić wygodne zestawy testów).


3

Brain-Flak , 64 bajty

([]){{}(({})<>)<>{({}[()]<{}>)}{}([])}{}<>([]){{}({}<>)<>([])}<>

Wypróbuj online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack

7
O kurczę! Napisałem rozwiązanie, a następnie przewinąłem w dół, aby je opublikować, ale okazało się, że napisaliśmy dokładnie to samo rozwiązanie bajt po bajcie! Nawet drobne szczegóły, takie jak ({}[()]<{}>)vs, ({}<{}>[()])były takie same! Co za zbieg okoliczności!
DJMcMayhem

@DJMcMayhem kradnie całą sławę XD
Christopher

Zrobiłem również bajt dla bajtu identyczne rozwiązanie, ale grałem w golfa o 4 bajty . Tylko niektóre opóźnione zawody :)
Wheat Wizard

2

Mathematica, 64 50 bajtów

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}

Nie mogłem się oprzeć dalszej grze w ten zgrabny kod; moja odpowiedź jest poniżej.
Mr.Wizard

2

C # (.NET Core) , 68 bajtów

n=>{var t="";for(int i=0;i<n.Length;i+=n[i]+1)t+=n[i]+" ";return t;}

Wypróbuj online!

Pobiera dane wejściowe jako tablicę liczb całkowitych, zwraca ciąg zawierający wartości, które nie zostały pominięte.


Fajny sposób na zrobienie tego i liczy się tak samo jak drukowanie.
TheLethalCoder

Uwielbiam proste rozwiązania. Wciąż muszę się uczyć LINQ, ponieważ widziałem, że skrócenie tak wielu c #
lambdas

Skraca go, ponieważ przez większość czasu możesz domniemywać zwrot. Chociaż jest to rzut pomiędzy ukrytym zwrotem z using System.Linq;normalną pętlą.
TheLethalCoder

2

R, 58 bajtów

f=function(x,p=1){cat(z<-x[p]);if(p+z<sum(x|1))f(x,p+z+1)}

Funkcja rekurencyjna. Bierze wektor xjako argument i intiuje wskaźnik p. Spowoduje to wydrukowanie odpowiedniego wpisu x, sprawdzenie, czy p+x[p]wyjdzie poza granice, a jeśli nie, wywołuje funkcję nowego wskaźnika.

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z])))

Jest to porównywalne rozwiązanie, które zwraca prawidłowy wektor zamiast drukowania cyfr.


co z wkładem numeric(0)? aka pusta tablica.
Giuseppe,

@Giuseppe Rzucę okiem, gdy będę za komputerem
JAD


2

Java (OpenJDK 8) , 53 bajty

Dzięki @ PunPun1000 i @TheLethalCoder

a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);}

Wypróbuj online!


Czy wydrukowanie wyników, tak jak w mojej odpowiedzi w języku C #, pozwoliłoby Ci coś zaoszczędzić?
TheLethalCoder

@TheLethalCoder Nie spróbuję
Roman Gräf

Czy możesz zapisać bajt, przechodząc ndo pętli?
TheLethalCoder

Ponadto wydaje się, że obecnie nie działa.
TheLethalCoder

Brakuje parena po (a[n+=1+a[n]]. Funkcja generuje również błąd po wypisaniu poprawnej wartości, nie wiem, czy jest to dozwolone, czy nie (pytanie mówi, że standardowy błąd jest ignorowany). Jeśli taka była intencja, możesz usunąć n<a.lengthpętlę for. Wreszcie kod TIO nie działa tak, jak jest, nawet w przypadku paren. Funkcja powinna być Consumer<int[]>afunc.accept(test)
PunPun1000,

2

Alice , 15 bajtów

/$.. \h&
\I@nO/

Wypróbuj online!

Wprowadź i wyodrębnij rozdzielone wierszem listy liczb całkowitych dziesiętnych.

Wyjaśnienie

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning.

Zapisanie liczby całkowitej n w kolejce iteratora powoduje, że następne polecenie zostanie wykonane n razy. Lustra takie jak /nie są poleceniami, więc następnym poleceniem będzie I. Dlatego jeśli po prostu odczytamy i wydrukujemy wartość x , odczytamy wartości x + 1 podczas następnej iteracji, a ostatnia z nich znajdzie się na górze stosu. Pomija to wymagane elementy listy numerów.


2

Mathematica , 37 (30?)

Dalsza gra w golfa według metody użytkownika user202729.

±{a_,x___}={a}~Join~±{x}~Drop~a
±_={}

Reguły nie wydają się wyraźnie określać formatu wyjściowego, więc może:

±{a_,x___}=a.±{x}~Drop~a
±_={}

Dane wyjściowe dla drugiej funkcji wyglądają następująco: 0.2.4.{}- zwłaszcza {}jest zwracane dla pustego zestawu, zgodnie z ostateczną regułą.


1
±Drop[{x},a]może być, ±{x}~Drop~aponieważ ±ma niższy priorytet niż Infix.
JungHwan Min

@JungHwanMin Brakowało mi tego; dzięki!
Mr.Wizard


2

Brain-Flak , 64 60 bajtów

4 bajty oszczędzasz na podstawie pomysłu od 0 '

([]){{}(({})<>())<>{({}[()]<{}>)}{}([])}{}<>{({}[()]<>)<>}<>

Wypróbuj online!

Adnotacja

([]){{}            #{Until the stack is empty}
  (({})<>())<>     #{Put n+1 to the offstack}
  {({}[()]<{}>)}{} #{Remove n items from the top}
([])}{}            #{End until}
<>                 #{Swap stacks}
{({}[()]<>)<>}<>   #{Move everything back onto the left stack decrementing by 1}


1

Python 2.4, 85 bajtów

Nie ma szans na wygraną w pythonie, ale uwielbiam onelinerów, a ten może być interesujący dla innych.
Okazuje się, że istnieje fantastyczna magiczna sztuczka, aby uzyskać dostęp do listy budynków wewnątrz zrozumienia, ale działa tylko w wersji 2.4, a przy niektórych zmianach w <= 2.3
locals()['_[1]']tak jest. Python tworzy tajną nazwę _[1]dla listy podczas jej tworzenia i zapisywania locals. Również nazwy _[2], _[3]... są używane dla list zagnieżdżonych.

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])]

Liczy więc liczbę już dodanych elementów plus ich sumę. Wynik jest indeksem następnego pożądanego elementu.
Myślę, że powinien istnieć sposób na uniknięcie wyliczenia. Jak dostęp do tablicy wejściowej bezpośrednio przez indeks: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Ale nie mogę wymyślić kompaktowego sposobu, aby zabezpieczyć go przed indeksowaniem poza zasięgiem (zachowując go oneliner)

wprowadź opis zdjęcia tutaj


1

Szybki, 63 bajty

func a(d:[Int]){var i=0;while i<d.count{print(d[i]);i+=d[i]+1}}

To jest mój pierwszy wpis, więc nie jestem w 100% pewien zasad, ale mam nadzieję, że ta odpowiedź wystarczy. Nie jestem pewien zasad dotyczących wprowadzania danych wejściowych do systemu. Mam krótszą odpowiedź, jeśli pozwolono mi przyjąć funkcję, która może zwrócić dane wejściowe.


Witamy w PPCG! Domyślnymi regułami jest to, że możesz mieć kod, który działa jako pełny program, więc wprowadź (zwykle) w STDIN i wyślij (zwykle) do STDOUT, lub funkcję, więc wejdź (zwykle) z parametrów funkcji i wyjdź (zwykle) z funkcja return.
Stephen

@StepHen - dzięki! To chyba powoduje, że moja inna wersja jest wtedy nieważna. Czekamy na więcej!
AnonymousReality

1

Perl 6 , 31 bajtów

{(@_,{.[1+.[0]..*]}...^0)[*;0]}

Sprawdź to

Rozszerzony:

{  # bare block lambda with implicit parameter 「@_」
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
}

Aby pomóc zrozumieć, jak działa kod, bez [*;0]tego wygenerowałby sekwencję podobną do następującej:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2)

1

Galaretka , 8 bajtów

ḢṄ‘ṫ@µL¿

Pełny program drukujący wyniki, po którym następuje nowa linia (pusta lista nie generuje danych wyjściowych).

Wypróbuj online!

W jaki sposób?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         '''

Wreszcie odpowiedź galaretki! BTW Mogę to zrobić w 7 bajtach.
Erik the Outgolfer

Mam również funkcję zwracania listy w 18 bajtach.
Erik the Outgolfer,

1

Python 3 , 35 bajtów

f=lambda h=0,*t:t and[h,*f(*t[h:])]

Wypróbuj online!

Uruchom z tym, f(*l)gdzie ljest twój wkład. Prawdopodobnie rozciąga reguły wprowadzania, ale uwielbiam zaawansowane rozpakowywanie.




Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.