অ্যারে একীকরণ

24

ভূমিকা

একই দৈর্ঘ্যের দুটি অ্যারে বিবেচনা করুন, বলুন A = [0,1,0,2]এবং B = [-1,1,2,2]। মনে করুন আমরা জানি যে তাদের বিষয়বস্তু কিছু অর্থে সমান, আইটেম অনুসারে আইটেম:

  • 0সমান -1,
  • 1সমান 1,
  • 0সমান 2, এবং
  • 2সমতূল্য 2।

সমানতা সকর্মক হল: -1এবং 0সমতুল্য, এবং 0এবং 2তাই হয় সমতুল্য, -1এবং 2এছাড়াও সমতুল্য। একীকরণ এর Aএবং Bঅ্যারে যেখানে প্রতিটি আইটেম A(অথবা B) বৃহত্তম সংখ্যা এটি সমতুল্য দ্বারা প্রতিস্থাপিত হয়েছে। এই ক্ষেত্রে, একীকরণ হবে[2,1,2,2] ।

কাজটি

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা সমান দৈর্ঘ্যের দুটি খালি খালি পূর্ণসংখ্যার অ্যারে নেয় এবং তাদের একীকরণকে আউটপুট করে। আপনি ফিরে আসার পরিবর্তে স্থানের যে কোনও একটি ইনপুট পরিবর্তন করতে পারেন। সর্বনিম্ন বাইট গণনা জিতেছে।

পরীক্ষার মামলা

[0] [0] -> [0]
[1] [2] -> [2]
[0,-1] [-1,-1] -> [0,0]
[0,1,0] [2,1,0] -> [2,1,2]
[1,2,3] [0,0,1] -> [3,3,3]
[0,1,0,2] [-1,1,2,2] -> [2,1,2,2]
[1,0,1,-4] [-3,-1,-2,2] -> [1,0,1,2]
[1,2,3,-2] [1,0,-3,-2] -> [1,2,3,-2]
[-3,-2,-1,0,1] [-1,-1,-1,-1,-1] -> [1,1,1,1,1]
[-3,-2,-1,0,1] [2,-1,0,1,-3] -> [2,2,2,2,2]
[-3,5,5,3,1] [4,2,3,1,2] -> [4,5,5,5,5]
[4,0,2,-5,0] [0,4,-5,3,5] -> [5,5,3,3,5]
[-2,4,-2,3,2,4,1,1] [-2,4,1,2,2,3,1,-2] -> [1,4,1,4,4,4,1,1]
[-10,-20,-11,12,-18,14,-8,-1,-14,15,-17,18,18,-6,3,1,15,-15,-19,-19] [-13,6,-4,3,19,1,-10,-15,-15,11,6,9,-11,18,6,6,-5,-15,7,-11] -> [-8,14,18,14,19,14,-8,-1,-1,15,14,18,18,18,14,14,15,-1,18,18]
[20,15,2,4,-10,-4,-19,15,-5,2,13,-3,-18,-5,-6,0,3,-6,3,-17] [-18,7,6,19,-8,-4,-16,-1,13,-18,8,8,-16,17,-9,14,-2,-12,7,6] -> [20,15,20,19,-8,-4,20,15,17,20,17,17,20,17,-6,14,15,-6,15,20]
code-golf  array-manipulation 
— Zgarb
সূত্র
3
আপনি কেন এই অপারেশনটিকে একীকরণ বলেছিলেন তা আমি নিশ্চিত নই।
— 59
4
@ ফ্যাটালাইজ আমি টাইপ ইউনিফিকেশনে অনুপ্রাণিত হয়েছি ।
— জাগারব

উত্তর:

6

জাভাস্ক্রিপ্ট (ES6), 100 90 110 102 96 বাইট

a=>b=>a.map(v=>t[v],a.map((_,k)=>a.map((x,i)=>t[x]=t[y=b[i]]=Math.max(k?t[x]:x,k?t[y]:y)),t={}))

আমার প্রাথমিক সমাধানটি ছিল 90 বাইট:

a=>b=>a.map(v=>t[v],a.map(_=>a.map((x,i)=>t[x]=t[y=b[i]]=Math.max(t[x]||x,t[y]||y)),t={}))

যদিও এটি সমস্ত প্রদত্ত পরীক্ষার কেসগুলি কেটে দিচ্ছে, তবে এটি এমন কিছুতে ব্যর্থ হয়:

A = [0, -1], B = [-1, -1]

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
এটি অনেকটা a.map...
— ETH প্রোডাকশন
পছন্দ করুন এর চেয়ে ভাল উপায় আর হতে পারে। মৃদু আকর্ষণীয় সত্য: প্রথম দুটি ঠিক পাশাপাশি a.mapপ্রতিস্থাপন করা যেতে পারে b.map।
— Arnauld
আপনার পরিস্থিতির জন্য আমি একটি নতুন পরীক্ষার কেস যুক্ত করেছি।
— জাগারব
5

সিজেম , 27 বাইট

l~_])\z_,*f{{_2$&,*|}/:e>}p

এটি অনলাইন চেষ্টা করুন! পরীক্ষা স্যুট.

ব্যাখ্যা

l~       e# Read and evaluate input, dumping arrays A and B on the stack.
_        e# Copy B.
])\      e# Wrap in array, pull off B, swap. Gives B [A B] on the stack.
z        e# Transpose the [A B] matrix to get a list of all equivalent pairs.
_,*      e# Repeat this list by the number of pairs. This is to ensure that the
         e# following procedure is applied often enough to allow transitive
         e# equivalences to propagate.
f{       e# Map this block over B, passing in the list of pairs each time...
  {      e#   For each pair...
    _2$  e#     Copy both the pair and the current value/list.
    &,   e#     Get the length of their intersection. If this is non-zero,
         e#     the current pair belongs to the current equivalence class.
    *    e#     Repeat the pair that many times.
    |    e#     Set union between the current value/list and the repeated pair.
         e#     This adds the pair to the current list iff that list already
         e#     contains one value from the pair.
  }/
  :e>    e#   Get the maximum value of this equivalence class.
}
p        e# Pretty print.
— মার্টিন ইন্ডার
সূত্র
4

পাইথন, 86 বাইট

f=lambda a,b:a*(a==b)or f(*[map({x:y for x,y in zip(a,b)if x<y}.get,x,x)for x in b,a])

একযোগে উভয় তালিকাগুলি প্রথম তালিকার প্রতিটি মানকে দ্বিতীয় তালিকায় সংশ্লিষ্ট উপাদান দ্বারা প্রতিস্থাপিত করে এটি আরও বেশি হলে আপডেট করে। প্রতিস্থাপনটি mapঅভিধানের getপদ্ধতিতে সম্পন্ন হয় । তারপরে তালিকাগুলি অদলবদল করে এবং সমান না হওয়া পর্যন্ত পুনরাবৃত্তি করে।

— xnor
সূত্র
2

পাইথ, 13 বাইট

eMumS{s@#dGGC

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা:

প্রতিটি জোড়া দিয়ে শুরু করুন। স্বচ্ছলভাবে ওভারল্যাপিং তালিকাগুলি সহ প্রতিটি জুড়ি (তালিকা) প্রসারিত করুন, উপাদানগুলি নকল করুন এবং সাজান। এই প্রক্রিয়াটি রূপান্তরিত হলে একবার থামুন। প্রতিটি তালিকার সর্বাধিক মুদ্রণ করুন।

— Jakube
সূত্র
2

পিএইচপি, 266 241 213 200 বাইট

সমাধান:

function u($x,$y){foreach($x as$i=>$j){$k[$y[$i]][]=$j;$k[$j][]=$y[$i];}$h=function($c,&$w)use($k,&$h){$w[]=$c;foreach($k[$c]as$u)!in_array($u,$w)&&$h($u,$w);return max($w);};return array_map($h,$x);}

ব্যবহার: u([1,2,3], [0,0,1]);পছন্দসই অ্যারে প্রদান করে।

গল্ফড নয়:

function unify($x, $y)
{
    foreach($x as $i=>$j) {
        $k[$y[$i]][] = $j;
        $k[$j][] = $y[$i];
    }

    $h = function ($c, &$w=[]) use ($k, &$h) {
        $w[] = $c;
        foreach($k[$c] as $u)
            !in_array($u, $w) && $h($u, $w);
        return max($w);
    };

    return array_map($h, $x);
}
— Progrock
সূত্র
0

জাভা, 273 263 বাইট

interface Z{int z(int x);default Z g(int m,int n){return x->{for(int t;x!=(t=x==m?z(n):z(x));)x=t;return x;};}static void f(int[]a,int[]b){Z y=x->x;int i=0,v;for(int u:a){u=y.z(u);v=y.z(b[i++]);if(u<v)y=y.g(u,v);if(v<u)y=y.g(v,u);}i=0;for(int u:a)a[i++]=y.z(u);}}

পদ্ধতিটি f(int[]a,int[]b)চ্যালেঞ্জ সমাধান করে।

interface Z{

  //should return an "equivalent" integer
  int z(int x);

  //return a Z lambda where the 1st arg is "equivalent" to the 2nd arg
  default Z g(int m,int n){
    return x->{
      for(int t;x!=(t=x==m?z(n):z(x));) //always find the last equivalent number for x
        x=t;
      return x;
    };
  }

  //solve the challenge
  static void f(int[]a,int[]b){
    Z y=x->x; //start off with all numbers only equivalent only to themselves
    int i=0,v;
    for(int u:a){
      u=y.z(u); //get a's element's equivalent number
      v=y.z(b[i++]); //get b's element's equivalent number
      if(u<v)y=y.g(u,v); //if a's was smaller than b's, make a's equivalent to b's
      if(v<u)y=y.g(v,u); //if b's was smaller than a's, make b's equivalent to a's
    }
    i=0;
    for(int u:a) //overwrite a with each element's equivalent value
      a[i++]=y.z(u);
  }

}

প্রথমে উভয় অ্যারে দিয়ে যান এবং সমান সংখ্যার খোঁজ রাখুন। তারপরে সমান সংখ্যাগুলি সংরক্ষণ করার জন্য প্রথম অ্যারেতে প্রতিটি উপাদান পরিবর্তন করুন।

— জ্যাক আম্মো
সূত্র
0

পাইথন, 522 বাইট

a = [-2,4,-2,3,2,4,1,1]
b = [-2,4,1,2,2,3,1,-2]
m = {}
visited = {}
for i in range(len(a)):
    if a[i] in m:
        if b[i] not in m[a[i]]:
            m[a[i]].append(b[i])
    else:
        l = []
        l.append(b[i])
        m[a[i]] = l
    if b[i] in m:
        if a[i] not in m[b[i]]:
            m[b[i]].append(a[i])
    else:
        l = []
        l.append(a[i])
        m[b[i]] = l

def dfs(v, maximum):
    if v > maximum:
        maximum = v
    visited[v] = True
    for n in m[v]:
        if not visited[n]:
            d = dfs(n, maximum)
            if d > v:
                maximum = d
    return maximum

result = []
for k in range(len(a)):
    for q in m:
        visited[q] = False
    result.append(max(dfs(a[k], a[k]), dfs(b[k], b[k])))

print(result)

ব্যাখ্যা

উভয় অ্যারেতে ( aএবং bএই ক্ষেত্রে) প্রতিটি অনন্য উপাদানের সাথে সম্পর্কিত মানগুলির একটি সারণী তৈরি করুন । উদাহরণস্বরূপ যদি

a = [0,1,0] 
b = [2,1,0]

তাহলে টেবিলটি হ'ল:

0:[0,2]
1:[1]
2:[0]

তারপরে প্রথম অনুসন্ধানটি গভীরতার সাথে প্রয়োগ করুন, উদাহরণস্বরূপ, ধরে নিন যে আমি aতখন মানটির সবচেয়ে বামতম উপাদানটি বেছে নিয়েছি 0এবং 0এর সমতুল্য রয়েছে: 0এবং 2। যেহেতু 0ইতিমধ্যে পরিদর্শন করা হয়েছে তাই যান 2। 2 equivalences রয়েছে: 0। মধ্যে বামদিকের উপাদান চয়নের জন্য শ্রেষ্ঠ ফলাফলের তাই aহয় 2। গাছটি এখানে:

   0   
 /   \
0     2
       \
        0

এবং আপনি সেখানে বৃহত্তম মান নিতে চান, ফলস্বরূপ 2।

— Bobas_Pett
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম! ইন কোড-গলফ , আপনি আপনার প্রোগ্রাম সংক্ষিপ্ত bytecount সম্ভব পেতে লক্ষ্য রাখি। এর অর্থ হ'ল ফাংশন এবং ভেরিয়েবলের নামগুলি সংক্ষিপ্ত করা এবং আপনার প্রোগ্রামের অপ্রয়োজনীয় সাদা স্থান অপসারণ করা।
— ক্রিটসি লিথোস
আপনার দুটি অ্যারে হার্ড-কোডিংয়ের পরিবর্তে ব্যবহারকারীর ইনপুট হিসাবে নেওয়া উচিত।
— Zgarb
0

পিএইচপি, 132 বাইট

function(&$a,$b){for(;$i<count($a);$i++){$r=$a[$i];$s=$b[$i];$r<$c[$s]?:$c[$s]=$r;$s<$c[$r]?:$c[$r]=$s;}foreach($a as&$v)$v=$c[$v];}

বেনামে ফাংশন যা দুটি অ্যারে নেয়।

চ্যালেঞ্জের আউটপুটে উল্লিখিত হিসাবে এটি আমার 'স্থানে থাকা অ্যারেগুলির একটিতে সংশোধন' করা আমার গ্রহণ। এটি দুটি অ্যারের প্রত্যেকটির মধ্য দিয়ে লুপ করে, সমানটি রেকর্ড করে যদি বর্তমানটি সঞ্চিত একের চেয়ে বড় হয়, তবে প্রথম অ্যারের মধ্য দিয়ে লুপ হয় এবং সমস্ত মানকে তাদের বৃহত্তম সমতুল্য দ্বারা প্রতিস্থাপন করে। প্রথম অ্যারেটি রেফারেন্স দ্বারা নেওয়া হয় (অতএব &$a), সুতরাং পাস করা অ্যারেটি 'জায়গায় জায়গায়' পরিবর্তন করা হয়।

— Xanderhall
সূত্র
0

জাভা, 170 বাইট

Golfed

(a,b)->{int[]d=a.clone();for(int i=0,y;i<d.length;i++){y=0;for(int j=0;j<a.length;j++)if(a[j]==d[i]||b[j]==d[i])y=Integer.max(y,Integer.max(a[j],b[j]));d[i]=y;}return d;}

Ungolfed

(a, b) -> {                                        // Two argument lambda
    int[] d = a.clone();                           // We clone our first array for modification
    for (int i = 0,y; i < d.length; i++) {         // Going through the elements of d...
        y = 0;                                     // We initialize our 'highest' equivalent
        for (int j = 0; j < a.length; j++) {       // Going through each of our arrays (a and b)...
            if (a[j] == d[i] || b[j] == d[i]) {    // If either of them is the number we're trying to match for equivalence...
                y = Integer.max(y, Integer.max(a[j], b[j])); // We see if the new number is bigger than the largest we've found.
            }
        }
        d[i] = y;                                  // We then assign the largest equivalent number for the current position in our output array.
    }
    return d; // And return!
}

অজ্ঞাতনামূলক ফাংশন যা int[]আর্গুমেন্ট হিসাবে দুটি গ্রহণ করে এবং একটি প্রদান করে int[]।

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