Avec une liste d'entiers non négatifs dans n'importe quel format raisonnable, parcourez-la en ignorant autant d'éléments que chaque nombre entier indiqué.
Voici un exemple travaillé:
[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
Un autre exemple travaillé, pas si égal à tous les deltas:
[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
Un exemple hors limites:
[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)
Règles
- Vous ne pouvez utiliser aucune astuce ennuyeuse parmi celles-ci , elles rendent le défi ennuyeux et sans intérêt.
- Vous devez uniquement renvoyer / imprimer le résultat final. La sortie STDERR est ignorée.
- Vous ne pouvez pas obtenir l'entrée sous forme de chaîne de chiffres dans aucune base (par exemple, "0102513162" pour le premier cas).
- Vous devez utiliser un ordre de gauche à droite pour la saisie.
- Comme dans les exemples travaillés, si vous sortez des limites, l'exécution se termine comme si c'était le cas.
- Vous devriez utiliser
0
pour sauter 0 éléments. - Étant donné la liste vide (
[]
) en entrée, vous devriez retourner[]
.
Cas de test
[] => []
[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]
C'est du code-golf , alors la réponse la plus courte gagne!
code-golf
array-manipulation
Erik l'Outgolfeur
la source
la source
""
?0
dans la sortie.Réponses:
Python 2 , 36 octets
Essayez-le en ligne!
la source
x[0]
au lieu dex[:1]
?[x[0]]
x[:1]
toute façon ...f=lambda x:x and[x[0]]+f(x[x[0]+1:])
Python 2 ,
49 44 *41 octets44 barré est encore régulier 44 :(
* -3 grâce à @ ASCII uniquement .
Essayez-le en ligne!
Imprime les résultats séparés par une nouvelle ligne, comme l'OP autorisé dans le chat. Je ne pense pas qu'il puisse être plus court en tant que programme complet non récursif .
Comment cela marche-t-il?
l=input()
- Lit la liste à partir de l'entrée standard.while l:
- Abuse du fait que les listes vides sont faussées en Python, boucle jusqu'à ce que la liste soit vide.print l[0];
- Imprime le premier élément de la liste.l=l[l[0]+1:]
- "Saute comme un lapin" - Coupe le premierl[0]+1
de la liste.Prenons un exemple
Compte tenu de la liste
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]
comme entrée, le code effectue les opérations suivantes (selon la définition ci - dessus) - imprime le premier élément de la matrice:5
, couper la première 6:[2, 1, 2, 1, 0, 0]
. Nous avons ensuite imprimer2
et couper les 3 premiers:[1,0,0]
. De même, nous produisons1
, coupons les 2 premiers et nous obtenons[0]
. Bien sûr,0
est imprimé et le programme se termine.la source
Haskell,
29 2726 octetsEnregistré 1 octet grâce à Zgarb.
Essayez-le en ligne.
la source
f x=x
sur la deuxième ligne enregistre un octet.JavaScript (ES6),
423935 octetsAncienne solution 39 octets
-3 octets grâce à @ThePirateBay
la source
a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r
05AB1E ,
109 octetsUtilise le codage 05AB1E . Essayez-le en ligne!
la source
Mathematica,
4644 octetsAlternatives:
la source
C #, 68 octets
Essayez-le en ligne!
Version complète / formatée:
Le renvoi d'une liste est plus long à 107 octets.
la source
Husk ,
8 à6 octetsEssayez-le en ligne!
-2 octets (et une idée de solution totalement nouvelle) grâce à Leo!
Explication
J'utilise la fonction de correspondance de modèle de liste
Γ
. Il prend une fonctionf
et une liste avec têtex
et queuexs
, et s'appliquef
àx
etxs
. Si la liste est vide,Γ
renvoie une valeur par défaut cohérente avec son type, dans ce cas une liste vide. Nous prenonsf
pour être↓
, ce qui laisse tomber desx
éléments dexs
. Cette fonction est ensuite itérée et les éléments résultants sont rassemblés dans une liste.la source
Python 2 ,
5955 octetsEssayez-le en ligne!
la source
l[i:i+l[i-1]]=[]
placedel l[i:i+l[i-1]]
pour sauvegarder un octetPyth, 22 octets
Suppression d'un octet inutile
la source
Python 2 ,
604241 octets-18 octets grâce à Luis Mendo
-1 octets grâce à Jonathan Frech
Essayez-le en ligne!
la source
i-=~x[i]
est un octet plus court quei+=1+x[i]
.Retina , 36 octets
Le nombre d'octets suppose un codage ISO 8859-1.
Les entrées et les sorties sont séparées par des sauts de ligne.
Essayez-le en ligne! (Utilise des virgules au lieu de sauts de ligne pour permettre des suites de tests pratiques.)
la source
Brain-Flak , 64 octets
Essayez-le en ligne!
la source
({}[()]<{}>)
vs({}<{}>[()])
étaient les mêmes! Quelle coïncidence!Mathematica,
6450 octetsla source
C # (.NET Core) , 68 octets
Essayez-le en ligne!
Prend l'entrée en tant que tableau d'entiers, retourne une chaîne contenant les valeurs non ignorées.
la source
using System.Linq;
une boucle normale.R, 58 octets
Fonction récursive. Prend un vecteur
x
comme argument et introduit un pointeurp
. Ceci affiche l’entrée correspondante dex
, vérifie sip+x[p]
les limites sont dépassées et, dans le cas contraire, appelle la fonction pour le nouveau pointeur.C'est une solution comparable qui renvoie un vecteur correct au lieu d'imprimer les chiffres.
la source
numeric(0)
? aka tableau vide.Java (OpenJDK 8), 53 bytes
Thanks to @PunPun1000 and @TheLethalCoder
Try it online!
la source
n
into the loop?(a[n+=1+a[n]]
. Function also throws an error after outputting the correct value, I don't know the concensus on whether this is allowed or not (the question does say anything to standard error is ignore). If that was the intention, then you can remove then<a.length
in the for loop. Finally the TIO code doesn't run as is, even with the paren. The function should be aConsumer<int[]>
and usefunc.accept(test)
Alice, 15 bytes
Try it online!
Input and output a linefeed-separated lists of decimal integers.
Explanation
Storing an integer n in the iterator queue causes the next command to be executed n times. Mirrors like
/
are not commands, so the next command will beI
. Therefore if we just read and printed a value x, we will read x+1 values on the next iteration, with the last of them ending up on top of the stack. This skips the required number list elements.la source
Mathematica, 37 (30?)
Further golfing of user202729's fine method.
The rules don't seem to explicitly specify the output format, so maybe:
Output for the second function looks like:
0.2.4.{}
— notably{}
is still returned for an empty set, conforming to the final rule.la source
±Drop[{x},a]
can be±{x}~Drop~a
because±
has a lower precedence thanInfix
.Common Lisp, 51 bytes
Try it online!
la source
Brain-Flak,
6460 bytes4 bytes save based on an idea from 0 '
Try it online!
Annotated
la source
Ruby,
36 3331Try it online.
la source
f=
as a header element.Python 2.4, 85 bytes
No chance to win in python with it, but I love oneliners and this one might be interesting to others.
Turns out, there is a fancy magic trick to access building list inside comprehension, but it works only in 2.4 and with some edits in <= 2.3
locals()['_[1]']
it is. Python creates secret name_[1]
for list, while it is created and store it inlocals
. Also names_[2]
,_[3]
... are used for nested lists.So it counts number of already added elements plus their sum. Result is the index of next desired element.
I think, that there should be a way to avoid enumerate. Like accessing input array directly by index:
[ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]
. But I can't figure out a compact way to protect it from index-out-of-range (while keeping it oneliner)la source
Swift, 63 bytes
This is my first entry, ever, so I'm not 100% sure on the rules, but hopefully this answer suffices. I'm a little unsure of rules on how to get the input into a system. I have a shorter answer if I was allowed to assume a function somewhere that can return the input.
la source
Perl 6, 31 bytes
Test it
Expanded:
To help understand how the code works, without
[*;0]
this would generate a sequence like the following:la source
Jelly, 8 bytes
A full program printing the results each followed by a newline (empty list produces no output).
Try it online!
How?
la source
Python 3, 35 bytes
Try it online!
Run it with
f(*l)
wherel
is your input. Arguably stretching the rules for input, but I just love advanced unpacking.la source
APL (Dyalog Unicode), 20 bytesSBCS
Try it online!
la source
Perl 5,
3630 + 1 (-a) = 31 bytesTry it online!
Takes its input as a space separated list of numbers.
la source
PowerShell, 25 bytes
Try it online!
la source