सबसे छोटी राशि के साथ एक बधाई सूची बनाएं

Question

दो सूचियाँ हैं Aऔर Bयदि वे समान लंबाई की हैं, और तत्व समान हैं जिनकी तुलना में बराबर की Aतुलना होती है B।

दूसरे शब्दों में, किसी भी दो वैध सूचकांक xऔर y:

• अगर है A[x] = A[y]तो B[x] = B[y]।
• अगर है A[x] != A[y]तो B[x] != B[y]।

उदाहरण के लिए, सूचियाँ [1, 2, 1, 4, 5]और [0, 1, 0, 2, 3]अनुरूप हैं।

काम

की एक अरिक्त सूची को देखते हुए गैर नकारात्मक पूर्णांक A, की एक नई सूची लौट गैर नकारात्मक पूर्णांक Bइस तरह के सर्वांगसम है कि Aथोड़ी देर में पूर्णांकों का योग को न्यूनतम करने, B।

संभावित रूप से कई संभव वैध आउटपुट हैं। उदाहरण के लिए, सूची में [12, 700, 3], किसी भी क्रमपरिवर्तन को [0, 1, 2]वैध आउटपुट माना जाएगा।

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

Format:
input ->
one possible valid output

[1 2 1 4 5] ->
[0 1 0 2 3] (this is the example given above)

[3 2 2 1 5 7 2] ->
[1 0 0 2 3 4 0]

[8 8 8 8 8] ->
[0 0 0 0 0]

[2] ->
[0]

[8 6 8 4 6 8 2 4 6 8 0 2 4 6 8] ->
[0 1 0 2 1 0 3 2 1 0 4 3 2 1 0]

[14 1] ->
[1 0]

[19 6 4 9 14 17 10 9 6 14 8 14 6 15] ->
[8 0 3 2 1 7 5 2 0 1 4 1 0 6]

[15] ->
[0]

[1 18 4 8 6 19 12 17 6 13 7 6 8 1 6] ->
[1 8 3 2 0 9 5 7 0 6 4 0 2 1 0]

[9 10 11 9 7 11 16 17 11 8 7] ->
[2 4 0 2 1 0 5 6 0 3 1]

[1 3 16 19 14] ->
[0 1 3 4 2]

[18 8] ->
[1 0]

[13 4 9 6] ->
[3 0 2 1]

[16 16 18 6 12 10 4 6] ->
[1 1 5 0 4 3 2 0]

[11 18] ->
[0 1]

[14 18 18 11 9 8 13 3 3 4] ->
[7 1 1 5 4 3 6 0 0 2]

[20 19 1 1 13] ->
[3 2 0 0 1]

[12] ->
[0]

[1 14 20 4 18 15 19] ->
[0 2 6 1 4 3 5]

[13 18 20] ->
[0 1 2]

[9 1 12 2] ->
[2 0 3 1]

[15 11 2 9 10 19 17 10 19 11 16 5 13 2] ->
[7 2 0 5 1 3 9 1 3 2 8 4 6 0]

[5 4 2 2 19 14 18 11 3 12 20 14 2 19 7] ->
[5 4 0 0 2 1 9 7 3 8 10 1 0 2 6]

[9 11 13 13 13 12 17 8 4] ->
[3 4 0 0 0 5 6 2 1]

[10 14 16 17 7 4 3] ->
[3 4 5 6 2 1 0]

[2 4 8 7 8 19 16 11 10 19 4 7 8] ->
[4 1 0 2 0 3 7 6 5 3 1 2 0]

[15 17 20 18 20 13 6 10 4 19 9 15 18 17 5] ->
[0 1 3 2 3 9 6 8 4 10 7 0 2 1 5]

[15 14 4 5 5 5 3 3 19 12 4] ->
[5 4 2 0 0 0 1 1 6 3 2]

[7 12] ->
[0 1]

[18 5 18 2 5 20 8 8] ->
[2 0 2 3 0 4 1 1]

[4 6 10 7 3 1] ->
[2 3 5 4 1 0]

[5] ->
[0]

[6 12 14 18] ->
[0 1 2 3]

[7 15 13 3 4 7 20] ->
[0 4 3 1 2 0 5]

[10 15 19 14] ->
[0 2 3 1]

[14] ->
[0]

[19 10 20 12 17 3 6 16] ->
[6 2 7 3 5 0 1 4]

[9 4 7 18 18 15 3] ->
[4 2 3 0 0 5 1]

[7 4 13 7] ->
[0 1 2 0]

[19 1 10 3 1] ->
[3 0 2 1 0]

[8 14 20 4] ->
[1 2 3 0]

[17 20 18 11 1 15 7 2] ->
[5 7 6 3 0 4 2 1]

[11 4 3 17] ->
[2 1 0 3]

[1 9 15 1 20 8 6] ->
[0 3 4 0 5 2 1]

[16 13 10] ->
[2 1 0]

[17 20 20 12 19 10 19 7 8 5 12 19] ->
[7 2 2 1 0 6 0 4 5 3 1 0]

[18 11] ->
[1 0]

[2 16 7 12 10 18 4 14 14 7 15 4 8 3 14] ->
[3 9 2 7 6 10 1 0 0 2 8 1 5 4 0]

[5 7 2 2 16 14 7 7 18 19 16] ->
[3 0 1 1 2 4 0 0 5 6 2]

[8 6 17 5 10 2 14] ->
[3 2 6 1 4 0 5]

यह कोड-गोल्फ है , इसलिए सबसे कम वैध जमा (बाइट्स में गिना जाता है) जीतता है।

Comments

संबंधित: जांचें कि क्या शब्द

— आइसोमॉर्फ

Answer 1

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

lambda L:map(sorted(set(L),key=L.count)[::-1].index,L)

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

संपादित करें: माल्टीसेन के मानचित्र थैक्स के माध्यम से 8 बाइट्स को बचाया

Comments

कम बाइट्स:lambda L:map(sorted(set(L),key=L.count)[::-1].index,L)

— माल्टीसेन

Answer 2

पायथ - 12 11 10 बाइट्स

XQ_o/QN{QU

टेस्ट सूट ।

Comments

अरे, यह जल्दी था! मैं केवल यह पता लगाने में कामयाब रहा कि हमसे क्या पूछा जा रहा है!

— झबरा

आप के साथ एक बाइट बचा सकते हैं mx_o/QN{Q।

Answer 3

जाप , 11 बाइट्स

£â ñ@è¦XÃbX

इसे ऑनलाइन टेस्ट करें!

व्याख्या

 £   â ñ@  è¦ Xà bX
UmX{Uâ ñX{Uè!=X} bX}   Ungolfed
                       Implicit: U = input array
UmX{               }   Map each item X in the input to:
    Uâ                   Take the unique items of U.
       ñX{     }         Sort each item X in this by
          Uè!=X            how many items in U are not equal to X.
                         This sorts the items that occur most to the front of the list.
                 bX      Return the index of X in this list.
                       Implicit: output result of last expression

Answer 4

जे , 11 बाइट्स

i.~~.\:#/.~

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

व्याख्या

i.~~.\:#/.~  Input: array A
       #/.~  Frequency of each unique character, sorted by first appearance
   ~.        Unique, sorted by first appearance
     \:      Sort down the uniques using their frequencies
i.~          First index in that for each element of A

Answer 5

रोड़ा , 55 बाइट्स

{|l|l|indexOf _,[sort(l)|count|[[-_2,_1]]|sort|_|[_2]]}

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

Answer 6

हास्केल , 93 91 85 बाइट्स

import Data.List
f a=[i|x<-a,(i,y:_)<-zip[0..]$sortOn((0-).length)$group$sort a,x==y]

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

संपादित करें: 6 बाइट्स हटाने के लिए @Laikoni को धन्यवाद!

बहुत कम नहीं लेकिन मैं कुछ और नहीं सोच सकता। यह विचार सरणी ( x<-a) पर पुनरावृत्ति करना है और एक टपल सूची ( (i,y:_)<-... ,x==y) में एक लुकअप करना है जो इनपुट में प्रत्येक अद्वितीय तत्व के लिए एक गैर-पूर्णांक पूर्णांक प्रदान करता है कि यह कितना सामान्य है। उस ट्यूल लिस्ट को पहले sortइनपुट द्वारा उत्पन्न किया जाता है , groupइसे समान तत्वों के सब्लिस्ट्स में सम्मिलित किया जाता है, उस सूची को सब्लिस्ट्स की लंबाई के अनुसार sortOn((0-).length)क्रमबद्ध किया जाता है ( लंबाई "अवरोही क्रम" में सॉर्ट करने के लिए नकारा जाता है), फिर अंत में एक अनंत सूची के साथ ज़िप करना; incrementing 0. हम वास्तविक तत्व को सबमिशन से निकालने के लिए मैचिंग पैटर्न का उपयोग करते हैं y।

Comments

आप पैटर्न पर मेल कर सकते हैं (i,y:_)और head<$>भाग को गिरा सकते हैं और कोष्ठक को बदल सकते हैं $।

— लैकोनी

Answer 7

मैथेमेटिका, 94 बाइट्स

(s=First/@Reverse@SortBy[Tally[j=#],Last];For[i=1,i<=Length@s,j=j//.s[[i]]->i+5!;i++];j-5!-1)&

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

Answer 8

CJam, 17 14 बाइट्स

^{-3 बाइट्स पीटर टेलर का धन्यवाद}

यह उस कार्यक्रम का एक गोल्फ संस्करण है जिसे मैंने टेस्टकेस बनाने के लिए उपयोग किया था।

{_$e`$W%1f=f#}

यह एक गुमनाम ब्लॉक है जो स्टैक के शीर्ष पर एक सरणी के रूप में इनपुट की अपेक्षा करता है और स्टैक के शीर्ष पर एक सरणी आउटपुट करता है।

स्पष्टीकरण:

{_$e`$W%1f=f#} Stack:                  [1 2 1 4 5]
 _             Duplicate:              [1 2 1 4 5] [1 2 1 4 5]
  $            Sort:                   [1 2 1 4 5] [1 1 2 4 5]
   e`          Run-length encode:      [1 2 1 4 5] [[2 1] [1 2] [1 4] [1 5]]
     $         Sort lexicographically: [1 2 1 4 5] [[1 2] [1 4] [1 5] [2 1]]
      W%       Reverse:                [1 2 1 4 5] [[2 1] [1 5] [1 4] [1 2]]
        1f=    Second element of each: [1 2 1 4 5] [1 5 4 2]
           f#  Vectorized indexing:    [0 3 0 2 1]

Comments

आप इसे विभाजित करके केवल तीन बाइट्स के लिए रिवर्स ऑर्डर में सॉर्ट कर सकते हैं $W%:।

— पीटर टेलर

@PeterTaylor आह, मैं arrays के लिए lexicographic तुलना भूल रहा हूँ एक बात है। धन्यवाद।

— एगलैंगिंग फ्रूट

Answer 9

टीआई-बेसिक, 66 बाइट्स

Ans+max(Ans+1)seq(sum(Ans=Ans(I)),I,1,dim(Ans→A
cumSum(Ans→B
SortD(∟A,∟B
cumSum(0≠ΔList(augment({0},∟A→A
SortA(∟B,∟A
∟A-1

व्याख्या

seq(sum(Ans=Ans(I)),I,1,dim(Ans    Calculates the frequency of each element of Ans.
                                   Comparing a value to a list returns a list of booleans,
                                   so taking the sum will produce the number of matches.

Ans+max(Ans+1)                     Multiplies each frequency by one more than the max element,
                                   then adds each original value.
                                   This ensures that identical values with the same frequency
                                   will be grouped together when sorting.
                                   Additionally, all resulting values will be positive.

→A                                 Stores to ∟A.

cumSum(Ans→B                       Stores the prefix sum of the result into ∟B.
                                   Since ∟A has only positive values, ∟B is guaranteed
                                   to be strictly increasing.

SortD(∟A,∟B                        Sort ∟A in descending order (by frequency), grouping
                                   identical values together. Also, dependently sort ∟B
                                   so the original ordering can be restored.

       0≠ΔList(augment({0},∟A      Prepends a 0 to ∟A and compares each consecutive difference
                                   to 0. This places a 1 at each element that is different
                                   from the previous element, and 0 everywhere else.
                                   The first element is never 0, so it is considered different.

cumSum(                      →A    Takes the prefix sum of this list and stores to ∟A.
                                   Since there is a 1 at each element with a new value,
                                   the running sum will increase by 1 at each value change.
                                   As a result, we've created a unique mapping.

SortA(∟B,∟A                        Sorts ∟B in ascending order with ∟A as a dependent,
                                   restoring the original element ordering.

∟A-1                               Since we started counting up at 1 instead of 0,
                                   subtract 1 from each element in ∟A and return it.

Answer 10

पर्ल 5 , 77 + 1 (-ए) = 78 बाइट्स

$c{$_}++for@F;%r=map{$_=>$i++.$"}sort{$c{$b}<=>$c{$a}}keys%c;print$r{$_}for@F

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

Answer 11

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

आवृत्ति द्वारा क्रमबद्ध, अद्वितीय मूल्यों की एक सूची का उपयोग करना।

x=>x.map(x=>Object.keys(C).sort((a,b)=>C[b]-C[a]).indexOf(x+''),C={},x.map(v=>C[v]=-~C[v]))

परीक्षा

var F=
x=>x.map(x=>Object.keys(C).sort((a,b)=>C[b]-C[a]).indexOf(x+''),C={},x.map(v=>C[v]=-~C[v]))

Test=`[1 2 1 4 5] -> [0 1 0 2 3]
[3 2 2 1 5 7 2] -> [1 0 0 2 3 4 0]
[8 8 8 8 8] -> [0 0 0 0 0]
[2] -> [0]
[8 6 8 4 6 8 2 4 6 8 0 2 4 6 8] -> [0 1 0 2 1 0 3 2 1 0 4 3 2 1 0]
[14 1] -> [1 0]
[19 6 4 9 14 17 10 9 6 14 8 14 6 15] -> [8 0 3 2 1 7 5 2 0 1 4 1 0 6]
[15] -> [0]
[1 18 4 8 6 19 12 17 6 13 7 6 8 1 6] -> [1 8 3 2 0 9 5 7 0 6 4 0 2 1 0]
[9 10 11 9 7 11 16 17 11 8 7] -> [2 4 0 2 1 0 5 6 0 3 1]
[1 3 16 19 14] -> [0 1 3 4 2]
[18 8] -> [1 0]
[13 4 9 6] -> [3 0 2 1]
[16 16 18 6 12 10 4 6] -> [1 1 5 0 4 3 2 0]
[11 18] -> [0 1]
[14 18 18 11 9 8 13 3 3 4] -> [7 1 1 5 4 3 6 0 0 2]
[20 19 1 1 13] -> [3 2 0 0 1]
[12] -> [0]
[1 14 20 4 18 15 19] -> [0 2 6 1 4 3 5]
[13 18 20] -> [0 1 2]
[9 1 12 2] -> [2 0 3 1]
[15 11 2 9 10 19 17 10 19 11 16 5 13 2] -> [7 2 0 5 1 3 9 1 3 2 8 4 6 0]
[5 4 2 2 19 14 18 11 3 12 20 14 2 19 7] -> [5 4 0 0 2 1 9 7 3 8 10 1 0 2 6]
[9 11 13 13 13 12 17 8 4] -> [3 4 0 0 0 5 6 2 1]
[10 14 16 17 7 4 3] -> [3 4 5 6 2 1 0]
[2 4 8 7 8 19 16 11 10 19 4 7 8] -> [4 1 0 2 0 3 7 6 5 3 1 2 0]
[15 17 20 18 20 13 6 10 4 19 9 15 18 17 5] -> [0 1 3 2 3 9 6 8 4 10 7 0 2 1 5]
[15 14 4 5 5 5 3 3 19 12 4] -> [5 4 2 0 0 0 1 1 6 3 2]
[7 12] -> [0 1]
[18 5 18 2 5 20 8 8] -> [2 0 2 3 0 4 1 1]
[4 6 10 7 3 1] -> [2 3 5 4 1 0]
[5] -> [0]
[6 12 14 18] -> [0 1 2 3]
[7 15 13 3 4 7 20] -> [0 4 3 1 2 0 5]
[10 15 19 14] -> [0 2 3 1]
[14] -> [0]
[19 10 20 12 17 3 6 16] -> [6 2 7 3 5 0 1 4]
[9 4 7 18 18 15 3] -> [4 2 3 0 0 5 1]
[7 4 13 7] -> [0 1 2 0]
[19 1 10 3 1] -> [3 0 2 1 0]
[8 14 20 4] -> [1 2 3 0]
[17 20 18 11 1 15 7 2] -> [5 7 6 3 0 4 2 1]
[11 4 3 17] -> [2 1 0 3]
[1 9 15 1 20 8 6] -> [0 3 4 0 5 2 1]
[16 13 10] -> [2 1 0]
[17 20 20 12 19 10 19 7 8 5 12 19] -> [7 2 2 1 0 6 0 4 5 3 1 0]
[18 11] -> [1 0]
[2 16 7 12 10 18 4 14 14 7 15 4 8 3 14] -> [3 9 2 7 6 10 1 0 0 2 8 1 5 4 0]
[5 7 2 2 16 14 7 7 18 19 16] -> [3 0 1 1 2 4 0 0 5 6 2]
[8 6 17 5 10 2 14] -> [3 2 6 1 4 0 5]`

Test.split(`\n`).forEach(row => {
  row=row.match(/\d+/g)
  var nv = row.length/2
  var tc = row.slice(0,nv)
  var exp = row.slice(nv)
  var xsum = eval(exp.join`+`)
  var result = F(tc)
  var rsum = eval(result.join`+`)
  var ok = xsum == rsum
  console.log('Test ' + (ok ? 'OK':'KO')
  + '\nInput [' + tc 
  + ']\nExpected (sum ' + xsum + ') ['+ exp 
  + ']\nResult (sum ' + rsum + ') [' + result + ']')
  
})

Answer 12

PHP , 92 बाइट्स

$b=array_unique($a);print_r(array_map(function($v)use($b){return array_search($v,$b);},$a));

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

Answer 13

आर , 58 बाइट्स

x=scan();cat(match(x,names(z<-table(x))[rev(order(z))])-1)

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

पोर्ट ऑफ चास ब्राउन का पायथन उत्तर ।

tableमें प्रत्येक तत्व की गिनती की गणना करता है x(मानों को namesविशेषता के रूप में संग्रहीत करता है ), orderसूचकांकों का क्रमांकन लौटाता है zऔर अंदर matchके पहले मैच का सूचकांक लौटाता xहै names(z)। फिर यह घटता है 1क्योंकि आर सूचकांक 1-आधारित हैं।