Inspiration .

Aufgabe

Rückwärtsdurchläufe der ungeraden Zahlen in einer gegebenen Liste von 2 bis 2 ¹⁵ nicht negativen ganzen Zahlen sind .

Beispiele

0 1 →  0 1
1 3 →  3 1
1 2 3 →  1 2 3
1 3 2 →  3 1 2
10 7 9 6 8 9 →  10 9 7 6 8 9
23 12 32 23 25 27 →  23 12 32 27 25 23
123 123 345 0 1 9 → 345 123 123 0 9 1

Python 2, 75 68 63 Bytes

5 Bytes dank Dennis.

Und ich habe Dennis übertroffen .

Dank an Byeonggon Lee für den Kern des Algorithmus.

o=t=[]
for i in input():o+=~i%2*(t+[i]);t=i%2*([i]+t)
print o+t

Ideone es!

Alte Version: 75 Bytes

Python 2, 79 75 73 Bytes

def f(x):
 i=j=0
 for n in x+[0]:
    if~n%2:x[i:j]=x[i:j][::-1];i=j+1
    j+=1

Dies ist eine Funktion, die ihr Argument ändert. Die zweite Einzugsebene ist ein Tabulator.

Teste es auf Ideone .

APL, 21-20 Bytes

{∊⌽¨⍵⊂⍨e⍲¯1↓0,e←2|⍵}

Probieren Sie es aus || Alle Testfälle

Erläuterung:

                  2|⍵ Select all the odd numbers
                e←    Save that to e
              0,      Append a 0
           ¯1↓        Delete the last element
         e⍲           NAND it with the original list of odd numbers
     ⍵⊂⍨             Partition the list: (even)(even)(odd odd odd)(even)
  ⌽¨                 Reverse each partition
 ∊                    Flatten the list

Edit: ~Dank De Morgans Gesetzen gerettet

Haskell, 46 44 Bytes

h%p|(l,r)<-span(odd.(h*))p=l++h:r
foldr(%)[]

Vielen Dank an @xnor für das Erkennen einer Falte und das Speichern von zwei Bytes.

Gelee , 10 Bytes

Ḃ¬ðœpUżx@F

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

Ḃ¬ðœpUżx@F  Main link. Argument: A (array)

Ḃ           Bit; return the parity bit of each integer in A.
 ¬          Logical NOT; turn even integers into 1's, odds into 0's.
  ð         Begin a new, dyadic link.
            Left argument: B (array of Booleans). Right argument: A
   œp       Partition; split A at 1's in B.
     U      Upend; reverse each resulting chunk of odd numbers.
       x@   Repeat (swapped); keep only numbers in A that correspond to a 1 in B.
      ż     Zipwith; interleave the reversed runs of odd integers (result to the
            left) and the flat array of even integers (result to the right).
         F  Flatten the resulting array of pairs.

Python 2, 78 75 Bytes

def r(l):
 def k(n):o=~n%2<<99;k.i+=o*2-1;return k.i-o
 k.i=0;l.sort(key=k)

Super hacky :)

Python3, 96 Bytes

Dank Leaky Nun konnten viele Bytes gespart werden!

o=l=[]
for c in input().split():
 if int(c)%2:l=[c]+l
 else:o+=l+[c];l=[]
print(" ".join(o+l))

C 107 Bytes

i;b[65536];f(){for(;i;)printf("%d ",b[--i]);}main(n){for(;~scanf("%d",&n);)n%2||f(),b[i++]=n,n%2||f();f();}

MATL , 20 Bytes

TiodgvYsG8XQ!"@gto?P

Die Eingabe ist ein Spaltenarray, das ;als Trennzeichen verwendet wird.

Probieren Sie es online!

Erläuterung

Betrachten Sie als Beispiel das Eingabearray [1;2;3;5;7;4;6;7;9]. Der erste Teil des Codes Tiodgvkonvertiert dieses Array in [1;1;1;0;0;1;0;1;0], wobei 1eine Änderung der Parität angezeigt wird . (Insbesondere erhält der Code die Parität jedes Eintrags des Eingabearrays, berechnet aufeinanderfolgende Differenzen, konvertiert Werte ungleich Null in 1und stellt a voran 1.)

Dann Ysberechnet die kumulative Summe , geben [1;2;3;3;3;4;4;5;5]. Jede dieser Nummern wird als Bezeichnung verwendet , anhand derer die Elemente der Eingabe gruppiert werden . Dies geschieht durch G8XQ!Aufteilen des Eingabearrays in ein Zellenarray, das die Gruppen enthält. In diesem Fall gibt es {[1] [2] [3;5;7] [4;6] [7;9]}.

Der Rest des Codes iteriert ( ") im Zellenarray. Jedes konstituierende numerische Array wird mit gepusht @g. toerstellt eine Kopie und berechnet die Parität . Wenn ( ?) das Ergebnis wahr ist, dh der Inhalt des Arrays ist ungerade, wird das Array umgedreht ( P).

Der Stapel wird implizit am Ende angezeigt . Jedes numerische vertikale Array wird angezeigt und enthält eine Liste von Zahlen, die durch Zeilenumbrüche getrennt sind.

Pyth, 14 Bytes

s_McQshMBx0%R2

           %R2Q   Take all elements of the input list modulo 2
         x0       Get the indices of all 0s
      hMB         Make a list of these indices and a list of these indices plus 1
     s            Concatenate them
   cQ             Chop the input list at all those positions
 _M               Reverse all resulting sublists
s                 Concatenate them

Testfälle

J , 33 31 30 Bytes

[:;]<@(A.~2-@|{.);.1~1,2|2-/\]

Verwendung

   f =: [:;]<@(A.~2-@|{.);.1~1,2|2-/\]
   f 0 1
0 1
   f 1 3
3 1
   f 1 2 3
1 2 3
   f 1 3 2
3 1 2
   f 10 7 9 6 8 9
10 9 7 6 8 9
   f 23 12 32 23 25 27
23 12 32 27 25 23
   f 123 123 345 0 1 9
345 123 123 0 9 1

C #, 179 178 177 Bytes

s=>{var o=new List<int>();var l=new Stack<int>();foreach(var n in s.Split(' ').Select(int.Parse)){if(n%2>0)l.Push(n);else{o.AddRange(l);o.Add(n);l.Clear();}}return o.Concat(l);}

Ich benutze ein C # Lambda. Sie können es auf .NETFiddle versuchen .

Der Code weniger verkleinern:

s => {
    var o=new List<int>();var l=new Stack<int>();
    foreach (var n in s.Split(' ').Select(int.Parse)) {
        if (n%2>0)
            l.Push(n);
        else {
            o.AddRange(l);
            o.Add(n);
            l.Clear();
        }
    }
    return o.Concat(l);
};

Ein großes Lob an Byeonggon Lee für den ursprünglichen Algorithmus.

Pyth, 29 28 Bytes

JYVQ=+J*%hN2+YN=Y*%N2+NY;+JY

Testsuite.

Direkte Übersetzung meiner Python-Antwort (wann ist die Übersetzung von Python zu Python eine gute Idee?)

TSQL 118 Bytes

DECLARE @ TABLE(i int identity, v int)
INSERT @ values(123),(123),(345),(0),(1),(9)

SELECT v FROM(SELECT sum((v+1)%2)over(order by i)x,*FROM @)z
ORDER BY x,IIF(v%2=1,max(i)over(partition by x),i),i desc

Geige

Clojure, 86 Bytes

#(flatten(reduce(fn[a b](if(odd? b)(conj(pop a)(conj[b](last a)))(conj a b[])))[[]]%))

Hier ist die ungolfed Version

#(flatten ; removes all empty vectors and flattens odd sequences
    (reduce 
        (fn[a b]
            (if(odd? b) ; if we encounter odd number in the seq
                (conj(pop a)(conj[b](last a))) ; return all elements but last and the element we encountered plus the last element of current result
                (conj a b[])) ; else just add the even number and the empty vector
            )
        [[]] ; starting vector, we need to have vector inside of vector if the sequence starts with odd number
        %    ; anonymous function arg
    )   
)

Grundsätzlich durchläuft es die Eingabesequenz und wenn es auf eine gerade Zahl stößt, addiert es die Zahl und den leeren Vektor, ansonsten, wenn es eine ungerade Zahl ist, ersetzt es das letzte Element durch diese Zahl plus dem, was im letzten Element war.

Zum Beispiel für diese Folge sieht 2 4 6 1 3 7 2es so aus:

• []<=2
• [2 []]<=4
• [2 [] 4 []]<=6
• [2 [] 4 [] 6 []]<=1
• [2 [] 4 [] 6 [1 []]]<=3
• [2 [] 4 [] 6 [3 [1 []]]]<=7
• [2 [] 4 [] 6 [7 [3 [1 []]]]]<=2
• [2 [] 4 [] 6 [7 [3 [1 []]]] 2 []]

Wenn Sie diesen Vektor abflachen, erhalten Sie die richtige Ausgabe. Sie können es hier online sehen: https://ideone.com/d2LLEC

JavaScript (ES6) 70 66

Bearbeite 4 Bytes gespeichert als @Neil

a=>[...a,[]].map(x=>x&1?o=[x,...o]:r=r.concat(o,x,o=[]),r=o=[])&&r

Stax , 15 10 Bytes ^CP437

Çⁿ╜"}☻≥º╚(

Probieren Sie es online!

Gebundenes Gelee! So traurig, dass beim Packen nur ein Byte gespart wurde.

Entpackte Version mit 11 Bytes:

{|e_^*}/Frm

Erläuterung

{|e_^*}ist ein Block, der alle geraden Zahlen abbildet nzu n+1, und alle ungeraden Zahlen nauf 0.

{|e_^*}/Frm
{     }/       Group array by same value from block
 |e            1 if the element is even, 0 if odd.
   _^          Get another copy of the current element and increment by 1
     *         Multiply them
        F      For each group execute the rest of the program
         r     Reverse the group
          m    Print elements from the group, one element per line.

Schale , 7 Bytes

ṁ↔ġ¤&%2

Probieren Sie es online!

Erläuterung

ṁ↔ġ¤&%2  Implicit input, a list of integers.
  ġ      Group by equality predicate:
   ¤ %2   Arguments modulo 2
    &     are both truthy.
ṁ        Map and concatenate
 ↔       reversing.

Ruby , 51 Bytes

->l{l.chunk(&:odd?).flat_map{|i,j|i ?j.reverse: j}}

Probieren Sie es online!

Einige geringfügige Abweichungen:

->l{l.chunk(&:odd?).flat_map{|i,j|i&&j.reverse||j}}
->l{l.chunk(&:odd?).flat_map{|i,j|!i ?j:j.reverse}}
->l{l.chunk(&:even?).flat_map{|i,j|i ?j:j.reverse}}

Perl 5 mit-p 42 Bytes

map{$_%2?$\=$_.$\:print$\.$_,$\=""}$_,<>}{

Probieren Sie es online!