चुकता अंतर को अधिकतम करें

Question

से पूर्णांक मूल्यों का क्रमपरिवर्तन पर विचार 1करने के लिए N। उदाहरण के लिए यह उदाहरण N = 4:

[1, 3, 4, 2]

हम इस सूची को चक्रीय मानते हैं, जैसे कि 1और 2इसे आसन्न माना जाता है। इस तरह की सूची के लिए हम एक मात्रा की गणना कर सकते हैं, आसन्न मूल्यों का कुल चुकता अंतर है:

(1-3)² + (3-4)² + (4-2)² + (2-1)² = 10

आपका कार्य एक क्रमांकन ढूंढना है जो एक सकारात्मक पूर्णांक को देखते हुए, इस मात्रा को अधिकतम करता है N। N = 4उपरोक्त उदाहरण के मामले में इष्टतम नहीं है (वास्तव में, यह न्यूनतम है)। हम 18निम्नलिखित क्रमचय (और साथ ही कई अन्य) के साथ कुल चुकता अंतर प्राप्त कर सकते हैं :

[1, 4, 2, 3]

आपका एल्गोरिथ्म बहुपद समय ( N) में चलना चाहिए । विशेष रूप से, आप बस सभी क्रमपरिवर्तन के कुल चुकता अंतर की गणना नहीं कर सकते।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।

आउटपुट किसी भी सुविधाजनक, अस्पष्ट, फ्लैट सूची या स्ट्रिंग प्रारूप में हो सकता है। आप से मूल्यों के साथ एक सूची वापस जाने के लिए चुन सकते हैं 0करने के लिए N-1के बजाय 1करने के लिए N।

मानक कोड-गोल्फ नियम लागू होते हैं।

परीक्षण डेटा

इस समस्या के लिए एक अच्छा विश्लेषणात्मक समाधान है। उदाहरण के लिए सभी मान्य समाधान N = 10निम्न सूची (चक्रीय पारियों और उत्क्रमण तक) के बराबर हैं:

[7, 5, 6, 4, 8, 2, 10, 1, 9, 3]

मैं उससे बहुत अधिक प्रकट नहीं करना चाहता (हालांकि यह संभवतः पैटर्न का पता लगाने के लिए पर्याप्त है), इसलिए किसी भी अधिक उदाहरण देने के बजाय, आप जांच सकते हैं कि आपके परिणामों में दिए गए कुल चुकता अंतर हैं N:

N    Total squared difference

1                         0
2                         2
3                         6
4                        18
5                        36
6                        66
7                       106
8                       162
9                       232
10                      322
33                    11936
100                  333202
333                12308236
1000              333332002

यह OEIS प्रविष्टि A064842 है (जिसमें आप फंस गए हैं तो इस चुनौती के समाधान के साथ एक पेपर का संदर्भ भी है)।

Answer 1

जैली, 24 21 15 14 10 9 बाइट्स

RUĖµ«/€ị"

कुल चुकता अंतर की गणना µ_ṙ1$²Sकरने के लिए, कोड में संलग्न करें। इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

अधिकतम वर्ग अंतर के साथ क्रमचय उत्पन्न करने का एक तरीका यह है कि पूर्णांक 1 से n को आरोही क्रम में ले जाएं, और दूसरे को बाएं से दाएं से दूसरे से स्वैप करें, बाएं से चौथे से दाएं से चौथे के साथ, और इसी तरह आगे जब तक हम बीच में मिलते हैं।

उदाहरण के लिए, n = 8, 9 के लिए हमारे पास है

1 2 3 4 5 6 7 8        1 2 3 4 5 6 7 8 9
  ^   ^ ^   ^            ^   ^   ^   ^

(कार्य पूर्ण होने के लिए पूर्णांक चिह्नित करता है), जिसके परिणामस्वरूप

1 7 3 5 4 6 2 8        1 8 3 6 5 4 7 2 9

स्वैप करने के बाद।

एन की समता के स्वतंत्र रूप से इन स्वैप को प्राप्त करने का एक तरीका निम्नानुसार है।

पूर्णांक को आरोही क्रम में और अवरोही क्रम में लिखना शुरू करें, एक के नीचे एक।

1 2 3 4 5 6 7 8        1 2 3 4 5 6 7 8 9
8 7 6 5 4 3 2 1        9 8 7 6 5 4 3 2 1

पूर्णांक के प्रत्येक जोड़े के लिए, जोड़ी की न्यूनतम गणना करें। यह निकटतम किनारे को दूरी देता है, यानी, बाईं या दाईं ओर से सूचकांक (जो भी कम हो)।

1 2 3 4 5 6 7 8        1 2 3 4 5 6 7 8 9
8 7 6 5 4 3 2 1        9 8 7 6 5 4 3 2 1

1 2 3 4 4 3 2 1        1 2 3 4 5 4 3 2 1

यदि न्यूनतम विषम है, तो पूर्णांक अपनी जगह पर रहना चाहिए, इसलिए हम पहली पंक्ति में से एक का चयन करते हैं; यदि यह सम्‍मिलित है, तो पूर्णांकों की अदला-बदली की जानी चाहिए, इसलिए हम दूसरी पंक्ति से एक का चयन करते हैं।

1   3     6   8        1   3   5   7   9
  7   5 4   2            8   6   4   2

यह वांछित आउटपुट है।

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

RUĖµ«/€ị"    Main link. Input: n

R            Range. Yields [1, ..., n].
 U           Upend. Yields [n, ..., 1].
  Ė          Enumerate. Yields p := [[1, n], [2, n-1], ... [n-1, 2], [n, 1]].

   µ         Begin a new, monadic chain. Argument: p
     /       Reduce...
      €        each pair of p...
    «          by minimum.
        "    For each minimum and the corresponding pair of p:
       ị       Select the element at that index.
            Indices are modular and 1-based in Jelly, so this selects the first
            element if the minimum is odd, and the second one if it is even.

Answer 2

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

n=>[...Array(n)].map((_,i)=>(i<n/2|n%2)^i%2?i+1:n-i)

9 बाइट्स @ धन्यवाद का धन्यवाद बचा लिया!

व्याख्या

यह दृष्टिकोण उस संख्या को निर्धारित करता है जो किसी सरणी में परिणामों को सुगम बनाने iके nबजाय सूचकांक में होना चाहिए । यह निम्नलिखित अवलोकन ( n = 7उदाहरण के रूप में उपयोग ) पर आधारित है :

• बाईं ओर सबसे कम संख्या और दाईं ओर सबसे अधिक से शुरू करें: [ 1, 7 ]
• ऑर्डर को स्विच करें ताकि सबसे कम दाईं ओर हो और सबसे बाईं तरफ हो, सबसे कम वेतन वृद्धि करें, उच्चतम को घटाएं, और उन्हें सरणी के बीच में रखें:[ 1, 6, 2, 7 ]
• उच्चतम और निम्नतम अभिसरण तक दोहराएं: [ 1, 6, 3, 4, 5, 2, 7 ]

उच्च और निम्न संख्या आसानी से n-iऔर i+1क्रमशः व्यक्त की जा सकती है।

var solution =

n=>
  [...Array(n)] // create an array of length n
  .map((_,i)=>  // set each value of the array at index i
    (i<n/2      // if we're on the left side,
    |n%2)       // or we're on the right and n is odd, even i => lower, odd i => higher
    ^i%2?       // else even i => higher, odd i => lower
    i+1:n-i
  )

N = <input type="number" id="input" oninput="result.textContent=solution(+this.value)" />
<pre id="result"></pre>

Comments

अच्छा एल्गोरिथ्म; मैंने कोशिश की और उन्हें उत्पन्न करने के एक फार्मूले के बारे में सोचने में विफल रहा, इसलिए मुझे धक्का देने और अशिक्षित होने के कुरूप तरीके का उपयोग करना पड़ा। हालाँकि, मैं निश्चित रूप से आपके तर्क को सरल बना सकता हूँ (i<n/2||n%2)^i%2?i+1:n-i।

— नील

@ नील वाह, मैं अभी उठा, इस बात का फैसला किया और अपने सटीक तर्क के साथ आया और जैसे ही आपने इसे पोस्ट किया, इसे टाइप करना शुरू कर दिया! पागल ...

— user81655

Answer 3

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

7 बाइट्स ने @ डेनिस की टिप्पणी के लिए धन्यवाद बचाया

n=input()
r=([],[n/2+1])[n%2]
for i in range(n/2,0,-1):k=[n+1-i];r=([i]+r+k,k+r+[i])[i%2]
print r

संपादित संस्करण 58 बाइट्स

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

मुझे पहले से ही विश्वास था कि इसे एक-लाइनर के रूप में करना संभव है, लेकिन तर्क मेरे लिए बहुत जटिल था। @ User81655 द्वारा जावास्क्रिप्ट-उत्तर और @ डेनिस पायथन-उत्तर में लैम्ब्डा-नोटेशन को देखते हुए, मैंने इसे नई कोशिश दी।

हालत के बराबर है

if i < n/2:
    i%2 != n%2
else:
    (i+1)%2

दुर्भाग्य से सभी परिवर्तन प्रयास जावास्क्रिप्ट-लॉजिक के प्रत्यक्ष अनुवाद की तुलना में केवल एक ही बाइट बचाते हैं (i<n/2or n%2)!=i%2।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह पायथन 2 प्रतीत होता है, इसलिए आपको int()इनपुट के आसपास की आवश्यकता नहीं है । इसके अलावा, आप लूप की बॉडी को उसी लाइन पर रख सकते हैं जैसे कि for...।

— डेनिस

Answer 4

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

lambda n:[(i^min(i,~i%n)%-2)%n for i in range(n)]

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसे आज़माएं ।

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

अगर मैं में एक नंबर है - [1 0, ..., n] , तो ~ मैं% एन = - (i +1)% एन = - (i + 1) + एन = (n - 1) - मैं , जिसका अर्थ है कि यह नक्शे 0 करने के लिए n - 1 , 1 करने के लिए n - 2 और सामान्य रूप में, जे ^वें बाएं से आइटम जे ^वें सही से।

के रूप में में विस्तार से बताया मेरी जेली जवाब , हम के बीच कम मूल्य पर देखना द्वारा उत्पादन निर्माण कर सकते हैं मैं और ~ मैं% n , और लेने मैं अगर यह भी है और ~ मैं% n अगर यह अजीब है। हम इसे इस प्रकार प्राप्त करते हैं।

• कम से कम भी हैं, तो min(i,~i%n)%-2निकलेगा 0 , इसलिए परिणाम XORing साथ मैं निकलेगा मैं , और उसके अवशेषों सापेक्ष कंप्यूटिंग n वापस आ जाएगी मैं ।

• यदि न्यूनतम विषम है, तो -1min(i,~i%n)%-2 का उत्पादन होगा , इसलिए I के साथ परिणाम XORing ~ i प्राप्त करेगा , इसलिए संपूर्ण अभिव्यक्ति ~ i% n का मूल्यांकन वांछित है।

Comments

आप सशर्त के रूप में कर के कुछ जोड़े को बचा सकते हैं (i^min(i,n+~i)%-2)%n।

— xnor

यह न केवल छोटा है, बल्कि बेहद चालाक है। धन्यवाद!

— डेनिस

Answer 5

PHP, 77 76 51 50 49 बाइट्स

आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है।

इस तरह से सरणी के पहले छमाही कोडांतरण:

• विषम संख्याओं का सूचकांक मान (1, 3, 5 ..) है।
• यहां तक ​​कि संख्याओं का मान भी है N+1-index(9, 7, 5)
• इसका परिणाम यह होगा 1, 9, 3, 7, 5

सरणी के उत्तरार्ध के लिए, बाहरी मानों को जोड़ते हैं N+1, जिसका अर्थ है कि आप उसी सही मूल्य को प्राप्त कर सकते हैं N-[left value]जहां से बाएं मान पहले से ही ज्ञात है।

for(;$k=$argv[1]-$j++;)echo" ",min($j,$k)%2?$j:$k;

इस तरह से चलाएँ (यह भी कुल चुकता अंतर दिखाता है) ( -dकेवल सौंदर्यशास्त्र के लिए जोड़ा गया):

php -d error_reporting=32757 -r 'for(;$k=$argv[1]-$j++;)echo~ß,$x[]=min($j,$k)%2?$j:$k;  for(;$c=$x[+$i++];)$b+=($c-($x[$i]?:$x[0]))**2;echo"\n$b\n";' 10

• एक बाइट को बाएं / दाएं स्थिति की उपेक्षा करके बचाया ताकि दूसरी टर्नरी को कोष्ठक के बिना घोंसला किया जा सके
• डेनिस के एल्गोरिथ्म को बेशर्मी से लागू करते हुए 25 बाइट्स बचाए
• बाद में आवश्यक स्थान से छुटकारा पाकर एक बाइट को बचाया echo
• ~ßएक जगह का उत्पादन करने के लिए उपयोग करके एक बाइट को बचाया ।

Answer 6

अजगर 2, 100

मुझे पता है कि पहले से ही एक अजगर जवाब है, लेकिन मुझे लगता है कि मैंने यह अलग तरीके से किया हो सकता है।

n=input();a=n%2;b=n/2;x=[b+1,b+a][a:]
for i in range(b+a-1):f=1-i%2*2;x=[x[-1]-f]+x+[x[0]+f]
print x

और कुल स्कोर का परीक्षण करने के लिए एक अतिरिक्त के रूप में:

def t(x,n):return sum((x[i]-x[(i+1)%n])**2for i in range(n))

Comments

def t(x,n):return sum((x[i]-x[i-1])**2for i in range(n))नकारात्मक सूचकांकों के निहित आवरण के आसपास का उपयोग करता है और 4 बाइट्स बचाता है। मुझे पता है, प्रतियोगिता का हिस्सा नहीं था। ;)

— 14:16 पर btwlf

Answer 7

CJam, 17 15 14 बाइट्स

{,W%ee_::e<.=}

यह एक ऐसा फ़ंक्शन है जो स्टैक से एक पूर्णांक n को पॉप करता है और बदले में [0… n-1] के क्रमचय को धकेलता है । कोड मेरे जेली उत्तर के समान दृष्टिकोण का उपयोग करता है ।

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

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

,W%ee_::e<.=    Function body. Stack: N

,               Turn N into [0 ... N-1].
 W%             Reverse to push [N-1 ... 0].
   ee           Enumerate. This pushes [[0 N-1] [1 N-2] ... [N-2 1] [N-1 0]].
     _          Push a copy of the array of pairs.
      ::e<      Reduce each pair by minimum.
          .=    Vectorized selection.
                For the Ith minimum M, select the Mth element of the Ith pair.
                Indices are modular and 0-based in CJam, so this selects the first
                element if the minimum is even, and the second one if it is odd.

Answer 8

एलआईएसपी, 86 बाइट्स

(defun g(n m)(if(= n m)(list n)(if(< m n)(cons m(reverse(cons n(g(- n 1)(+ m 1))))))))

फ़ंक्शन के इनपुट अनुक्रम की शुरुआत (एम) और अंत (एन) मूल्यों को चुनने की अनुमति देते हैं।

प्रदान किए गए नमूनों के अनुसार फ़ंक्शन का परीक्षण करने के लिए, एन को एन और एम से 1 निर्धारित किया गया है।

यहाँ फ़ंक्शन का परीक्षण करने के लिए कोड:

    (defun g(n m)(if(= n m)(list n)(if(< m n)(cons m(reverse(cons n(g(- n 1)(+ m 1))))))))

(defun sq (c)
    (apply #'+ (mapcar #'(lambda(x y) (* (- x y) (- x y))) c (append (cdr c) (list (car c))))))

(format t "N~20TSequence~50TSquared Difference~%")
(mapcar #'(lambda (x)(format t "~S~20T~S~50T~S~%" x (g x 1) (sq (g x 1)))) '(1 2 3 4 5 6 7 8 9 10 33 100 333 1000))

Ideone पर यह कोशिश करो !

Answer 9

जूलिया, 39 बाइट्स

n->map(i->min(i-1,n-i)%2>0?n-~-i:i,1:n)

यह 1: n के क्रमचय को प्रिंट करता है । 0: n-1 का क्रमचय न तो लागत करता है और न ही बाइट बचाता है:

n->map(i->min(i,n+~i)%2>0?i:n+~i,0:n-1)

यह अंतिम संस्करण मेरे पायथन उत्तर का सीधा पोर्ट है ।

Answer 10

ईएस 6, 77 बाइट्स

n=>[...Array(n)].map(_=>r[++i&2?"push":"unshift"](i&1?n--:++j),i=j=0,r=[])&&r

i&1नमूने बीच में चरम से अंक। i&2शुरुआत या जोड़ों में परिणाम के अंत करने के लिए उन्हें कहते हैं।

Answer 11

आर, 117 86 बाइट्स

z=1:(n<-scan());a=pmin(z,n:1);for(i in seq(2,,2,n%/%2))z[b]=z[rev(b<-which(a==i,T))];z

संपादित @Dennis 'जेली एल्गोरिथ्म के एक कार्यान्वयन के साथ गाड़ी में लंबे समय के संस्करण की जगह