Sla als een konijn over!

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

Gegeven een lijst van niet-negatieve gehele getallen in een redelijk formaat, itereert u deze en slaat u zoveel elementen over als elk geheel getal dat u gebruikt zegt.


Hier is een uitgewerkt voorbeeld:

[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 

Nog een uitgewerkt voorbeeld, niet zo all-equal-delta's:

[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 

Een out-of-bounds-voorbeeld:

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

Reglement

  • Je mag geen saaie cheats gebruiken tussen deze , ze maken de uitdaging saai en oninteressant.
  • U moet het eindresultaat alleen retourneren / afdrukken. STDERR-uitvoer wordt genegeerd.
  • Mogelijk krijgt u de invoer niet als een reeks cijfers in een willekeurige basis (bijv. "0102513162" voor de eerste case).
  • U moet de volgorde van links naar rechts gebruiken voor invoer.
  • Net als in de uitgewerkte voorbeelden eindigt de uitvoering, als u zich buiten de grenzen begeeft, als anders.
  • Gebruik 0 voor het overslaan van 0 elementen.
  • Gezien de lege lijst ( [] ) als invoer, moet u [] retourneren.

Testgevallen

[]                                                     => []
[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] 

Dit is , dus het kortste antwoord wint!

5 Comments
Erik the Outgolfer 07/28/2017
Sandbox (alleen voor 2k + gebruikers)
3 Shaggy 07/28/2017
Ja, ik heb het net gezien. / zet een bril op
2 Rod 07/28/2017
Waarschijnlijk een kabouter ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
Is het goed dat er volgnullen in mijn array zitten? zou me ~ 18 bytes besparen
1 Erik the Outgolfer 07/28/2017
@ RomanGräf Sorry maar nee, dat zou te dubbelzinnig zijn, omdat er in sommige gevallen 0 s achterblijft in de uitvoer.

30 Answers


Rod 07/28/2017.

Python 2 , 36 bytes

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

Probeer het online!

4 comments
Mr. Xcoder 07/28/2017
Ik had verwacht outgolfed te worden, maar niet zo slecht :)
Erik the Outgolfer 07/28/2017
Kun je x[0] niet doen in plaats van x[:1] ?
Rod 07/28/2017
@EriktheOutgolfer Ja, maar het moet een lijst zijn, dus het zou [x[0]]
Erik the Outgolfer 07/28/2017
@Rod Je slaat sowieso geen bytes op met x[:1] ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2 , 49 46 * 41 bytes

Doorgestreept 4 is nog steeds reguliere 4 :(

* -3 thanks to @ASCII-only .

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

Probeer het online!

Drukt de resultaten af ​​gescheiden door een nieuwe regel, zoals het OP toestond in de chat. Ik denk niet dat het korter kan worden als een non-recursive full program .


Hoe werkt dit?

  • l=input() - Leest de lijst van de standaardinvoer.

  • while l: - Misbruikt het feit dat lege lijsten vals zijn in Python, wordt herhaald totdat de lijst leeg is.

  • print l[0]; - Drukt het eerste element van de lijst af.

  • l=l[l[0]+1:] - "Slaat over als een konijn" - Versier de eerste l[0]+1 uit de lijst.

Laten we een voorbeeld nemen

Gegeven de lijst [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] als invoer, voert de code het volgende uit (volgens de uitleg hierboven) - Drukt het eerste item van de array: 5 , trim de eerste 6: [2, 1, 2, 1, 0, 0] . We printen dan 2 en knippen de eerste 3: [1,0,0] . Evenzo voeren we 1 , knippen we de eerste 2 bij en krijgen we [0] . Natuurlijk wordt 0 afgedrukt en eindigt het programma.

1 comments

w0lf 07/28/2017.

Haskell, 29 27 26 bytes

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

1 byte opgeslagen dankzij Zgarb.

Probeer het online.

2 comments
Zgarb 07/28/2017
f x=x op de tweede regel slaat een byte op.
w0lf 07/28/2017
@Zgarb Cool, bedankt!

Adnan 07/28/2017.

05AB1E , 10 9 bytes

[¬Dg>#=ƒ¦ 

Gebruikt de 05AB1E codering. Probeer het online!

1 comments
Magic Octopus Urn 07/28/2017
Ja, dat is veel beter dan wat ik dacht.

Martin Ender 07/28/2017.

Mathematica, 46 44 bytes

SequenceCases[#,NO 

alternatieven:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
Wow, dat is fantastisch!

Johan Karlsson 07/28/2017.

JavaScript (ES6), 42 39 35 bytes

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] 

Oude oplossing 39 bytes

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

-3 bytes thanks to @ThePirateBay

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

TheLethalCoder 07/28/2017.

C #, 68 bytes

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

Probeer het online!

Volledige / geformatteerde versie:

 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();
        }
    }
} 

Het retourneren van een lijst is langer bij 107 bytes.

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
Waarom heeft iemand dit onder de aandacht gebracht?
Thomas Ayoub 07/31/2017
Om je score te voltooien en een perfecte 5k te maken?
TheLethalCoder 07/31/2017
@ThomasAyoub We kunnen alleen maar aannemen dat het iemand met OCD was, ja.

Zgarb 07/28/2017.

Husk , 8 6 bytes

←TU¡Γ↓ 

Probeer het online!

-2 bytes (en een compleet nieuw idee voor de oplossing) dankzij Leo!

Uitleg

Ik gebruik de Γ . Het neemt een functie f en een lijst met kop x en staart xs , en past f op x en xs . Als de lijst leeg is, retourneert Γ een standaardwaarde die overeenkomt met het type, in dit geval een lege lijst. We nemen f om , die x elementen uit xs . Deze functie wordt vervolgens herhaald en de resulterende elementen worden verzameld in een lijst.

←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
Je kunt de standaardwaarde van ø laten vallen, en alles zal nog steeds magisch werken :)
Zgarb 07/28/2017
@Leo Oh wauw, dat is slim!
Erik the Outgolfer 07/28/2017
Waarom heb je CW dit gegeven?
Zgarb 07/28/2017
@ErikTheOutgolfer Dat was een vergissing (ik ben op mijn telefoon en blijkbaar per ongeluk iets geduwd). Ik probeer het ongedaan te maken ...

Ruud 07/28/2017.

Python 2 , 59 55 bytes

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

Probeer het online!

2 comments
1 Rod 07/28/2017
U kunt l[i:i+l[i-1]]=[] plaats del l[i:i+l[i-1]] om een ​​byte op te slaan
1 ASCII-only 07/28/2017

Dave 07/28/2017.

Pyth, 22 Bytes

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

Een nutteloze byte verwijderd

4 comments
Erik the Outgolfer 07/28/2017
Ik zie er 23 bytes.
Dave 07/28/2017
Typo :) sorry ...
3 Wheat Wizard 07/28/2017
Ik weet niet zeker waarom je een slechte stem hebt. Het is mogelijk dat je bij het bewerken van je antwoord een "automatische stemming" hebt geactiveerd. De redenen voor dit automatische downvote zijn verwarrend en vreselijk, maar het gebeurt als het systeem uw antwoord als "lage kwaliteit" beschouwt op basis van de heuristiek. Het is ook mogelijk dat iemand je antwoord niet leuk vond, maar ik zie er op dit moment niets mis mee, dus ik weet niet zeker waarom dat het geval zou zijn.
isaacg 07/31/2017
Ik ben blij dat je Pyth gebruikt!

Rod 07/28/2017.

Python 2 , 60 42 bytes

-18 bytes dankzij Luis Mendo

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

Probeer het online!


Martin Ender 07/28/2017.

Retina , 36 bytes

Het aantal bytes gaat uit van de ISO 8859-1-codering.

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

Invoer en uitvoer worden door linefeed gescheiden met een nalaadlijn.

Probeer het online! (Gebruikt komma's in plaats van lijnfeeds om gemakkelijke testsuites toe te staan.)


Riley 07/28/2017.

Brain-Flak , 64 bytes

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

Probeer het online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
Heilige rotzooi! Ik schreef een oplossing op en scrolde naar beneden om het te plaatsen, maar het bleek dat we byte-byte exact dezelfde oplossing schreven! Zelfs kleine details zoals ({}[()]<{}>) vs ({}<{}>[()]) waren hetzelfde! Wat een toeval!
2EZ 4RTZ 07/28/2017
@DJMcMisschien steelt hij alle roem XD

user202729 07/28/2017.

Mathematica, 64 50 bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
Ik kon het verder golfen niet weerstaan ​​deze nette code; mijn antwoord is hieronder.

jkelm 07/28/2017.

C # (.NET Core) , 68 bytes

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

Probeer het online!

Neemt input als een array van gehele getallen, retourneert een string die de niet-overgeslagen waarden bevat.

3 comments
TheLethalCoder 07/28/2017
Leuke manier om het te doen en komt in dezelfde telling als afdrukken.
jkelm 07/28/2017
Ik hou van de simpele oplossingen. Toch moet ik LINQ leren, zoals ik heb gezien dat zo veel c # lambdas verkorten ..
TheLethalCoder 07/28/2017
Verkort het omdat u het grootste deel van de tijd impliciet kunt terugkeren. Hoewel het een gooi is tussen impliciete terugkeer met using System.Linq; en een normale lus.

Jarko Dubbeldam 07/28/2017.

R, 58 bytes

f=function(x,p=1)NO 

Recursieve functie. Neemt een vector x als argument en voert een pointer in p . Dit drukt de overeenkomstige invoer van x , controleert of p+x[p] buiten de grenzen zou komen, en zo niet, roept de functie voor de nieuwe aanwijzer.

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

Dit is een vergelijkbare oplossing die een juiste vector retourneert in plaats van de cijfers af te drukken.

3 comments
Giuseppe 07/28/2017
hoe zit het met een invoer van numeric(0) ? aka lege array.
Jarko Dubbeldam 07/28/2017
@Giuseppe Ik zal het bekijken als ik achter mijn pc sta
Giuseppe 08/24/2017
57 bytes! en het behandelt ook de lege behuizing.

Roman Gräf 07/28/2017.

Java (OpenJDK 8) , 53 bytes

Dank aan @ PunPun1000 en @TheLethalCoder

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

Probeer het online!

5 comments
TheLethalCoder 07/28/2017
Zou het afdrukken van de resultaten, zoals in mijn C # -antwoord, u iets besparen?
Roman Gräf 07/28/2017
@TheLethalCoder Ziek proberen
TheLethalCoder 07/28/2017
Kun je een byte opslaan door n in de lus te verplaatsen?
TheLethalCoder 07/28/2017
Bovendien lijkt dit op dit moment niet te werken.
PunPun1000 07/28/2017
Je mist een paar na de (a[n+=1+a[n]] Functie gooit ook een fout na het uitvoeren van de juiste waarde, ik weet niet de consensus over of dit is toegestaan ​​of niet (de vraag doet iets zeggen naar de standaard fout wordt genegeerd.) Als dat de bedoeling was, dan kun je de n in de for-lus verwijderen. Eindelijk loopt de TIO-code niet zoals het is, zelfs niet met het paar. een Consumer en gebruik func.accept(test)

Martin Ender 07/28/2017.

Alice , 15 bytes

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

Probeer het online!

Voer een door linefeed gescheiden lijst met decimale gehele getallen in en uitvoer uit.

Uitleg

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

Het opslaan van een geheel getal n in de iteratierequee zorgt ervoor dat het volgende commando n keer wordt uitgevoerd. Spiegels als / zijn geen commando's, dus het volgende commando zal I . Als we dus een waarde x lezen en afdrukken, lezen we de x+1 waarden bij de volgende iteratie, waarbij de laatste op de stapel terechtkomt. Hiermee worden de vereiste nummerlijstelementen overgeslagen.


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

Verder golfen van de fijne methode van user202729.

±NO 

De regels lijken niet expliciet het uitvoerformaat te specificeren, dus misschien:

±NO 

Uitvoer voor de tweede functie ziet eruit als: 0.2.4.{} - met name {} wordt nog steeds geretourneerd voor een lege set, conform de laatste regel.

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO kan ±NO omdat ± een lagere prioriteit heeft dan Infix .
Mr.Wizard 07/28/2017
@JungHwanMin Ik heb dat gemist; bedankt!

Jenny_mathy 07/28/2017.

Mathematica, 65 bytes

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

Probeer het online!


w0lf 07/28/2017.

Ruby, 36 33 31

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

Probeer het online.

4 comments
sethrin 07/30/2017
Je mag de f= als headerelement aftrekken.
w0lf 07/30/2017
@sethrin Zelfs als ik het recursief moet noemen?
sethrin 07/30/2017
Hmm, goede vraag. Ik denk van niet. Ik vond trouwens heel erg leuk over je oplossing.
w0lf 07/30/2017
@sethrin Bedankt! :)

AnonymousReality 07/28/2017.

Snel, 63 bytes

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

Dit is mijn eerste inzending ooit, dus ik ben niet 100% zeker van de regels, maar hopelijk volstaat dit antwoord. Ik ben een beetje onzeker over regels voor het verkrijgen van de invoer in een systeem. Ik heb een korter antwoord als ik ergens een functie mag aannemen die de invoer kan retourneren.

2 comments
Stephen 07/28/2017
Welkom bij PPCG! De standaardregels zijn dat je code kunt hebben die werkt als een volledig programma, dus voer (meestal) in STDIN in en uitvoer (meestal) naar STDOUT, or een functie, dus gebruik (meestal) van functieparameters en uitvoer (meestal) van functie retourneren.
AnonymousReality 07/28/2017
@StepHen - bedankt! Ik veronderstel dat dat mijn andere versie dan ongeldig maakt. Ik kijk er naar uit om meer bij te dragen!

Perl 6 , 31 bytes

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

Test het

Expanded:

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

Om te helpen begrijpen hoe de code werkt, zonder [*;0] , zou dit een reeks als volgt genereren:

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

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

Probeer het online!


C ++ (gcc), 172 bytes

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

Probeer het online

De vreselijke (c/91?"":" ") Is voor correcte spatiëring in output. Zonder dit (-15 bytes) is de uitvoer in de vorm: [0,2,4] , wanneer ik dit in eenvoudige " " (-9 bytes) verander, is de uitvoer als [ 0, 2, 4] (extra ruimte aan het begin) .

<<(c/93?"":"]") aan het uiteinde is alleen om [] lege invoerhoek te verwerken

Drukt geen volgende eindlijn af.

1 comments
Erik the Outgolfer 07/30/2017
U kunt ook de nummers afdrukken gescheiden door een no-digit scheidingsteken, geen behoefte aan [] en u kunt lege uitvoer voor die rand-zaak hebben, en geen behoefte aan (c/91?"":" ") . U hoeft het formaat van de voorbeelden in de uitdaging niet te evenaren.

Jonathan Allan 07/29/2017.

Jelly , 8 bytes

ḢṄ‘ṫ@µL¿ 

Een volledig programma dat de resultaten afdrukt, elk gevolgd door een nieuwe regel (lege lijst levert geen uitvoer op).

Try it online!

Hoe?

ḢṄ‘ṫ@µ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
Eindelijk een Jelly antwoord! BTW ik kan het in 7 bytes doen.
Erik the Outgolfer 07/30/2017
En ik heb ook een functie voor het retourneren van de lijst in 18 bytes.

Evpok 07/30/2017.

Python 3 , 35 bytes

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

Probeer het online!

Voer het uit met f(*l) waarbij l uw invoer is. Wellicht strekken de regels voor invoer uit, maar ik ben dol op geavanceerd uitpakken.


cliffroot 07/28/2017.

Clojure, 67 bytes

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

Begint met de beginparameters [0 []] , waarbij 0 de teller is en [] het resultaat is. Als het eerste element in deze lijst 0 voegt item n van het argument toe aan het resultaat en gaat deze lijst verder [n [... n]] anders verlaagt het het eerste element. (deze uitleg voelt vreselijk voor mij)

Zie het online


Dead Possum 07/28/2017.

Python 2,4, 85 bytes

Geen kans om ermee te winnen in python, maar ik ben dol op oneliners en deze kan interessant zijn voor anderen.
Blijkt, er is een mooie goocheltruc om binnen het begrip toegang te krijgen tot de bouwlijst, maar het werkt alleen in 2.4 en met enkele bewerkingen in <= 2.3
locals()['_[1]'] is het. Python maakt geheime naam _[1] voor lijst, terwijl het is gemaakt en slaat het op bij locals . Ook namen _[2] , _[3] ... worden gebruikt voor geneste lijsten.

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

Dus telt het aantal al toegevoegde elementen plus hun som. Het resultaat is de index van het volgende gewenste element.
Ik denk dat er een manier moet zijn om op te sommen. Vind het leuk om toegang te krijgen tot inputarray direct op index: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] . Maar ik kan een compacte manier niet vinden om hem te beschermen tegen index-buiten-bereik (terwijl hij oneliner blijft)

voer de beschrijving van de afbeelding hier in


Neil 07/28/2017.

Batch, 69 bytes

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

(Ik heb de () s rondom nodig for anders gebeurt de goto binnen de lus.)

Related questions

Hot questions

Language

Popular Tags