영감 .

직무

음수가 아닌 2 ~ 2 ¹⁵ 개의 주어진 목록에서 홀수의 역행.

예

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

파이썬 2, 75 68 63 바이트

Dennis 덕분에 5 바이트.

그리고 나는 Dennis를 능가했다 .

알고리즘의 핵심 으로 이병곤 에게 감사의 말 을 전한다 .

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

무시 했어!

이전 버전 : 75 바이트

파이썬 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

편집 : ~De Morgan의 법률 덕분에 저장되었습니다

하스켈, 46 44 바이트

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

접기를 인식하고 2 바이트를 절약 한 @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.

파이썬 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)

슈퍼 해키 :)

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오고 연속적인 차이를 계산 하고 0이 아닌 값을로 변환 하고 앞에 붙습니다 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 # 람다를 사용합니다. .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);
};

독자적인 알고리즘을 위해 이병곤에게 전해진다 .

Pyth, 29 28 바이트

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

테스트 스위트.

내 파이썬 답변 의 직접 번역 (파이썬에서 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

깡깡이

클로저, 86 바이트

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

ungolfed 버전은 다음과 같습니다

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

기본적으로 입력 시퀀스를 거치고 짝수를 만나면 숫자를 추가하고 빈 벡터를 추가합니다. 그렇지 않으면 홀수이면 마지막 요소를이 숫자와 마지막 요소에 있던 숫자로 바꿉니다.

예를 들어이 seq의 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에서 온라인으로 볼 수 있습니다.

자바 스크립트 (ES6) 70 66

thx @Neil으로 저장된 4 바이트 편집

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

Stax , 15 10 바이트 ^CP437

Çⁿ╜"}☻≥º╚(

온라인으로 사용해보십시오!

묶인 젤리! 포장이 1 바이트 만 절약한다는 것이 슬프습니다.

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.

루비 , 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}}

펄 5 와 -p42 바이트

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

온라인으로 사용해보십시오!