फ़्लोटिंग गिरोह

Question

परिचय

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

संकट

हमारे प्रलय के दिन को एक ही लाइन पर 5 पूर्णांकों द्वारा वर्णित किया जा सकता है जो द्वीप समुदायों को सहयोग करने वाले एक समूह का प्रतिनिधित्व करते हैं। उन्हें पश्चिम (सबसे बाएं पूर्णांक) से पूर्व (सबसे दाएं पूर्णांक) तक आदेश दिया जाता है।

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

दुनिया के अंत में संचालन प्रबंधक को एक कार्यक्रम की आवश्यकता होती है जो प्रत्येक गांव की अंतिम आबादी की गणना कर सके।

उदाहरण इनपुट

3 8 6 0 2

उदाहरण आउटपुट

8 1 0 1 0

मान्यताओं

• इनपुट स्टड के माध्यम से प्रदान किया जा सकता है, एक मनमाने ढंग से नामित फ़ाइल से पढ़ा जाता है, या एक तर्क के रूप में स्वीकार किया जाता है
• प्रत्येक द्वीप के लिए, 0 <= जनसंख्या <= 1024
• आबादी कभी भी एक द्वीप को नहीं छोड़ती है

सबसे छोटा जवाब जीत!

Comments

जब आप तर्क कहते हैं, तो क्या आप एक फ़ंक्शन के तर्क के रूप में या प्रोग्राम के लिए कमांड-लाइन तर्क के रूप में हैं?

— हेंसी तोहारामो

@AleksiTorhamo कमांड-लाइन arg, इसलिए यह आपके कुल की ओर नहीं गिना जाएगा।

— रेनबोल्ट

मुझे यह बहु-प्रश्न- प्रसंग प्रलयकाल की कहानी बहुत पसंद है।

— मिखाईलकाज़ी

पुन: "आबादी कभी एक द्वीप को नहीं छोड़ती" - आपका उदाहरण जनसंख्या को कई द्वीपों को एक पंक्ति में आगे बढ़ाता है। क्या कोई और अर्थ है जो मुझे याद आ रहा है?

— एलन गोल्ड

@ एलेनगॉल्ड आबादी वास्तव में कई द्वीपों में चली गई, लेकिन उन्होंने कभी एक को नहीं छोड़ा। यदि सुदूर द्वीप पर 32 लोग होते, तो वे 16, 8, 4 की तरह मर जाते, और अंत में 2 सबसे बाएं द्वीप पर पहुंच जाते।

— रेनबोल्ड

Answer 1

एपीएल, 16 अक्षर

{(1e9,4⍴2)⊤2⊥⍎⍵}

इस ब्लॉक को इनपुट स्ट्रिंग के रूप में दिया गया है:

{(1e9,4⍴2)⊤2⊥⍵} "3 8 6 0 2"
8 1 0 1 0

या इस इनपुट को इस ब्लॉक में तर्क के रूप में दिए जाने पर एक चार्ट कम:

{(1e9,4⍴2)⊤2⊥⍵} 3 8 6 0 2
8 1 0 1 0

यह इस टिप्पणी में इल्मरी करोनन के विचार पर आधारित है ।

• 2⊥⍵ इनपुट का आधार 2 रूपांतरण करता है।
• (1e9,4⍴2)⊤इस प्रकार इस संख्या को आधार 2 (चार अंतिम अंकों के लिए) और आधार 1e9 को पहले के लिए परिवर्तित करता है, जो ऊपर दी गई इनपुट श्रेणियों के लिए पर्याप्त है। ( 1e9,4⍴2सूची बनाता है 1e9 2 2 2 2।)

ध्यान दें कि इस प्रक्रिया के दौरान आधार रूपांतरण द्वारा स्वचालित रूप से पलायन पश्चिम किया जाता है।

Comments

यह जीनियस है।

— गारेथ

APLअवैध होना चाहिए ...

— कीवी

@ कीवी मुझे आपकी टिप्पणी समझ नहीं आ रही है। एपीएल को अवैध क्यों घोषित किया जाना चाहिए? अपने एपीएल समाधान को भी जमा करने के लिए स्वतंत्र महसूस करें।

— हावर्ड

@ कीवी: यह एपीएल का उपयोग करने से अधिक है ... यह समाधान के लिए एक बहुत ही चतुर दृष्टिकोण है, जो एपीएल कार्यक्रम में बहुत करीने से फिट होने के लिए होता है। यह गोल्फ क्या है!

— क्लाउडीयू

Answer 2

GolfScript, 23 22 अक्षर

~]{{.2/@+\2%}*]}4*' '*

एक पुनरावृत्त दृष्टिकोण। सरणी को कई बार पुनरावृत्त किया जाता है और हर बार कई जोड़े को दाएं से बाएं स्थानांतरित किया जाता है। ऑनलाइन उदाहरण का प्रयास करें ।

कोड की संक्षिप्त व्याख्या:

~]       # convert input to an integer
{        # loop 4 times (enough for a 5-elements input)
  {      # inject this block into the array
    .    # duplicate (l r r)
    2/   # determine surviving people (l r r%2)
    @+\  # add to the left (l+r/2 r)
    2%   # determine remaining people (l+r/2 r%2)
  }*
  ]      # make array again of the results
}4*
' '*     # format output

Comments

+1, यह मुझे मिल सकने वाली किसी भी चीज़ से छोटा है। अब, अगर यह केवल उस pesky "पश्चिमी द्वीप पर रोक" नियम के लिए नहीं थे, तो यह ~]{2base}2*' '*चाल

— चलेगा

@IlmariKaronen सही भाषा चुनें ( APL समाधान देखें ) और pesky नियम ठीक हो जाता है।

— हावर्ड

Answer 3

गोल्फस्क्रिप्ट (25 वर्ण)

~]-1%{\.1&\2/@+}*]-1%' '*

ऑनलाइन डेमो

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

Answer 4

जावास्क्रिप्ट / ईएस 6 (69)

बिटवाइज़ ऑपरेटरों के साथ खेलना:

• x&=1 सबसे कम बिट रखता है (1 यदि विषम, 0 यदि भी)
• x>>1 पूर्णांक के लिए 2 से विभाजन है

f=a=>{a=a.split(' ');for(i=5;--i;a[i]&=1)a[i-1]-=-(a[i]>>1);return a}

ES6 के बिना संस्करण:

function f(a){a=a.split(' ');for(i=5;--i;a[i]&=1)a[i-1]-=-(a[i]>>1);return a}

उदाहरण:
f("3 8 6 0 2")रिटर्न [8, 1, 0, 1, 0]
f("0 997 998 999 1000")रिटर्न[935, 0, 1, 1, 0]

Comments

पायथन के जवाबों में से एक पर रशियर की टिप्पणियां देखें; इनपुट उदाहरण में दिए गए प्रारूप के बाद एक स्ट्रिंग होना चाहिए, एक सूची नहीं।

— अलेक्सी तोराहो

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

— रेनबोल्ट

ठीक है, संपादित किया गया। क्या आउटपुट भी जुड़ना चाहिए या सरणी प्रारूप ठीक है?

— माइकल एम।

मैं अधिक-से-कम उसी के साथ आया: f=a=>{a=a.split(' ');for(x=5;--x;a[x]&=1)a[x-1]-=-a[x]/2|0;return a}जो 68 वर्णों का है।

— MT0

Answer 5

अजगर - 96 वर्ण

पहली बार गोल्फ! स्टड से इनपुट।

n=map(int,raw_input().split())
x=4
while x:n[x-1]+=n[x]/2;n[x]%=2;x-=1
print' '.join(map(str,n))

Comments

आप इसे 100 तक नीचे

— ला

@AleksiTorhamo धन्यवाद। मैंने यह भी सीखा कि अजगर के किसी भी संस्करण में पूर्णांक विभाजन के लिए मुझे केवल एक ही स्लैश की आवश्यकता होती है, इसलिए मैंने इसे 100 से नीचे खटखटाया।

— रेनबोल्ट

आह, सच! मैंने यह भी महसूस किया कि आप ' 'विभाजन से भी बाहर निकल सकते हैं , इसे नीचे ला सकते हैं और 96 python2 समाधान को हरा सकते हैं।

— अलेक्सी तोराहो

Answer 6

जे (26 अक्षर)

यहाँ J में मेरा समाधान है: ((<.@-:@}.,0:)+{.,2|}.)^:_

   islands1 =: 3 8 6 0 2
   islands2 =: 3 8 6 3 2
   ((<.@-:@}.,0:)+{.,2|}.)^:_ islands1
8 1 0 1 0
   ((<.@-:@}.,0:)+{.,2|}.)^:_ islands2
9 0 0 0 0

यह सामान्य समाधान किसी भी संख्या में द्वीपों के साथ काम करना चाहिए।

Answer 7

माणिक, 97 90 74 72

ऑनलाइन संस्करण

इसे थोड़ा और आगे बढ़ाया, अब और नहीं उलटा ...

f=->i{i=i.split.map(&:to_i);(1..4).each{|n|i[-n-1]+=i[-n]/2;i[-n]%=2};i}

Comments

बंटवारे से पहले लेकिन बाद में आपको स्ट्रिंग को उल्टा नहीं करना चाहिए। अन्यथा आपके समाधान इनपुट में बहु अंकों की संख्या के लिए गलत परिणाम प्राप्त कर सकते हैं।

— हावर्ड

मैंने भी दोनों "संभावनाओं" पर विचार किया - यद्यपि एक से अधिक अंकों के साथ संख्याओं के बारे में पता नहीं है ...: D धन्यवाद!

— डेविड हेरमैन

Answer 8

C - 121 वर्ण

इनपुट स्टड से लिया गया है।

a[5];main(i){b(i=0,0);while(i++<5)printf("%i ",a[i-1]);}b(i,j){scanf("%i",&i);return j<5?i+=
b(i,j+1)/2,a[j]=j?i&1:i,i:0;}

Comments

क्या यह हार्ड-कोड केवल 5 द्वीपों के लिए है?

— जोबिट्स

Answer 9

पायथन 2 - 98 वर्ण

स्टड से इनपुट।

s=[0]
for v in raw_input().split()[::-1]:s=[int(v)+s[0]/2,s[0]%2]+s[1:4]
print' '.join(map(str,s))

पायथन 3 - 79 वर्ण

स्टड से इनपुट।

s=[0]
for v in input().split()[::-1]:s=[int(v)+s[0]//2,s[0]%2]+s[1:4]
print(*s)

Answer 10

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

b=1
for x in raw_input().split():b=2*b+int(x)
print b/16-2,' '.join(bin(b)[-4:])

किसी भी द्वीप पर शुरू होने वाले X लोग X * 2 के बराबर हैं जो एक द्वीप को दाईं ओर शुरू करते हैं। यह कोड प्रारंभिक कॉन्फ़िगरेशन में सभी को दूर-सही-द्वीपों में अपने समकक्ष में परिवर्तित करता है, फिर परिणाम का द्विआधारी प्रतिनिधित्व का उपयोग करता है यह निर्धारित करने के लिए कि प्रत्येक द्वीप पर कितने लोग समाप्त होते हैं।

EDIT: कोड bको 0 के बजाय 1 से प्रारंभ करके छोटा कर दिया , जिससे binएक प्रारूप स्ट्रिंग के बजाय उपयोग की अनुमति दी गई ।

Comments

बाइनरी प्रतिनिधित्व का उपयोग करना सरल है! Lettercount.com ने आपको 85 दिए। क्या आपने ओवरकाउंट किया, या लेटरकाउंट का उपयोग करने के लिए एक बुरा उपकरण है?

— रेनबोलेट

@Rusher: मेरा टूल CRLF लाइन एंडिंग्स का उपयोग कर रहा था। यूनिक्स लाइन के अंत के साथ इसे

— गिनते हुए

Answer 11

पायथन (101)

l=map(int,raw_input().split())
for i in range(4):l[3-i]+=l[4-i]/2;l[4-i]%=2
print' '.join(map(str,l))

हम सूची में पीछे से सामने की ओर लूप करते हैं और स्पेसिफिकेशन के अनुसार आबादी को घुमाते हैं, फिर सूची को प्रिंट करते हैं। यहाँ एक त्वरित परीक्षण है:

>>> l=map(int,raw_input().split())
3 8 6 0 2
>>> for i in range(4):l[3-i]+=l[4-i]/2;l[4-i]%=2
... 
>>> print' '.join(map(str,l))
8 1 0 1 0

Comments

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

— रेनबोल्ड

@Rusher I ने प्रश्न में उपयोग किए गए सटीक प्रारूप के साथ काम करने का उत्तर अपडेट किया।

— अर्शजी

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

— रेनबोल्ट

Answer 12

गणितज्ञ १०५

यह किसी भी संख्या में द्वीपों के साथ काम करना चाहिए।

f[w_,n_:1]:=
If[n==Length@w,w,
f[w~ReplacePart~{-n-> Mod[z=w[[-n]],2],-(n+1)->(w[[-(n+1)]]+ z~Quotient~2)},n+1]]

उदाहरण

5 द्वीप

f[{3, 8, 6, 0, 2}]

{8, 1, 0, 1, 0}

---

25 द्वीप

f[{145, 144, 144, 59, 35, 129, 109, 99, 200, 24, 219, 96, 12, 121, 75,20, 153, 124, 131, 178, 228, 120, 63, 207, 228}]

{270, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }

Comments

मेरा समाधान 270, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0आपके लंबे परीक्षण डेटा के लिए पैदा करता है । मुझे लगता है कि मैंने पुष्टि की है कि मैं सही हूं।

— OldCurmudgeon

अजीब, यह देखते हुए कि यह कैसे काम करता है। मैं कल मामले पर एक नज़र डालूंगा।

— डेविड मार्क

Answer 13

जावा - 647 533 लेकिन जावा 8 स्ट्रीम के लिए कुछ ब्राउनी पॉइंट की उम्मीद करना।

class I{int p;I e;I(int p,I e){this.p=p;this.e=e;}void x(){if(e!=null){int r=p&1;e.p+=(p-r)/2;p=r;}}public String toString(){return ""+p;}}Deque<I>B(String d){H<I>e=new H<>();return Arrays.stream(d.split(" ")).map(s->Integer.valueOf(s)).map(p->e.hold(new I(p,e.held()))).collect(Collectors.toCollection(LinkedList::new));}void x(Deque<I>is){is.descendingIterator().forEachRemaining((I i)->{i.x();});}void t(String s){Deque<I> a=B(s);x(a);System.out.println(a);}class H<T>{T h=null;H(){}T hold(T t){return (h=t);}T held(){return h;}}

असम्बद्ध रूप:

private static class Island {
  int population;
  final Island eastwardIsland;

  Island(int population, Island eastwardIsland) {
    this.population = population;
    this.eastwardIsland = eastwardIsland;
  }

  private void exodus() {
    if (eastwardIsland != null) {
      // How many remain.
      int remain = population & 1;
      // How many leave.
      int leave = population - remain;
      // Account for 50% death rate.
      int arrive = leave / 2;
      // Modify the eastward island population.
      eastwardIsland.population += arrive;
      // Change my population.
      population = remain;
    }
  }

  @Override
  public String toString() {
    return String.valueOf(population);
  }

}

private Deque<Island> buildIslands(String data) {
  // Holds the island to the east as we traverse.
  final Holder<Island> eastward = new Holder<>();
  // Build my list of islands - assumes order is retained.
  return Arrays.stream(data.split(" "))
          // Convert to int.
          .map(s -> Integer.valueOf(s))
          // Build the island in a chain.
          .map(p -> eastward.hold(new Island(p, eastward.held())))
          // Roll them into a linked list.
          .collect(Collectors.toCollection(LinkedList::new));
}

private void exodus(Deque<Island> islands) {
  // Walk backwards.
  islands.descendingIterator()
          // Perform all exodus.
          .forEachRemaining((Island i) -> {
            i.exodus();
          });
}

private void test(String data) {
  Deque<Island> archipelago = buildIslands(data);
  // Initiate the exodus.
  exodus(archipelago);
  // Print them.
  System.out.println(archipelago);
}

की सहायता से:

// Mutable final.
private static class Holder<T> {
  private T held = null;

  public Holder() {
  }

  public Holder(T it) {
    held = it;
  }

  public T hold(T it) {
    return (held = it);
  }

  public T held() {
    return held;
  }

  @Override
  public String toString() {
    return held == null ? "null" : held.toString();
  }

}

थोड़ा चिंतित है कि @ डेविडक्रैहर का परीक्षण:

145 144 144 59 35 129 109 99 200 24 219 96 12 121 7520 153 124 131 178 228 120 63 207 228

उत्पन्न करता है

270, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0

Answer 14

जावा - 196 195

मैंने खुद से कहा कि मैं इसे पोस्ट नहीं करूंगा अगर मैं इसे 200 से कम नहीं कर सका ... मुझे ईमानदारी से नहीं लगता कि मैं किसी और चीज से छुटकारा पा सकता हूं, यह जावा के लिए बहुत पतला है।

class H{public static void main(String[]a){int l=a.length,p[]=new int[l],i=l;for(;i-->0;){p[i]=Integer.valueOf(a[i]);if(l-i>1){p[i]+=p[i+1]/2;p[i+1]%=2;}}for(;++i<l;System.out.print(p[i]+" "));}}

कतार टूट जाती है:

class H{
    public static void main(String[]a){
        int l=a.length,p[]=new int[l],i=l;
        for(;i-->0;){
            p[i]=Integer.valueOf(a[i]);
            if(l-i>1){
                p[i]+=p[i+1]/2;
                p[i+1]%=2;
            }
        }
        for(;++i<l;System.out.print(p[i]+" "));
    }
}

नमूना इनपुट आउटपुट:

$ java H 3 8 6 0 2
8 1 0 1 0

$ java H 0 1 2 3 4 5 6 7 8 9 10
1 1 1 1 1 1 1 0 1 0 0

$java H 235 897 158 693
809 1 0 1

Answer 15

जावा - 179 अक्षर

दबा हुआ:

class F{public static void main(String[] a){int l=0,x,s,i=a.length-1;String z="";for(;0<=i;i--){x=Integer.valueOf(a[i])+l;s=i>0?x%2:x;l=(x-x%2)/2;z=s+" "+z;}System.out.print(z);}}

सामान्य:

public class FloatingHorde {

    public static void main(String[] a) {
        int leave = 0;
        String outputStr = "";
        for (int i = a.length - 1; 0 <= i ; i--) {
            int x = Integer.valueOf(a[i]) + leave;
            int stays = i > 0 ? x % 2 : x;
            leave = (x - x % 2) / 2;
            outputStr = stays + " " + outputStr;
        }
        System.out.print(outputStr);
    }
}

नमूना उत्पादन:

$ java F 3 8 6 0 2
8 1 0 1 0

$ java F 7 6 5 4 3
11 1 1 1 1

Answer 16

Emacs Lisp 144 chars

छोटा नहीं है, लेकिन यह काम करता है

(lambda (d)
   (setq x d)(while(cdr x)
           (setcar(cdr x)(+(/(-(car x)(%(car x)2))2)(cadr x)))
           (setcar x (-(car x)(*(/(car x)2)2)))
       (pop x))
   (reverse d))

Comments

आप एक हेडर जोड़ सकते हैं जैसे #Java - 123 कैरेक्टर

— रेनबोलेट

Answer 17

awk - 44 वर्ण

{for(i=NF;i>1;){n=int($i/2);$i%=2;$--i+=n}}1

Answer 18

जावा - ११६ वर्ण

उदाहरण के लिए int[] i = {2, 33, 16, 5};(मुझे लगता है कि वे संख्या में नहीं जोड़ते हैं, क्योंकि प्रत्येक संख्या भिन्न हो सकती है) आउटपुट होगा23 0 0 1

for(int j = i.length-1; j > 0; j--) {       
    while(i[j] > 1) {
        i[j] -= 2;
        i[j-1]++;
    }       
}
for(int j = 0; j < i.length; j++) {     
    System.out.print(i[j] + " ");
}

Comments

क्या आप एक संकलक प्रदान कर सकते हैं जो इस कोड को चलाएगा? साथ ही, इनपुट के लिए प्रारूप और संभावित स्रोतों को प्रश्न में प्रदान किया गया था। जावा सरणी में इनपुट को ढालना आपको दूसरों पर अनुचित लाभ देता है।

— रेनबोल्ट