15

हाइड्रस को मारने में सक्षम एक कुशल योद्धा होने के बजाय ( यहां और यहां देखें ), इस बार आप एक योद्धा हैं जो जीव को मारने के लिए एक या कौन से हथियारों का उपयोग करने के लिए पूर्व ज्ञान नहीं है।

इस समस्या में, जब भी आप एक ही सिर काटते हैं, तो दो एक ही जगह बढ़ेंगे। चूंकि आपके पास एक साथ कई सिर काटने की व्यवस्था नहीं है, इसलिए सिर की संख्या केवल बढ़ेगी। इस मामले में, हमारा हाइड्रा N(एन heads 1) प्रमुखों के साथ शुरू हो सकता है । चलो पहली मुठभेड़ को एक पीढ़ी कहते हैं और हम पहली पीढ़ी से 0 के रूप में सिर का प्रतिनिधित्व करेंगे , 1 के रूप में पहला झटका के बाद बनाए गए सिर , और इसी तरह।

इनपुट

आपको एक पूर्णांक दिया जाएगा जो यह Nदर्शाता है कि शुरू में हाइड्रा के कितने सिर हैं और Nकिस सूचकांक में आकार की एक सूची है (उदाहरणों में मैं 0-अनुक्रमित प्रारूप का उपयोग करूँगा) आप एक सिर काट लेंगे। आप हमेशा मान सकते हैं कि दिए गए अनुक्रमित मान्य हैं - याद रखें कि सूची (यानी: सिर) बढ़ेगी जैसे ही आप सिर काटते हैं।

उदाहरण

इनपुट : N = 4और[0,4,2,5]

जनरेशन 0 - अटैक इंडेक्स 0

0 0 0 0     =>     1 1 0 0 0
^                  ^ ^

जनरेशन 1 - हमला सूचकांक 4

1 1 0 0 0     =>     1 1 0 0 2 2
        ^                    ^ ^

जेनरेशन 2 - अटैक इंडेक्स 2

1 1 0 0 2 2     =>     1 1 3 3 0 2 2
    ^                      ^ ^

जनरेशन 3 - हमला सूचकांक 5

1 1 3 3 0 2 2     =>     1 1 3 3 0 4 4 2
          ^                        ^ ^

अंतिम पीढ़ी

1 1 3 3 0 4 4 2

जैसा कि आप देख सकते हैं, दिए गए सूचकांक पिछली पीढ़ी की सूची से संबंधित हैं।

उत्पादन

आपको अंतिम पीढ़ी को आउटपुट करने की आवश्यकता है।

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

N = 1 and [0] => [1,1]
N = 2 and [0,0] => [2,2,1,0]
N = 2 and [0,1] => [1,2,2,0]
N = 2 and [1,0] => [2,2,1,1]
N = 2 and [1,1] => [0,2,2,1]
N = 4 and [0,4,2,5] => [1,1,3,3,0,4,4,2]
N = 6 and [0,0,0,0,0,0] => [6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0]
N = 6 and [5,6,7,8,9,10] => [0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 6]
N = 10 and [1,7,3,12,9,0,15,2,2,10] => [6, 6, 9, 9, 8, 1, 3, 3, 0, 0, 10, 10, 2, 5, 5, 0, 0, 4, 7, 7]

यह कोड-गोल्फ है तो बाइट्स जीत में सबसे कम जवाब!

code-golf

— मुझे पता नहीं है
स्रोत

सैंडबॉक्स लिंक

— आईवेवेनोइडिया

एक परीक्षण मामले की आवश्यकता है जहां सिर की प्रारंभिक संख्या कटे हुए सिर की संख्या से अधिक हो। मुझे लगता है कि मैं कम से कम एक वर्तमान उत्तर देखता हूं जो उस मामले को विफल कर देगा।

— Xcali

@ Xcali सिर काटने की संख्या वास्तव में सिर की प्रारंभिक संख्या के बराबर होने की गारंटी है: आपको एक पूर्णांक N(...) और आकार की एक सूची दी जाएगीN (लेकिन जब मैंने पहली बार पढ़ा तो मुझे वह हिस्सा याद नहीं आया। चुनौती।) इसलिए, Nबस बेकार है।

— अरनुलद

3

मैंने वास्तव Nमें इनपुट से हटाने के बारे में सोचा क्योंकि यह सरणी के आकार के रूप में दिया गया है। हालाँकि, मैंने सोचा कि समाधान बाइट्स को बचाने के Nबजाय उन पर array.size()या इसी तरह से भरोसा करेंगे ।

— इहवेनॉइडिया

1

स्टिक कॉमिक का प्रासंगिक क्रम (+ अगले एक)।

— पाओलो एबरमन

11

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

H,a=input()
H*=[0]
for i in a:H[i:i+1]=[max(H)+1]*2
print H

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

बहुत चालाक -1 xnor के लिए धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत

2

धत तेरे की। मुझे 52 सेकंड तक

— हराएं

1

@TFeld LOL आप पीढ़ी के लिए एक अतिरिक्त चर से बचने की कोशिश की! : D

— आउटगॉल्फ

9

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

n,a=input()
h=[0]*n
for c in a:h[c:c+1]=[max(h)+1]*2
print h

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

— TFeld
स्रोत

5

स्टैक्स , 12 11 बाइट्स

î╓≡╧▄#¥oWä)A

भागो और इसे staxlang.xyz पर डीबग करें!

बचत के एक बाइट के लिए पुनरावर्ती करने के लिए धन्यवाद !

अनपैक्ड (13 बाइट्स) और स्पष्टीकरण:

z),{i^c\&:fFm
z)               Push initial array of zeroes to stack
  ,              Push array of attacks to stack
   {       F     For each attack, push it and then:
    i^c\           Push [x,x], where x is the generation number
        &          Set the head at the attack index to this new array
         :f        Flatten
            m    Print the last generation

चुनौती स्पष्ट रूप से कहती है "आपको अंतिम पीढ़ी को आउटपुट करने की आवश्यकता है," इसलिए मेरा अनुमान है कि यह आम सहमति यहां नहीं है। यदि ऐसा होता है, हालांकि, दस बाइट्स को एक अन्यथा खाली स्टैक पर परिणाम छोड़कर प्रबंधित किया जा सकता है:

z),Fi^c\&:f

— खुल्द्रेसथ न’बैरी
स्रोत

1

0]*से बदला जा सकता है z)। संपादित करें: जाहिरा तौर पर यह अनैच्छिक व्यवहार है, लेकिन पैड-लेफ्ट अपने ऑपरेंड को किसी भी क्रम में लेता है। (एनपीएम लोल)

— पुनरावर्ती

1

@ अपरिचित अनैच्छिक व्यवहार व्यवहार का सबसे अच्छा प्रकार है :)

— खुल्द्रेसेथ ना'बरिया

5

हास्केल , 63 57 बाइट्स

foldl(\y(x,n)->take n y++x:x:drop(n+1)y).(0<$)<*>zip[1..]

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

— बी मेहता ने
स्रोत

takeऔर dropसे छोटे हैं splitAt। टर्निंग gएक लैम्ब्डा में एक और बाइट की बचत होती है: foldl(\y(x,n)->take n y++x:x:drop(n+1)y).(0<$)<*>zip[1..]।

— nimi

आह अच्छा - मैंने इन दोनों की कोशिश की लेकिन किसी कारण से मैंने केवल gपॉइंटफ्री बनाने का प्रयास किया , और यह सिर्फ खराब हो गया।

— बी। मेहता

4

Oracle SQL, 325 बाइट्स

select listagg(ascii(substr(l,level,1)),', ')within group(order by level)
from(select * from t
model dimension by(1 i)measures(l,r)
rules iterate(1e5)until(r[1]is null)
(l[1]=regexp_replace(l[1],'.',chr(:n-length(r[1])+1)||chr(:n-length(r[1])+1),1,ascii(substr(r[1],1,1))+1),r[1]=substr(r[1],2)))
connect by level<=length(l);

एसक्यूएल * प्लस में टेस्ट करें।

SQL> set heading off
SQL>
SQL> create table t(l varchar2(4000), r varchar2(4000));

Table created.

SQL>
SQL> var n number;
SQL> exec :n := 10;

PL/SQL procedure successfully completed.

SQL>
SQL> insert into t
  2  values(rpad(chr(0),:n,chr(0)), chr(1)||chr(7)||chr(3)||chr(12)||chr(9)||chr(0)||chr(15)||chr(2)||chr(2)||chr(10));

1 row created.

SQL>
SQL> select listagg(ascii(substr(l,level,1)),', ')within group(order by level)
  2  from(select * from t
  3  model dimension by(1 i)measures(l,r)
  4  rules iterate(1e5)until(r[1]is null)
  5  (l[1]=regexp_replace(l[1],'.',chr(:n-length(r[1])+1)||chr(:n-length(r[1])+1),1,ascii(substr(r[1],1,1))+1),r[1]=substr(r[1],2)))
  6  connect by level<=length(l);

6, 6, 9, 9, 8, 1, 3, 3, 0, 0, 10, 10, 2, 5, 5, 0, 0, 4, 7, 7

पुनश्च। 255 तक की संख्या के लिए काम करता है।

— डॉ। वाई विट
स्रोत

3

Zsh , 41 बाइट्स

हम नियमों के अनुसार , एन को नजरअंदाज करते हैं ।

for i;a+=(0)
for i;a[i]=($[++j] $j)
<<<$a

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

सुंदर मानक: शुरू करने के लिए 0s की एक सरणी बनाएं, इसे पूरा करने के लिए प्रिंट करें। a[i]=(a b)बदलने और डालने दोनों की विधि मेरे लिए नई है, खुश मुझे इसके लिए एक उपयोग मिला।

या, 41 बाइट्स :

a[#]=
for i;a[i]=($[++j] $j)
<<<${a/#%/0}

यह एक कम मानक है। हम कुछ साफ-सुथरी तरकीबों का लाभ उठाते हैं:

${a/#%/0}: यह प्रतिस्थापन है, लेकिन #और %लंगर बताने zsh आरंभ और अंत में मैच। चूंकि यह खाली है, हम सभी खाली तत्वों को 0 से बदलते हैं।
a[#]=: यह प्रभावी रूप $#से Zsh में आकार के एक खाली सरणी की घोषणा करता है । यह char *a[argc]सी में जैसा है। यदि हम ऐसा नहीं करते हैं, तो हमें उस अनुगामी शून्य की आवश्यकता नहीं होगी।

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

— GammaFunction
स्रोत

3

स्काला , 104 बाइट्स

def^(l:Seq[Int],r:Seq[Int]):Seq[Int]=if(r.size>0)^(l.patch(r(0),Seq.fill(2)(l.max+1),1),r.drop(1))else l

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

अब तक का सबसे लंबा जवाब लगता है। :)

List.fill(2)(l.max+1)के साथ प्रतिस्थापित किया जा सकता है, List(l.max+1,l.max+1)लेकिन लंबाई समान रहती है।

— डॉ। वाई विट
स्रोत

3

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

nदोनों संस्करणों में 8 बाइट्स की बचत करने वाले सरणी की लंबाई हमेशा इंगित करने के लिए @ शागी के लिए धन्यवाद

0-अनुक्रमित प्रारूप में सरणी की अपेक्षा करता है। उपेक्षा करता है n।

a=>a.map(i=>b.splice(i,1,++g,g),b=a.map(_=>g=0))&&b

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

जावास्क्रिप्ट (Node.js) , 64 56 बाइट्स

उपयोग करना reduce()और flat():

a=>a.reduce((b,i,g)=>b.flat(1,b[i]=[++g,g]),a.map(_=>0))

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

— Arnauld
स्रोत

चाहेंगे a=>a.map(i=>b.splice(i,1,++g,g),b=a.map(_=>g=0))&&bकाम करते हैं, लेने के बिना n?

— झबरा

@ शगुन उफ़। मुझे वह हिस्सा याद आ गया: और आकार की एक सूचीN । तो, हाँ, ऐसा लगता है कि nबेकार है।

— अरनौलड

2

जाप , 14 बाइट्स

rÈhY[°TT] c}Uî

कोशिश करो

— अज्ञान का अवतार
स्रोत

2

PHP , 101 बाइट्स

function h($n,$a){$h=array_fill(0,$n,0);foreach($a as$b)array_splice($h,$b,0,$h[$b]=++$x);return $h;}

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

— XMark
स्रोत

स्वागत हे! एक व्याख्या और एक ऑनलाइन दुभाषिया के लिंक को जोड़ने पर विचार करें, जैसे कि TIO । कोड-केवल उत्तर आमतौर पर स्वचालित रूप से निम्न-गुणवत्ता के रूप में चिह्नित होते हैं। विवरण के लिए मौजूदा उत्तर देखें।

— mbomb007

मैंने एक

— टीआईओ

1

पर्ल 5 `-pal` , 48 बाइट्स

@h=($i=0)x@F;splice@h,$_,1,(++$i)x2for@F;$_="@h"

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

STDIN से अंतरिक्ष-अलग सूची के रूप में सरणी लेता है। इनपुट नहीं करता है n।

— wastl
स्रोत

मामले में कोई भी सोच रहा है कि क्या इनपुट लेने की अनुमति नहीं है: कोडगुल्फ.मेटा.स्टैकएक्सचेंज.com

— questions/

1

रेटिना 0.8.2 , 69 बाइट्स

\d+
$*_
r`_\G
,0
+`^((,*)_)(_)*(.*,,(?<-3>\d+,)*)\d+
$2$4$.1,$.1
^,+

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। 1 अनुक्रमित। के रूप में इनपुट लेता है ...list,N। सूची की लंबाई की आवश्यकता नहीं है N। स्पष्टीकरण:

\d+
$*_

सभी इनपुट्स को यूनीरी में कनवर्ट करें, लेकिन उपयोग करते हुए _, ताकि यह अंक के बाद के उपयोगों के साथ भ्रमित न हो 1। (रेटिना 1 2-बाइट की बचत के लिए स्वचालित रूप से ऐसा करेगा।)

r`_\G
,0

शून्य Nकी एक सरणी के साथ बदलें N, लेकिन सूची में परिवर्तन न करें।

+`

सूची के सभी तत्वों को संसाधित करें।

^((,*)_)(_)*(.*,,(?<-3>\d+,)*)\d+

सूची में अगला तत्व और सरणी में समतुल्य स्थिति ज्ञात कीजिए। $1= वर्तमान पीढ़ी (लंबाई के रूप में), $2= पिछली पीढ़ियों से कॉमा, $3वर्तमान सूचकांक - 1, $4= पहला $3प्रमुख।

$2$4$.1,$.1

दशमलव में वर्तमान पीढ़ी की दो प्रतियों के साथ वर्तमान सूचकांक में सिर को बदलें।

— नील
स्रोत

1

पायथ , 16 बाइट्स

u.nXGH,=+Z1ZE*]0

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

दिलचस्प है, यह पता चला है कि मैं sसूची को समतल करने के लिए उपयोग नहीं कर सकता क्योंकि यह वास्तव में आशुलिपि है +F, जो +सूची के बाएं दो तत्वों पर प्रदर्शन करता है जब तक कि सभी तत्वों को संसाधित नहीं किया गया है। इसका मतलब यह है कि पहले कुछ तत्व बस अभिव्यक्त किए जा सकते हैं, यह इस बात पर निर्भर करता है कि अंतिम प्रतिस्थापन कहां हुआ था।

u.nXGH,=+Z1ZE*]0Q   Implicit: Q=input 1 (N), E=input 2 (array), Z=0
                    Trailing Q inferred
              ]0    [0]
             *  Q   Repeat Q times
u           E       Reduce E, with current value G and next value H, starting with the above:
       =+Z1           Increment Z in-place
      ,  Z Z          Pair the updated Z with itself
   XGH                In G, replace the element with index H with the above
 .n                   Flatten
                    Implicit print

— सोक
स्रोत

1

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

;`ɼṁœP@j‘ɼɗƒ@

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

मोनाडिक लिंक जो अपने तर्क के रूप में कटौती करने के लिए सिर की 1-अनुक्रमित सूची लेता है और अंतिम पीढ़ी को वापस करता है।

— निक केनेडी
स्रोत

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 94 89 85 बाइट्स

a=>b=>b.Aggregate(new int[a-(a-=a)].ToList(),(c,d)=>{c.Insert(d,c[d]=++a);return c;})

एंड्रयू बोमर को 2 बाइट्स धन्यवाद दिया

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

— अज्ञान का अवतार
स्रोत

आप पुन: उपयोग करके 2 बाइट बचा सकते हैं। a=>b=>b.Aggregate(new int[a-(a-=a)].ToList(),(c,d)=>{c[d]=++a;c.Insert(d,a);return c;})<

— एंड्रयू बॉमर

विगत 5 मिनट, derp। आप इसे यहाँ

— एंड्रयू बॉमर

@AndrewBaumher धन्यवाद

— अज्ञानता का अवतार

1

05AB1E , 10 बाइट्स

-IvN>D‚yǝ˜

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

   -             # subtract the input from itself (yields a list of 0s)
    Iv           # for each number y in the input
      N          # push the 0-based loop count
       >         # add 1 to get the generation number
        D        # duplicate
         ‚       # wrap the two copies in a list
          yǝ     # replace the element at index y with that list
            ˜    # flatten

— ग्रिमी
स्रोत

हाइड्रा पर हमला

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

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

स्टैक्स , 12 11 बाइट्स

अनपैक्ड (13 बाइट्स) और स्पष्टीकरण:

हास्केल , 63 57 बाइट्स

Oracle SQL, 325 बाइट्स

Zsh , 41 बाइट्स

स्काला , 104 बाइट्स

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

जावास्क्रिप्ट (Node.js) , 64 56 बाइट्स

जाप , 14 बाइट्स

PHP , 101 बाइट्स

पर्ल 5 -pal , 48 बाइट्स

रेटिना 0.8.2 , 69 बाइट्स

पायथ , 16 बाइट्स

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 94 89 85 बाइट्स

05AB1E , 10 बाइट्स

पर्ल 5 `-pal` , 48 बाइट्स