कार्य

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

— एडम
स्रोत

4

1. मैंने केवल उदाहरणों को देखने के बाद चुनौती को समझा। मुझे लगता है कि दृश्यों की तुलना में विषम पूर्णांक के रन स्पष्ट होंगे । 2. मुझे नहीं लगता कि एक स्पष्ट ऊपरी सीमा तय करना अच्छी बात है। यदि किसी भाषा में केवल 8-बिट पूर्णांक हैं, तो भाग लेना बहुत कठिन होगा।

— डेनिस

इसके अलावा, मुझे यकीन नहीं है कि आगे क्या संख्यात्मक अभिकलन है। क्या इसका मतलब यह है कि मैं एक अपरिवर्तनीय टपल वापस नहीं कर सकता या केवल संख्याओं को प्रिंट कर सकता हूं?

— डेनिस

@ डेनिस अपडेटेड जैसा आपने सुझाव दिया। यह इनपुट / आउटपुट को स्ट्रिंग के रूप में रोकना है। बेहतर शब्दों के लिए कोई सुझाव?

— एडम जूल

4

आप स्ट्रिंग आउटपुट को क्यों रोकना चाहते हैं?

— डेनिस

2

हां, दूसरी चुनौती को देखते हुए, अधिकांश उत्तर जीरो पर विभाजित होने पर निर्भर करते हैं, जबकि यहां आपको एक शर्त पर विभाजित करना होगा, जिसमें अधिकांश भाषाओं में बिल्ट-इन नहीं होता है।

— xnor

8

पायथन 2, 75 68 63 बाइट्स

5 बाइट्स डेनिस के लिए धन्यवाद।

और मैंने डेनिस को पछाड़ दिया है ।

एल्गोरिथ्म के मूल के लिए ब्योंगॉन ली को श्रेय ।

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

Ideone यह!

पुराना संस्करण: 75 बाइट्स

— लीक नन
स्रोत

बंधी हुई, सच में। इसके अलावा, मैं 81 की गिनती कर रहा हूं, 75 की नहीं। मैं अनुमान लगा रहा हूं कि आपने इसे टैब के साथ गिना है, लेकिन एसई संपादक रिक्त स्थान से भरा है।

— DJMcMayhem

@DrGreenEggsandIronMan आपका अनुमान सही है। पठनीयता के लिए टैब। या तो स्रोत की गिनती करें या एक विचारधारा की गिनती करें।

— लीकी नून

1

printparens की जरूरत नहीं है इसके अलावा, आप केवल aएक बार उपयोग करते हैं , इसलिए चर की कोई आवश्यकता नहीं है।

— डेनिस

5

पायथन 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 पर इसका परीक्षण करें ।

— डेनिस
स्रोत

इसके लिए मेटा कहाँ है?

— लीके नन

meta.codegolf.stackexchange.com/a/4942/12012

— डेनिस

5

एपीएल, 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

संपादित करें: ~डी मॉर्गन के कानूनों के लिए धन्यवाद सहेजा गया

— Woofmao
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! यह एक अच्छी पोस्ट है।

— NoOneIsHere

5

हास्केल, 46 44 बाइट्स

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

एक गुना पहचानने और दो बाइट्स बचाने के लिए @xnor का धन्यवाद।

— लिन
स्रोत

अच्छी विधि, विशेष रूप से (h*)! आप f x=xखाली सूची से मिलान करने के लिए दूसरा लिखकर आधार मामले पर एक बाइट को बचा सकते हैं , हालांकि ऐसा लगता है कि यह foldrअभी भी कम है h%p|(l,r)<-span(odd.(h*))p=l++h:r;foldr(%)[]:

— xnor

मुझे पता था कि यह सिर्फ एक के foldrबाद था ! धन्यवाद।

— लिन

4

जेली , 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.

— डेनिस
स्रोत

4

पायथन 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)

सुपर हैकी :)

— orlp
स्रोत

क्या है k.i?

— लीकी नून

k.i=0आखिरी लाइन पर @LeakyNun । यह सिर्फ एक चर है।

— orlp

मुझे नहीं मिला। हैं kऔर k.iसंबंधित हैं?

— लीकी नून

@LeakyNun No. k.iकी कॉल के बीच एक निरंतर चर है k। globalकीवर्ड का उपयोग किए बिना इसे एक अस्थायी वैश्विक के रूप में देखें ।

— orlp

4

पायथन 3, 96 बाइट्स

लीक नयन के लिए धन्यवाद बाइट्स का एक बहुत बचाया!

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

— ब्योंगोंग ली
स्रोत

3

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

— orlp
स्रोत

3

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 दर्शाता है । (विशेष रूप से, कोड इनपुट सरणी के प्रत्येक प्रविष्टि की समता प्राप्त करता है, लगातार अंतर की गणना करता है, नॉनजरो मानों को धर्मान्तरित करता है , और एक प्रीपेन्ड करता है11 ।)

फिर Ysगणना करता है संचयी योग , दे रही है [1;2;3;3;3;4;4;5;5]। इनमें से प्रत्येक नंबर को एक लेबल के रूप में उपयोग किया जाएगा , जिसके आधार पर इनपुट के तत्वों को समूहीकृत किया जाएगा । यह द्वारा किया जाता है G8XQ!, जो इनपुट सरणी को एक सेल सरणी में विभाजित करता है जिसमें समूह होते हैं। इस मामले में यह देता है {[1] [2] [3;5;7] [4;6] [7;9]}।

शेष कोड सेल सरणी पर पुनरावृत्त करता है ( ")। प्रत्येक घटक संख्यात्मक सरणी के साथ धकेल दिया जाता है @g। toएक प्रति बनाता है और उसकी समता की गणना करता है । यदि ( ?) परिणाम सत्य है, अर्थात सरणी सामग्री विषम हैं, तो सरणी फ़्लिप की गई है (P ) है।

स्टैक को अंत में प्रदर्शित किया जाता है। प्रत्येक न्यूमेरिकल वर्टिकल ऐरे को प्रदर्शित किया जाता है, जो न्यूलाइन्स द्वारा अलग किए गए नंबरों की एक सूची प्रदान करता है।

— लुइस मेंडो
स्रोत

2

अजगर, 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

परीक्षण के मामलों

— एंडर्स कसीर्ग
स्रोत

2

जे , 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

— मील की दूरी पर
स्रोत

2

सी #, 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 # लंबो का उपयोग करता हूं। आप इसे .NETField पर आज़मा सकते हैं ।

कोड कम संक्षिप्त करें:

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

मूल एल्गोरिथ्म के लिए यशगान ली को कुडोस ।

— aloisdg codidact.com पर जा रहा है
स्रोत

1

आप 2 बाइट्स (या वास्तव में 1, को बचाने के लिए स्थान foreach(varबदल सकते हैं और बदल सकते हैं , क्योंकि आपका वर्तमान उत्तर 179 बाइट्स 178 के बजाय है)। if(n%2==1)if(n%2>0)

— केविन क्रूज़सेन

@ केविनक्रूजसेन इसे कम मिनिफ़ाइ सेक्शन में बदला गया था लेकिन मिनिइज़ एक में नहीं। इसके अलावा, आपको फ़ॉरवर्ड स्पेस के लिए धन्यवाद!

— aloisdg

1

पायथ, 29 28 बाइट्स

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

परीक्षण सूट।

मेरे अजगर जवाब का सीधा अनुवाद (जब अजगर से अजगर में अनुवाद करना एक अच्छा संकेत बन गया है)?

— लीक नन
स्रोत

1

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

बेला

— t-clausen.dk
स्रोत

1

क्लोजर, 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

— cliffroot
स्रोत

1

जावास्क्रिप्ट (ईएस 6) 70 66

4 बाइट्स संपादित करें thx @Neil को बचाया

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

— edc65
स्रोत

:r=r.concat(o,x,o=[]),आपको कुछ बाइट्स बचाता है। मुझे लगता है कि आप इस तरह से एक और दो को बचाने के लिए आगे बढ़ सकते हैं a=>[...a,[]].map(x=>x&1?o=[x,...o]:r=r.concat(o,x,o=[]),r=o=[])&&r:।

— नील

का अर्थ क्या है ...o?

— aloisdg

1

@aloisdg codegolf.stackexchange.com/a/37723/21348

— edc65

@ जोड़ा तत्व के रूप में प्रयुक्त खाली सरणी एक मास्टर स्ट्रोक है

— edc65

1

स्टेक्स , 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.

— वेइजुन झोउ
स्रोत

1

भूसी , 7 बाइट्स

ṁ↔ġ¤&%2

इसे ऑनलाइन आज़माएं!

व्याख्या

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

— ज़गरब
स्रोत

0

रूबी , 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}}

— आसोन तुहिद
स्रोत

0

पर्ल 5 के साथ `-p`, 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

रिवर्स रन

कार्य

उदाहरण

पायथन 2, 75 68 63 बाइट्स

पायथन 2, 79 75 73 बाइट्स

एपीएल, 21 20 बाइट्स

हास्केल, 46 44 बाइट्स

जेली , 10 बाइट्स

यह काम किस प्रकार करता है

पायथन 2, 78 75 बाइट्स

पायथन 3, 96 बाइट्स

सी, 107 बाइट्स

MATL , 20 बाइट्स

व्याख्या

अजगर, 14 बाइट्स

जे , 33 31 30 बाइट्स

प्रयोग

सी #, 179 178 177 बाइट्स

पायथ, 29 28 बाइट्स

TSQL 118 बाइट्स

क्लोजर, 86 बाइट्स

जावास्क्रिप्ट (ईएस 6) 70 66

स्टेक्स , 15 10 बाइट्स CP437

व्याख्या

भूसी , 7 बाइट्स

व्याख्या

रूबी , 51 बाइट्स

पर्ल 5 के साथ -p, 42 बाइट्स

स्टेक्स , 15 10 बाइट्स ^CP437

पर्ल 5 के साथ `-p`, 42 बाइट्स