Hoppa som en kanin!

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

Med en lista över icke-negativa heltal i något rimligt format, iterera över det, hoppar så många element som varje heltal du går på säger.


Här är ett fungerat exempel:

[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 

Ett annat fungerat exempel, inte så alldeles lika dela:

[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 

Ett externt exempel:

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

regler

  • Du får inte använda någon tråkig fuska bland dessa , de gör utmaningen tråkig och ointressant.
  • Du bör bara returnera / skriva ut det slutliga resultatet. STDERR-utgången ignoreras.
  • Du får inte få inmatningen som en sträng av siffror i någon bas (t.ex. "0102513162" för det första fallet).
  • Du måste använda vänster-till-höger ordning för inmatning.
  • Som i de bearbetade exemplen, om du går ut ur gränsen, avslutas exekveringen som om det är annat.
  • Du bör använda 0 för att hoppa över 0 element.
  • Med tanke på den tomma listan ( [] ) som inmatning, ska du returnera [] .

Testfall

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

Detta är , så kortaste svaret vinner!

5 Comments
Erik the Outgolfer 07/28/2017
Sandlåda (endast 2k + användare)
3 Shaggy 07/28/2017
Ja, bara upptäckt det. / sätter på glasögon
2 Rod 07/28/2017
Förmodligen en predikan ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
Är det okej att ha nackdelar i min serie? skulle rädda mig ~ 18 byte
1 Erik the Outgolfer 07/28/2017
@ RomanGräf Tyvärr men nej, det skulle vara alltför tvetydigt eftersom det finns fall du borde ha efterföljande 0 s i utgången.

30 Answers


Rod 07/28/2017.

Python 2 , 36 byte

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

Prova det online!

4 comments
Mr. Xcoder 07/28/2017
Jag förväntade mig att bli outgolfed, men inte så illa :)
Erik the Outgolfer 07/28/2017
Kan du inte göra x[0] istället för x[:1] ?
Rod 07/28/2017
@EriktheOutgolfer ja, men det måste vara en lista, så det skulle vara [x[0]]
Erik the Outgolfer 07/28/2017
@Rod Du sparar inte några byte med x[:1] ändå ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

Python 2 , 49 46 * 41 byte

Korsad 4 är fortfarande vanlig 4 :(

* -3 thanks to @ASCII-only .

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

Prova det online!

Skriver ut resultaten separerade av en ny linje, eftersom OP-enheten tillåts i chatt. Jag tror inte att det kan bli kortare som ett non-recursive full program .


Hur fungerar detta?

  • l=input() - Läser listan från standardinmatningen.

  • while l: - missbrukar det faktum att tomma listor är falska i Python, loopar tills listan är tom.

  • print l[0]; - Skriver ut det första elementet i listan.

  • l=l[l[0]+1:] - "Hoppar som en kanin" - Trims den första l[0]+1 från listan.

Låt oss ta ett exempel

Med tanke på listan [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] som ingång, utför koden följande (enligt förklaringen ovan) - Skriver ut den första delen av array: 5 , trimma de första 6: [2, 1, 2, 1, 0, 0] . Vi skriver sedan ut 2 och trimmer de första 3: [1,0,0] . På samma sätt utmatar vi 1 , beskär de första 2, och vi får [0] . Naturligtvis skrivs 0 ut och programmet avslutas.

1 comments

w0lf 07/28/2017.

Haskell, 29 27 26 byte

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

Sparat 1 byte tack vare Zgarb.

Prova det online.

2 comments
Zgarb 07/28/2017
f x=x på den andra raden sparar en byte.
w0lf 07/28/2017
@Zgarb Cool, tack!

Adnan 07/28/2017.

05AB1E , 10 9 byte

[¬Dg>#=ƒ¦ 

Använder 05AB1E kodningen. Prova det online!

1 comments
Magic Octopus Urn 07/28/2017
Ja, det är väldigt bättre än vad jag tänkte.

Martin Ender 07/28/2017.

Mathematica, 46 44 byte

SequenceCases[#,NO 

alternativ:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
Wow det är bra!

Johan Karlsson 07/28/2017.

JavaScript (ES6), 42 39 35 byte

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] 

Gamla lösningen 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 byte a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

TheLethalCoder 07/28/2017.

C #, 68 byte

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

Prova det online!

Full / formaterad version:

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

Återgå en lista är längre vid 107 byte.

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
Varför har någon nedröstat detta?
Thomas Ayoub 07/31/2017
Att runda dina poäng och göra en perfekt 5k?
TheLethalCoder 07/31/2017
@ThomasAyoub Vi kan bara anta att det var någon med OCD ja.

Zgarb 07/28/2017.

Skal , 8 6 byte

←TU¡Γ↓ 

Prova det online!

-2 byte (och en helt ny lösningidé) tack vare Leo!

Förklaring

Jag använder listmönsterkortfunktionen Γ . Det tar en funktion f och en lista med huvud x och svans xs , och gäller f till x och xs . Om listan är tom returnerar Γ ett standardvärde som överensstämmer med dess typ, i det här fallet en tom lista. Vi tar f att vara , som släpper x element från xs . Denna funktion itereras sedan och de resulterande elementen samlas i en lista.

←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
Du kan släppa standardvärdet på ø, och allt kommer fortfarande att fungera magiskt :)
Zgarb 07/28/2017
@ Lee Oh wow, det är smart!
Erik the Outgolfer 07/28/2017
Varför gjorde du CW detta?
Zgarb 07/28/2017
@ErikTheOutgolfer Det var ett misstag (jag är på min telefon och uppenbarligen tryckt något av misstag). Jag försöker ångra det ...

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 

Prova det online!

2 comments
1 Rod 07/28/2017
Du kan använda l[i:i+l[i-1]]=[] istället del l[i:i+l[i-1]] att spara en byte
1 ASCII-only 07/28/2017

Dave 07/28/2017.

Pyth, 22 Bytes

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

Ta bort en värdelös byte

4 comments
Erik the Outgolfer 07/28/2017
Jag ser 23 bytes där.
Dave 07/28/2017
Typo :) förlåt ...
3 Wheat Wizard 07/28/2017
Jag är inte säker på varför du har en nedröstning. Det finns en möjlighet att när du redigerade ditt svar svarade detta för en "automatisk nedröstning". Anledningarna till denna automatiska downvote är förvirrande och fruktansvärda men det händer om systemet anser att ditt svar är "lågkvalitativt" baserat på det heuristiska. Det är också möjligt att någon inte tyckte om ditt svar, men jag ser inte något fel med det just nu, så jag är inte säker på varför det skulle vara fallet.
isaacg 07/31/2017
Jag är glad att du använder Pyth!

Rod 07/28/2017.

Python 2 , 60 42 byte

-18 byte tack vare Luis Mendo

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

Prova det online!


Martin Ender 07/28/2017.

Näthinnan , 36 byte

Byte-räkning förutsätter ISO 8859-1-kodning.

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

Inmatning och utmatning är linefeed-separerade med en efterföljande radmatning.

Prova det online! (Använd kommatecken istället för linefeeds för att möjliggöra lämpliga testpaket.)


Riley 07/28/2017.

Brain-Flak , 64 byte

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

Prova det online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
Helig skit! Jag skrev upp en lösning och rullade sedan ner för att skicka den, men det visar sig att vi skrev exact samma lösning byte-for-byte! Även mindre detaljer som ({}[()]<{}>) vs ({}<{}>[()]) var samma! Vilket sammanträffande!
2EZ 4RTZ 07/28/2017
@DJMcMayhem stjäl all berömmelse XD

user202729 07/28/2017.

Mathematica, 64 50 bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
Jag kunde inte motstå ytterligare golf denna snyggingskod; mitt svar är nedan.

jkelm 07/28/2017.

C # (. NET Core) , 68 byte

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

Prova det online!

Tar in som en grupp av heltal, returnerar en sträng som innehåller de ej hoppade värdena.

3 comments
TheLethalCoder 07/28/2017
Trevligt sätt att göra det och kommer in på samma sätt som utskrift.
jkelm 07/28/2017
Jag älskar de enkla lösningarna. Jag måste fortfarande lära mig LINQ, men jag har sett att förkorta så många c # lambdas.
TheLethalCoder 07/28/2017
Förkortar det eftersom du kan implicit återvända för det mesta. Även om det är en kasta upp mellan implicit återgång med att using System.Linq; och en normal slinga.

Jarko Dubbeldam 07/28/2017.

R, 58 byte

f=function(x,p=1)NO 

Rekursiv funktion. Tar en vektor x som argument och integrerar en pekare p . Detta skriver ut motsvarande post för x , kontrollerar om p+x[p] skulle gå utanför gränsen, och om inte, ringer funktionen för den nya pekaren.

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

Det här är en jämförbar lösning som returnerar en riktig vektor istället för att skriva siffrorna.

3 comments
Giuseppe 07/28/2017
Vad sägs om en ingång av numeric(0) ? aka tom matris.
Jarko Dubbeldam 07/28/2017
@Giuseppe Jag tar en titt på det när jag är bakom min dator
Giuseppe 08/24/2017
57 byte! och det hanterar också det tomma fodralet.

Roman Gräf 07/28/2017.

Java (OpenJDK 8) , 53 byte

Tack vare @ PunPun1000 och @TheLethalCoder

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

Prova det online!

5 comments
TheLethalCoder 07/28/2017
Skulle du skriva ut resultaten, som i mitt C # -svar, sparar du något?
Roman Gräf 07/28/2017
@TheLethalCoder Ill försök
TheLethalCoder 07/28/2017
Kan du spara en byte genom att flytta n till slingan?
TheLethalCoder 07/28/2017
Plus detta verkar inte fungera just nu.
PunPun1000 07/28/2017
Du saknar en paren efter (a[n+=1+a[n]] . Funktionen kastar också ett fel efter att ha skrivit rätt värde, jag vet inte konsensus om detta är tillåtet eller inte (frågan gör säg att någonting till standardfel ignoreras). Om det var avsikten, kan du ta bort n i n . Slutligen körs inte TIO-koden som den är, även med paren. Funktionen ska vara en Consumer och använd func.accept(test)

Martin Ender 07/28/2017.

Alice , 15 byte

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

Prova det online!

Inmata och mata ut en radmatningsseparerade listor med decimala heltal.

Förklaring

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

Om du lagrar ett heltal n i iteratorkön får nästa kommando att utföras n gånger. Speglar som / inte kommandon, så nästa kommando blir I . Därför om vi bara läser och skrivit ett värde x , läser vi x+1 värden vid nästa iteration, med sista av dem som slutar på toppen av stapeln. Detta hoppar över de nödvändiga nummerlistelementen.


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

Vidare golf av användaren202729s fina metod.

±NO 

Reglerna tycks inte explicit ange utdataformatet, så kanske:

±NO 

Utgången för den andra funktionen ser ut som: 0.2.4.{} - särskilt {} 0.2.4.{} fortfarande för en tom uppsättning, som överensstämmer med slutbestämmelsen.

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO kan vara ±NO eftersom ± har lägre prioritet än Infix .
Mr.Wizard 07/28/2017
@JungHwanMin jag missade det; tack!

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

Prova det online!


w0lf 07/28/2017.

Ruby, 36 33 31

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

Prova det online.

4 comments
sethrin 07/30/2017
Du får subtrahera f= som ett rubrikelement.
w0lf 07/30/2017
@setrin Även om jag behöver ringa det rekursivt?
sethrin 07/30/2017
Hmm, bra fråga. Jag antar det inte. Jag gjorde väldigt mycket om din lösning, förresten.
w0lf 07/30/2017
@sethrin tack! :)

AnonymousReality 07/28/2017.

Swift, 63 byte

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

Detta är min första inlägg, någonsin, så jag är inte 100% säker på reglerna, men förhoppningsvis är detta svar tillräckligt. Jag är lite osäker på regler om hur man får inmatningen i ett system. Jag har ett kortare svar om jag fick anta en funktion någonstans som kan returnera inmatningen.

2 comments
Stephen 07/28/2017
Välkommen till PPCG! Standardreglerna är att du antingen kan ha kod som fungerar som ett fullständigt program, så inmatar (vanligtvis) i STDIN och utmatas (vanligtvis) till STDOUT, or en funktion, så inmatar (vanligtvis) från funktionsparametrar och utdata (vanligtvis) från funktion returnera.
AnonymousReality 07/28/2017
@StepHen - tack! Jag antar att det gör min andra version ogiltig då. Ser fram emot att bidra mer!

Perl 6 , 31 byte

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

Testa det

Expanderat:

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

För att hjälpa till att förstå hur koden fungerar, utan [*;0] skulle detta generera en sekvens som följande:

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

Vanlig Lisp, 51 byte

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

Prova det online!


C ++ (gcc), 172 byte

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

Prova det online

Den fruktansvärda (c/91?"":" ") Är för korrekt avstånd i utmatningen. Utan den (-15 bytes) är utgången i form: [0,2,4] , när jag ändrar den till enkel " " (-9 byte) är utgången som [ 0, 2, 4] (extra utrymme i början) .

<<(c/93?"":"]") i slutet är endast för att hantera [] tom ingång hörn fall

Skriver ut ingen bakre ändlinje.

1 comments
Erik the Outgolfer 07/30/2017
Du kan också skriva ut siffrorna separerade med en siffra utan siffra, inget behov av [] och du kan ha tom utmatning för det här kassen och behöver inte (c/91?"":" ") . Du behöver inte matcha formatet på exemplen i utmaningen.

Jonathan Allan 07/29/2017.

Gelé , 8 byte

ḢṄ‘ṫ@µL¿ 

Ett fullständigt program skriver ut resultaten, följt av en ny linje (tom lista ger ingen utmatning).

Try it online!

Hur?

ḢṄ‘ṫ@µ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
Slutligen ett gelésvar! BTW Jag kan göra det i 7 byte.
Erik the Outgolfer 07/30/2017
Och jag har också en lista-returfunktion i 18 byte.

Evpok 07/30/2017.

Python 3 , 35 byte

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

Prova det online!

Kör den med f(*l) där l är din ingång. Förhoppningsvis sträcker reglerna för input, men jag älskar bara avancerad utpakking.


cliffroot 07/28/2017.

Clojure, 67 byte

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

Börjar med de inledande parametrarna [0 []] , där 0 är räknaren och [] är resultatet. Om det första elementet i den här listan är 0 lägger punkt n från argumentet till resultatet och passerar vidare denna lista [n [... n]] ökar annars det första elementet. (denna förklaring känns hemsk för mig)

Se det online


Dead Possum 07/28/2017.

Python 2,4, 85 byte

Ingen chans att vinna i python med det, men jag älskar oneliners och den här kan vara intressant för andra.
Visas, det finns ett snyggt magiskt trick för att få tillgång till bygglistor inom förståelse, men det fungerar bara i 2.4 och med några ändringar i <= 2.3
locals()['_[1]'] det är. Python skapar hemligt namn _[1] för lista, medan det skapas och lagras i locals . Även namnen _[2] , _[3] ... används för kapslade listor.

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

Så det räknas antal redan tillagda element plus deras summa. Resultatet är indexet för nästa önskat element.
Jag tror att det borde finnas ett sätt att undvika att räkna upp. Gilla tillgång till ingångs array direkt efter index: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ] . Men jag kan inte räkna ut ett kompakt sätt att skydda det från index-out-of-range (samtidigt som det hålls på nätet)

skriv in bildbeskrivningen här


Neil 07/28/2017.

Batch, 69 byte

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

(Jag behöver () s runt om for annars händer goto inuti slingan.)

Related questions

Hot questions

Language

Popular Tags