খালি শূন্যস্থান পূরণ করে ফাঁকা স্থান পূরণ করুন

Question

এমন একটি ফাংশন (যেমন placeAt) লিখুন যা অ-নেতিবাচক পূর্ণসংখ্যার অ্যারে নেয় এবং একটি সূচক যা অ-নেতিবাচক পূর্ণসংখ্য হয়। এটি প্রদত্ত সূচকে একটি 1 স্থাপন করা উচিত, সম্ভবত স্পটটি ফাঁকা করার জন্য অন্য এন্ট্রিগুলিকে এক স্থান দ্বারা স্থানান্তরিত করা উচিত, 0 টি ফাঁকা দাগের জন্য দাঁড়িয়ে আছে।

• পছন্দসই সূচকে এন্ট্রি যদি 0 হয় তবে এটি 1 দিয়ে পূরণ করুন।
• অন্যথায়, সূচকের বাম দিকে নিকটতম 0 টি সন্ধান করুন। স্থান তৈরি করতে সেই স্থানের বাম দিকে একটি স্থানের স্থান পরিবর্তন করুন, তারপরে একটি 1 দিয়ে সূচকটি পূরণ করুন।
• বামদিকে যদি 0 না থাকে তবে ডানদিকে যাচ্ছেন।
• উভয়ই যদি সম্ভব না হয় (যেমন যদি 0 না থাকে) তবে অ্যারেটি অপরিবর্তিত অবস্থায় ফিরিয়ে দিন।

আইটেমগুলি 0-সূচকযুক্ত। ফাংশনটির নাম আপনি যা চান তা হতে পারে।

উদাহরণ:

(অক্ষরগুলি কোনও ধনাত্মক পূর্ণসংখ্যার মানগুলির জন্য দাঁড়ায়))

[a, b, 0, c, d, 0] placeAt 2    // output [a, b, 1, c, d, 0]    place 2 is 0, just fill
[a, b, 0, c, d, 0] placeAt 3    // output [a, b, c, 1, d, 0]    place 3 is filled, shift items left
[a, b, 0, c, d, 0] placeAt 0    // output [1, a, b, c, d, 0]    place 0 is filled, can't shift left, shift items right
[a, b, 0, c, d, 0] placeAt 1    // output [a, 1, b, c, d, 0]    place 1 is filled, can't shift left, shift items right
[0, a, b, 0, c, d, 0] placeAt 2 // output [a, b, 1, 0, c, d, 0] place 2 is filled, shift items left
[0, a, b, 0, c, d, 0] placeAt 4 // output [0, a, b, c, 1, d, 0] place 4 is filled, shift items left (notice you keep shifting up until a 0)
[0, 2, 0, 2] placeAt 3          // output [0, 2, 2, 1]          place 3 is filled, shift items left

এটি একটি কোড গল্ফ চ্যালেঞ্জ। 9 দিনের শেষে স্বল্পতম এন্ট্রি জিতল।

Comments

আপনি কীভাবে জানবেন যে উভয়ই সম্ভব হলে বামে বা ডানে স্থানান্তরিত করতে হবে? এছাড়াও, না থাকলে কী হবে 0?

— xnor

জন্য [0, 2, 0, 2] placeAt 3, আউটপুট বৈধ [2, 0, 2, 1]? কোডটি কি আসলে একটি ফাংশন হিসাবে পরিচিত হয় placeAt? মনে রাখবেন যে কিছু ভাষার ঠিক ফাংশন নেই। "একটি ব্যতিক্রম নিক্ষেপ" কিছু ভাষার ক্ষেত্রেও প্রযোজ্য নয়; আমি একটি ত্রুটি নির্দেশ করে একটি আউটপুট অনুমতি দেওয়ার পরামর্শ দেব।

— xnor

অ্যারে নেতিবাচক মান থাকতে পারে?

— কেড

আমি 99% নিশ্চিত যে আমি এই চ্যালেঞ্জের নিয়মগুলির সাথে ওপি'র উদ্দেশ্যগুলি বুঝতে পেরেছি, তাই আমি পোস্টটি পুনর্গঠিত করেছি (এটি এখনই সারিতে রয়েছে) এবং আমি প্রশ্নের উত্তর দেওয়ার চেষ্টা করব। উদাহরণস্বরূপ, প্রয়োজন হলে আপনি আমার যে কোনও উত্তর সংশোধন করতে পারেন।

— ETH প্রোডাকশনগুলি

@ এক্সনোর বামে স্থানান্তর ডান স্থানান্তরের চেয়ে সর্বদা অগ্রাধিকার নেয়। যদি 0 না থাকে তবে কেবল আসল অ্যারেটি ফিরিয়ে দিন। এছাড়াও, [2, 0, 2, 1]কোনও আইনি আউটপুট নয়, কারণ আপনার সর্বদা যতটা সম্ভব কয়েকটি উপাদান স্থান পরিবর্তন করা উচিত এবং আপনি যা চান তাতে ফাংশনটির নাম দিতে পারেন।

— ETH প্রোডাকশনগুলি

Answer 1

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

যে কোনও ইকামাস্ক্রিপ্ট comp অনুবর্তী ব্রাউজারে স্নিপেট চলমান পরীক্ষা করুন (উল্লেখযোগ্যভাবে ক্রোম এমএসআইই নয়। আমি ফায়ারফক্সে পরীক্ষা করেছি, সাফারি 9 যেতে পারে)

(আমি অন্যান্য উত্তরগুলির দিকে নজর না দিয়ে এটি পেয়েছি, এখন আমি দেখতে পেয়েছি এটি রিঙ্কের সাথে খুব মিল Yet তবুও বেশ খাটো Pro সম্ভবত এই উত্তরটির জন্য আমি অনেকগুলি অগ্রগতি পাব না)

F=(a,p,q=~a.lastIndexOf(0,p)||~a.indexOf(0))=>(q&&(a.splice(~q,1),a.splice(p,0,1)),a)

// Ungolfed
U=(a,p)=>{
  q = a.lastIndexOf(0, p)
  if (q < 0) q = a.indexOf(0)
  if (q >= 0) {
    a.splice(q, 1)
    a.splice(p, 0, 1)
  }
  return a
}  

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

[ [['a', 'b', 0, 'c', 'd', 0], 2, ['a', 'b', 1, 'c', 'd', 0]] // place 2 is 0, just fill
, [['a', 'b', 0, 'c', 'd', 0], 3, ['a', 'b', 'c', 1, 'd', 0]] // place 3 is filled, shift items left
, [['a', 'b', 0, 'c', 'd', 0], 0, [1, 'a', 'b', 'c', 'd', 0]] // place 0 is filled, can't shift left, shift items right
, [['a', 'b', 0, 'c', 'd', 0], 1, ['a', 1, 'b', 'c', 'd', 0]] // place 1 is filled, can't shift left, shift items right
, [[0, 'a', 'b', 0, 'c', 'd', 0], 2, ['a', 'b', 1, 0, 'c', 'd', 0]] // place 2 is filled, shift items left
, [[0, 'a', 'b', 0, 'c', 'd', 0], 4, [0, 'a', 'b', 'c', 1, 'd', 0]] // place 4 is filled, shift items left (notice you keep shifting up until a 0)
, [['a', 'b', 'c', 'd'], 2, ['a', 'b', 'c', 'd']] // impossible
, [[0, 2, 0, 2], 3, [0, 2, 2, 1]]] // place 3 is filled, shift items left
.forEach(t=>{
  i=t[0]+''
  r=F(t[0],t[1])+''
  k=t[2]+''
  out('Test ' + (r==k?'OK':'Fail') +'\nInput: '+i+' '+t[1]+'\nResult:'+r+'\nCheck: '+k+'\n')
})

<pre id=O></pre>

Comments

+1 কারণ আমি মাত্র কমা অপারেটর সম্পর্কে শিখেছি এবং আমাকে মারধর করার জন্য

— rink.attendant.6

@ রিঙ্ক.এটএন্ডেন্ট &. তবে আপনার যোগদানের জন্য && এর ব্যবহার spliceআমার কমা থেকে ভাল

— edc65

Answer 2

জুলিয়া, 122 বাইট

জিনিস শুরু করার জন্য অনুমিতের একটি নির্বাক বাস্তবায়ন।

f(x,i)=(i+=1;x[i]==0?(x[i]=1):i>2&&x[i-1]==0?(x[i-1]=x[i];x[i]=1):i<length(x)-1&&x[i+1]==0?(x[i+1]=x[i];x[i]=1):error();x)

Ungolfed:

function placeAt(x::Array, i::Int)
    # Make i 1-indexed
    i += 1

    # Shift and modify the array as necessary
    if x[i] == 0
        x[i] = 1
    elseif i > 2 && x[i-1] == 0
        x[i-1], x[i] = x[i], 1
    elseif i < length(x)-1 && x[i+1] == 0
        x[i+1], x[i] = x[i], 1
    else
        error()
    end

    # Return the modified array
    x
end

Answer 3

জাভাস্ক্রিপ্ট (ES6), 98 বাইট

আমার কফিস্ক্রিপ্ট উত্তরের মত অনেকটা একই পদ্ধতি কিন্তু আমি একটি returnবিবৃতি সংরক্ষণের জন্য চূড়ান্তভাবে সংক্ষিপ্তসার্চিট করছি :

f=(a,x)=>(~($=a.lastIndexOf(0,x))||~(_=a.indexOf(0,x)))&&a.splice(~$?$:_,1)&&a.splice(x,0,1)&&a||a

ব্যাখ্যা

আরও সহজে ব্যাখ্যা করতে, আমি আমার কোডটি কিছুটা পুনরায় সাজিয়েছি:

// Declare function f with two arguments: array and position
f = (a, x) => {
    // Take the part of the array from beginning to x and find the last 0
    $ = a.lastIndexOf(0, x)

    // Find the first 0 after position x
    _ = a.indexOf(0, x);

    // indexOf returns -1 if they aren't found
    // ~1 == 0 so I am checking if either $ or _ is truthy (zeros were found)
    if (~$ || ~_)
       // If zeros were found in the left, use that.
       // Otherwise use the found zero in the right.
       // Delete it from the array
       // Array.prototype.splice will return an array which evaluates to truthy
       // and continues execution with the &&
       // Insert value 1 at position x, deleting 0 elements
       // The last value is returned
       return a.splice(~$ ? $ : _, 1) && a.splice(x, 0, 1) && a
    else
       // No zeros were found so just return the original
       // In the golfed code the if would have evaluated to false to cut into the || part
       return a
}

জেএস শর্ট সার্কিট মূল্যায়নের বিষয়ে কিছু তথ্য এখানে ।

ডেমো

এই মুহূর্তে এই ডেমোটি কেবল ফায়ারফক্স এবং এজগুলিতে ইএস 6 ব্যবহারের কারণে কাজ করে:

f=(a,x)=>(~($=a.lastIndexOf(0,x))||~(_=a.indexOf(0,x)))&&a.splice(~$?$:_,1)&&a.splice(x,0,1)&&a||a

// Snippet stuff
console.log = x => O.innerHTML += x + '\n';

console.log(f(['a', 'b', 0, 'c', 'd', 0], 2))
console.log(f(['a', 'b', 0, 'c', 'd', 0], 3))
console.log(f(['a', 'b', 0, 'c', 'd', 0], 0))
console.log(f([0, 'a', 'b', 0, 'c', 'd', 0], 2))
console.log(f([0, 'a', 'b', 0, 'c', 'd', 0], 4))
console.log(f(['a', 'b', 0, 'c', 'd', 0], 2))
console.log(f(['a', 'b', 0, 'c', 'd', 0], 1))

<pre id=O></pre>

Comments

কিভাবে এই কাজ আপনি ব্যাখ্যা করতে পারেন দয়া করে।

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

@ ইগুনেস ব্যাখ্যা যোগ করেছেন

— rink.attendant.6

এটি কাজ করে নাf(['a', 'b', 0, 'c', 'd', 0], 2)

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

@ ইগুনেস ফিক্সড আমি ভুলে গেছি যে কফিস্ক্রিপ্ট তাদের শর্টহ্যান্ড স্লাইস ব্যবহার করার সময় স্বয়ংক্রিয়ভাবে একটি যুক্ত করে [a..b]।

— rink.attendant.6

কাজ করে নাf(['a', 'b', 0, 'c', 'd', 0], 1)

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

Answer 4

রুবি, 208 বাইট

def f(a,i)
  x=a.take(i).rindex(0);y=a[i+1..-1].index(0)
  if a[i]==0
    a[i]=1
  elsif !x.nil?
    a.delete_at(x);a.insert(i,1)
  elsif !y.nil?
    a.delete_at(y+i+1);a.insert(i,1)
  end
  a
end

Comments

পিপিসিজিতে আপনাকে স্বাগতম! রুবির জন্য কিছু সহজ গল্ফিং টিপস: আপনার কোনও ইন্ডেন্টেশন লাগবে না, যাতে আপনি সমস্ত স্থান থেকে মুক্তি পেতে পারেন। তারপরে আপনার সেমিকোলনগুলিরও দরকার নেই, কারণ একটি একক নিউলাইন একই সংখ্যক বাইট। একটি বিবৃতি শেষে পদ্ধতি কলগুলির জন্য প্রথম বন্ধনী প্রয়োজন হয় না, তাই আপনি করতে পারেন, উদাহরণস্বরূপ .rindex 0, প্রতিবার একটি বাইট সংরক্ষণ করা। এছাড়াও আপনি একটি পদ্ধতি, যা এমনকি নেই পরিবর্তে একটি proc ব্যবহার করে কিছু বাইট সংরক্ষণ নাম প্রকাশে অনিচ্ছুক করতে পারেন: ->a,i{...}। যদি / এলসিফ / এলসিফ সম্ভবত নেস্টেড টের্নারি অপারেটর দিয়ে সংক্ষিপ্ত করা যায় ...?...:...?...:...।

— মার্টিন এন্ডার

সদয় পরামর্শের জন্য অনেক ধন্যবাদ। আমি এটি খতিয়ে দেখব এবং আমি কি করতে পারি তা দেখতে পাবো।

— হ্যান্ড্রেক

Answer 5

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

e=elem 0
r=reverse
f=(g.).splitAt
g(a,y@(x:b))|e(x:a)=r(h(x:r a)1)++b|e y=a++h y 1|1<2=a++y 
h(0:r)n=n:r
h(a:r)n=n:h r a

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

*Main> mapM_ (print.uncurry f) [ 
                (2,[2,3,0,4,5,0]),
                (3,[2,3,0,4,5,0]),
                (0,[2,3,0,4,5,0]),
                (1,[2,3,0,4,5,0]),
                (2,[0,2,3,0,4,5,0]),
                (4,[0,2,3,0,4,5,0]),
                (3,[0,2,0,2]),
                (2,[2,3,4,5])  ]
[2,3,1,4,5,0]
[2,3,4,1,5,0]
[1,2,3,4,5,0]
[2,1,3,4,5,0]
[2,3,1,0,4,5,0]
[0,2,3,4,1,5,0]
[0,2,2,1]
[2,3,4,5]

এটি কীভাবে কাজ করে: প্রদত্ত অবস্থানে ইনপুট তালিকাটি বাম অংশে বিভক্ত করুন a, অবস্থানটিতে উপাদানটি নিজেই xএবং ডান অংশে বিভক্ত করুন b। যদি একটি এর 0মধ্যে a++x, মেক প্রথম ঘর 0এর বিপরীত a++x। যদি একটি এর 0মধ্যে x++b, করতে সেখানে রুম। যদি কিছু না 0থাকে তবে মূল তালিকাটি আবার পেতে সমস্ত অংশ অপরিবর্তিতভাবে একত্রিত করুন।

Answer 6

কফিস্ক্রিপ্ট, 96 বাইট

f=(a,_)->a.splice((if~($=a.lastIndexOf 0,_)then $ else a.indexOf 0),1);a.splice(_,0,1)if 0in a;a

Answer 7

পাইথন 2, 102 বাইট

def f(a,i):
 x=(a[i-1::-1]+a[i:]+[0]).index(0)
 if x<len(a):del a[(x,i-x-1)[x<i]];a[i:i]=[1]
 return a

শৃঙ্খলার পরে সূচকটির পরে স্বাভাবিক ক্রম অনুসারে সন্নিবেশ সূচক পর্যন্ত বিপরীত তালিকার সাথে তাল মিলিয়ে শূন্যের সূচক গণনা করে প্রথম শূন্যের সূচকটি সন্ধান করে। ValueErrorকোনও শূন্য পাওয়া না গেলে ব্যতিক্রম এড়াতে শেষ পর্যন্ত একটি শূন্য যুক্ত করা হয় । তারপরে কেবল মুছুন, সন্নিবেশ করুন এবং ফিরে আসুন।

Answer 8

আর, 87 বাইট

f=function(a,i)if(0%in%a)append(a[-abs(min((b=which(a==0))*(1-(b<=i+1)*2)))],1,i)else a

ব্যাখ্যা

function(a,i)
if(0%in%a)                      # as long as a 0 exists
    append(                     # append 1 after i
        a[
          -abs(                 # remove absolute of min index
            min(                # minimum of adjusted index
              (b=which(a==0))*  # index of all 0's
              (1-(b<=i+1)*2)    # multiple -1 if <= i
              )
            )
        ]
        ,1
        ,i
    )
else                            # otherwise return untouched
    a

টেস্ট

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

Answer 9

সি #, 265 বাইট

গল্ফড (265 অক্ষর)

static void placeAt(String[]Q,int P){int I;if(Q[P]=="0"){Q[P]="1";}else{I=Array.IndexOf(Q,"0");if(I>=0){if(I<P){for(int i=I;i<=P;i++){Q[i]=(i==P)?"1":Q[i+1];}}else if(I>P){for(int i=I;i>=P;i--){Q[i]=(i==P)?"1":Q[i-1];}}}}foreach(String s in Q)Console.Write(s+" ");}

সাদা স্পেস এবং ইন্ডেন্টেশন সহ

static void placeAt(String[] Q, int P)
    {
        int I;

        if(Q[P] == "0")
        {
            Q[P] = "1";
        }
        else
        {
            I = Array.IndexOf(Q, "0");
            if (I >= 0)
            {
                if (I < P)
                {
                    for (int i = I; i <= P; i++)
                    {
                        Q[i] = (i == P) ? "1" : Q[i + 1];
                    }
                }
                else if (I > P)
                {
                    for (int i = I; i >= P; i--)
                    {
                        Q[i] = (i == P) ? "1" : Q[i - 1];
                    }
                }
            }
        }

        foreach (String s in Q)
            Console.Write(s + " ");
    }

পুরো প্রোগ্রাম

using System;

class FillZero
{
    static void placeAt(String[] Q, int P)
    {
        int I;

        if(Q[P] == "0")
        {
            Q[P] = "1";
        }
        else
        {
            I = Array.IndexOf(Q, "0");
            if (I >= 0)
            {
                if (I < P)
                {
                    for (int i = I; i <= P; i++)
                    {
                        Q[i] = (i == P) ? "1" : Q[i + 1];
                    }
                }
                else if (I > P)
                {
                    for (int i = I; i >= P; i--)
                    {
                        Q[i] = (i == P) ? "1" : Q[i - 1];
                    }
                }
            }
        }

        foreach (String s in Q)
            Console.Write(s + " ");
    }

    static void Main()
    {
        String[] X = {"a", "b", "0", "c", "d", "0"};
        placeAt(X , 1);

    }

}

পরীক্ষার কেস

Comments

এটি এর জন্য কাজ করে না([0, 'a', 'b', 0, 'c', 'd'], 2)

— eguneys

আপনি সমস্ত অপ্রয়োজনীয় হোয়াইটস্পেস সরানোর, উদাহরণস্বরূপ কিছু অক্ষর সংরক্ষণ করতে পারবেন String[] Q, int Pকরার String[]Q,int P।

— ProgramFOX

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

— মেরিন নাকারমি

হাই @ প্রোগ্রামফক্স, আপনার মূল্যবান মন্তব্যের জন্য ধন্যবাদ। আমি কিছু 10 টি অক্ষর সংরক্ষণ করেছি।

— মেরিন নাকারমি

Answer 10

সি, 154 বাইট

p(a,l,i,c)int*a;{for(c=i;c+1;c--){if(!a[c]){for(;c<i;c++)a[c]=a[c+1];return a[i]=1;}}for(c=i;c<l;c++){if(!a[c]){for(;c>i;c--)a[c]=a[c-1];return a[i]=1;}}}

প্রদত্ত পরীক্ষার কেসগুলি পাস করে, একটি অ্যারের নির্দেশক, l অ্যারের দৈর্ঘ্য (আমি আশা করি এটি সংক্ষেপটি ভাঙ্গবে না), আমি সন্নিবেশের জন্য সূচক এবং সি অভ্যন্তরীণভাবে ব্যবহৃত হয়। লুপগুলির জন্য বাম এবং ডান অনুসন্ধান একত্রিত করে সম্ভবত উন্নত করা যেতে পারে।

উদাহরণ

int main(int argc, char * argv[]) {
    int a[] = {0, 2, 0, 2};
    p(a, 4, 3);
}

Ungolfed

সোজা ফরোয়ার্ড, এবং কে ওআরআর শৈলীর ঘোষণার বাইরে কোনও কৌশল নয়।

p(a,l,i,c) int *a; {
    /* Search left from i (also handles a[i] == 0) */
    for (c=i;c+1;c--) {
            if (!a[c]) {
                    /* Shift items left until i */ 
                    for (;c<i;c++) a[c]=a[c+1];
                    return a[i]=1;
            }
    }
    /* Search right from i */
    for (c=i;c<l;c++) {
            if(!a[c]) {
                    /* Shift items right until i */
                    for(;c>i;c--) a[c]=a[c-1]; 
                    return a[i]=1;
            }
    }
}