ক্ষুদ্রতম যোগফলের সাথে একটি একত্রিত তালিকা তৈরি করুন

24

দুটি তালিকাগুলি 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]একত্রিত।

কাজটি

একটি nonempty তালিকা দেওয়া নন-নেগেটিভ পূর্ণসংখ্যার 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]

এটি কোড-গল্ফ , তাই সংক্ষিপ্ততম বৈধ জমা (বাইটে গণনা করা) জয়ী।

code-golf  array-manipulation 
— ফল ফল
সূত্র
— xnor

উত্তর:

5

পাইথন 2 , 62 54 বাইট

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

এটি অনলাইন চেষ্টা করুন!

সম্পাদনা করুন: মাল্টেসেনে মানচিত্র থেক্স থেকে 8 টি বাইট সংরক্ষণ করা হয়েছে

— চ্যাস ব্রাউন
সূত্র
কম বাইট:lambda L:map(sorted(set(L),key=L.count)[::-1].index,L)
— মালটিসেন
4

পাইথ - 12 11 10 বাইট

XQ_o/QN{QU

টেস্ট স্যুট ।

— Maltysen
সূত্র
1
অভিশাপ, তাড়াতাড়ি! আমি কেবল আমাদের কাছে কী জিজ্ঞাসা করা হয়েছিল তা নির্ধারণ করতে পেরেছি!
— শেগি
আপনি এটি দিয়ে একটি বাইট সংরক্ষণ করতে পারেন mx_o/QN{Q।
4

জাপট , 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
— ETHproductions
সূত্র
2

হাস্কেল , 93 91 85 বাইট

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

এটি অনলাইন চেষ্টা করুন!

সম্পাদনা: 6 লাইক কেটে দেওয়ার জন্য লাইকোনিকে ধন্যবাদ!

খুব ছোট নয় তবে আমি আর কিছু ভাবতে পারি না। ধারণাটি হ'ল অ্যারে ( x<-a) এর উপরে পুনরাবৃত্তি করা এবং একটি টিউপল তালিকায় একটি অনুসন্ধান করা ( (i,y:_)<-... ,x==y) যা ইনপুটে প্রতিটি অনন্য উপাদানকে এটি কতটা সাধারণ তার উপর নির্ভর করে একটি nonnegative পূর্ণসংখ্যা বরাদ্দ করে। সেই টিপল তালিকাটি প্রথমে sortইনপুট যুক্ত করে, groupসমান উপাদানের সাবলিস্টে যুক্ত করে, তালিকাটিকে সাবলিস্টের দৈর্ঘ্য অনুসারে বাছাই করে ( sortOn((0-).length); দৈর্ঘ্যটিকে "অবতরণ" ক্রমে সাজানোর জন্য অবহেলা করা হয়), এবং অবশেষে এটি অসীম তালিকার সাথে জিপ করে 0 থেকে বৃদ্ধি করা আমরা সাবলিস্ট থেকে প্রকৃত উপাদানটি বের করতে প্যাটার্ন ম্যাচিং ব্যবহার করি y।

— user1472751
সূত্র
1
আপনি প্যাটার্নটির সাথে মিল (i,y:_)রেখে head<$>অংশটি ফেলে দিতে পারেন এবং প্রথম বন্ধনী প্রতিস্থাপন করতে পারেন $।
— লাইকনি
1

সিজেম, 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]
— ফল ফল
সূত্র
আপনি শুধুমাত্র তিনটি এটা বিভাজন আপ বাইট জন্য বিপরীত ক্রম সাজাতে পারেন: $W%।
— পিটার টেলর
@ পিটারটেলর আহ, আমি অ্যারে এর জন্য অভিধানের তুলনা ভুলে যাচ্ছি। ধন্যবাদ।
— ফেব্রুয়ারিতে এসোলাং ফল
1

টিআই-বেসিক, 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.
— calc84maniac
সূত্র
1

জাভাস্ক্রিপ্ট (ES6), 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 + ']')
  
})
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
0

আর , 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-ভিত্তিক।

— : Giuseppe
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.