启示。

任务

在2到2 ^15个非负整数的给定列表中对奇数进行反向运算。

例子

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字节

5字节感谢丹尼斯。

而且我已经超越了丹尼斯。

学分Byeonggon李对算法的核心。

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

伊迪恩！

旧版本：75个字节

Python 2，79 75 73字节

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

这是一个修改其参数的函数。第二个缩进级别是制表符。

在Ideone上进行测试。

APL，21 20字节

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

试试看 || 所有测试用例

说明：

                  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

编辑：保存了~对德摩根法律的感谢

Haskell，46 44字节

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

感谢@xnor识别折叠并节省了两个字节。

果冻，10 字节

Ḃ¬ðœpUżx@F

在线尝试！或验证所有测试用例。

怎么运行的

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

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)

超级hacky :)

Python3，96个字节

感谢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字节

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字节

TiodgvYsG8XQ!"@gto?P

输入是一个列数组，;用作分隔符。

在线尝试！

说明

以输入数组为例[1;2;3;5;7;4;6;7;9]。代码的第一部分Tiodgv将此数组转换为[1;1;1;0;0;1;0;1;0]，其中1表示奇偶校验的更改。（具体来说，该代码获取输入数组每个条目的奇偶校验，计算连续的差，将非零值转换为1，并在a之前加上前缀1。）

然后Ys计算累积和，得出[1;2;3;3;3;4;4;5;5]。这些数字中的每一个都将用作标签，基于此标签将对输入的元素进行分组。这是通过完成的G8XQ!，将输入数组拆分为包含组的单元格数组。在这种情况下，它给出了{[1] [2] [3;5;7] [4;6] [7;9]}。

其余代码在单元数组上迭代（"）。每个组成数字数组用推动@g。to复制并计算其奇偶校验。如果（?）结果为真，即数组内容为奇数，则将数组翻转（P）。

堆栈隐式显示在末尾。将显示每个数字垂直数组，并给出由换行符分隔的数字列表。

Pyth，14个字节

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

测试用例

J，33 31 30字节

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

用法

   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字节

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

我使用C＃lambda。您可以在.NETFiddle上尝试。

代码少了：

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

对于原始算法，我向Byeonggon Lee表示敬意。

Pyth，29 28字节

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

测试套件。

直接翻译我的python答案（何时从python转换为pyth成为一个好主意？）

TSQL 118字节

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

小提琴

Clojure，86个字节

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

这是非高尔夫版本

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

基本上，它会遍历输入序列，如果遇到偶数，它将加数字和空向量，否则，如果它是奇数，它将用该数字替换最后一个元素加上最后一个元素的内容。

例如，此序列2 4 6 1 3 7 2如下所示：

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

然后展平此向量将给出正确的输出。您可以在此处在线查看：https：//ideone.com/d2LLEC

JavaScript（ES6）70 66

编辑保存的4个字节thx @Neil

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

Stax，15个10 字节^CP437

Çⁿ╜"}☻≥º╚(

在线尝试！

绑果冻！ 太可惜了，打包只保存了一个字节。

11字节的解压缩版本：

{|e_^*}/Frm

说明

{|e_^*}是所有的偶数映射块n来n+1，和所有的奇数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.

外壳，7个字节

ṁ↔ġ¤&%2

在线尝试！

说明

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

Ruby，51个字节

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

在线尝试！

一些细微的变化：

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

具有-p42个字节的Perl 5

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

在线尝试！