Passer comme un lapin!

Erik the Outgolfer 08/26/2017. 30 answers, 2.887 views
code-golf array-manipulation

À partir d'une liste d'entiers non négatifs dans tout format raisonnable, parcourez-la en ignorant autant d'éléments que chaque entier sur lequel vous parlez.


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 tout-égal-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 pas utiliser de triche ennuyeuse parmi ceux-ci , ils rendent le défi ennuyeux et inintéressant.
  • Vous devriez seulement retourner / imprimer le résultat final. La sortie STDERR est ignorée.
  • Vous ne pouvez pas obtenir l'entrée comme une chaîne de chiffres dans n'importe quelle base (par exemple "0102513162" pour le premier cas).
  • Vous devez utiliser l'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 elle était terminée.
  • Vous devez utiliser 0 pour ignorer 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 le , donc la réponse la plus courte gagne!

5 Comments
Erik the Outgolfer 07/28/2017
Sandbox (2k + utilisateurs seulement)
3 Shaggy 07/28/2017
Oui, je l'ai juste repéré. / met des lunettes
2 Rod 07/28/2017
Probablement un lutin ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
Est-il acceptable d'avoir des zéros de fin dans mon tableau? me sauver ~ 18 octets
1 Erik the Outgolfer 07/28/2017
@ RomanGräf Désolé mais non, ce serait trop ambigu car il y a des cas où vous devriez avoir 0 s dans la sortie.

30 Answers


Rod 07/28/2017.

Python 2 , 36 octets

 f=lambda x:x and x[:1]+f(x[x[0]+1:]) 

Essayez-le en ligne!

4 comments
Mr. Xcoder 07/28/2017
Je m'attendais à être dégonflé, mais pas si mal :)
Erik the Outgolfer 07/28/2017
Ne pouvez-vous pas faire x[0] au lieu de x[:1] ?
Rod 07/28/2017
@EriktheOutgolfer oui, mais il doit être une liste, donc ce serait [x[0]]
Erik the Outgolfer 07/28/2017
@Rod Vous ne sauvegardez aucun octet avec x[:1] toute façon ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2 , 49 46 * 41 octets

Croisé 4 est toujours régulier 4 :(

* -3 thanks to @ASCII-only .

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

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 non-recursive full program .


Comment cela marche-t-il?

  • l=input() - Lit la liste à partir de l'entrée standard.

  • while l: - Abuse le fait que les listes vides sont falsifié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" - Ajuste le premier l[0]+1 de la liste.

Prenons un exemple

Étant donné la liste [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] comme entrée, le code exécute les opérations suivantes (selon l'explication ci-dessus) - Imprime le premier élément du array: 5 , rogner les 6 premiers: [2, 1, 2, 1, 0, 0] . Nous imprimons ensuite 2 et découpons les 3 premiers: [1,0,0] . De même, nous produisons 1 , recadrer les 2 premiers, et nous obtenons [0] . Bien sûr, 0 est imprimé et le programme se termine.

1 comments

w0lf 07/28/2017.

Haskell, 29 27 26 octets

 j(x:y)=x:j(drop x y)
j x=x 

Enregistré 1 octet grâce à Zgarb.

Essayez-le en ligne.

2 comments
Zgarb 07/28/2017
f x=x sur la deuxième ligne enregistre un octet.
w0lf 07/28/2017
@Zgarb Cool, merci!

Adnan 07/28/2017.

05AB1E , 10 9 octets

[¬Dg>#=ƒ¦ 

Utilise l'encodage 05AB1E . Essayez-le en ligne!

1 comments
Magic Octopus Urn 07/28/2017
Oui, c'est bien mieux que ce que je pensais.

Martin Ender 07/28/2017.

Mathematica, 46 44 octets

SequenceCases[#,NO 

Alternatives:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
Wow c'est génial!

Johan Karlsson 07/28/2017.

JavaScript (ES6), 42 39 35 octets

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] 

Ancienne solution 39 octets

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

-3 bytes thanks to @ThePirateBay

1 comments
ThePirateBay 07/28/2017
39 octets a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

TheLethalCoder 07/28/2017.

C #, 68 octets

 a=>{for(int i=0;i 

Essayez-le en ligne!

Version complète / formatée:

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

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

            Console.ReadLine();
        }
    }
} 

Le retour d'une liste est plus long à 107 octets.

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
Pourquoi quelqu'un a-t-il déprécié cela?
Thomas Ayoub 07/31/2017
Pour arrondir votre score et faire un 5k parfait?
TheLethalCoder 07/31/2017
@ThomasAyoub Nous pouvons seulement supposer que c'était quelqu'un avec OCD oui.

Zgarb 07/28/2017.

Husk , 8 6 octets

←TU¡Γ↓ 

Essayez-le en ligne!

-2 octets (et une idée de solution complètement nouvelle) grâce à Leo!

Explication

J'utilise la fonction de correspondance de modèle de liste Γ . Il prend une fonction f et une liste avec la tête x et la queue xs , et applique f à x et xs . Si la liste est vide, Γ renvoie une valeur par défaut cohérente avec son type, dans ce cas une liste vide. Nous prenons f pour être , qui laisse tomber x éléments de xs . Cette fonction est ensuite itérée et les éléments résultants sont collectés dans une liste.

←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] 
5 comments
Leo 07/28/2017
Vous pouvez laisser tomber la valeur par défaut de ø, et tout fonctionnera comme par magie :)
Leo 07/28/2017
Zgarb 07/28/2017
@Leo Oh wow, c'est intelligent!
Erik the Outgolfer 07/28/2017
Pourquoi avez-vous CW cela?
Zgarb 07/28/2017
@ErikTheOutgolfer C'était une erreur (je suis sur mon téléphone et apparemment poussé quelque chose par hasard). J'essaie de le défaire ...

Ruud 07/28/2017.

Python 2 , 59 55 octets

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

Essayez-le en ligne!

2 comments
1 Rod 07/28/2017
Vous pouvez utiliser l[i:i+l[i-1]]=[] place de del l[i:i+l[i-1]] pour sauvegarder un octet
1 ASCII-only 07/28/2017

Dave 07/28/2017.

Pyth, 22 octets

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

Retiré un octet inutile

4 comments
Erik the Outgolfer 07/28/2017
Je vois 23 octets là.
Dave 07/28/2017
Typo :) désolé ...
3 Wheat Wizard 07/28/2017
Je ne sais pas pourquoi vous avez un vote négatif. Il est possible que lorsque vous avez corrigé votre réponse, cela a déclenché un "vote automatique". Les raisons de ce downvote automatique sont déroutantes et terribles mais cela arrive si le système considère que votre réponse est de "mauvaise qualité" sur la base de ses heuristiques. Il est également possible que quelqu'un n'a pas aimé votre réponse, mais je ne vois rien de mal pour le moment, donc je ne sais pas pourquoi ce serait le cas.
isaacg 07/31/2017
Je suis content que tu utilises Pyth!

Rod 07/28/2017.

Python 2 , 60 42 octets

-18 octets grâce à Luis Mendo

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

Essayez-le en ligne!


Martin Ender 07/28/2017.

Rétine , 36 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Les entrées et les sorties sont séparées par des sauts de ligne avec un saut de ligne final.

Essayez-le en ligne! (Utilise des virgules au lieu des sauts de ligne pour permettre des suites de test pratiques.)


Riley 07/28/2017.

Cerveau-Flak , 64 octets

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

Essayez-le en ligne!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
De la merde! J'ai rédigé une solution, puis j'ai fait défiler la page pour la publier, mais il s'avère que nous avons écrit exact même solution octet par octet! Même des détails mineurs comme ({}[()]<{}>) vs ({}<{}>[()]) étaient les mêmes! Quelle coïncidence!
2EZ 4RTZ 07/28/2017
@DJMcMayhem voler toute la gloire XD

user202729 07/28/2017.

Mathematica, 64 50 octets

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
Je ne pouvais pas résister à plus de golfer ce code soigné; Ma réponse est ci-dessous.

jkelm 07/28/2017.

C # (.NET Core) , 68 octets

 n=>{var t="";for(int i=0;i 

Essayez-le en ligne!

Prend une entrée sous la forme d'un tableau d'entiers, renvoie une chaîne contenant les valeurs non ignorées.

3 comments
TheLethalCoder 07/28/2017
Belle façon de le faire et arrive au même compte que l'impression.
jkelm 07/28/2017
J'aime les solutions simples. Encore faut-il apprendre LINQ, comme je l'ai vu qui raccourcissent tant de c # lambdas ..
TheLethalCoder 07/28/2017
Raccourcit parce que vous pouvez le retour implicite la plupart du temps. Bien que ce soit un mélange entre le retour implicite avec l' using System.Linq; et une boucle normale.

Jarko Dubbeldam 07/28/2017.

R, 58 octets

f=function(x,p=1)NO 

Fonction récursive Prend un vecteur x comme argument et intiate un pointeur p . Ceci imprime l'entrée correspondante de x , vérifie si p+x[p] serait en dehors des limites, et sinon, appelle la fonction pour le nouveau pointeur.

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]))) 

C'est une solution comparable qui renvoie un vecteur correct au lieu d'imprimer les chiffres.

3 comments
Giuseppe 07/28/2017
qu'en est-il d'une entrée de numeric(0) ? aka tableau vide.
Jarko Dubbeldam 07/28/2017
@ Giuseppe Je vais jeter un coup d'oeil quand je suis derrière mon pc
Giuseppe 08/24/2017
57 octets! et il gère également le boîtier vide.

Roman Gräf 07/28/2017.

Java (OpenJDK 8) , 53 octets

Merci à @ PunPun1000 et @TheLethalCoder

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

Essayez-le en ligne!

5 comments
TheLethalCoder 07/28/2017
Est-ce que l'impression des résultats, comme dans ma réponse C #, vous sauver quelque chose?
Roman Gräf 07/28/2017
@TheLethalCoder Ill essayer
TheLethalCoder 07/28/2017
Pouvez-vous enregistrer un octet en déplaçant n dans la boucle?
TheLethalCoder 07/28/2017
De plus, cela ne semble pas fonctionner pour le moment.
PunPun1000 07/28/2017
Il vous manque un parent après le (a[n+=1+a[n]] . La fonction jette également une erreur après sortie de la valeur correcte, je ne sais pas le consensus sur si cela est autorisé ou non (la question Tout ce qui est dans l'erreur standard est ignoré.) Si c'était l'intention, alors vous pouvez supprimer la n dans la boucle for. Enfin, le code TIO ne fonctionne pas tel quel, même avec le paramètre paren. un Consumer et utilise func.accept(test)

Martin Ender 07/28/2017.

Alice , 15 octets

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

Essayez-le en ligne!

Entrez et sortez des listes séparées par des sauts de ligne d'entiers décimaux.

Explication

/   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. 

Le stockage d'un entier n dans la file d'attente de l'itérateur entraîne l'exécution n fois de la commande suivante. Les miroirs comme / ne sont pas des commandes, donc la prochaine commande sera I Par conséquent, si nous venons de lire et d'imprimer une valeur x , nous lirons des valeurs x+1 à l'itération suivante, le dernier d'entre elles se retrouvant au sommet de la pile. Cela ignore les éléments de liste de numéros requis.


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

Poursuite du golf de la méthode fine de user202729.

±NO 

Les règles ne semblent pas spécifier explicitement le format de sortie, donc peut-être:

±NO 

La sortie pour la deuxième fonction ressemble à: 0.2.4.{} - notamment {} est toujours renvoyé pour un ensemble vide, conformément à la règle finale.

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO peut être ±NO parce que ± a une priorité inférieure à Infix .
Mr.Wizard 07/28/2017
@JungHwanMin j'ai raté ça; Merci!

Jenny_mathy 07/28/2017.

Mathematica, 65 octets

(s=#;t=1;w={};While[t<=Length@s,AppendTo[w,k=s[[t]]];t=t+k+1];w)& 

Essayez-le en ligne!


w0lf 07/28/2017.

Ruby, 36 33 31

f=->l{a,*l=l;a&&f[l.drop(p a)]} 

Essayez-le en ligne.

4 comments
sethrin 07/30/2017
Vous êtes autorisé à soustraire le f= comme un élément d'en-tête.
w0lf 07/30/2017
@sethrin Même si j'ai besoin de l'appeler récursivement?
sethrin 07/30/2017
Hmm, bonne question. Je suppose que non. En passant, j'ai beaucoup aimé votre solution.
w0lf 07/30/2017
@sethrin Merci! :)

AnonymousReality 07/28/2017.

Swift, 63 octets

func a(d:[Int]){var i=0;while i 

C'est ma première entrée, jamais, donc je ne suis pas sûr à 100% sur les règles, mais j'espère que cette réponse suffira. Je suis un peu incertain des règles sur la façon d'obtenir l'entrée dans un système. J'ai une réponse plus courte si j'ai été autorisé à assumer une fonction quelque part qui peut retourner l'entrée.

2 comments
Stephen 07/28/2017
Bienvenue au PPCG! Les règles par défaut sont que vous pouvez soit avoir un code qui fonctionne comme un programme complet, donc entrer (habituellement) dans STDIN et sortir (habituellement) vers STDOUT, or une fonction, donc entrer (habituellement) des paramètres de la fonction et la sortie (habituellement) de retour de fonction.
AnonymousReality 07/28/2017
@StepHen - merci! Je suppose que cela rend mon autre version invalide alors. Au plaisir de contribuer plus!

Perl 6 , 31 octets

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

Essaye-le

Étendu:

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

Pour aider à comprendre comment le code fonctionne, sans [*;0] cela générerait une séquence comme celle-ci:

 [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) 

Renzo 07/29/2017.

Common Lisp, 51 octets

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x))) 

Essayez-le en ligne!


C ++ (gcc), 172 octets

#includeint main(){std::istream& i=std::cin;char c;int a,b;while(i>>c&&i>>a){std::cout<>c&&i>>b);}std::cout< 

Essayez-le en ligne

Le terrible (c/91?"":" ") Est pour l'espacement correct en sortie. Sans cela (-15 octets) la sortie est en forme: [0,2,4] , quand je la change en simple " " (-9 octets) la sortie est comme [ 0, 2, 4] (espace supplémentaire au début) .

<<(c/93?"":"]") à la fin est seulement de gérer [] case de coin d'entrée vide

N'imprime aucune ligne de fin.

1 comments
Erik the Outgolfer 07/30/2017
Vous pouvez également imprimer les nombres séparés par un séparateur sans chiffre, pas besoin de [] et vous pouvez avoir une sortie vide pour ce cas, et pas besoin de (c/91?"":" ") . Vous n'avez pas à faire correspondre le format des exemples dans le défi.

Jonathan Allan 07/29/2017.

Gelée , 8 octets

ḢṄ‘ṫ@µL¿ 

Un programme complet imprime les résultats chacun suivi d'une nouvelle ligne (la liste vide ne produit pas de sortie).

Try it online!

Comment?

ḢṄ‘ṫ@µ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
                                                                         ''' 
2 comments
Erik the Outgolfer 07/30/2017
Enfin une réponse Jelly! BTW je peux le faire en 7 octets.
Erik the Outgolfer 07/30/2017
Et j'ai aussi une fonction list-return dans 18 octets.

Evpok 07/30/2017.

Python 3 , 35 octets

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

Essayez-le en ligne!

Exécutez-le avec f(*l)l est votre entrée. Sans doute étirer les règles de saisie, mais j'adore le déballage avancé.


cliffroot 07/28/2017.

Clojure, 67 octets

#(nth(reduce(fn[[z k]b](if(= z 0)[b(conj k b)][(- z 1)k]))[0[]]%)1) 

Commence avec les paramètres initiaux [0 []] , où 0 est le compteur et [] est le résultat. Si le premier élément de cette liste est 0 ajoute l'élément n de l'argument au résultat et passe plus loin cette liste [n [... n]] sinon décrémente le premier élément. (Cette explication me semble horrible)

Voir en ligne


Dead Possum 07/28/2017.

Python 2.4, 85 octets

Pas de chance de gagner en python avec ça, mais j'adore les oneliners et celui-ci pourrait être intéressant pour les autres.
Il s'avère qu'il y a une astuce magique pour accéder à la liste de construction à l'intérieur de la compréhension, mais cela ne fonctionne qu'en 2.4 et avec quelques modifications dans <= 2.3
locals()['_[1]'] c'est. Python crée le nom secret _[1] pour la liste, pendant qu'il est créé et le stocke dans les locals . Les noms _[2] , _[3] ... sont également utilisés pour les listes imbriquées.

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

Il compte donc le nombre d'éléments déjà ajoutés plus leur somme. Le résultat est l'indice du prochain élément désiré.
Je pense qu'il devrait y avoir un moyen d'éviter d'énumérer. Comme accéder au tableau d'entrée directement par index: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] . Mais je ne peux pas trouver un moyen compact pour le protéger de l'index hors de portée (tout en le gardant oneliner)

entrez la description de l'image ici


Neil 07/28/2017.

Lot, 69 octets

:l
@if not "%1"=="" echo %1&(for /l %%i in (0,1,%1)do @shift)&goto l 

(J'ai besoin de la () s autour de la for sinon le goto se passe à l'intérieur de la boucle.)

Related questions

Hot questions

Language

Popular Tags