465 की व्यवस्था

24

यहां चुनौती है। किसी श्रेणी में सभी पूर्णांकों को आउटपुट करने के लिए कुछ कोड लिखें। आसान लगता है, लेकिन यहाँ मुश्किल हिस्सा है। यह सबसे कम संख्या के साथ शुरू होगा, फिर उच्चतम। फिर सबसे कम संख्या जो अभी सरणी में नहीं है। तब उच्चतम जो अभी तक इसमें नहीं है।

उदाहरण:

हमारी शुरुआत के रूप में 1 से 5 लेते हैं

संख्याएं हैं [1, 2, 3, 4, 5]।

हम पहले लेते हैं, इसलिए [1]। शेष संख्याएँ [2, 3, 4, 5] हैं। हम अंतिम, नया सरणी लेते हैं [1, 5]। शेष संख्याएं [2, 3, 4] हैं। हम पहला, नया ऐरे लेते हैं [1, 5, 2]। शेष नंबर [3, 4] हैं। हम अंतिम लेते हैं, नई सरणी [1, 5, 2, 4] है। शेष नंबर [3] हैं। हम पहला, नया ऐरर लेते हैं [1, 5, 2, 4, 3]। कोई संख्या शेष नहीं है, हम कर रहे हैं। आउटपुट [1, 5, 2, 4, 3]

नियम:

  • यह कोड गोल्फ है, इसे सबसे कम बाइट्स, किसी भी भाषा में लिखें।
  • कोई मानक खामियां नहीं हैं।
  • ऑनलाइन दुभाषिया के लिंक, कृपया? (जैसे https://tio.run/ )
  • दो इनपुट, दोनों पूर्णांक। रेंज का कम अंत, और रेंज का उच्च अंत।
  • मुझे कोई आपत्ति नहीं है कि आउटपुट का डेटा प्रकार क्या है, लेकिन इसे सही क्रम में संख्याएं दिखानी चाहिए।

उदाहरण

निम्न: 4 उच्च: 6 परिणाम: 4 6 5

निम्न: 1 उच्च: 5 परिणाम: 1 5 2 4 3

निम्न: -1 उच्च: 1 परिणाम: -1 1 0

निम्न: -1 उच्च: 2 परिणाम: -1 2 0 1

निम्न: -50 उच्च: 50 परिणाम: -50 50 -49 49 -48 48 -47 47 -46 46 -45 45 -44 44 -43 43 -42 43 -42 41 -41 40 -40 40 -39 39 -38 38 -37 37 -36 36 -35 35 -34 34 -33 33 -32 32 -31 31 -30 30 -29 29 -28 28 -27 27 -26 26 -25 26 -25 25 -24 24 -23 23 -22 22 -21 21 - 20 20 -19 19 -18 18 -17 17 -16 16 -15 15 -14 14 -13 13 -12 12 -11 11 -10 10 -9 10 -9 9 -8 8 -7 7 -6 6 -5 5 -4 4 -3 3 -2 2 -1 1 0

हैप्पी गोल्फिंग!

code-golf 
— AJFaraday
स्रोत
2
लगभग डुप्लिकेट (अंतर यह है कि इस एक को विलय से पहले दूसरे छमाही को उलटने की आवश्यकता होती है)।
— पीटर टेलर
क्या इनपुट हमेशा कम अंत, उच्च अंत के क्रम में होने वाला है?
— सुमेर
1
@ सुमेर १ yes हाँ। इनपुट सत्यापन के खिलाफ यहां समुदाय मृत है, और मैंने रिवर्स-ऑर्डर इनपुट के लिए नहीं कहा है, इसलिए हम यह मान सकते हैं कि यह हमेशा कम - उच्च होगा।
— AJFaraday
1
@ Sumner18 ये चुनौतियाँ आम तौर पर कैसे काम करती हैं, हम इस बात की परवाह नहीं करते हैं कि अमान्य इनपुट कैसे संभाले जाते हैं। आपके कोड को केवल इस बात से आंका जाता है कि यह कैसे मान्य इनपुट के साथ सफल होता है (यानी दोनों पूर्णांक हैं, पहला दूसरे से कम है)
— AJFaraday
1
@AJFaraday: आपको मुख्य पोस्ट पर एक नोट जोड़ना चाहिए जो यह दर्शाता है कि X हमेशा (यानी X =! Y) की तुलना में सख्ती से कम होगा, मैंने यह टिप्पणी याद की;)
— digEmAll

जवाबों:

15

आर , ३ 38 ३ 38 36 बाइट्स

function(a,b)rbind(a:b,b:a)[a:b-a+1]

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

  • -1 बाइट धन्यवाद @ user2390246
  • -1 बाइट की बदौलत @Kirill L

इस तथ्य को उजागर करते हुए कि R, कॉलम-वार को संग्रहीत करता है

— digEmAll
स्रोत
उपयोग करना rbindमेरे दृष्टिकोण से बहुत बेहतर है, लेकिन आप [seq(a:b)]इसके बजाय का उपयोग करके 1 बाइट बचा सकते हैं unique।
— user2390246
आप सही हैं, मैं उस टिप्पणी से चूक गया जहाँ निर्दिष्ट किया गया है कि <b (कभी नहीं के बराबर), इसलिए हम उपयोग कर सकते हैंseq(a:b)
— digEmAll
@digEmAll मेरा समाधान अनिवार्य रूप से पहेली की शाब्दिक व्याख्या था, मैंने कभी ऐसा कुछ करने के बारे में सोचा भी नहीं होगा। प्रभावशाली, एक उत्थान है!
— सुमेर
1
— किरिल एल।
8

आर , ६५ ६४ ६१ 60 बाइट्स

-1 बाइट रॉबर्ट एस के लिए धन्यवाद।

-4 अधिक digEmAll के लिए धन्यवाद 

x=scan();z=x:x[2];while(sum(z|1)){cat(z[1],"");z=rev(z[-1])}

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

— Sumner18
स्रोत
आप बदल सकते हैं length(z)के साथ sum(z|1)करने के लिए सेव 1 बाइट :)
— रॉबर्ट एस
मुझे समझ नहीं आता कि यह कैसे काम करता है लेकिन मुझे लगता है कि यह काम करता है। योग (z | 1) ऐसा लगता है कि यह हमेशा कम से कम 1 का मूल्यांकन करेगा, जो कि लूप को अंतहीन रूप से लूप में ले जाएगा। लेकिन स्पष्ट रूप से नहीं
— सुमेर
4
z एक वेक्टर है। उस वेक्टर का प्रत्येक तत्व |1 के साथ एड होता है। जो हमेशा 1 के बराबर होता है। जब आप योग लेते हैं, तो आपके पास वेक्टर भरा होता है, TRUEइसलिए परिणाम वेक्टर की लंबाई के बराबर होता है। यदि वेक्टर खाली है, तो आप |आउटपुट वेक्टर के साथ कुछ भी नहीं है logical(0)। जब आप उस राशि को लेते हैं, तो यह 0
— OganM
5

PowerShell , 59 48 बाइट्स

param($a,$b)(($z=0..($b-$a))|%{$a+$_;$b-$_})[$z]

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

(लंबा लगता है ...)

इनपुट लेता है $aऔर $b, रेंज का निर्माण करता है 0 .. ($b-$a), स्टोर करता है $z, फिर उस रेंज के माध्यम से लूप करता है। उस सीमा के माध्यम से लूपिंग का उपयोग केवल काउंटर के रूप में किया जाता है ताकि यह सुनिश्चित किया जा सके कि हमें पर्याप्त पुनरावृत्तियाँ मिलें। प्रत्येक यात्रा, हम डाल $aऔर $bइसके अलावा / घटाव के साथ पाइपलाइन पर। यह हमें ऐसा कुछ देता है 1,5,2,4,3,3,4,2,5,1जिससे हमें इसमें से टुकड़ा करने की आवश्यकता 0होती है$b-$a मूल सरणी (यानी, गिनती) , इसलिए हम केवल उपयुक्त तत्वों के साथ छोड़ दिए जाते हैं। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

-11 बाइट्स mazzy के लिए धन्यवाद।

— AdmBorkBork
स्रोत
— मेज़ी
@mazzy आह, मुझे वह $b-$aचाल पसंद है - यह चतुर है!
— AdmBorkBork
5

05AB1E , 6 बाइट्स

ŸDvć,R

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

व्याख्या

Ÿ        # push range [min ... max]
 D       # duplicate
  v      # for each element in the copy
   ć,    # extract and print the head of the original list
     R   # and then reverse it
— Emigna
स्रोत
,2ä`R.ι नॉन इटेरेटिव इन्टरलेवेव का उपयोग करते हुए, लेकिन यह अभी भी बहुत बेहतर है।
— मैजिक ऑक्टोपस Urn
1
@MagicOctopusUrn: मैं पहली बार एक गैर पुनरावृत्ति समाधान करने की कोशिश की है, लेकिन यह भी बदतर के बाद से मैं के बारे में पता नहीं था .ι;)
— Emigna
जैसा कि मेरे मन में था, वैसा ही मेरे लिए भी स्पष्ट है। मुझे @MagicOctopusUrn के माध्यम से आपका वैकल्पिक 7-बटर पसंद है। :)
— केविन क्रूज़सेन
1
@ क्रिश्चियनविल्स: मेरे लिए काम करने लगता है ।
— एमिगा
1
@ केविनक्रूजसेन: मैंने इसके बजाय एक जोड़ी पर स्विच किया, जैसा कि अधिक सहज तरीके से महसूस किया गया :)
— एमिगा
4

आर , 51 बाइट्स

function(x,y,z=x:y)matrix(c(z,rev(z)),2,,T)[seq(z)]

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

स्पष्टीकरण: x:yलंबाई के अनुक्रम के लिए N, दो x-by-N मैट्रिक्स बनाएँ, जिसमें क्रम x: y शीर्ष पंक्ति में और y: x नीचे पंक्ति में हो matrix(c(z,rev(z)),2,,T)। यदि हम Nमैट्रिक्स के पहले तत्वों का चयन करते हैं [seq(z)], तो उन्हें आवश्यक आउटपुट देते हुए, कॉलम द्वारा चुना जाएगा।

DigEmAll द्वारा बहिष्कृत

— user2390246
स्रोत
1
मैंने आपके सामने 30 सेकंड पहले एक समान दृष्टिकोण पोस्ट किया था: D
— digEmAll
@digEmAll हाँ, लेकिन तुम्हारा बहुत बेहतर है!
— user2390246
4

CQuents , 19 बाइट्स

#|B-A+1&A+k-1,B-k+1

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

ध्यान दें कि यह अभी TIO पर काम नहीं करता है क्योंकि TIO का दुभाषिया अप टू डेट नहीं है।

व्याख्या

#|B-A+1&A+k-1,B-k+1
                      A is the first input, B is the second input
#|B-A+1               n = B - A + 1
       &              Print the first n terms of the sequence
                      k starts at 1 and increments whenever we return to the first term
        A+k-1,         Terms alternate between A + k - 1 and
              B-k+1     B - k + 1
                       increment k
— स्टीफन
स्रोत
4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 46 बाइट्स

a=>b=>{for(;a<=b;Write(a+(b>a++?b--+"":"")));}

सहेजे गए 4 बाइट्स दाना के लिए धन्यवाद!

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 65 बाइट्स

void z(int a,int b){if(a<=b){Write(a+(b>a?b+"":""));z(a+1,b-1);}}

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

— अज्ञान का अवतार
स्रोत
4

JVM बाइटकोड (OpenJDK asmtools JASM), 449 बाइट्स

enum b{const #1=Method java/io/PrintStream.print:(I)V;static Method a:(II)V stack 2 locals 4{getstatic java/lang/System.out:"Ljava/io/PrintStream;";astore 3;ldc 0;istore 2;l:iload 2;ldc 1;if_icmpeq t;aload 3;iload 0;invokevirtual #1;iinc 0,1;iinc 2,1;goto c;t:aload 3;iload 1;invokevirtual #1;iinc 1,-1;iinc 2,-1;c:aload 3;ldc 32;i2c;invokevirtual java/io/PrintStream.print:(C)V;iload 0;iload 1;if_icmpne l;aload 3;iload 0;invokevirtual #1;return;}}

Ungolfed (और थोड़ा साफ)

 enum b {    
    public static Method "a":(II)V stack 5 locals 4 {
        getstatic "java/lang/System"."out":"Ljava/io/PrintStream;";
        astore 3;
        ldc 0;
        istore 2;
    loop:
        iload 2;
        ldc 1;
        if_icmpeq true;
    false:
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 0,1;
        iinc 2,1;
        goto cond;
    true:
        aload 3;
        iload 1;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 1,-1;
        iinc 2,-1;
        goto cond;
    cond:
        iload 0;
        iload 1;
        if_icmpne loop;
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        return;
    }
}

स्टैंडअलोन फ़ंक्शन, को जावा से कहा जाना चाहिए b.a(num1,num2) ।

व्याख्या

यह कोड विधि मापदंडों को चर के रूप में उपयोग करता है, साथ ही स्थानीय # 3 में एक बूलियन तय करता है कि किस संख्या को आउटपुट करना है। प्रत्येक लूप पुनरावृत्ति या तो बाएं या दाएं आउटपुट है, और वह संख्या बाएं के लिए बढ़ी हुई है या दाईं ओर बढ़ी हुई है। लूप तब तक जारी रहता है जब तक कि दोनों संख्याएं समान नहीं होती हैं, फिर वह संख्या आउटपुट है।

... मैं एक अलग लग रहा है मैं बाइट गिनती पर बड़े पैमाने पर प्रकोप है

— बिल्ली का बच्चा
स्रोत
4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 56 54 बाइट्स

यह मेरी पहली बार गोल्फ है!

f[a_,b_]:=(c=a~Range~b;Drop[c~Riffle~Reverse@c,a-b-1])

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

सहेजे गए 2 बाइट्स infix संकेतन का उपयोग करते हुए।

स्पष्टीकरण:

f[a_,b_]:=                                   \function of two variables
c=a~Range~b;                                 \list of integers from a to b 
                           Reverse@c         \same list in reverse
                  c~Riffle~Reverse@c         \interleave the two lists
             Drop[c~Riffle~Reverse@c,a-b-1]  \drop last |a-b-1| elements (note a-b-1 < 0)

वैकल्पिक रूप से, हम उपयोग कर सकते हैं Take[...,b-a+1] उसी परिणाम के लिए ।

टेस्ट:

f[4, 6]
f[1, 5]
f[-1, 1]
f[-1, 2]

ouput:

{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}
— काई
स्रोत
"इसे ऑनलाइन आज़माएं" लिंक 403 देता है। "क्षमा करें, आपके पास इस आइटम को एक्सेस करने की अनुमति नहीं है।"
— रोहित नामजोशी
@RohitNamjoshi I ने लिंक अपडेट किया
— काई
ध्यान दें कि TIO पर आप वास्तविक कोड बॉक्स के ऊपर और नीचे टेक्स्ट बॉक्स में हेडर और फुटर कोड रख सकते हैं। यह कोड को साफ दिखता है, साथ ही साथ आपको PPCG उत्तर फॉर्मैटर (esc-sg) का लाभ उठाने की अनुमति देता है। इसे ऑनलाइन आज़माएं!
— जो किंग
@JoKing की बहुत सराहना की, मैंने पहले कभी इसका इस्तेमाल नहीं किया था!
— काई
3

फोर्थ (gforth) , 52 बाइट्स

: f 2dup - 1+ 0 do dup . i 2 mod 2* 1- - swap loop ;

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

व्याख्या

0 से लूप (अंत - प्रारंभ)। स्टैक के ऊपर अंत और प्रारंभ करें।

प्रत्येक परिवर्तन:

  • वर्तमान संख्या को आउटपुट करें
  • वर्तमान संख्या से 1 जोड़ें (घटाएँ)
  • दूसरी संख्या के साथ वर्तमान संख्या को स्विच करें

कोड स्पष्टीकरण

: f           \ start new word definition
  2dup -      \ get the size of the range (total number of integers)
  1+ 0        \ add 1 to the size because forth loops are [Inclusive, Exclusive) 
  do          \ start counted loop from 0 to size+1
    dup .     \ output the current top of the stack
    i 2 mod   \ get the index of the loop modulus 2
    2* 1-     \ convert from 0,1 to -1,1
    -         \ subtract result from top of stack (adds 1 to lower bound and subtracts 1 from upper)
    swap      \ swap the top two stack numbers 
  loop        \ end the counted loop
;             \ end the word definition
— reffu
स्रोत
3

हास्केल, 30 बाइट्स

l%h=l:take(h-l)(h:(l+1)%(h-1))

उपयोग: 3%7देता है `[3,7,4,6,5]

आदानों के l, hलिए फ़ंक्शन इनपुट के साथ पुनरावर्ती कॉल करता है l+1, h-1, और l,hभीख में जोड़ता है। किसी भी रुकने की स्थिति के बजाय, कोड take(h-l)अनुक्रम को सही लंबाई तक छोटा करने के लिए उपयोग करता है (जो कि अन्यथा बढ़ती संख्या और घटती संख्या का एक अनंत क्रम होगा)।

— गर्वित हेकलर
स्रोत
3

ब्रेकीलॉग , 15 बाइट्स

⟦₂{∅|b↔↰T&hg,T}

इनपुट 2-तत्व सूची [लो, हाय] है। ध्यान दें कि अंडरस्कोर का उपयोग नकारात्मक संख्याओं के लिए किया जाता है। इसे ऑनलाइन आज़माएं!

व्याख्या

⟦₂               2-argument inclusive range: [1,5] -> [1,2,3,4,5]
  {           }  Call this recursive predicate to calculate the output:
   ∅               Base case: the input is empty list; nothing to do
    |              Otherwise (recursive case):      [1,2,3,4,5]
     b             Behead the input list            [2,3,4,5]
      ↔            Reverse                          [5,4,3,2]
       ↰           Call the predicate recursively   [5,2,4,3]
        T          Label the result T
         &         Also, with the input list,
          h        Take the head                    1
           g       Wrap it in a list                [1]
            ,T     Append T from earlier            [1,5,2,4,3]
— DLosc
स्रोत
3

मैथॉल्फ , 6 बाइट्स

↨_x^─▀

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

के साथ स्पष्टीकरण (1, 5)

↨        inclusive range from a to b    [1, 2, 3, 4, 5]
 _       duplicate TOS                  [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]
  x      reverse int/array/string       [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]
   ^     zip top two elements on stack  [[1, 5], [2, 4], [3, 3], [4, 2], [5, 1]]
    ─    flatten array                  [1, 5, 2, 4, 3, 3, 4, 2, 5, 1]
     ▀   unique elements of string/list [1, 5, 2, 4, 3]

यह क्यों काम करता है इसका कारण इस तथ्य के कारण है कि आउटपुट में सभी तत्व अद्वितीय होने चाहिए, इसलिए अद्वितीय तत्व ऑपरेटर सही आउटपुट का उत्पादन करते हुए, सरणी के दूसरे छमाही को फ़िल्टर करेगा।

— maxb
स्रोत
2

रूबी , 37 36 33 बाइट्स

f=->a,b{a>b ?[]:[a,b]|f[a+1,b-1]}

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

जी बी द्वारा सहेजे गए 3 बाइट्स के साथ पुनरावर्ती संस्करण।

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

->a,b{d=*c=a..b;c.map{d.reverse!.pop}}

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

गैर-पुनरावर्ती संस्करण।

— किरिल एल।
स्रोत
2

क्यूबिक्स, 16 बाइट्स

;w(.II>sO-?@;)^/

इसे यहाँ आज़माएँ

Cubified

    ; w
    ( .
I I > s O - ? @
; ) ^ / . . . .
    . .
    . .

व्याख्या

मूल रूप से, यह दो सीमाओं को एक साथ एक समय में एक कदम के करीब ले जाता है जब तक वे मिलते हैं। लूप के माध्यम से हर बार, हम sवैप सीमा, Output, के साथ अंतर है, और वेतन वृद्धि ले )या साथ घटती (हस्ताक्षर के आधार पर।

2

अजगर, 10 8 बाइट्स

{.iF_B}F

इसे यहाँ आज़माएँ

व्याख्या

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.