आइटम एकत्र करें और रखें

Question

इस चुनौती का लक्ष्य चयनित वस्तुओं को एक सूची में एकत्र करना और उन्हें सूची में एक निश्चित स्थान पर ले जाना है।

एक दृश्य उदाहरण के रूप में, इनपुट वैल्यूज (ब्लैक बॉक्सेड पूर्णांकों द्वारा दर्शाया गया) और सत्य मानों की एक समान सूची लें, जहाँ सत्य को दर्शाया जाता है कि आइटम का चयन किया गया है (नीले बॉक्स द्वारा दर्शाया गया है, जहां सत्य है Tऔर Fमिथ्या है):

पहला तार्किक कदम सत्य के रूप में चिह्नित वस्तुओं को अलग करना है और उनकी संबंधित सूचियों में सच्चाई नहीं है। ध्यान दें कि प्रत्येक सूची में सापेक्ष क्रम बनाए रखा जाना चाहिए (अर्थात चयनित वस्तुओं का क्रम होना चाहिए 1,4,5, और अचयनित वस्तुओं का क्रम होना चाहिए 2,3,6,7)!

दूसरे तार्किक कदम को अचयनित वस्तुओं की शेष सूची में एक सूचकांक दिया गया है, दिए गए सूचकांक में आइटम से पहले सभी चयनित आइटम डालें। इंडेक्सिंग 0 से शुरू होता है, मान लीजिए कि आप इंडेक्स 3 में चयन सम्मिलित करना चाहते हैं। यह 7बॉक्स से पहले स्पॉट से मेल खाती है , इसलिए चयनित आइटम को इससे पहले डाला जाना चाहिए 7।

अंतिम समाधान तो है 2,3,6,1,4,5,7।

ध्यान दें कि इस तार्किक आरेख में एक तरह से यह किया जा सकता है; आपके प्रोग्राम को उतने ही तार्किक कदम उठाने की आवश्यकता नहीं है, जब तक कि आउटपुट हमेशा एक ही देखने योग्य परिणाम उत्पन्न नहीं करता है।

इनपुट

आपके प्रोग्राम को 3 इनपुट दिए गए हैं:

1. आइटमों का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची। यह एक खाली सूची हो सकती है। इस सूची में हमेशा अद्वितीय सकारात्मक पूर्णांक शामिल होंगे, जरूरी नहीं कि क्रमबद्ध क्रम में (यानी 5 दो बार सूची में नहीं होंगे)।
2. वस्तुओं की सूची के समान लंबाई के साथ सत्य / मिथ्या मूल्यों की एक सूची, जहां एक सत्य मूल्य दर्शाता है कि एक ही सूचकांक में आइटम का चयन किया गया है।
3. चयन पूर्ण करने के लिए एक पूर्णांक जहां प्रतिनिधित्व होता है। आप चुन सकते हैं कि सूची के पहले आइटम का सूचकांक क्या है जब तक यह आपके प्रोग्राम के प्रत्येक रन में स्थिर है (उदाहरण के लिए पहला आइटम इंडेक्स 0 या इंडेक्स 1 हो सकता है)। कृपया निर्दिष्ट करें कि आपका कार्यक्रम किस सम्मेलन का पालन करता है। यह सूचकांक सीमा में होना चाहिए [starting_idx, ending_idx+1], अर्थात यह हमेशा एक वैध सूचकांक होगा। केस इंडेक्स के लिए ending_idx+1, चयन को सूची के अंत में डाला जाना चाहिए। आप मान सकते हैं कि यह पूर्णांक आपकी भाषा के मूल पूर्णांक प्रकार में फिट होगा।

इनपुट वांछित (stdio, फ़ंक्शन पैरामीटर, आदि) से किसी भी स्रोत से आ सकता है

उत्पादन

आउटपुट एक सूची है जो वस्तुओं के अंतिम अनुक्रम का प्रतिनिधित्व करती है। यह वांछित किसी भी स्रोत (stdio, रिटर्न वैल्यू, फंक्शन आउटपुट पैरामीटर, आदि) के लिए हो सकता है। आपको किसी भी इनपुट को जगह में बदलने की अनुमति है (उदाहरण के लिए, फ़ंक्शन पैरामीटर के रूप में संशोधित-सक्षम सूची दी गई है, और आपका फ़ंक्शन उस सूची में इन-प्लेस संचालित होता है)।

परीक्षण के मामलों

निम्नलिखित सभी परीक्षण मामले 0-आधारित अनुक्रमण को मानते हैं। मैंने चयन मास्क के लिए क्रमशः झूठी / सत्य मूल्यों को इंगित करने के लिए 0 और 1 का उपयोग किया है।

टेस्ट मामलों के रूप में सूचीबद्ध सूचियों के रूप में होता है [a,b,c], लेकिन जब तक आपकी इनपुट सूची एक परिमित क्रम अनुक्रम का प्रतिनिधित्व करती है जो ठीक है।

इनपुट:

[]
[]
0

आउटपुट:

[]

इनपुट:

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

आउटपुट:

[2,3,6,1,4,5,7]

इनपुट:

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

आउटपुट:

[1,4,5,2,3,6,7]

इनपुट:

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

आउटपुट:

[2,3,6,7,1,4,5]

इनपुट:

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

आउटपुट:

[1,2,3,4,5,6,7]

इनपुट:

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

आउटपुट:

[1,2,3,4,5,6,7]

इनपुट:

[1,3,2,5,4,6]
[1,0,0,1,1,0]
3

आउटपुट:

[3,2,6,1,5,4]

स्कोरिंग

यह कोड गोल्फ है; बाइट्स जीत में सबसे कम जवाब। मानक कमियां निषिद्ध हैं। आपको किसी भी बिल्ट-इन वांछित का उपयोग करने की अनुमति है।

Comments

क्या इनपुट और आउटपुट '' 1 2 3 "," 1 0 0 ", 1 'जैसे हो सकते हैं?

— betseg

हां, दो परिमित क्रम पूर्णांक अनुक्रमों और पूर्णांक अनुक्रमणिका का प्रतिनिधित्व करने वाली कोई भी चीज़ ठीक है।

— helloworld922

क्या पहले सरणी में नकारात्मक आइटम या शून्य होंगे?

— लीक नन

मैं नहीं कहना चाहता हूं, लेकिन मुझे इस बात पर भी संदेह है कि आपके पास कौन सा समाधान है जिसके लिए यह आवश्यक है। तो हाँ, आप मान सकते हैं कि पहली सूची में केवल धनात्मक पूर्णांक है।

— helloworld922

@PeterTaylor नहीं। मैंने इसे "सत्य / झूठे मूल्यों की एक सूची ..." पढ़ने के लिए तय किया। क्या सत्य / मिथ्या मूल्यों के "प्रकार" का वर्णन करने के लिए एक अच्छा नाम है? बूलियन की तरह?

— हेलोवर्ल्ड 922

Answer 1

MATL, 9 बाइट्स

&)i:&)bwv

यह समाधान दूसरे इनपुट के रूप में T(सत्य) और F(गलत) मूल्यों की एक सरणी को स्वीकार करता है । पहले परीक्षण के मामले में, खाली सरणियों के साथ, यह कोई आउटपुट नहीं पैदा करता है।

इसे ऑनलाइन आज़माएं! और सभी परीक्षण मामलों के लिए थोड़ा संशोधित संस्करण ।

व्याख्या

    % Implicitly grab the first two inputs
&)  % Index into the first array using the boolean, places two items on the stack:
    % 1) The values where the boolean is TRUE and 2) the values where it is FALSE.
i   % Explicitly grab the third input (N)
:   % Create an array from 1...N
&)  % Index into the FALSE group using this array as an index. Puts two items on the stack:
    % 1) The first N elements of the FALSE group and 2) other members of the FALSE group
b   % Bubble the TRUE members up to the top of the stack
w   % Flip the top two stack elements to get things in the right order
v   % Vertically concatenate all arrays on the stack
    % Implicitly display the result

Answer 2

गणितज्ञ, ६६ ६२ बाइट्स

^{@MartinEnder से 4 बाइट्स बचाए ।}

a=#2~Extract~Position[#3,#4>0]&;##&@@@Insert[##~a~0,##~a~1,#]&

अनाम फ़ंक्शन। 1-आधारित इंडेक्स, सूची और मार्कर को इनपुट के रूप में लेता है और आउटपुट के रूप में पुन: सूचीबद्ध सूची देता है।

Answer 3

हास्केल, 70 बाइट्स

m%n=[e|(e,b)<-zip m n,b]
(l#s)p|(h,t)<-splitAt p$l%(not<$>s)=h++l%s++t

प्रयोग उदाहरण: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7]।

यह काम किस प्रकार करता है:

m%n=[e|(e,b)<-zip m n,b]        -- helper function, that extracts the elements of m
                                -- with corresponding True values in n
(l#s)p                          -- l: list of values
                                   s: list of booleans
                                   p: position to insert
  |                   (not<$>s) -- negate the booleans in s
                    l%          -- extract elements of l
          splitAt p             -- split this list at index p
   (h,t)<-                      -- bind h to the part before the split
                                -- t to the part after the split
     = h++l%s++t                -- insert elements at True positions between h and t

Answer 4

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

(a,b,c)=>(d=a.filter((_,i)=>!b[i]),d.splice(c,0,...a.filter((_,i)=>b[i])),d)

Answer 5

जेली , 10 बाइट्स

¬+\>⁵Ḥ³oỤị

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

¬+\>⁵Ḥ³oỤị  Main link.
            Arguments: x (list of Booleans), y (list of inputs), z (index)
¬           Logical NOT; invert all Booleans in x.
 +\         Take the cumulative sum.
            This replaces each entry with the number of zeroes up to that entry.
   >⁵       Compare the results with z.
            This yields 0 for the first z zeroes, 1 for all others. The behavior
            for ones is not important.
    Ḥ       Unhalve; multiply the previous resulting by 2.
     ³o     Take the element-wise logical NOT of x and the previous result.
            This replaces all but the first z zeroes in x with twos.
       Ụ    Grade up; sort the indices of the result according to the corr. values.
        ị   Retrieve the items of y at those indices.

Answer 6

सी #, 132 बाइट्स

int[]r(int[]a,bool[]b,int l){var x=a.Where((i,j)=>!b[j]);return x.Take(l).Concat(a.Where((i,j)=>b[j])).Concat(x.Skip(l)).ToArray();}

ungolfed:

    public static int[] r(int[] a,bool[] b,int l)
    {
        var x = a.Where((i, j) => !b[j]);
        return x.Take(l).Concat(a.Where((i, j) => b[j])).Concat(x.Skip(l)).ToArray();
    }

सुधार विचारों की सराहना की।

Answer 7

पायथन 3, 91 बाइट्स

def f(a,x,i):b=[c for c,z in zip(a,x)if z<1];return b[:i]+[c for c in a if(c in b)<1]+b[i:]

जहां aतत्व / संख्या सूची xहै, True/Falseसूची है और iसूचकांक है।

बेहतर पठनीयता के लिए बहुस्तरीय संस्करण:

def f(a,x,i):
    b=[c for c,z in zip(a,x)if z<1]
    return b[:i]+[c for c in a if(c in b)<1]+b[i:] 

यह कैसे काम करता है?

zip(a,x)ट्यूपल्स की सूची में कॉल का परिणाम जहां उनमें से प्रत्येक में जानकारी है (element,0|1):। फिर एक सूची समझ का उपयोग उन तत्वों को निर्धारित करने के लिए किया जाता है, जिनका 0/Falseमूल्य जुड़ा हुआ है और उन्हें चर में संग्रहीत करता है b।

तो [c for c,z in zip(a,x)if z<1]एक सूची बनाता है जिसमें सभी तत्व शामिल होते हैं जिनमें 0( False) मूल्य जुड़ा होता है।

उसके बाद, तत्व है जो एक है की सूची True|1(जो की जांच करने के तत्वों द्वारा निर्धारित किया जाता मूल्य जुड़े aमें मौजूद नहीं हैं b: [c for c in a if(c in b)<1]) सभी तत्वों है कि एक के साथ इस सूची में सम्मिलित किया जाता है 0( Falseजुड़े (सूची) मूल्य bनिर्दिष्ट सूचकांक पर) iऔर परिणामी सूची वापस आ गई है।

Answer 8

पायथन 3, 106 93 बाइट्स

def f(x,y,z):
 t,f=[],[]
 for n in range(len(x)):(f,t)[y[n]].append(x[n])
 f[z:z]=t
 return f

पुराना संस्करण:

def f(x,y,z):
 t,f=[],[]
 for n in range(len(x)):
  if y[n]:t+=[x[n]]
  else:f+=[x[n]]
 f[z:z]=t
 return f