L'inspiration .

Tâche

Inverser des séries de nombres impairs dans une liste donnée de 2 à 2 ¹⁵ entiers non négatifs.

Exemples

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 octets

5 octets grâce à Dennis.

Et j'ai déjoué Dennis .

Crédits à Byeonggon Lee pour le cœur de l'algorithme.

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

Ideone it!

Ancienne version: 75 octets

Python 2, 79 75 73 octets

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

Il s'agit d'une fonction qui modifie son argument en place. Le deuxième niveau d'indentation est un tabulateur.

Testez-le sur Ideone .

APL, 21 20 octets

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

Essayez-le || Tous les cas de test

Explication:

                  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: sauvé un ~merci aux lois de De Morgan

Haskell, 46 44 octets

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

Merci à @xnor d'avoir reconnu un pli et d'avoir sauvé deux octets.

Gelée , 10 octets

Ḃ¬ðœpUżx@F

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

Ḃ¬ðœ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 octets

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 octets

Beaucoup d'octets enregistrés grâce à Leaky Nun!

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 octets

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 octets

TiodgvYsG8XQ!"@gto?P

L'entrée est un tableau de colonnes, utilisant ; comme séparateur.

Essayez-le en ligne!

Explication

Prenons comme exemple le tableau d'entrée [1;2;3;5;7;4;6;7;9]. La première partie du code Tiodgv,, convertit ce tableau en [1;1;1;0;0;1;0;1;0], où 1indique un changement de parité . (Plus précisément, le code obtient la parité de chaque entrée du tableau d'entrée, calcule des différences consécutives, convertit des valeurs différentes de zéro 1et ajoute un1 .)

YsCalcule ensuite la somme cumulée , donnant [1;2;3;3;3;4;4;5;5]. Chacun de ces numéros sera utilisé comme une étiquette , sur la base de laquelle les éléments de l'entrée seront regroupés . Cela se fait par G8XQ!, qui divise le tableau d'entrée en un tableau de cellules contenant les groupes. Dans ce cas, cela donne{[1] [2] [3;5;7] [4;6] [7;9]} .

Le reste du code itère ( ") sur le tableau de cellules. Chaque tableau numérique constituant est poussé avec @g. tofait une copie et calcule sa parité . Si ( ?) le résultat est vrai, c'est-à-dire que le contenu du tableau est impair, le tableau est retourné ( P).

La pile est implicitement affichée à la fin. Chaque tableau vertical numérique est affiché, donnant une liste de nombres séparés par des retours à la ligne.

Pyth, 14 octets

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

Cas de test

J , 33 31 30 octets

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

Usage

   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 octets

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

J'utilise un lambda C #. Vous pouvez l'essayer sur .NETFiddle .

Le code moins réduit:

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

Félicitations à Byeonggon Lee pour l'algorithme d'origine.

Pyth, 29 28 octets

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

Suite de tests.

Traduction directe de ma réponse python (quand la traduction de python en pyth est-elle devenue une bonne idée?)

TSQL 118 octets

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

Violon

Clojure, 86 octets

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

Voici la version non golfée

#(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
    )   
)

Fondamentalement, il passe par la séquence d'entrée et s'il rencontre un nombre pair, il ajoute le nombre et le vecteur vide sinon, s'il s'agit d'un nombre impair, il remplace le dernier élément par ce numéro plus ce qui était dans le dernier élément.

Par exemple, pour cette séquence, 2 4 6 1 3 7 2cela se passe comme suit:

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

Et puis aplatir ce vecteur donne la sortie correcte. Vous pouvez le voir en ligne ici: https://ideone.com/d2LLEC

JavaScript (ES6) 70 66

Modifier 4 octets enregistrés thx @Neil

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

Stax , 15 10 octets ^CP437

Çⁿ╜"}☻≥º╚(

Essayez-le en ligne!

Gelée attachée! Tellement triste que l'emballage n'ait économisé qu'un octet.

Version non compressée avec 11 octets:

{|e_^*}/Frm

Explication

{|e_^*}est un bloc qui mappe tous les nombres pairs nà n+1, et tous les nombres impairs nà 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.

Husk , 7 octets

ṁ↔ġ¤&%2

Essayez-le en ligne!

Explication

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

Rubis , 51 octets

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

Essayez-le en ligne!

Quelques légères variations:

->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 avec -p, 42 octets

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

Essayez-le en ligne!