किताब पढ़ना आसान है, लेकिन किताब को छापना थोड़ा मुश्किल हो सकता है। बुकलेट को प्रिंट करते समय, प्रिंटर को पृष्ठों को एक निश्चित तरीके से व्यवस्थित करने की आवश्यकता होती है ताकि बाएं से दाएं पढ़ा जा सके। जिस तरह से यह किया जाता है वह नीचे की तरह एक पैटर्न का उपयोग कर रहा है

n, 1, 2, n-1, n-2, 3, 4, n-3, n-4, 5, 6, n-5, n-6, 7, 8, n-7, n-8, 9, 10, n-9, n-10, 11, 12, n-11…

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

4 पेज बुकलेट: 4, 1, 2, 3

8 पेज की बुकलेट: 8,1,2,7,6,3,4,5

12 पेज की बुकलेट: 12,1,2,11,10,3,4,9,8,5,6,7

16 पेज की बुकलेट: 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

20 पेज की बुकलेट: 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

कार्य

आपका कार्य, पूर्णांक दिया गया है, जो nकि 4 से अधिक है, संख्याओं की एक सरणी प्रदर्शित करता है जिसका उपयोग nपृष्ठों की एक पुस्तक को प्रिंट करने के लिए किया जा सकता है ।

ध्यान दें: जब तक आउटपुट सही संख्या उत्पन्न करता है, चाहे रिक्त स्थान, अल्पविराम, हाइफ़ेंस, या कोष्ठक द्वारा सीमांकित किया जाए, समाधान के लिए किसी भी विधि का उपयोग किया जा सकता है

यह एक कोड-गोल्फ प्रश्न है, इसलिए उत्तर बाइट्स में स्कोर किए जाएंगे, सबसे कम बाइट जीतने के साथ।

code-golf sequence

— tisaconundrum
स्रोत

क्या हम इस बात की गारंटी देते हैं कि इनपुट हमेशा 4 या यहां तक कि एक ही नंबर से विभाज्य होगा? किसी भी तरह से, क्या आप कुछ और परीक्षण मामलों को जोड़ सकते हैं, कृपया? और पीपीसीजी में आपका स्वागत है :)

— झबरा

8

PPCG और अच्छी पहली चुनौती में आपका स्वागत है! ध्यान दें कि हम उन्हें पोस्ट करने से पहले सैंडबॉक्स में नई चुनौतियों का प्रस्ताव करने की सलाह देते हैं।

— ओलिवर नी

1

आपके इनपुट

— tisaconundrum

1

अच्छा होगा (लेकिन शायद तुच्छ) किसी भी मूल्य का समर्थन करने के लिए, यदि आवश्यक हो तो खाली पन्नों के साथ भरना (एक और चुनौती, शायद!)

— बैरानका

1

क्या हम अल्पविराम के बजाय किसी स्थान, हाइफ़न, या अन्य सीमांकक के साथ सरणी का परिसीमन कर सकते हैं?

— तेहपर्स

8

05AB1E , 9 8 7 बाइट्स

L`[Žˆrˆ

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

व्याख्या

L           # push range [1 ... input]
 `          # split as separate to stack
  [Ž        # loop until stack is empty
    ˆ       # add top of stack to global list
     r      # reverse stack
      ˆ     # add top of stack to global list
            # implicitly display global list

— Emigna
स्रोत

13

जावास्क्रिप्ट (ईएस 6), 49 45 बाइट्स

@RickHitchcock की मदद से 4 बाइट्स बचाए

f=(n,k=1)=>n<k?[]:[n,k,k+1,n-1,...f(n-2,k+2)]

डेमो

कोड स्निपेट दिखाएं

f=(n,k=1)=>n<k?[]:[n,k,k+1,n-1,...f(n-2,k+2)]

console.log(JSON.stringify(f(4)))
console.log(JSON.stringify(f(8)))
console.log(JSON.stringify(f(12)))
console.log(JSON.stringify(f(16)))
console.log(JSON.stringify(f(20)))

स्निपेट का विस्तार करें

गैर-पुनरावर्ती, 51 बाइट्स

n=>[...Array(n)].map((_,i)=>[2*n-i,,++i][i&2]+1>>1)

डेमो

कोड स्निपेट दिखाएं

let f =

n=>[...Array(n)].map((_,i)=>[2*n-i,,++i][i&2]+1>>1)

console.log(JSON.stringify(f(4)))
console.log(JSON.stringify(f(8)))
console.log(JSON.stringify(f(12)))
console.log(JSON.stringify(f(16)))
console.log(JSON.stringify(f(20)))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

47 बाइट्स: f=(n,a=1)=>n<a+3?[]:[n,a,a+1,n-1,...f(n-2,a+2)]

— रिक हिचकॉक

1

@RickHitchcock n<aवास्तव में पर्याप्त है, इसलिए 4 बाइट्स बचाए गए हैं। धन्यवाद!

— अरनुलद

6

पायथन 2, 99 93 88 58 56 55 बाइट्स

f=input()
for i in range(1,f/2,2):print-~f-i,i,i+1,f-i,

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

_{-6 बाइट्स को हटाकर अनावश्यक इंडेंटेशन, धन्यवाद ओलिवर नी}

_{-5 बाइट्स सशर्त बदलकर, धन्यवाद लुइस मेन्डो}

_{-30 बाइट्स प्रिंट स्टेटमेंट का अनुकूलन करके, धन्यवाद अर्नोल्ड पामर}

_{एक पंक्ति पर लूप लगाकर -2 बाइट्स, धन्यवाद nedla2004}

_{-1 कुछ बाइटरी करके बाइट, धन्यवाद मिस्टर एक्सकोडर}

— LyricLy
स्रोत

4 के बजाय 1 स्थान का उपयोग करके बाइट्स को बचाएं

— ओलिवर नी

अरे हाँ, मैं हमेशा इसके बारे में भूल जाता हूं। धन्यवाद।

— LyricLy

1

-29 बाइट्स का उपयोग करके lambda(हालांकि यह एक अलग उत्तर को वारंट करने के लिए पर्याप्त भिन्न हो सकता है)।

— नॉटजैगन

@notjagan आगे बढ़ो और अपने आप को चाहो तो पोस्ट करो।

— LyricLy

58 बाइट्स अपने प्रिंट को थोड़ा बदलकर। अब यह f-i+1,i,i+1,f-iअंतिम मूल्य को सशर्त रूप से प्रिंट करने के बजाय प्रत्येक लूप में प्रिंट करता है। इसने शुरुआती को हटाने की भी अनुमति दी print f,।

— अर्नोल्ड पामर

6

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

lambda n:map(range(1,n+1).pop,n/4*[-1,0,0,-1])

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

[1..n]रिपीटिंग पैटर्न में फ्रंट और बैक से रेंज और पॉप उत्पन्न करता हैback, front, front, back, ...

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

f=lambda n,k=1:n/k*[0]and[n,k,k+1,n-1]+f(n-2,k+2)

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

पहले 4 तत्वों को उत्पन्न करता है, फिर ऊपरी रूप nसे 2 के मूल्य में कमी और 2 से कम मूल्य में kवृद्धि के साथ पुनरावृत्ति जारी रखता है ।

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

lambda n:[[n-i/2,i/2+1][-i%4/2]for i in range(n)]

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

सीधे iसूची का 'मूल्य' उत्पन्न करता है , -i%4/2कम या उच्च मूल्य लेने के लिए बूलियन के रूप में उपयोग करता है।

— XNOR
स्रोत

6

पायथन 3 , 68 63 62 बाइट्स

J5 बाइट्स @ नोटजागन (रिक्त स्थान को हटाने और [*...]इसके बजाय का उपयोग करने के लिए list()) के लिए धन्यवाद ।

S1 बाइट @ovs (के *1बजाय [:]) के लिए धन्यवाद ।

def f(n):r=[*range(1,n+1)];return[r.pop(k%4//2-1)for k in r*1]

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

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

-5 बाइट्स।

— नॉटजैगन

1

आप r*1इसके बजाय r[:]-1 बाइट के लिए उपयोग कर सकते हैं

— ovs

5

MATL , 19 17 10 बाइट्स

:t"0&)@o?P

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

व्याख्या

:          % Implicitly input n. Push range [1 2 ... n]
t          % Duplicate
"          % For each (that is, do n times)
  0&)      %   Push last element, and then subarray with remaining elements
  @        %   Push 1-based iteration index
  o?       %   Is it odd? If so
    P      %     Reverse subarray of remaining elements
           %   Implicit end
           % Implicit end
           % Implicitly display stack

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

5

जेली , 12 11 बाइट्स

11 बाइट्स में सुधार, "कंबाइनटोरियल मेथड्स":

9Bṁ×ḶṚÆ¡‘Œ?

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

कैसे?

यह क्रमपरिवर्तन गणना और भाज्य संख्या प्रणाली का उपयोग करता है:

9Bṁ×ḶṚÆ¡‘Œ? - Link n                        e.g. 16
9B          - nine in binary                     [1,0,0,1]
  ṁ         - mould like n                       [1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]
    Ḷ       - lowered range(n)                   [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
   ×        - multiply                           [0,0,0,3,4,0,0,7,8,0,0,11,12,0,0,15]
     Ṛ      - reverse                            [15,0,0,12,11,0,0,8,7,0,0,4,3,0,0,0]
      Æ¡    - convert from factorial base        19621302981954 (=15*15!+12*12!+...+3*3!)
        ‘   - increment                          19621302981955 (we actually wanted 1*0! too)
         Œ? - shortest permutation of natural numbers [1,2,...] that would reside at that
            -   index in a sorted list of all permutations of those same numbers
            -                                    [16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9]

अकल्पनीय 12 बटर, "बुनाई पैटर्न":

RṚ‘żRs2Z€FḊṁ

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

कैसे?

यह सरल दृष्टिकोण है, यह दो किस्में बनाता है, उन्हें इंटरलेव करता है और फिर ढीले सिरे को काटता है:

RṚ‘żRs2Z€FḊṁ - Link: n                      e.g. 8
R            - range(n)                          [1,2,3,4,5,6,7,8]
 Ṛ           - reverse                           [8,7,6,5,4,3,2,1]
  ‘          - increment                         [9,8,7,6,5,4,3,2]
    R        - range(n)                          [1,2,3,4,5,6,7,8]
   ż         - zip (interleave)                  [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8]]
     s2      - split into chunks of length 2     [[[9,1],[8,2]],[[7,3],[6,4]],[[5,5],[4,6]],[[3,7],[2,8]]]
       Z€    - transpose €ach (cross-stitch?!)   [[[9,8],[1,2]],[[7,6],[3,4]],[[5,4],[5,6]],[[3,2],[7,8]]]
         F   - flatten                           [9,8,1,2,7,6,3,4,5,4,5,6,3,2,7,8]
          Ḋ  - dequeue (removes excess start)    [8,1,2,7,6,3,4,5,4,5,6,3,2,7,8]
           ṁ - mould like n (removes excess end) [8,1,2,7,6,3,4,5]

— जोनाथन एलन
स्रोत

यह है चालाक। +1

— आउटगोलेफर

4

ऑक्टेव , 43 36 बाइट्स

C (gcc) में इस उत्तर का एक पोर्ट यहां पाया जा सकता है ।

@(n)[n-(k=1:2:n/2)+1;k;k+1;n-k](:)';

व्याख्या

k=1:2:n/2: n/22. चरणों में 1 से एक रैखिक अनुक्रम उत्पन्न करता है। ध्यान दें कि यह तुरंत अगले चरण में उपयोग किया जाता है।
[n-k+1;k;k+1;n-k]: एक 4 पंक्ति मैट्रिक्स बनाता है जैसे कि पहली पंक्ति n, n-2, n-4...नीचे अनुक्रम बनाती है n-(n/2)+2, दूसरी पंक्ति 1, 3, 5...ऊपर है n/2 - 1, तीसरी पंक्ति 1 द्वारा जोड़ी गई दूसरी पंक्ति है और चौथी पंक्ति 1 द्वारा जोड़ी गई पहली पंक्ति है।
[n-k+1;k;k+1;n-k](:)': यह एक एकल स्तंभ वेक्टर बनाने के लिए इस मैट्रिक्स के सभी स्तंभों को एक साथ बाएं से दाएं तक ढेर करता है, और हम इसे आसान प्रदर्शन के लिए एक पंक्ति वेक्टर में स्थानांतरित करते हैं। इस तरह से स्तंभों को स्टैकिंग करने से अनुक्रम वांछित होता है।

ध्यान दें कि यह एक अनाम फ़ंक्शन है, इसलिए आप इसे उपयोग करने से पहले एक चर में असाइन कर सकते हैं, या आप ansफ़ंक्शन का निर्माण करने के बाद निर्मित चर का उपयोग कर सकते हैं ।

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

— रायरेंग - मोनिका को बहाल करें
स्रोत

1

नमस्ते, मुझे लगता है कि आप इसे एक अनाम फ़ंक्शन बनाकर भी छोटा कर सकते हैं, इसलिए आपको इनपुट पर कॉल करने की आवश्यकता नहीं है। इस लिंक को देखें: gnu.org/software/octave/doc/v4.0.3/…

— Michthan

1

@ मिखथन सच। मैंने मूल रूप से इसे इस तरह से किया क्योंकि कोड एक से अधिक कथन था। मैंने इस पर एक और दरार ले ली ताकि inputमैं कॉल को हटा दूं और मैंने आधार वृद्धिशील वेक्टर को संग्रहीत करके वाक्यविन्यास को थोड़ा अधिक दुरुपयोग किया क्योंकि मैं पहली पंक्ति बना रहा था और nवास्तविक अनाम फ़ंक्शन इनपुट से इनपुट ले रहा था ताकि मैं अब इसे फिट कर सकूं एक बयान। धन्यवाद!

— रायरेंग - मोनिका

3

आर , 48 बाइट्स (सुधार)

@ बाइट्स -7 बाइट्स के लिए धन्यवाद!

n=scan();(x=order(1:n%%2))[order(-(n/2+.5-x)^2)]

चाल है कि x=1:n;x[order(x%%2)]के बराबर है order(1:n%%2)।

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

आर , 55 बाइट्स (मूल)

golfed

n=scan();x=1:n;x=x[order(x%%2)];x[order(-(n/2+.5-x)^2)]

टिप्पणियों के साथ अपुष्ट

nस्टडिन से पढ़ें ।

n=scan()

x1 से पृष्ठों के अनुक्रम के रूप में परिभाषित करें n।

x=1:n

आदेश पृष्ठ तो असमान पृष्ठों से पहले भी पृष्ठ हैं।

x=x[order(x%%2)]

द्वारा गणना की गई पुस्तक के केंद्र के संबंध में अवरोही क्रम में पृष्ठ n/2+.5।

x[order(-(n/2+.5-x)^2)]

8 पृष्ठों के साथ उदाहरण:

केंद्र 4.5 है;
पृष्ठ 1 और 8 केंद्र से सबसे दूर हैं, लेकिन 8 पहले आता है क्योंकि 8 सम है;
पृष्ठ 2 और 7 केंद्र से अगले सबसे दूर हैं, लेकिन 2 पहले भी आते हैं क्योंकि 2 समान है;
और इसी तरह।

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

— djhurio
स्रोत

1

अच्छा, मेरे (चोरी) समाधान से बेहतर तरीका है

— Giuseppe

1

48 बाइट्स!

— ग्यूसेप

1

ट्रिक यह सूचित कर रही थी कि (1:n)[order(1:n%%2)]जैसेorder(1:n%%2)

— Giuseppe

2

गणितज्ञ, ५४ ५३ ४५ बाइट्स

Join@@Range[#][[(-1)^k{k,-k}]]~Table~{k,#/2}&

व्याख्या

Join@@Range[#][[(-1)^k{k,-k}]]~Table~{k,#/2}&  (* Input: # *)
                              ~Table~{k,#/2}   (* Iterate from k=1 to #/2 *)
      Range[#][[            ]]                 (* From {1..#}, take... *)
                      {k,-k}                   (* k-th and negative k-th element *)
                                               (* negative k-th = k-th from the end *)
                (-1)^k                         (* Reversed for odd k *)
Join@@                                         (* Join the result *)

— जंगवान मिन
स्रोत

2

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

^{ओट्स के लिए -1 बाइट धन्यवाद !}

lambda n:sum([[i,i+1,n-i,n+~i]for i in range(1,n/2,2)],[n])[:n]

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

— notjagan
स्रोत

2

n-i-1हो सकता हैn+~i

— अंडा

2

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

n#a|n<a=[]|x<-n-2=n:a:a+1:n-1:x#(a+2)
(#1)

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

एक बाइट लंबी:

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

f n=[1,3..div n 2]>>= \x->[n-x+1,x,x+1,n-x]

— nimi
स्रोत

2

जावा 8, 84 72 बाइट्स

n->{for(int j=0;++j<n;System.out.printf("%d,%d,%d,%d,",n--,j++,j,n--));}

या

n->{for(int j=0;++j<n;System.out.print(n--+","+j+++","+j+","+n--+","));}

-12 बाइट्स सी # जवाब पर @TheLethalCoder की टिप्पणी के लिए धन्यवाद ।

पुराना उत्तर (84 बाइट्स):

n->{int r[]=new int[n],i=1,N=n,J=1;for(r[0]=n;i<n;r[i]=-~i++%4<2?J++:--N);return r;}

स्पष्टीकरण:

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

n->{                  // Method with integer parameter and no return-type
  for(int j=0;++j<n;  //  Loop from 1 to `n` (exclusive)
    System.out.printf("%d,%d,%d,%d,",n--,j++,j,n--)
                      //   Print four numbers simultaneously
  );                  //  End of loop
}                     // End of method

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

1

पर्ल 5 , 47 + 1 (एन) = 48 बाइट्स

$,=$";print$_--,$i+++1,$i+++1,$_--,''while$_>$i

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

— Xcali
स्रोत

थोड़ा अलग दृष्टिकोण खोजने में कामयाब रहे, लेकिन ठीक उसी बाइट की गिनती के साथ समाप्त हुआ! इसे ऑनलाइन आज़माएं!

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

1

स्विफ्ट 3 , 74 बाइट्स

func g(f:Int){for i in stride(from:1,to:f/2,by:2){print(f-i+1,i,i+1,f-i)}}

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

स्विफ्ट 3 , 60 बाइट्स

{f in stride(from:1,to:f/2,by:2).map{(f-$0+1,$0,$0+1,f-$0)}}

किसी कारण से, यह मैंने अब तक की कोशिश की है किसी भी ऑनलाइन वातावरण में काम नहीं करता है। यदि आप इसका परीक्षण करना चाहते हैं, तो इसके var g=सामने रखें, और इसे Xcode (खेल के मैदान)print(g(12)) में बुलाएं ।

यहाँ मैं एक Xcode खेल के मैदान में इसे चलाने के बाद एक तस्वीर है, संस्करण 8.3.1 (स्विफ्ट 3.1 चला रहा है):

— मिस्टर एक्सकोडर
स्रोत

1

QBIC , 25 बाइट्स

[1,:/2,2|?b-a+1,a,1+a,b-a

हालांकि इनपुट% 4 है, वास्तविक लय 2-आधारित है।

व्याख्या

[1,:/2,2|   FOR ( b=1; b <= <input>/2; b=b+2)               
?           PRINT
 b-a+1,     n
 a,         1
 1+a,       2
 b-a        n-1

— steenbergh
स्रोत

1

सी (जीसीसी) , 66 बाइट्स

C (gcc) में मेरे ऑक्टेव उत्तर का एक पोर्ट :

f(n,i){for(i=1;i<n/2;i+=2)printf("%d %d %d %d ",n-i+1,i,i+1,n-i);}

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

— रायरेंग - मोनिका को बहाल करें
स्रोत

1

CQuents , 21 बाइट्स

=n::n-z+1,z+1,x-1,z-1

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

व्याख्या

                            Implicit input n
=n                          First item in the sequence is n
  ::                        Mode :: (Sequence 2): print sequence from 1 to n
                            Comma delimited items are rotated through
    n-z+1,                    n - previous + 1
          z+1,                previous + 1
              x-1,            third-previous - 1
                  z-1         previous - 1

— स्टीफन
स्रोत

1

आर , 64 60 बाइट्स

भयावह रूप से djhurio द्वारा फैलाया गया ! उनका जवाब काफी सुरुचिपूर्ण है, इसे बढ़ाएं।

n=scan();matrix(c(n-(k=seq(1,n/2,2))+1,k,k+1,n-k),4,,T)[1:n]

रायरेंग के ऑक्टेव उत्तर का एक बंदरगाह ।

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

मूल समाधान (64 बाइट्स):

f=function(n,l=1:n)`if`(n,c(l[i<-c(n,1,2,n-1)],f(n-4,l[-i])),{})

पुनरावर्ती कार्य।

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

— ग्यूसेप
स्रोत

पहली बार किसी ने कभी प्रेरणा के रूप में मेरा एक उत्तर दिया। धन्यवाद :)

— रायरेंग - मोनिका

1

आपको हराना मुश्किल था, लेकिन मैंने इसे 55 बाइट के जवाब ( codegolf.stackexchange.com/a/138045/13849 ) के साथ प्रबंधित किया ।

— djhurio

1

बैश + पर्ल + ग्रॉफ + Psutils, 48 बाइट्स

perl -nE'say".bp
"x--$_'|groff|psbook>/dev/null

पर आउटपुट दिखाता है stderr। आउटपुट में कुछ अनुगामी कचरा होता है।

उपयोग का उदाहरण:

$ echo 20 | perl -nE'say".bp
> "x--$_'|groff|psbook>/dev/null
[20] [1] [2] [19] [18] [3] [4] [17] [16] [5] [6] [15] [14] [7] [8] [13] [12] 
[9] [10] [11] Wrote 20 pages, 4787 bytes

— ninjalj
स्रोत

0

पायथ , 21 20 बाइट्स

sm[hK-QddhdK):1/Q2 2

परीक्षण सूट।

यदि नेस्टेड सूची के रूप में आउटपुट की अनुमति है:

पायथ , 20 19 बाइट्स

m[hK-QddhdK):1/Q2 2

परीक्षण सूट।

व्याख्या

sm [hK-QddhdK): 1 / Q2 2 - पूर्ण कार्यक्रम।

 m: 1 / Q2 2 - वेरिएबल d के साथ मैप ओवर रेंज (1, इनपुट () / 2,2)।
  [) - के साथ एक सूची का निर्माण:
   hK-Qd - इनपुट - d + 1,
        डी - डी,
         एचडी - डी + 1 और
           के - इनपुट - डी।
s - सूची को समतल करता है और स्पष्ट रूप से प्रिंट करता है।

— मिस्टर एक्सकोडर
स्रोत

0

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

->n{1.step(n/2,2){|x|p n-x+1,x,x+1,n-x}}

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

— जीबी
स्रोत

0

सी #, 107 बाइट्स

int[]F(int p){var a=new int[p];for(int i=0,q=1;q<p;a[i++]=p--){a[i++]=p--;a[i++]=q++;a[i++]=q++;}return a;}

दो काउंटरों को रखें, एक 1 पर शुरू होता है, एक पी पर। प्रत्येक लूप पुनरावृत्ति में, चार तत्वों को लिखें और प्रत्येक प्रविष्टि के बाद बस इन्क्रीमेंट या डिक्रीमेंट काउंटर। जब काउंटर बीच में मिलते हैं, तो रुकें।

int[] F(int p)
{
    var a = new int[p];
    for(int i = 0, q = 1; q < p; a[i++] = p--)
    {
        a[i++] = p--;
        a[i++] = q++;
        a[i++] = q++;
    }
    return a;
}

— हाथ-ए-खाना
स्रोत

आप एक प्रतिनिधि में विधि रखकर कुछ बाइट्स बचा सकते हैं। आपका कोड तब इस तरह दिखेगा: बायटेकाउंट में शामिल नहीं होने के p=>{var a=new int[p];for(int i=0,q=1;q<p;a[i++]=p--){a[i++]=p--;a[i++]=q++;a[i++]=q++;}return a;};साथ System.Func<int, int[]> f =। इसके अलावा, आप TIO के लिए एक लिंक जोड़ सकते हैं, जो लोगों द्वारा अपने कोड को खुद से आज़माने की अनुमति देते समय बहुत उपयोगी है!

— इयान एच।

@IanH। एक लंबो का उपयोग करते समय अनुगामी अर्ध उपनिवेश को छोड़ा जा सकता है।

— TheLethalCoder

आरंभ qकरने के लिए 0पर और पूर्व वेतन वृद्धि q<p-> ++q<pऔर फिर एक बाइट को बचाने के लिए दूसरे पोस्ट वेतन वृद्धि को हटा दें। दो लूपिंग लूप स्टेटमेंट्स को लूप के अंतिम चरण में ले जाएं ताकि आप घुंघराले ब्रेस को हटा सकें।

— TheLethalCoder

2

यदि एक अनुगामी अल्पविराम को 71 बाइट्स के लिए निम्नलिखित कार्यों की अनुमति है p=>{for(int q=0;++q<p;)System.Console.Write(p--+$",{q++},{q},{p--},");}। TIO।

— TheLethalCoder

0

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

(x:y:r)#(a:b:s)=x:y:a:b:r#s
f n=take n$n:[1..]#[n-1,n-2..]

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

— Laikoni
स्रोत

0

पायथ , 27 24 23 बाइट्स

अंत में के बजाय मुद्रण भर से -3 बाइट्स।

-1 श्री एक्सकोडर को धन्यवाद

V:1/Q2 2pjd[-QtNNhN-QNk

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

या ऑनलाइन कंपाइलर / एक्जिक्यूटर पर

यह पायथ में मेरा पहला वास्तविक कार्यक्रम है, इसलिए शायद बेहतर तरीके हैं जिनके बारे में मुझे नहीं पता है।

व्याख्या

V:1/Q2 2pjd[-QtNNhN-QNk
V:1/Q2 2                   # For N in range(1, Q/2, 2):
        pjd                # print " ".join(...),
           [-QtNNhN-QNk    # The list [n - (N-1), N, N + 1, n - N, ""] (n is input)

— आर्नोल्ड पाल्मर
स्रोत

मुझे कुछ सुधार मिले , और उन्होंने निर्णय लिया कि वे अपने स्वयं के उत्तर के हकदार हैं।

— श्री Xcoder

वैसे, की जगह FNके साथ Vके लिए -1 बाइट

— श्री Xcoder

0

सी ++ (जीसीसी) , 89 84 68 बाइट्स

अनाम जेनेरिक लैम्ब्डा के रूप में। n#pages (% 4 == 0) है और Cपरिणाम के लिए एक संदर्भ पैरामीटर है, एक खाली कंटेनर जैसे vector<int>(केवल push_backआवश्यक है)।

[](int n,auto&C){for(int i=0,j=0;i<n;C.push_back(++j%4<2?n--:++i));}

पिछला समाधान:

#define P C.push_back(
[](int n,auto&C){for(int i=0;i<n;P n--),P++i),P++i),P n--));}

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

थोड़ा अपराजित:

auto f=
[](int n,auto&C){
 for(int i=0,j=0;
     i<n;
     C.push_back(++j%4<2 ? n-- : ++i));
}

पिछले समाधान _{थोड़ा ungolfed} :

auto f=
[](int n, auto&C){
 for(
  int i=0;
  i<n;
   P n--),
   P++i),
   P++i),
   P n--)
 );
}
;

यह काफी सीधा विकसित था और अंकगणित में कुछ मामूली अनुकूलन सुनिश्चित हैं।

Edit1: अंकगणित के एकीकरण ने 5 बाइट बचाए
Edit2: एकीकरण के बाद 4 चरण संयुक्त थे

उपयोग:

std::vector<int> result;
f(n, result);

प्रिंट-वेरिएंट, 77 बाइट्स ^{आउट-डेटेड}

यदि आप मानों को छापने पर जोर देते हैं, तो इसका समाधान है:

[](int n,auto&o){for(int i=0;i<n;o<<n--<<' '<<++i<<' '<<++i<<' '<<n--<<' ');}

oतुम्हारी इच्छा कहाँ है std::ostream, जैसेstd::cout

उपयोग (यदि दूसरा लंबोदर को सौंपा गया था g):

g(n, std::cout);

— कार्ल नेफ
स्रोत

0

आम लिस्प, 79 बाइट्स

(defun f(n &optional(k 1))(and(> n k)`(,n,k,(1+ k),(1- n),@(f(- n 2)(+ k 2)))))

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

— रेंज़ो
स्रोत

0

लुआ, 94 बाइट्स

इस चुनौती के लिए मैं वास्तव में 2 अलग-अलग तरीकों से आया हूं जो दोनों 94 बाइट्स हैं।

विधि 1:

function f(n,i)i=i or 1 return n>i and('%s,%s,%s,%s,%s'):format(n,i,i+1,n-1,f(n-2,i+2))or''end

टिप्पणी कोड:

function f(n,i)
  i=i or 1
  -- On the first iteration i will be nil so I'm setting it's value to 1 if it is.

  return n>i and ('%s,%s,%s,%s,%s'):format(n,i,i+1,n-1,f(n-2,i+2)) or ''
  -- Here i return a ternary statement
  -- If n>i is true, it will return a string using string.format() and part of this is recursion
  -- If it's false, it will just return an empty string
end

विधि 2:

function f(n,i)i=i or 1 return n>i and n..','..i..','..i+1 ..','..n-1 ..','..f(n-2,i+2)or''end

यह विधि पहले तरीके के समान है, हालांकि मैं बजाय string.format () के बजाय एक संक्षिप्त स्ट्रिंग लौटा रहा हूँ

दोनों तरीकों में मैंने n की अवधारणा का उपयोग किया है और मैं एक साथ करीब हो रहा हूं

— eniallator
स्रोत

0

PHP, 51 + 1 बाइट्स

while($i<$k=&$argn)echo$k--,_,++$i,_,++$i,_,$k--,_;

एक अनुगामी सीमांकक के साथ अंडरस्कोर द्वारा अलग किए गए प्रिंट पेज नंबर। ऑनलाइन के
साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत

0

जे , 22 बाइट्स

($,)_2|.`]\1+],@,.&i.-

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

व्याख्या

($,)_2|.`]\1+],@,.&i.-  Input: integer n
             ]          Identity
                     -  Negate
                  &i.   Form the ranges [0, 1, ..., n-1] and [n-1, ..., 1, 0]
                ,.      Interleave
              ,@        Flatten
           1+           Add 1
    _2    \             For each non-overlapping sublist of size 2
        `                 Cycle between these two operations
      |.                    Reverse for the first, third, ...
         ]                  Identity for the second, fourth, ...
  ,                     Flatten
 $                      Reshape to length n

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

एक पुस्तिका प्रिंट करें

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

कार्य

05AB1E , 9 8 7 बाइट्स

जावास्क्रिप्ट (ईएस 6), 49 45 बाइट्स

डेमो

गैर-पुनरावर्ती, 51 बाइट्स

डेमो

पायथन 2, 99 93 88 58 56 55 बाइट्स

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

पायथन 3 , 68 63 62 बाइट्स

MATL , 19 17 10 बाइट्स

व्याख्या

जेली , 12 11 बाइट्स

कैसे?

कैसे?

ऑक्टेव , 43 36 बाइट्स

व्याख्या

आर , 48 बाइट्स (सुधार)

आर , 55 बाइट्स (मूल)

golfed

टिप्पणियों के साथ अपुष्ट

गणितज्ञ, ५४ ५३ ४५ बाइट्स

व्याख्या

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

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

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

जावा 8, 84 72 बाइट्स

पर्ल 5 , 47 + 1 (एन) = 48 बाइट्स

स्विफ्ट 3 , 74 बाइट्स

स्विफ्ट 3 , 60 बाइट्स

QBIC , 25 बाइट्स

व्याख्या

सी (जीसीसी) , 66 बाइट्स

CQuents , 21 बाइट्स

व्याख्या

आर , 64 60 बाइट्स

मूल समाधान (64 बाइट्स):

बैश + पर्ल + ग्रॉफ + Psutils, 48 ​​बाइट्स

पायथ , 21 20 बाइट्स

पायथ , 20 19 बाइट्स

व्याख्या

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

सी #, 107 बाइट्स

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

पायथ , 27 24 23 बाइट्स

व्याख्या

सी ++ (जीसीसी) , 89 84 68 बाइट्स

प्रिंट-वेरिएंट, 77 बाइट्स आउट-डेटेड

आम लिस्प, 79 बाइट्स

लुआ, 94 बाइट्स

PHP, 51 + 1 बाइट्स

जे , 22 बाइट्स

व्याख्या

बैश + पर्ल + ग्रॉफ + Psutils, 48 बाइट्स

प्रिंट-वेरिएंट, 77 बाइट्स ^{आउट-डेटेड}