खाली जगह को खाली करके खाली जगह भरें

Question

एक फ़ंक्शन (जैसे placeAt) लिखें जो गैर-नकारात्मक पूर्णांक का एक सरणी लेता है और एक सूचकांक जो एक गैर-नकारात्मक पूर्णांक है। इसे दिए गए इंडेक्स में 1 रखना चाहिए, संभवतः उस स्पॉट को खाली करने के लिए अन्य प्रविष्टियों को एक स्थान पर शिफ्ट करना, 0 के साथ खाली स्थानों के लिए खड़ा है।

• यदि वांछित सूचकांक में प्रवेश 0 है, तो इसे 1 से भरें।
• अन्यथा, सूचकांक के बाईं ओर निकटतम 0 की तलाश करें। कमरे बनाने के लिए उस 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% यकीन है कि मैं इस चुनौती के नियमों के साथ ओपी के इरादों को समझता हूं, इसलिए मैंने पोस्ट को पुनर्गठित किया है (यह अभी कतार में है) और मैं सवालों के जवाब देने का प्रयास करूंगा। उदाहरण के लिए, अगर जरूरत हो तो आप मेरे किसी भी उत्तर को सही कर सकते हैं।

— ETHproductions

@ एक्सनोर शिफ्टिंग हमेशा राइट शिफ्टिंग को प्राथमिकता देती है। यदि कोई 0 नहीं है, तो मूल सरणी वापस करें। इसके अलावा, [2, 0, 2, 1]एक कानूनी आउटपुट नहीं है, क्योंकि आपको हमेशा यथासंभव कुछ तत्वों को स्थानांतरित करना चाहिए, और आप जो चाहें फ़ंक्शन को नाम दे सकते हैं।

— ETHproductions

Answer 1

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

किसी भी EcmaScript 6 अनुरूप ब्राउज़र पर स्निपेट का परीक्षण करना (विशेष रूप से क्रोम नहीं MSIE। मैंने फ़ायरफ़ॉक्स, सफारी 9 पर परीक्षण किया जा सकता है)।

(मैं किसी भी अन्य उत्तरों को देखे बिना ऐसा पाया, अब मैं देखता हूं कि यह रिंक के समान है। फिर भी बहुत छोटा है। संभवतः मुझे इस एक के लिए कई अपवोट नहीं मिलेंगे)

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.attenders.6

@ rink.attenders.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

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

मेरे CoffeeScript जवाब के रूप में बहुत ज्यादा एक ही दृष्टिकोण है, लेकिन मैं एक 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
}

यहाँ जेएस शॉर्ट-सर्किट मूल्यांकन पर कुछ जानकारी दी गई है।

डेमो

फिलहाल यह डेमो केवल ES6 के उपयोग के कारण फ़ायरफ़ॉक्स और एज में काम करता है:

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

यह काम आप कैसे समझा सकते हैं कृपया

— उदाहरण १५'१५ को

@eguneys स्पष्टीकरण जोड़ा गया

— rink.attenders.6

इसके लिए काम नहीं करता हैf(['a', 'b', 0, 'c', 'd', 0], 2)

— eguneys

@eguneys फिक्स्ड। मैं भूल गया कि कॉफ़ीस्क्रिप्ट अपने शॉर्टहैंड स्लाइस का उपयोग करते समय स्वचालित रूप से जोड़ता है [a..b]।

— rink.attenders.6

के लिए काम नहीं करता हैf(['a', 'b', 0, 'c', 'd', 0], 1)

— eguneys

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

PPCG में आपका स्वागत है! रूबी के लिए कुछ सरल गोल्फ युक्तियाँ: आपको किसी भी इंडेंटेशन की आवश्यकता नहीं है, ताकि आप सभी रिक्त स्थान से छुटकारा पा सकें। फिर आपको अर्धविराम की भी आवश्यकता नहीं है, क्योंकि एक ही नई पंक्ति बाइट्स की समान संख्या है। एक बयान के अंत में विधि कॉल को कोष्ठकों की आवश्यकता नहीं होती है, इसलिए आप .rindex 0हर बार एक बाइट की बचत कर सकते हैं । आप एक विधि के बजाय एक खरीद का उपयोग करके कुछ बाइट्स भी बचा सकते हैं, जिसका नाम भी नहीं है ->a,i{...}:। अगर / elsif / elsif को संभवत: नेस्टेड टर्नरी ऑपरेटर के साथ छोटा किया जा सकता है ...?...:...?...:...।

— मार्टिन एंडर

इस तरह की सलाह के लिए बहुत बहुत धन्यवाद। मैं इसे देखूंगा और देखूंगा कि मैं क्या कर सकता हूं।

— हैंडब्रेक

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।

— प्रोग्रामफॉक्स

हाय @eguneys, कि बाहर इशारा करने के लिए धन्यवाद। मैंने तर्क को संशोधित किया है और इस प्रकार आपके सभी परीक्षण मामलों के लिए काम करता है। मैंने परीक्षण मामलों की छवि भी अपडेट की है। सही ढंग से किया जाता है, हालांकि स्थानांतरण परिणाम अलग हैं।

— मेरिन नाकामरी

हाय @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;}}}

दिए गए परीक्षण मामलों को पास करता है, ए सरणी का सूचक है, एल सरणी की लंबाई है (मुझे आशा है कि यह संक्षिप्त नहीं है), मैं सम्मिलित करने के लिए सूचकांक और सी आंतरिक रूप से उपयोग किया जाता है। संभवतः छोरों के लिए बाईं और दाईं खोज के संयोजन से सुधार किया जा सकता है।

उदाहरण

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;
            }
    }
}