জেনারালাইজড অ্যারে রিফেল


22

সপ্তাহ শুরু করার জন্য একটি সাধারণ গল্ফ! আপনাকে তিনটি অ্যারে দেওয়া হবে: বেস অ্যারে B , মান অ্যারে V এবং সূচক অ্যারে I । আপনি অন্য অ্যারের কোথা থেকে মান উত্পাদন করা উচিত Vঢোকানো হয় Bদ্বারা নির্দিষ্ট সূচকের এ I। এখানে একটি উদাহরণ:

Base:    [5, 1, 4, 1, 3]
Values:  [0, 0, 7]
Indices: [5, 0, 3]

সূচকগুলি বেস অ্যারেতে নিম্নলিখিত অবস্থানগুলিতে নির্দেশ করে:

[ 5, 1, 4, 1, 3 ]
 ^        ^    ^
 0        3    5

সুতরাং মান অ্যারে থেকে সংশ্লিষ্ট উপাদানগুলি সন্নিবেশ করাতে ফলাফলটি হওয়া উচিত:

[0, 5, 1, 4, 7, 1, 3, 0]

বিধি

আপনি STDIN (অথবা নিকটতম বিকল্প), কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিয়ে কোনও প্রোগ্রাম বা ফাংশন লিখতে পারেন এবং ফলাফলটি STDOUT (বা নিকটতম বিকল্প), ফাংশন রিটার্ন মান, বা Bপরামিতি হিসাবে প্রদত্ত অ্যারে পরিবর্তন করে আউটপুট দিতে পারেন ।

যদি আপনার জমাটি কোনও ফাংশন হয় Iএবং Vকোনওভাবেই এটি সংশোধন করা যায়, পাশাপাশি Bএটি আউটপুট ব্যবহার না করে।

আপনি ইনপুট সম্পর্কে নিম্নলিখিত অনুমানগুলি করতে পারেন:

  • বেস এবং মান অ্যারের সমস্ত উপাদানগুলি অ-নেতিবাচক পূর্ণসংখ্যা হবে।
  • মান অ্যারেতে বেস অ্যারের চেয়ে সর্বাধিক আরও একটি উপাদান থাকবে।
  • মান অ্যারে এবং সূচক অ্যারেতে একই সংখ্যক উপাদান থাকবে।
  • সূচকের অ্যারেটিতে বারবার সূচকগুলি থাকবে না এবং সমস্ত সূচক সীমার মধ্যে থাকবে।
  • বেস ও মান অ্যারে পারে পুনরাবৃত্তি উপাদান ধারণ করে।
  • যে কোনও বা সমস্ত অ্যারে খালি থাকতে পারে।
  • সূচকগুলি কোনও নির্দিষ্ট ক্রমে দেওয়া আছে তা আপনি ধরে নিতে পারবেন না।
  • আপনি কোনও সুবিধাজনক, দ্ব্যর্থহীন স্ট্রিং বা তালিকার বিন্যাসে ইনপুট এবং উত্পাদন আউটপুট পেতে পারেন। আপনি পৃথক ক্রমে তিনটি অ্যারে গ্রহণ করতে চয়ন করতে পারেন।
  • আপনি 0-ভিত্তিক এবং 1-ভিত্তিক সূচকের মধ্যে চয়ন করতে পারেন।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

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

B V I => Result0-ভিত্তিক সূচকের জন্য বিন্যাসে দেওয়া । আপনি যদি 1-ভিত্তিক সূচক ব্যবহার করেন তবে তৃতীয় অ্যারের উপাদানগুলিকে 1 দ্বারা বৃদ্ধি করুন।

[] [] [] => []
[] [1] [0] => [1]
[1,2] [] [] => [1,2]
[1,2] [3] [0] => [3,1,2]
[1,2] [3] [1] => [1,3,2]
[1,2] [3] [2] => [1,2,3]
[0,0,0] [1,1,1,1] [0,1,2,3] => [1,0,1,0,1,0,1]
[5,1,4,1,3] [0,0,7] [5,0,3] => [0,5,1,4,7,1,3,0]
[1,2,3,4] [4,3,2,1] [4,0,3,1] => [3,1,1,2,3,2,4,4]

আপনি যদি অন্য আকর্ষণীয় প্রান্তের মামলাগুলি দেখতে পান তবে আমাকে জানান, এবং আমি সেগুলি যুক্ত করব।

লিডারবোর্ড

নিয়মিত লিডারবোর্ড এবং ভাষার দ্বারা বিজয়ীদের একটি সংক্ষিপ্ত বিবরণ উভয়ই তৈরি করতে এখানে একটি স্ট্যাক স্নিপেট।

আপনার উত্তরটি প্রদর্শিত হয়েছে তা নিশ্চিত করার জন্য, দয়া করে নীচের মার্কডাউন টেমপ্লেটটি ব্যবহার করে আপনার উত্তরটি শিরোনাম দিয়ে শুরু করুন:

# Language Name, N bytes

Nআপনার জমা দেওয়ার আকারটি কোথায় ? আপনি যদি নিজের স্কোরটি উন্নত করেন তবে আপনি পুরানো স্কোরগুলি শিরোনামে রেখে দিতে পারেন । এই ক্ষেত্রে:

# Ruby, <s>104</s> <s>101</s> 96 bytes


4
NULLযেখানে খালি অ্যারে রয়েছে সেখানে ভাষার শূন্য অ্যারে সম্পর্কে আপনি কী অনুভব করছেন NULL?
অ্যালেক্স এ।

@AlexA। যদি এটি একটি সাধারণ / উল্লিখিত ভাষায় (গুলি) খালি অ্যারের প্রতিনিধিত্ব করে তবে আমি এটির সাথে ভাল আছি।
মার্টিন এন্ডার

3
একটি সহজ গল্ফ ? পুরো সপ্তাহে আমি সিজেমে সবচেয়ে জটিল কাজটি করেছি। : পি
ডেনিস

উত্তর:


13

পাইথ, 14 বাইট

s.icFPQmedSCtQ

প্রদর্শন.

এই প্রোগ্রামটি ইনপুটগুলিকে অর্ডার বেস, সূচকগুলি, মানগুলিতে তালিকার 3-tuple হিসাবে গ্রহণ করে takes

উদাহরণের ব্যাখ্যা [5, 1, 4, 1, 3], [5, 0, 3], [0, 0, 7]:

  1. ইনপুট নিন: অন্তর্নিহিত, কি ইনপুট।

  2. সূচী তৈরি করুন, মান জোড়: CtQ=[(5, 0), (0, 0), (3, 7)]

  3. জোড়গুলিকে ক্রমবর্ধমান সূচী ক্রমে সাজান: SCtQ=[(0, 0), (3, 7), (5, 0)]

  4. প্রতিটি জুটির মান নিন: medSCtQ=[0, 7, 0]

  5. সূচকগুলির স্থানে বেস তালিকাটি বিভক্ত করুন: cFPQ=[[], [5, 1, 4], [1, 3], []]

  6. ইন্টারলিভ 3 এবং 4: .icFPQmedSCtQ=[[], 0, [5, 1, 4], 7, [1, 3], 0, []]

  7. এক তালিকায় একত্রিত করুন: s.icFPQmedSCtQ=[0, 5, 1, 4, 7, 1, 3, 0]


অভিশাপ। কখন থেকে আমাদের একটি ইন্টারলিও পদ্ধতি আছে? শুধু পোস্ট করতে চেয়েছিলেন ssC,cFPQamedSCtQ]
জাকুব

5
@ জাকুব isaac 6 দিন আগে এটি লুক্কায়িতভাবে প্রতিশ্রুতিবদ্ধ।
orlp


3
@ জ্যাকুব যেহেতু পাইথ যে কোনও সমস্যা সমাধানের জন্য বাড়তে পারে। গল্ফিং ল্যাঙ্গুয়েজগুলির সাথে এটাই সমস্যা। রহস্যময় ভাষাগুলির স্বার্থে গুপ্ত ভাষা বিদ্যমান; যেহেতু তারা পরে * ডিজাইন করা হয়েছে।
সেনটিও

@ স্পেনিয়াও ন্যায্য কথা বলতে গেলে হোস্ট ল্যাঙ্গুয়েজ (পাইথন) কিছু সময়ের জন্য আলাদা নামে ইন্টারলেভিং করেছে ।
মেগো

16

পাইথন 2, 54

lambda B,*X:map(B.insert,*zip(*sorted(zip(*X))[::-1]))

হিসাবে ইনপুট লাগে B,I,VBযখন ডাকা হয় ইনপুটটি পরিবর্তন করে (এটি সম্ভব আমাকে স্মরণ করিয়ে দেওয়ার জন্য মার্টিন ব্যাটনারকে ধন্যবাদ)।

প্রতিটি সূচক / উপাদান জুটিতে mapকল করতে ব্যবহার করে B.insert। উপাদানগুলি সন্নিবেশ করায় তালিকার সূচকগুলি স্থানান্তরিত হওয়ার বিষয়টি এড়াতে, কুরুচিপূর্ণ জিপ / সাজানো / আনজিপ দ্বারা সূচকের ক্রম হ্রাস ক্রমে জোড়গুলি বাছাই করে। স্থানান্তরিত সমস্যার জন্য না হলে, আমরা কেবল করতে পারি map(B.insert,*X)

পুরানো পদ্ধতি (65):

B,V,I=input()
for i,v in sorted(zip(I,V))[::-1]:B[i:i]=v,
print B

5

হাস্কেল, 62 বাইট

import Data.List
f b v i=map snd$sort$zip[0.5,1.5..]b++zip i v

ব্যবহারের উদাহরণ: f [5,1,4,1,3] [0,0,7] [5,0,3]-> [0,5,1,4,7,1,3,0]

এটি কীভাবে কাজ করে: "এবং দেড়" সূচকগুলি 0.5(উদাহরণস্বরূপ [(0.5,5),(1.5,1),(2.5,4),(3.5,1),(4.5,3)]) থেকে শুরু করে বেস তালিকাকে বাড়িয়ে তুলুন এবং সূচক-মান জুটির সাহায্যে এটি যুক্ত করুন। অনুসারে বাছাই করুন এবং বাতিল করুন।

মন্তব্য : আমি এখানে প্রতারণা করছি কিনা তা জানেন না। গাণিতিক দৃষ্টিকোণ থেকে এটি ঠিক আছে তবে কোনও প্রোগ্রামার যুক্তিযুক্ত হতে পারে যে সূচকের [5,0,3]তালিকাটি Integersঅনুরোধ করা তালিকার তালিকা নয় , তবে একটি তালিকা Fractionals(সঠিক বলতে গেলে, টাইপটি বহুকর্মী, তবে অবশ্যই Fractionalশ্রেণীর অন্তর্গত , যেমন Floatবা Double)।


5

রুবি, 60 59 53 বাইট

->a,b,c{c.zip(b).sort.reverse.map{|i,v|a.insert i,v}}

এবং ungolfed সংস্করণ

def riffle(array, values, indices)
    indices.zip(values).sort.reverse.each do |index, value|
        array.insert(index, value)
    end
end

2
পরিবর্তে আপনি এটি একটি নামহীন ফাংশন করে এই কমান পারেন: ->a,b,c{...}। এছাড়াও সম্ভাবনাগুলি প্রথম insertবন্ধনীগুলির প্রয়োজন হয় না।
মার্টিন এন্ডার

@ মার্টিনবাটনার আমি ল্যাম্বদার সাথে নামহীন ফাংশন সম্পর্কে জানতাম, তবে আমি অনুভব করিনি যে এই চ্যালেঞ্জের মনোভাব ছিল (যা সাধারণত নামকরণের জন্য বলে)। যদিও পেরেনসকে স্পট করার জন্য ধন্যবাদ।
ডিলান ফ্রেইস

চ্যালেঞ্জটি নির্দিষ্টভাবে কোনও নামযুক্ত ফাংশন জিজ্ঞাসা না করলে নামহীন ফাংশন সর্বদা গ্রহণযোগ্য । এবং আমি কোনও নামকৃত ফাংশন চাইনি (আমি কখনই করি না;))।
মার্টিন ইন্ডার

5

সিজেম, 34 23 18 বাইট

{.\2/\ee+{0=}$1f=}

আমার প্রথম সিজাম জমা। পরামর্শগুলি স্বাগত, আমি নিশ্চিত গল্ফ করার অনেক কিছুই আছে।

@ মার্টিনব্যাটনার এবং @ ডেনিসের সাহায্যে 16 বাইট সংরক্ষণ করা হয়েছে।

ক্রমানুসারে স্ট্যাকের ইনপুট প্রত্যাশা করা ফাংশন B V I(আমি শীর্ষস্থানীয়)।

ব্যবহারের উদাহরণ:

[5 1 4 1 3] [0 0 7] [5 0 3] {.\2/\ee+{0=}$1f=}~

পদ্ধতি:

  • অ্যারের এর iতম উপাদানটি যুক্ত করুনi+0.5
  • সন্নিবেশ অবস্থানের সাথে জোড়া সন্নিবেশ মান
  • ফলস্বরূপ দুটি অ্যারে মার্জ করুন
  • অবস্থান উপাদানগুলির উপর ভিত্তি করে অ্যারে সাজান
  • মান উপাদান রাখুন

এই ভাসমান পয়েন্টটি আমার চেয়ে অনেক চালাক এবং (দুঃখের সাথে) ভাল। q~.5fm.\2/\ee+$1f=pবেনামে কোনও ফাংশন ব্যবহার করে আপনি 19 বাইট এবং 18 বাইটে নামতে পারেন :{.5fm.\2/\ee+$1f=}
ডেনিস

ভাসমান-বিন্দু কৌশলটি ছাড়াই একই ধারণা: {.\2/\ee+{0=}$1f=}(এখনও 18 বাইট)
ডেনিস

@ ডেনিস ধন্যবাদ, আমি এর get array elementজন্য অপারেটরটি খুঁজে পেলাম না 1f=। যদিও আমি এটি পুরো প্রোগ্রাম হিসাবে রেখে দেব।
এলোমেলো

আপনার কল আপনি কেন কোনও ফাংশন পোস্ট করার বিরোধিতা করছেন তা জিজ্ঞাসা করতে আপনি কি আপত্তি করেন?
ডেনিস

@ ডেনিস আমি সদ্য সিজেএম শুরু করেছি এবং কীভাবে ফাংশনগুলি ব্যবহার করব তা নিশ্চিত ছিল না। এখন আমি এটি বুঝতে পেরেছিলাম তাই আমি তার উত্তরটি পরিবর্তন করেছি।
এলোমেলো

5

কে, 22 21 বাইট

{,//+(y@<z;(z@<z)_ x)}

আমরা একটি 3 যুক্তি ফাংশন নির্ধারণ {…}অন্তর্নিহিত ভেরিয়েবল সঙ্গে x, yএবং zশুরু তালিকা, মান তালিকা এবং সূচক তালিকা যথাক্রমে উপস্থাপন করে। "কাটা" অপারেটর ( _) প্রদত্ত সূচকের ( (z@<z)) অনুসারে বাছাই করা তালিকার পরিবর্তে প্রারম্ভিক তালিকাটি বিভক্ত করতে ব্যবহৃত হয় । আমরা একটি তালিকা তৈরি করে ( (a;b)) এর ট্রান্সপোজ ( +) গ্রহণ করে ফলাফলকে সমতল করে (মূলত অ্যারের বিভক্ত অংশের সাথে) মানগুলি আন্তঃলিখন করি ,//

ব্যবহারের উদাহরণ:

  f:{,//+(y@<z;(z@<z)_ x)}
{,//+(y@<z;(z@<z)_ x)}

  f[1 2 3 4;4 3 2 1;4 0 3 1]
3 1 1 2 3 2 4 4

  f[5 1 4 1 3;0 0 7;5 0 3]
0 5 1 4 7 1 3 0

আন্ডারস্কোরের চারপাশের স্পেসগুলি প্রয়োজনীয় কারণ কে সনাক্তকারীগুলিতে আন্ডারস্কোরগুলি অনুমতি দেয়। কে 5 এই সম্ভাব্য দ্বিধাটি সরিয়ে দেয়। আমরা যদি আরোহী ক্রমে আগত সূচকগুলিতে নির্ভর করতে পারি এবং আন্ডারস্কোরগুলি বৈধ শনাক্তকারী না হয় তবে আমরা আরও ভাল 13 টি বাইট প্রোগ্রাম ব্যবহার করতে পারি:

{,//+(y;z_x)}

(দীর্ঘশ্বাস.)

সম্পাদনা:

{,//+(y@<z;(z@<z)_ x)} / before
{,//+(y@<z;z[<z]_ x)}  / after

প্রতিসাম্যতা ভাঙে, তবে আমরা […]ইনফিক্স @ইনডেক্সিং অপারেটরের পরিবর্তে বন্ধনী ইনডেক্সিং ( ) ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারি । সাধারণত এটি প্রোগ্রামগুলিকে দীর্ঘায়িত করে, তবে এই ক্ষেত্রে zকাটাটি সম্পাদনের আগে বাছাই করার জন্য আমাদের প্যারেনস প্রয়োজন ।


4

পাইথ, 17 বাইট

ssC,cFPQamedSCtQ]

@ আইসএইচজি ইতিমধ্যে আমার সমাধানটি বীট করেছে। তবে যেহেতু আমার ডকুমেন্টেশন শেষ হয়েছে, আমি যাইহোক এটি পোস্ট করব।

এটি বিন্যাসে ইনপুট নেয় B, I, V । আপনি এটি এখানে চেষ্টা করতে পারেন: বিক্ষোভ বা টেস্ট স্যুট

ব্যাখ্যা:

আমি B = [5,1,4,1,3], I = [5,0,3], V = [0,0,7]ওপি থেকে উদাহরণটি ব্যবহার করছি ।

                    implicit: Q = input()
      PQ            all elements but last of Q   => [[5,1,4,1,3], [5,0,3]]
    cF              split B it the indices in I  => [[], [5,1,4], [1,3], []]

              tQ    all elements but first of Q  => [[5,0,3], [0,0,7]]
             C      zip                          => [(5,0), (0,0), (3,7)]
            S       sort                         => [(0,0), (3,7), (5,0)]
         med        extract the end of each pair => [0,7,0]
        a       ]   append an empty list         => [0,7,0,[]]

   ,                create a pair => ([[], [5,1,4], [1,3], []], [0,7,0,[]])
  C                 zip           => [([],0), ([5,1,4],7), ([1,3],0), ([],[])]
 s                  sum           => ([],0,[5,1,4],7,[1,3],0,[],[])
s                   sum           => [0,5,1,4,7,1,3,0]

4

জাভাস্ক্রিপ্ট (ES6), 75

3 টি অ্যারে প্যারামিটার সহ একটি ফাংশন, অ্যারে ফিরিয়ে দেয়। অদ্ভুতভাবে, এই ফাংশনটি এর পরিবর্তন করেi প্যারামিটারটি (যেমনটি ওপি কর্তৃক যথাযথভাবে অনুমোদিত)

স্নিপেট চালানো পরীক্ষা করুন, ফায়ারফক্স কেবল যথারীতি।

f=(b,v,i,j=0)=>b.concat(v).map(p=>(p=i.indexOf(j))<0?b[j++]:(i[p]=-1,v[p]))

// TEST
out=x=>O.innerHTML+=x+'\n'

test=[
{ b:[], v:[], i:[], k:[] },
{ b:[], v:[1], i:[0], k:[1] },
{ b:[1,2], v:[], i:[], k:[1,2] },
{ b:[1,2], v:[3], i:[0], k:[3,1,2] },
{ b:[1,2], v:[3], i:[1], k:[1,3,2] },
{ b:[1,2], v:[3], i:[2], k:[1,2,3] },
{ b:[0,0,0], v:[1,1,1,1], i:[0,1,2,3], k:[1,0,1,0,1,0,1] },
{ b:[5,1,4,1,3], v:[0,0,7], i:[5,0,3], k:[0,5,1,4,7,1,3,0] },
{ b:[1,2,3,4], v:[4,3,2,1], i:[4,0,3,1], k:[3,1,1,2,3,2,4,4] }
];

test.forEach(x=>{
  r = f(x.b,x.v,x.i.slice(0)) // pass a copy of i, as the function will alter it
  ok = ''+r==''+x.k
  s='Test ' + (ok?'OK':'FAIL')
  +'\n B ['+x.b
  +']\n V ['+x.v
  +']\n I ['+x.i
  +']\n Result ['+r
  +']\n Check  ['+x.k
  +']\n'
  out(s)
  
})
<pre id=O></pre>


কৌতূহলের বাইরে, কোড সম্পর্কে কী এটি ফায়ারফক্সের সাথে নির্দিষ্ট করে তোলে? এটি কারণ এটি ES6?
অ্যালেক্স এ।

@ অ্যালেক্সা.আইটি কারণ এটি ইএস 6, হ্যাঁ। বিশেষত fat arrow functionক্রোমের বিকাশকারী সংস্করণেও এটি প্রয়োগ করা হয় না (
এএফআইএইকি

প্রকৃতপক্ষে, এমনকি ক্রমের ক্যানারি বিল্ড এটি সমর্থন করে না।
ডকম্যাক্স

4

গণিত, 52 51 বাইট

Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&

উদাহরণ:

In[1]:= f = Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&;

In[2]:= f[{5, 1, 4, 1, 3}, {0, 0, 7}, {5, 0, 3}]

Out[2]= {0, 5, 1, 4, 7, 1, 3, 0}

ব্যাখ্যা:

উপরের উদাহরণ ব্যবহার করে।

  • Tr@#2->#&~MapIndexed~# => {1 -> 5, 2 -> 1, 3 -> 4, 4 -> 1, 5 -> 3}
  • Thread[#3+.5->#2] => {5.5 -> 0, 0.5 -> 0, 3.5 -> 7}
  • তারপরে এই দুটি তালিকার (সাজানো) ইউনিয়ন নিন। (=>{0.5 -> 0, 1 -> 5, 2 -> 1, 3 -> 4, 3.5 -> 7, 4 -> 1, 5 -> 3, 5.5 -> 0} )
  • এবং তারপরে প্রতিটি জুটির শেষ উপাদানটি নিন। (=> {0, 5, 1, 4, 7, 1, 3, 0})


3

আর, 75 বাইট

function(b,v,i){n=b;j=0;for(g in v)n=append(n,g,i[j<-j+1]+sum(i<i[j])-1);n}

এটি একটি নামহীন ফাংশন তৈরি করে। এটি কল করার জন্য, এটির একটি নাম দিনf=function... । দ্রষ্টব্য যে অ্যারেগুলি অবশ্যই 1-সূচিযুক্ত হতে হবে কারণ এটি ঠিক কীভাবে রোল।

অবহেলিত + ব্যাখ্যা:

f <- function(b, v, i) {
    # Initialize the output vector to b
    n <- b

    # Initialize an index over the indices
    j <- 0

    # Loop over the values to insert
    for(g in v) {
        # Get the index of the next given insertion index
        j <- j + 1

        # Insert g into n.
        # The position at which to insert the value is determined by
        # adding the number of indices less than the current one and
        # subtracting 1. The subtraction is because we're using the
        # `after` argument in the `append` function.

        n <- append(n, g, i[j] + sum(i < i[j]) - 1)
    }

    # Return n
    n
}

উদাহরণ:

> f(c(), c(), c())
[1] NULL

> f(c(0, 0, 0), c(1, 1, 1, 1), c(1, 2, 3, 4))
[1] 1 0 1 0 1 0 1

> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(6, 1, 4))
[1] 0 5 1 4 7 1 3 0

পরামর্শ সর্বদা হিসাবে স্বাগত!


2

সিজেম, 19 বাইট

l~_,)N*q~.{t}~.\N-p

এটি একটি সম্পূর্ণ প্রোগ্রাম যা পাঠাগুলি অ্যারে বি , আমি এবং ভী এসটিডিআইএন থেকে (লাইন প্রতি এক, সেই ক্রমে) পড়ে।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

l~    e# Evaluate the first line of input.
_,)   e# Compute the array length and add 1.
N*    e# Push a string of that many linefeeds.
q~    e# Evaluate the remaining input.
.{t}~ e# Vectorized array set: for each index in the array from line 2, replace the
      e# LF at that index by the corresponding element of the array from line 3.
.\    e# Interleave the two arrays on the stack.
N-    e# Remove the linefeeds.
p     e# Print.

সিজেম, 20 বাইট

{Qa+@@.{a2$2$=+t}e_}

এটি একটি বেনাম ফাংশন যা স্ট্যাক থেকে বি , ভি এবং আই (উপরে থেকে নীচে) পপ করে এবং বিনিময়ে স্ট্যাকের উপর একটি একক অ্যারে ছেড়ে দেয়।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

Qa+      e# Append [[]] to B.
@@       e# Rotate V and I on top of B.
.{       e# For each v in V and the corresponding i in I:
   a     e#     Push [v].
   2$2$= e#     Retrieve b := B[i].
   +     e#     Append to push [v b].
         e#     The stack now consists of: B i [v b]
   t     e#     Set B[i] := [v b].
}        e#
e_       e# Flatten B.

1

রুবি, 48 বাইট

আমি মনে করি এটি নিয়ম মেনে চলে তবে দয়া করে পরীক্ষা করুন।

->b,v,i{l=-1;i.map{|j|b[j]=[v[l+=1],b[j]]};b*?:}

ইনপুট হিসাবে তিনটি অ্যারে গ্রহণ করে নামহীন ফাংশন। এমন একটি স্ট্রিং আউটপুট দেয় যা রুবি এক্সপ্রেশন সহ সংখ্যার অ্যারেতে দ্ব্যর্থহীনভাবে পার্স করা যায়x.split(/:+/).map(&:to_i)

আদর্শের উপর পরীক্ষার মামলাগুলি ।

আমি আরও 3 বাইট বাঁচাতে পারলাম, তবে আউটপুট ফর্ম্যাটটি [1,2,[nil,5]]নিয়মগুলি কিছুটা বেশি মাইচ ইমো প্রসারিত করছে, যদিও এটি অস্পষ্ট।


আমি মনে করি বর্তমান ফর্ম্যাটটি ঠিক আছে। ইন্টারলেভেং nilমান সহ নেস্টেড অ্যারেগুলি প্রসারিত কিছুটা। তবে উভয় ক্ষেত্রেই এটি প্রতিযোগিতাটি জিতছে না, সুতরাং আমি এটি নিয়ে কোনওভাবেই সত্যই চিন্তিত নই।
মার্টিন ইন্ডার

1

আর, 60

নামহীন ফাংশন হিসাবে যা খ, ভি এবং i নেয়

function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}

এনএ দিয়ে খ প্রসারিত করে যেখানে ফাঁকা স্থানগুলি পূরণ করে যেখানে ভি দিয়ে এনএ ছাড়া ভেক্টরকে ফেরত দেয়

> f=function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}
> f(c(), c(), c())
logical(0)
> f(c(0, 0, 0), c(1, 1, 1, 1), c(0, 1, 2, 3))
[1] 1 0 1 0 1 0 1
> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(5, 0, 3))
[1] 0 5 1 4 7 1 3 0

1

জাভা, 253, 226, 219, 209

ঠিক বিজয়ী নন, তবে ওহ ভাল।

ধরে নিচ্ছি যে বি, ভি, এবং আমি শূন্য নই। v (লোয়ারকেস ভি) হ'ল মান / সূত্রগুলির অ্যারেগুলির দৈর্ঘ্য। আর রিটার্ন করা অ্যারে। r হল ফিরে আসা অ্যারের দৈর্ঘ্য। x, y এবং আমি সমস্ত অস্থায়ী ints are

int[]f(int[]B,int[]V,int[]I){int v=V.length,r=B.length+v,x,y,i;int[]R=java.utils.Arrays.copyOf(B,r);for(x=0;x<v;x++){i=I[x];for(y=0;y<x;y++)if(I[x]>I[y])i++;for(y=r-2;y>=i;y--)R[y+1]=R[y];R[i]=V[x];}return R;}

সম্প্রসারিত:

int[]f( int[] B, int[] V, int[] I ) {
    int v = V.length, //length of Values
        r = B.length + v, //length of the result
        x, y, i; //temps
        int[] R = java.utils.Arrays.copyOf( B, r );       
        for( x = 0; x < v; x++ ) {
        i = I[x];
        for( y = 0; y < x; y++ )
            if( I[x] > I[y] )
                i++;
        for( y = r - 2; y >= i; y-- )
            R[y+1] = R[y];
        R[i] = V[x];
    }
    return R;
}

1

এপিএল, 22 বাইট

{(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}

পরীক্ষার মামলার সাথে মেলে toIO ← 0 তে।

এটি একটি স্ট্যান্ডার্ড অ্যালগরিদম: প্রথম আর্গুমেন্টের সূচক ভেক্টর প্রদত্ত সূচীগুলিতে যুক্ত করা হয় (তৃতীয় যুক্তি)। ক্রমশক্তি গণনা করে যা সূচীগুলি আরোহণের ক্রমানুসারে বাছাই করে। যেহেতু এপিএল এর বাছাই করা অ্যালগরিদম সংজ্ঞা অনুসারে স্থিতিশীল, ফলন গণনা দ্বিতীয় এবং প্রথম যুক্তির ক্যাটেনেশনের উপাদানটিকে সঠিক জায়গায় রাখে।

উদাহরণস্বরূপ :

    {(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}(5 1 4 1 3)(0 0 7)(5 0 3)
0 5 1 4 7 1 3 0
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.