भेस में क्रमपरिवर्तन

Question

वास्तविक प्रविष्टियों के साथ एक आयामी वेक्टर को देखते हुए संबंध में निकटतम क्रमपरिवर्तन ।$n$$v$$p$$(1,2,...,n)$$l_1$

विवरण

• यदि यह अधिक सुविधाजनक है, तो आप इसके बजाय क्रमपरिवर्तन का उपयोग कर सकते हैं । यदि कई निकटतम क्रमपरिवर्तन हैं, तो आप उनमें से किसी एक या वैकल्पिक रूप से आउटपुट कर सकते हैं।$(0,1,...,n-1)$
• दो वैक्टर के बीच की दूरी के रूप में परिभाषित किया गया है$l_1$$u,v$ $$d(u,v) = \sum_i \vert u_i-v_i\vert.$$
• यदि आप चाहते हैं, तो आप मान सकते हैं कि इनपुट में केवल पूर्णांक होते हैं।

उदाहरण

[0.5  1] -> [1 2], [2 1]
c*[1 1 ... 1] -> any permutation
[1 4 2 6 2] -> [1 4 3 5 2], [1 4 2 5 3]
[1 3 5 4 1] -> [2 3 5 4 1], [1 3 5 4 2]
[7 7 3 2 5 6 4 2] -> [8 7 3 2 5 6 4 1], [8 7 3 1 5 6 4 2], [7 8 3 2 5 6 4 1], [7 8 3 1 5 6 4 2]
[-2 4 5 7 -1 9 3] -> [1 4 5 6 2 7 3], [2 4 5 6 1 7 3], [1 4 5 7 2 6 3], [2 4 5 7 1 6 3]
[0 4 2 10 -1 10 5] -> [1 4 2 6 3 7 5], [1 4 3 6 2 7 5], [2 4 3 6 1 7 5], [3 4 2 6 1 7 5], [1 4 2 7 3 6 5], [1 4 3 7 2 6 5], [2 4 3 7 1 6 5], [3 4 2 7 1 6 5]

अधिक उदाहरण उत्पन्न करने के लिए अष्टक लिपि ।

Comments

क्या हम गारंटी देते हैं कि सभी तत्व v, से अधिक होंगे 0? या, कम से कम, नहीं 0?

— शैगी

नहीं, vकिसी भी पूर्णांक की प्रविष्टियाँ हो सकती हैं। (कुछ और उदाहरण जोड़ा गया।)

— flawr

यदि वे कोई वास्तविक संख्या हो सकते हैं तो [1.6 2]एक महत्वपूर्ण परीक्षण मामला है (लालची एल्गोरिथ्म / लेक्सियोग्राफिक प्रकार गलत उत्तर देता है)।

— हिस्टोक्रेट

भेस में डुप्लिकेट? मुझे यकीन नहीं है कि इसे इस तरह से बंद किया जाना चाहिए, हालांकि, यह स्पष्ट नहीं है कि यह एक ही कार्य है (जैसा कि अब xnor द्वारा सिद्ध किया गया है)।

— अरनुलद

(वास्तव में, यह एक ही कार्य नहीं है, लेकिन जुड़ी हुई चुनौती के सभी समाधान इस एक के समाधान हैं।)

— अरनौल्ड

Answer 1

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

def f(l):z=zip(l,range(len(l)));print map(sorted(z).index,z)

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

शून्य-अनुक्रमण का उपयोग करता है।

एक सरल विचार के साथ एक तेज एल्गोरिथ्म। के करीब के रूप में यह सुनिश्चित करने के लिए हम बजाय इनपुट सूची दूसरे स्थान पर रखना करने की आवश्यकता है $(1,2,...,n)$ संभव के रूप में, हम, के रूप में नीचे साबित बस इसे तरह करना चाहिए। जब से हम बजाय permuting रहे हैं $(1,2,...,n)$ , हम क्रमचय चुनें कि मेरा चैलेंज में की तरह, इनपुट सूची के रूप में उसी तरह का आदेश दिया एक आदेश की नकल (इनपुट को छोड़कर दोहराता हो सकता है)। (संपादित करें: मील ने इसे और अधिक समान चुनौती दी , जहां डेनिस का भी यही जवाब है ।)

दावा: सूची का एक क्रमचय $l$ कि करने के लिए इसकी दूरी को कम करता है $(1,2,...,n)$ है $l$ अनुसार क्रमबद्ध।

सबूत: कुछ अन्य परिवर्तन पर विचार करें $l'$ के $l$ । हम यह साबित करेंगे कि $l$ छँटाई से बेहतर नहीं हो सकता ।

दो सूचकांक उठाओ $i,j$ कि $l'$ आउट-ऑफ-आदेश है, यह है कि जहां $i<j$ लेकिन $l'_i > l'_j$ । हम बताते हैं कि उन्हें गमागमन के लिए दूरी में वृद्धि नहीं कर सकते हैं $(1,2,...,n)$ । हम ध्यान दें कि स्वैप इन दोनों तत्वों के योगदान को निम्नानुसार बदलता है:

$$|l'_i - i | + |l'_j - j | \to |l'_i - j | + |l'_j - i|.$$

यहाँ यह दिखाने का एक साफ तरीका है कि यह वृद्धि नहीं हो सकती है। दो लोगों के एक नंबर लाइन पर चलने, एक से जा रहा पर विचार करें $l'_i$ करने के लिए $i$ और से अन्य $l'_j$ के लिए $j$ । उनके द्वारा चलने वाली कुल दूरी बाईं तरफ की अभिव्यक्ति है। के बाद से $i<j$ लेकिन $l'_i > l'_j$ , वे स्विच जो नंबर लाइन है, जो साधन वे अपने सैर के दौरान कुछ बिंदु पर पार करना होगा इसे कहते पर अधिक है $p$ । लेकिन जब वे $p$, फिर वे अपने गंतव्यों की अदला-बदली कर सकते थे और समान दूरी पर चल सकते थे। और फिर, यह उनके लिए एक स्वैप के रूप में अपने स्वैप किए गए गंतव्यों तक चलने के बजाय बदतर नहीं हो सकता है , जो कि $p$ के लिए एक वेपाइंट के रूप में उपयोग करने के बजाय , जो दाईं ओर की कुल दूरी देता है।

तो, में दो बाहर के आदेश तत्वों छँटाई $l'$ इसकी दूरी के लिए बनाता है $(1,2,...,n)$ छोटे या एक ही। इस प्रक्रिया को दोहराते हुए अंततः $l$ को सॉर्ट किया जाएगा । तो, $l$ अनुसार क्रमबद्ध है कम से कम के रूप में अच्छा के रूप में $l'$ के किसी भी चुनाव के लिए $l'$ है, जो इष्टतम के रूप में या इष्टतम के लिए बंधे साधन यह।

ध्यान दें कि का केवल संपत्ति $(1,2,...,n)$ है कि हम इस्तेमाल किया है कि यह, हल कर रहा है तो एक ही एल्गोरिथ्म किसी भी तय हो गई सूची में इसकी दूरी कम करने के लिए किसी भी सूची दूसरे स्थान पर रखना करने के लिए काम करेंगे है।

कोड में, इसका एकमात्र उद्देश्य z=zip(l,range(len(l)))इनपुट तत्वों को विशिष्ट बनाना है, जो कि असमान तत्वों के बीच समान तुलना रखते हुए संबंधों से बचना है। यदि हम जिस इनपुट की गारंटी देते हैं, वह कोई दोहराता नहीं है, तो हम इसे हटा सकते हैं और बस lambda l:map(sorted(l).index,l)।

Comments

शानदार अंतर्दृष्टि

— जोनाह

आपने ऑर्डर ढूंढने में इसे सरल कर दिया है ।

— मील

@ मील्स यह बहुत ही मजेदार है, मैं उस चुनौती के बारे में पूरी तरह से भूल गया, भले ही मैंने एक उत्तर लिखा हो, और डेनिस के पास यह सटीक पायथन उत्तर है जो मैंने गोल्फ की मदद की।

— xnor

वह "दृश्य प्रमाण" साफ-सुथरा है। मुझे एक ही विचार मिला लेकिन इसे साबित करने के लिए उस फॉर्मूले के प्रत्येक मामले को रखना पड़ा। एक पक्ष की टिप्पणी के रूप में, तीसरे पक्ष के पुस्तकालयों का उपयोग करके पायथन में रैंक प्राप्त करने के कुछ विकल्प इस पोस्ट में दिखाए गए हैं ।

— जोएल

Answer 2

05AB1E , 7 बाइट्स

āœΣαO}н

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

---

व्याख्या

ā              # get the numbers 1 to len(input) + 1
 œ             # Permutations of this
  Σ  }         # Sort by ...
   α           # Absolute difference
    O          # Sum these
      н        # And get the first one 
               # implicitly print

Comments

हर बार मैं इस से चकित हूं, 05AB1E क्या नहीं कर सकता है?

— यादृच्छिक लड़के

@Therandomguy 05AB1E में बहुत कुछ नहीं किया जा सकता है, लेकिन यह बहुत बुरा है: regex- आधारित चुनौतियां; मैट्रिक्स-आधारित चुनौतियां (हालांकि कुछ नए बिल्डरों के बाद इसमें सुधार किया गया है); काल्पनिक संख्या की कमी; दिनांक / समय संबंधी चुनौतियाँ; हालांकि, हालांकि, कठिन है, यह अभी भी आमतौर पर किया जा सकता है। दो उदाहरण देने के लिए: कार्य दिवस उलटी गिनती (अगले दिन पर जाएं, और सप्ताह का दिन मैन्युअल रूप से किया जाता है); बाइनरी खुद को बाइनरी में आउटपुट करती है (UTF-8 रूपांतरण मैन्युअल रूप से किया जाता है)।

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

@Grimy को अब तय किया जाना चाहिए :)

— डाटा

Answer 3

पर्ल 6 , 44 बाइट्स

{permutations(+$_).min((*[]Z-$_)>>.abs.sum)}

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

अनाम कोडब्लॉक जो 0 अनुक्रमण के साथ पहला न्यूनतम क्रमांकन लौटाता है।

स्पष्टीकरण:

{                                          }   # Anonymous code block
 permutations(+$_)                             # From the permutations with the same length
                  .min(                   )    # Find the minimum by
                                      .sum       # The sum of
                                >>.abs           # The absolute values of
                       (*[]Z-$_)                 # The zip subtraction with the input

मुझे लगता है कि मैं भी .sumपूर्ण मूल्यों की सूची से छुटकारा पा सकता हूं और छांट सकता हूं, लेकिन मुझे यकीन नहीं है कि यह वास्तव में महत्वपूर्ण है, हालांकि यह मेरे वर्तमान परीक्षण मामलों से गुजरता है।

Comments

यह मेरे मस्तिष्क को भी तोड़ रहा था (या "इसके लिए एक लालची एल्गोरिथ्म काम करता है?" का अधिकतर-समतुल्य प्रश्न)। सबसे सरल प्रतिधारण है [0.6 1](यह मानकर कि हम 0-अनुक्रमित हैं), यदि आप [1,0]1.4 के स्कोर के लिए मिलने वाले पहले मूल्य के लिए अनुकूलन करते हैं , लेकिन यदि आप पूरे वेक्टर के लिए अनुकूलन करते हैं तो 1 अंक के लिए दूसरी स्थिति में अधिक मूल्यवान है। 0.6 की।

— हिस्टोक्रेट

Answer 4

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

LŒ!ạS¥ÐṂ

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

Answer 5

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

Œ¿œ?J

एक मोनडिक लिंक जो संख्याओं की एक सूची को स्वीकार करता है जो पूर्णांकों की सूची प्रदान करता है।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

Œ¿œ?J - Link: list of numbers, X
Œ¿    - Index of X in a lexicographically sorted list of
         all permutations of X's items
    J - range of length of X
  œ?  - Permutation at the index given on the left of the
         items given on the right

एनबी L(की लम्बाई) के स्थान पर काम करेगा Jके बाद से œ?एक पूर्णांक को देखते हुए n, सही पर परोक्ष रेंज होगा [1..n]साथ काम करने के लिए है, लेकिन Jस्पष्ट है।

Answer 6

रूबी , 63 60 बाइट्स

->v{[*1..v.size].permutation.max_by{|p|eval [p,0]*'*%p+'%v}}

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

यहां एक गणित की चाल है जो अन्य उत्तरों में भी सहायक हो सकती है - अंतरों के पूर्ण मूल्यों के योग को कम करने के बजाय, हम उत्पादों के योग को अधिकतम करते हैं। वह काम क्यों करता है?

की राशि (x-y) squaredको कम से कम करने के बराबर नहीं है|x-y| , लेकिन यह हमेशा एक वैध जवाब देगा, यह सिर्फ छोटे लोगों पर बड़े अंतर को कम करने को प्राथमिकता देता है जबकि वास्तविक चुनौती दोनों के बीच उदासीन है।

पर (x-y)*(x-y)= x*x+y*y-2*x*y। चूँकि वर्गाकार शब्द हमेशा किसी भी क्रमपरिवर्तन के लिए राशि में कहीं न कहीं दिखाई देंगे, इसलिए वे परिणाम को प्रभावित नहीं करते हैं, इसलिए हम इसे सरल बना सकते हैं -2*x*y। 2कारकों बाहर है, तो हम करने के लिए आसान बनाने में कर सकते हैं -x*y। फिर यदि हम अधिकतम करने के लिए न्यूनतम परिवर्तन करते हैं, तो हम सरल कर सकते हैं x*y।

सहज रूप से, यह देखने के समान है कि यदि आप क्षैतिज दीवारों के एक सेट और ऊर्ध्वाधर वाले सेट का उपयोग करके वर्ग फुटेज को अधिकतम करने की कोशिश कर रहे हैं, तो आप उन जोड़ीदार दीवारों को बंद कर सकते हैं जो कमरे बनाने के लिए एक-दूसरे के करीब हैं। संभव के रूप में वर्ग के करीब के रूप में। 3*3 + 4*4 = 25, जबकि3*4 + 4*3 = 24 ।

संपादित करें: ज़िप और राशि का उपयोग करने के बजाय एक प्रारूप स्ट्रिंग का निर्माण और मूल्यांकन करके तीन बाइट्स सहेजे गए।

Comments

(Xy) वर्ग के योग को कम से कम करने के योग के बराबर नहीं है। xy |, लेकिन यह हमेशा एक वैध उत्तर देगा। यह मामला क्यों है? क्या कोई नहीं$y$ वह कम करता है $\sum |x-y|$ but not $\sum (x-y)^2$?

— Joel

Answer 7

Gaia, 13 bytes

e:l┅f⟪D†Σ⟫∫ₔ(

Try it online!

e:		| eval and dup input
l┅f		| push permutations of [1..length(input)]
⟪   ⟫∫ₔ		| iterate over the permutations, sorting with minimum first
 D†Σ		| the sum of the absolute difference of the paired elements
       (	| and select the first (minimum)

Answer 8

JavaScript (ES6), 61 bytes

Based on xnor's insight.

a=>[...a].map(g=n=>g[n]=a.sort((a,b)=>a-b).indexOf(n,g[n])+1)

Try it online!

Commented

a =>                    // a[] = input array
  [...a]                // create a copy of a[] (unsorted)
  .map(g = n =>         // let g be in a object; for each value n in the copy of a[]:
    g[n] =              //   update g[n]:
      a.sort(           //     sort a[] ...
        (a, b) => a - b //       ... in ascending order
      ).indexOf(        //     and find the position
        n,              //       of n in this sorted array,
        g[n]            //       starting at g[n] (interpreted as 0 if undefined)
      ) + 1             //     add 1
  )                     // end of map()

---

JavaScript (ES6),  130  128 bytes

There  must be  definitely is a more direct way...

0-indexed.

a=>(m=g=(k,p=[])=>1/a[k]?(h=i=>i>k||g(k+1,b=[...p],b.splice(i,0,k),h(-~i)))``:p.map((v,i)=>k+=(v-=a[i])*v)|k>m||(R=p,m=k))(0)&&R

Try it online! (with 1-indexed output)

How?

The helper function $g$ computes all permutations of $(0,...,n-1)$, where $n$ is the implicit length of the input array $a[\;]$.

For each permutation $p$, we compute:

$$k=n-1+\sum_{i=0}^{n-1}(p_i-a_i)^2$$ The only reason for the leading $n-1$ is that we re-use the internal counter of $g$ to save a few bytes, but it has no impact on the final result.

We eventually return the permutation that leads to the smallest $k$.

Answer 9

Wolfram Language (Mathematica), 14 bytes

#@*#&@Ordering

Try it online!

Based on xnor's insight.

Answer 10

Python 2, 149 126 112 bytes

-23 bytes thanks to Mr. Xcoder

-14 bytes thanks to xnor

from itertools import*
f=lambda a:min(permutations(range(len(a))),key=lambda x:sum(abs(a-b)for a,b in zip(x,a)))

Try it online!

Uses permutations of (0 ... n-1).

Comments

You can switch to Python 2, so that you don't need functools anymore.

— Mr. Xcoder

reduce is usually overkill, especially here where you're adding stuff. I think you can just do sum(abs(p-q)for p,q in zip(x,a)).

— xnor

Answer 11

w/o any permutation package

Python 3, 238 bytes

def p(a,r,l):
 if r==[]:l+=[a];return
 for i in range(len(r)):
  p(a+[r[i]],r[:i]+r[i+1:],l)
def m(l):
 s=(float("inf"),0);q=[];p([],list(range(len(l))),q)
 for t in q:D=sum(abs(e-f)for e,f in zip(l,t));s=(D,t)if D<s[0]else s
 return s[1]

Try it online!

Answer 12

Wolfram Language (Mathematica), 57 bytes

f@n_:=MinimalBy[Permutations@Range@Length@n,Tr@Abs[n-#]&]

Try it online!

Answer 13

Japt -g, 12 bytes

Êõ á ñÈíaU x

Try it

For 0-indexed, replace the first 2 bytes with m, to map the array to its indices instead.

Êõ á ñÈíaU x     :Implicit input of array U
Ê                :Length
 õ               :Range [0,Ê]
   á             :Permutations
     ñÈ          :Sort by
       í U       :  Interleave with U
        a        :  Reduce each pair by absolute difference
           x     :  Reduce resulting array by addition
                 :Implicit output of first sub-array

Answer 14

J, ²⁵ 8 bytes

#\/:@/:]

Try it online!

Much shorter answer based xnor's brilliant idea.

original answer

J, 25 bytes

(0{]/:1#.|@-"1)i.@!@#A.#\

Try it online!