पृष्ठभूमि

प्रोग्रामर इन दिनों अपने बफ़र्स को सीधा रखने के लिए प्रतीत नहीं कर सकते हैं! त्रुटि का एक सामान्य स्रोत एक सरणी सूचकांक का उपयोग करने की कोशिश कर रहा है जो बफर के लिए बहुत बड़ा है। आपका कार्य एक बफर को लागू करना है जहां बड़े सूचक एक आकार में कम हो जाते हैं जो बफर को संभाल सकता है। क्योंकि मैं यह तय करता हूं कि सभी के लिए सबसे अच्छा क्या है, आप इस बफर को मेरे सटीक विनिर्देशों पर लागू करेंगे।

अवलोकन

आपके पास एक सम्मिलित-केवल बफ़र है जो आकार में बढ़ता है क्योंकि इसमें तत्व जोड़े जाते हैं। बफर शून्य अनुक्रमित, और भी अनुक्रमित है सापेक्ष अपने वर्तमान आकार। इस चुनौती के लिए विशेष नियम यह है:

इंडेक्स पर एक आइटम डालने के लिए i का अर्थ है j की गणना करना , j = i % buffer.length()और सूची में jth आइटम के बाद नया आइटम डालना ।

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

यदि बफ़र में केवल एक आइटम है, तो आप हमेशा 0 आइटम के बाद सम्मिलित कर रहे हैं । यह सामान्य मामले का सिर्फ एक उदाहरण है।

यदि बफ़र में 6 आइटम होते हैं: [4, 9, 14, 8, 5, 2]और आपको 10इंडेक्स 15 पर एक नया आइटम सम्मिलित करने के लिए कहा जाता है , तो आप पाते हैं कि 15 % 6 == 3, और फिर इंडेक्स 3 के10 बाद नया डालें जो एक परिणामी बफर देता है 8[4, 9, 14, 8, 10, 5, 2]

संकट

एक फ़ंक्शन या प्रोग्राम लिखें जो पॉजिटिव पूर्णांकों की एक आदेशित सूची में लेता है, और पॉजिटिव पूर्णांक सूचकांकों को जिस पर उन्हें सम्मिलित करना है।

एक खाली बफर के साथ शुरू करें, और संबंधित सूचकांकों को बफर में निर्दिष्ट पूर्णांक जोड़ें।

सभी निर्दिष्ट सम्मिलन के बाद बफर में हैं पूर्णांक की आदेशित सूची को आउटपुट करें।

यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है।

इनपुट दिशानिर्देश

आप इनपुट सूचियों को ले सकते हैं, हालांकि आप फिट दिखते हैं। उदाहरण:

जोड़े की सूची: [ [1,1], [2,4], [3,9], [4,16], [5,25]...]
आइटम सूची और सूची सूची: [1, 2, 3, 4, 5...], [1, 4, 9, 16, 25]
चपटा: [1, 1, 2, 4, 3, 9, 4, 16, 5, 25 ...]
आदि।

आप मान सकते हैं कि इनपुट में हमेशा कम से कम एक आइटम और संबंधित सूचकांक होता है।

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

ऊपर से वर्ग मामला:

[(1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64)] -> [1, 2, 8, 7, 6, 5, 4, 3]

मैंने इन्हें अनियमित रूप से उत्पन्न किया:

[(11, 9), (13, 14)] -> [11, 13]
[(1, 18), (11, 7), (3, 35), (16, 22)] -> [1, 11, 16, 3]
[(3, 16), (16, 37), (0, 28), (18, 24)] -> [3, 18, 0, 16]
[(7, 26), (8, 20), (11, 39), (1, 23), (17, 27)] -> [7, 8, 11, 1, 17]
[(15, 35), (17, 7), (16, 15), (1, 13), (2, 6), (11, 34)] -> [15, 17, 1, 2, 16, 11]
[(2, 13), (1, 20), (16, 25), (8, 21), (5, 2), (16, 37), (3, 0)] -> [2, 3, 8, 1, 16, 5, 16]
[(6, 20), (15, 15), (12, 26), (10, 27), (17, 13), (7, 18), (4, 16)] -> [6, 10, 17, 12, 7, 4, 15]
[(18, 9), (5, 34), (15, 4), (12, 29), (2, 5), (7, 0), (7, 10), (16, 38)] -> [18, 7, 15, 2, 16, 5, 7, 12]
[(0, 12), (12, 0), (4, 16), (15, 12), (6, 28), (8, 10), (11, 24), (0, 25)] -> [0, 11, 8, 6, 15, 0, 4, 12]
[(6, 12), (14, 13), (10, 33), (11, 35), (1, 3), (0, 28), (15, 27), (8, 10), (1, 2)] -> [6, 14, 10, 1, 11, 8, 15, 0, 1]
[(2, 29), (19, 30), (18, 17), (13, 3), (0, 21), (19, 19), (11, 13), (12, 31), (3, 25)] -> [2, 13, 3, 11, 0, 12, 19, 18, 19]

पायथन 3 संदर्भ कार्यान्वयन

def f(inputs):
    # `inputs` is a list of pairs
    buff = []
    for item, index in inputs:
        if len(buff) == 0:
            buff.insert(0, item)
        else:
            insert_after = index % len(buff)
            buff.insert(insert_after+1, item)
    return buff

code-golf

— turbulencetoo
स्रोत

क्या इनपुट को रिवर्स में लिया जा सकता है?

— 21

हाँ, मुझे लगता है कि इनपुट जितना संभव हो उतना कम या ज्यादा लचीला हो सकता है।

— turbulencetoo

4

MATL , 24 22 बाइट्स

"N?@2)yn\Q:&)@1)wv}@1)

इनपुट एक मैट्रिक्स है ( ;पंक्ति विभाजक के रूप में) जिसमें पहली पंक्ति में मान हैं और दूसरी में सूचकांक हैं।

आउटपुट एक कॉलम ऐरे है, जिसे न्यूलाइन्स द्वारा अलग किए गए नंबरों के रूप में प्रदर्शित किया जाता है।

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

व्याख्या

"          % Input matrix (implicit). For each column 
  N        %   Number of elements in the stack
  ?        %   If nonzero (true for all iterations but the first)
    @2)    %     Push second element of current column: new index
    yn     %     Duplicate current buffer; push its number of elements
    \      %     Modulo
    Q      %     Add 1
    :&)    %     Split buffer at that point. This gives two pieces, one
           %     of which may be empty
    @1)    %     Push first element of current column: new value
    wv     %     Swap; concatenate all stack. This places the new value
           %     between the two pieces of the buffer
  }        %   Else (this is executed only in the first iteration)
    @1)    %     Push first element of current column: new value
           %   End (implicit)
           % End (implicit)
           % Display (implicit)

— लुइस मेंडो
स्रोत

8

पर्ल, 37 बाइट्स

-lpझंडे के लिए कोड + 2 बाइट्स के 35 बाइट्स ।

splice@F,1+<>%(@F||1),0,$_}{$_="@F"

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

कार्यान्वयन काफी सीधे आगे है, सूचकांक spliceमें सरणी @Fमें सम्मिलित करता है 1+<>%(@F||1)(ध्यान दें कि @F||1सरणी खाली होने के मामले को संभालती है)।

बस कुछ शब्द (प्रतीत होता है) बेजोड़ ब्रेसिज़ के बारे में }{(क्योंकि मेरे पास इसके बारे में एक टिप्पणी थी, और मुझे लगता है कि यह उन लोगों के लिए काफी अजीब है जो पर्ल को नहीं जानते हैं), और यह पर्ल गोल्फिंग में एक बहुत ही सामान्य चाल है:
-pध्वज कोड को घेरता है के साथ (लगभग) while(<>){ CODE } continue { print }, ( continueप्रत्येक पुनरावृत्ति के बाद निष्पादित किया जाता है)। इसलिए उन बेजोड़ के साथ }{, मैं अपना कोड बदल देता हूं while(<>) { CODE}{ } continue { print }। तो यह मेरे कोड (लेकिन यह कोई समस्या नहीं है) के ठीक बाद एक खाली ब्लॉक बनाता है, और continueइसे केवल एक बार निष्पादित किया जाता है, while(यानी जब सभी इनपुट पढ़ा गया हो)।

— बापू
स्रोत

3

वह }{मुझे पागल कर रहा है ...

— ETHproductions

@ETHproductions मैं इसका उपयोग कर रहा हूं, लेकिन मुझे इसे अन्य लोगों को दिखाना पसंद है, वे हमेशा सोचते हैं कि कुछ गलत है! :) (नकारात्मक पक्ष यह है कि मेरे emacs इंडेंटेशन के साथ गड़बड़ है ..)

— दादा

1

यह }{मुझे इस भ्रम

— लुइस मेंडो

हाँ, मैंने किया। :-)

— डेनिस

5

ईएस 6 (जावास्क्रिप्ट), 58,57,53, 50 बाइट्स

golfed

a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b

इनपुट के रूप में सूचकांक-मूल्य जोड़े की एक सरणी लेता है।

संपादन

&&मान वापस करने के लिए उपयोग करें , -1 बाइट
हटाया |0(जैसा कि स्पष्ट रूप से ब्याह स्पष्ट रूप से NaN को अच्छी तरह से संभाल सकता है), -2 बाइट्स
नक्शे परb=[] दूसरा "तर्क" बनाया () , -2 बाइट्स (Thx @ETHproductions!)
नक्शे के साथ बदल दिया b.length () सूचकांक (i), -3 बाइट्स (Thx @Patrick रॉबर्ट्स!)

परीक्षा

F=a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b

F([[11, 9], [13, 14]])
[ 11, 13 ]

F([[2, 29], [19, 30], [18, 17], [13, 3], [0, 21], [19, 19], [11, 13], [12, 31], [3, 25]])
[ 2, 13, 3, 11, 0, 12, 19, 18, 19 ]

— टसेपेल्लिन
स्रोत

1

अच्छा, मुझे गैर-पुनरावर्ती दृष्टिकोण की कोशिश करनी चाहिए। मुझे लगता है कि आप कर सकते हैंa=>a.map(e=>...,b=[])&&b

— ETHproductions

2

आप को बदलने के द्वारा 3 बाइट्स घटा सकते e=>करने के लिए (e,i)=>और का उपयोग कर iके बजायb.length

— पैट्रिक रॉबर्ट्स

@PatrickRoberts यह एक अच्छा विचार है! धन्यवाद !

— जेपेलिन

5

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

b!(x,i)|b==[]=[x]|j<-1+i`mod`length b=take j b++x:drop j b
foldl(!)[]

इसे ऑनलाइन आज़माएं! उपयोग: foldl(!)[] [(1,5),(2,4),(3,7)]। @Nimi के लिए एक बाइट धन्यवाद!

स्पष्टीकरण:

b!(x,i)                         -- b!(x,i) inserts x into list b at position i+1
 | b==[] = [x]                  -- if b is empty return the list with element x
 | j <- 1 + i `mod` length b    -- otherwise compute the overflow-save insertion index j
     = take j b ++ x : drop j b -- and return the first j elements of b + x + the rest of b
foldl(!)[]                      -- given a list [(1,2),(3,5),...], insert each element with function ! into the initially empty buffer

मापांक की गणना के बिना समाधान: (90 बाइट्स)

f h t(x,-1)=h++x:t
f h[]p=f[]h p
f h(c:t)(x,i)=f(h++[c])t(x,i-1)
g((x,_):r)=foldl(f[])[x]r

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

— Laikoni
स्रोत

j<-1+i`mod`length bएक बाइट बचाता है।

— निमि

4

पायथन 2 , 64 62 58 56 बाइट्स

x=[]
for n,i in input():x[i%(len(x)or 1)+1:0]=n,
print x

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

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

— डेनिस
स्रोत

क्या आप (len(x)or 1)लंबाई को शुरू करने के बजाय कर सकते हैं ?

— xnor

छोटे रास्ते की तलाश है। दोनों len(x or[0])और -~len(x[1:])टाई।

— xnor

4

पायथन 2 , 62 60 बाइट्स

जोड़े की सूची के रूप में इनपुट लेता है, परिणाम प्रिंट करता है। संपादित करें: डेनिस द्वारा बहिष्कृत

b=[]
for x,y in input():b.insert(1+y%(len(b)or 1),x)
print b

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

यह काफी सरल है - इनपुट के माध्यम से लूप, वस्तुओं को सही जगह पर डालना, और फिर परिणाम प्रिंट करना। यह तय करना कि किस इंडेक्स में किसके साथ क्या करना है 1+y%(len(b)or 1)। यह or 1एक खाली सूची के किनारे मामले को संभालने के साथ मॉड्यूलर अनुक्रमण करने का मानक तरीका है ।

— FlipTack
स्रोत

3

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

f=([[q,r],...a],z=[])=>z.splice(r%z.length+1,0,q)+a?f(a,z):z

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=([[q,r],...a],z=[])=>z.splice(r%z.length+1,0,q)+a?f(a,z):z

I.textContent = I.textContent.replace(/(.+) -> (.+)/g, (_,a,b) => _ + " (" + (f(eval(a.replace(/\(/g, "[").replace(/\)/g, "]"))) + "" == eval(b) + "") + ")")

<pre id=I>[(11, 9), (13, 14)] -> [11, 13]
[(1, 18), (11, 7), (3, 35), (16, 22)] -> [1, 11, 16, 3]
[(3, 16), (16, 37), (0, 28), (18, 24)] -> [3, 18, 0, 16]
[(7, 26), (8, 20), (11, 39), (1, 23), (17, 27)] -> [7, 8, 11, 1, 17]
[(15, 35), (17, 7), (16, 15), (1, 13), (2, 6), (11, 34)] -> [15, 17, 1, 2, 16, 11]
[(2, 13), (1, 20), (16, 25), (8, 21), (5, 2), (16, 37), (3, 0)] -> [2, 3, 8, 1, 16, 5, 16]
[(6, 20), (15, 15), (12, 26), (10, 27), (17, 13), (7, 18), (4, 16)] -> [6, 10, 17, 12, 7, 4, 15]
[(18, 9), (5, 34), (15, 4), (12, 29), (2, 5), (7, 0), (7, 10), (16, 38)] -> [18, 7, 15, 2, 16, 5, 7, 12]
[(0, 12), (12, 0), (4, 16), (15, 12), (6, 28), (8, 10), (11, 24), (0, 25)] -> [0, 11, 8, 6, 15, 0, 4, 12]
[(6, 12), (14, 13), (10, 33), (11, 35), (1, 3), (0, 28), (15, 27), (8, 10), (1, 2)] -> [6, 14, 10, 1, 11, 8, 15, 0, 1]
[(2, 29), (19, 30), (18, 17), (13, 3), (0, 21), (19, 19), (11, 13), (12, 31), (3, 25)] -> [2, 13, 3, 11, 0, 12, 19, 18, 19]</pre>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

2

वी , 38 40 35 बाइट्स

यह उत्तर सूची की परिभाषा को मोड़ता है, और सामान्य रूप से आप सूची हेरफेर के लिए उपयोग की जाने वाली भाषा नहीं है, लेकिन मैं इसका उपयोग करना चाहता था [count]/{regex}जिसे मैंने हाल ही में वी में जोड़ा है। इनपुट को पसंद किया जाता है [index] [num] [index] [num] ...और पसंद किया जाता है [num] [num] [num]।

Í ¨ä«© ½/¯ÜdÜ+òhea ±^
Hdd2xdG@"
X

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

2 छिपे हुए पात्रों के लिए Hexdump:

00000000: cd20 a8e4 aba9 20bd 2faf dc64 dc2b f268  . .... ./..d.+.h
00000010: 6561 20b1 161b 5e0a 4864 6432 7864 4740  ea ...^.Hdd2xdG@
00000020: 220a 58                                  ".X

व्याख्या

dG@"सभी प्रारूपों के लिए कोड\d+ \d+ जोड़ों ताकि एक सूची 1 2 3 4 5 6 जैसे समाप्त हो जाए

a 2^[^3/\d\+
hea 4^[^5/\d\+
hea 6^[^

और फिर dG@"निम्नलिखित की तरह V कोड के रूप में उस सभी को निष्पादित करता है:

a 2^[                 | insert " 2" and return to command mode
     ^                | LOOP: go to the first number
      3/\d\+          | find the 3rd number (0 indexed)
h                     | move one character left
 e                    | go to the end of the next word
  a 4^[               | append " 4" and return to command mode
       ^5/\d\+        | basically the same as LOOP on, just with different numbers

— nmjcman101
स्रोत

सिर्फ यह कहना कि गैर-प्रतिस्पर्धा की स्थिति केवल उन भाषाओं या भाषा सुविधाओं के लिए है जो चुनौती से नई हैं

— क्रिस्ति लिथोस

आह, धन्यवाद कि तुम नहीं जानते थे। मैं इसे अनुरूप बनाता हूँ

— nmjcman101

2

PHP, 72 92 बाइट्स

for($b=[];++$i<$argc;)array_splice($b,$b?$argv[$i]%count($b)+1:0,0,$argv[++$i]);print_r($b);

कमांड लाइन तर्क से चपटा इनपुट लेता है। साथ चलाना -nr।

— टाइटस
स्रोत

मैं काफी निश्चित हूं कि यह उत्तर अमान्य है: मुझे एक मिला Fatal error: Uncaught DivisionByZeroError: Modulo by zero, निश्चित किया गया, फिर कोशिश की गई 1 1 1 2 1 3और [1=>null]आउटपुट के बजाय मिला[1,3,2]

— user59178

यह अब भी j+1डालने के बजाय ओवरराइट करता है j, नहीं? 18 1 7 11 35 3 22 16=> के [1,11,16]बजाय[1,11,16,3]

— user59178

@ user59178: ओह, मैं insertकीवर्ड से चूक गया था । धन्यवाद; तय की।

— टाइटस

2

जावा 7, 125 124 बाइट्स

import java.util.*;List z(int[]a){List r=new Stack();for(int i=0,q=a.length/2;i<q;)r.add(i<1?0:a[i+q]%i+1,a[i++]);return r;}

सूचकांक के बाद मूल्यों की एक फ्लैट सूची को स्वीकार करता है। वर्गों परीक्षण मामले के लिए इनपुट होगाnew int[] {1, 2, 3, 4, 5, 6, 7, 8, 1, 4, 9, 16, 25, 36, 49, 64}

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

— प्रहार
स्रोत

1

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

Fold[Insert[#,#2[[1]],Mod[Last@#2,Tr[1^#]]+2/.0/0->-1]&,{},#]&

पहले तर्क के साथ शुद्ध कार्य #जोड़े की सूची होने की उम्मीद है। खाली सूची से शुरू करते हुए {}, निम्नलिखित Foldसूची के #साथ इनपुट सूची को छोड़ दिया :

Insert[                                            Insert
       #,                                          into the first argument
         #2[[1]],                                  the first element of the second argument
                 Mod[                              at the position given by the modulus of
                     Last@#2,                      the second element of the second argument
                             Tr[1^#]               with respect to the length of the first argument
                                    ]+2            plus 2 (plus 1 to account for 1-indexing, plus 1 because we are inserting after that position)
                                       /.          then replace
                                         0/0       Indeterminate
                                            ->     with
                                              -1   negative 1
                                                ]& End of function

— ngenisis
स्रोत

1

पर्ल 6 , 51 बाइट्स

{my @a;.map:{splice @a,(@a??$^b%@a+1!!0),0,$^a};@a}

चपटा इनपुट लेता है।

— SMLS
स्रोत

1

क्लोजर, 87 बाइट्स

#(reduce(fn[r[v i]](let[[b e](split-at(+(mod i(max(count r)1))1)r)](concat b[v]e)))[]%)

— NikoNyrh
स्रोत

ओवरफ्लो-प्रूफ बफर

पृष्ठभूमि

अवलोकन

संकट

इनपुट दिशानिर्देश

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

पायथन 3 संदर्भ कार्यान्वयन

MATL , 24 22 बाइट्स

व्याख्या

पर्ल, 37 बाइट्स

ईएस 6 (जावास्क्रिप्ट), 58,57,53, 50 बाइट्स

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

पायथन 2 , 64 62 58 56 बाइट्स

पायथन 2 , 62 60 बाइट्स

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

टेस्ट स्निपेट

वी , 38 40 35 बाइट्स

व्याख्या

PHP, 72 92 बाइट्स

जावा 7, 125 124 बाइट्स

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

पर्ल 6 , 51 बाइट्स

क्लोजर, 87 बाइट्स