चुंबकीय मूर्तियां

Question

यह ग्राफ निर्माण पर मेरी पहले की चुनौती का एक ढीला निरंतरता है ।

पृष्ठभूमि

एक सनकी कलाकार ने आपको उसकी मूर्तियों की संरचनात्मक अखंडता का अनुमान लगाने के लिए काम पर रखा है। वह क्यूब के आकार के चुम्बकों का एक समूह बनाकर, और एक-एक करके उन्हें एक विशाल ढेर में गिराकर कला के अपने काम करता है। उनकी पद्धति का बेहतर विश्लेषण करने के लिए, हम निम्नलिखित दो-आयामी मॉडल का उपयोग करते हैं। हम एक खाली तल से शुरू करते हैं, और #किसी भी पूर्णांक के समन्वय पर एक चुंबक गिराते हैं , कहते हैं 0:

       |
       v
       #
===============
       0

यदि एक और चुंबक को गिराया जाता है 0, तो यह पिछले एक के ऊपर समाप्त होता है:

       |
       v
       #
       #
===============
       0

अब, हम एक और चुंबक को यहाँ पर छोड़ते हैं 0, और फिर एक पर 1:

        |
       #v
       ##
       #
===============
       0

जैसा कि ऊपर देखा गया है, एक गिरता हुआ चुंबक दूसरे चुंबक से चिपक जाता है, जो पहले गुजरता है (पहले वाला इसे धीमा कर देता है)। दूसरे चुंबक को सीधे पहले वाले से नीचे नहीं होना चाहिए, और दोनों तरफ एक चुंबक अभी भी एक चुंबक के रूप में गिना जाता है:

      #   #
      ##|##
      # v #
      ### #
      #   #
===============
       0

कलाकार चाहते हैं कि आप अंतिम मूर्तिकला में अधिकतम ऊर्ध्वाधर अंतर की गणना करें, अर्थात्, एक ही स्तंभ पर दो मैग्नेट के बीच की खाली जगह, या एक चुंबक और उसके नीचे की जमीन की अधिकतम संख्या। उपरोक्त तस्वीर में, यह संख्या 3 (कॉलम पर 2) होगी।

इनपुट

पूर्णांक की एक सूची, निर्देशांक का प्रतिनिधित्व करते हुए जहां कलाकार अपने मैग्नेट को छोड़ देता है, बाएं से दाएं पढ़ा जाता है। आप यह मान सकते हैं कि निर्देशांक संतुष्ट हैं -1024 <= i < 1024और सूची की लंबाई सबसे अधिक है 1024, अगर यह मदद करता है।

उत्पादन

अंतिम मूर्तिकला में अधिकतम ऊर्ध्वाधर अंतर। खाली मूर्तिकला में अंतर है -1, और इस मामले को शामिल किया जाना है, क्योंकि हमारा मूर्तिकार एक डेडिस्ट है।

अतिरिक्त नियम

आप एक समारोह या एक पूर्ण कार्यक्रम दे सकते हैं। सबसे छोटी बाइट गिनती जीतती है, और मानक खामियों को रोक दिया जाता है। स्पष्टीकरण के साथ कोड पसंद किया जाता है।

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

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

Answer 1

डायलॉग एपीएल, 73 70 वर्ण

{y←⍬⋄⌈/¯1,,¯1-2-/0,x⊢⌸{y,←⌈/(1+y/⍨0=⍵),Y⊃⍨2⊃⍒Y←1 1,∪y/⍨1=⍵}¨|x-¯1↓¨,\x←⍵}

{y←⍬⋄¯1⌈⌈/,¯1-2-/¯1,⍵⊢⌸{y,←⌈/(1+y/⍨0=⍵),⊃1↓{⍵[⍒⍵]}∪y/⍨1=⍵}¨|⍵-¯1↓¨,\⍵}

First statement:
       y←⍬  initialize semi-global variable y with an empty vector
Second statement, from right to left:
         ⍵  the vector of x coordinates
       ,\⍵  concat-scan: all prefixes of ⍵ of length 1, 2, ..., ≢⍵
   ¯1↓¨,\⍵  drop the last element of each prefix, lengths are 0, 1, ..., (≢⍵)-1
|⍵-¯1↓¨,\⍵  for each x: magnitudes of differences between x and its predecessors
 {...}¨...  execute the code in parens for each item of the argument
         ⍵  is now a single vector of differences from those described above
       1=⍵  boolean mask, where are our neighbouring xs?
    y/⍨1=⍵  select the ys corresponding to our neighbouring xs
   ∪y/⍨1=⍵  unique ys
   {⍵[⍒⍵]}  sort descending
       ⊃1↓  first of one-drop, i.e. get the second element if it exists, otherwise 0
       0=⍵  which previous xs are the same as our x?
  1+y/⍨0=⍵  select the corresponding ys and add 1 to them
        ⌈/  maximum of all the ys described so far
       y,←  append to the semi-global y
            the result from {} will be identical to y
  ⍵⊢⌸{...}  a matrix of ys, grouped in rows by x (which is now in ⍵) and zero-padded
       ¯1,  prepend ¯1 to the left of each row
       2-/  differences between consecutive horizontal elements, result is a matrix
       ¯1-  negative one minus each element of the matrix
         ,  ravel the matrix (linearize it to a vector)
        ⌈/  maximum; if the vector is empty, return ¯1.8e308, a very small number
     ¯1⌈⌈/  greater of ¯1 and the ⌈/  to avoid the very small number

Comments

नोट: यह 122 बाइट्स लंबा है (चुनौती बाइट्स में है), यूटीएफ -8 को मानते हुए।

— मटनवार्क

Codegolf.stackexchange.com/questions/42536/…

— ngn

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

— माउंटन व्यूमार्क

@MtnViewMark बाइट्स द्वारा स्कोरिंग का मतलब UTF-8 बाइट्स द्वारा स्कोरिंग नहीं है। एपीएल के लिए ऐसा करना एएससीआईआई को एक महत्वपूर्ण मानक के रूप में मान्यता देने के लिए बहुत पुराना होने के कारण इसे दंडित कर रहा है। APL का कैरेक्टर सेट सिंगल-बाइट कोडपेज के भीतर आसानी से फिट होता है और वह कोडपेज मौजूद है । इसलिए प्रत्येक कोड को एन्कोडिंग के रूप में उस कोडपेज का उपयोग करना एक बाइट है। दूसरी ओर, यदि आप हास्केल में गैर-एएससीआईआई पात्रों का उपयोग करते हैं, तो आपको एक एन्कोडिंग का उपयोग करना होगा जिसमें एएससीआईआई और गैर-एएससीआईआई दोनों अक्षर शामिल हैं - और यह आमतौर पर यूटीएफ -8 है।

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

@ngn - अब इस पर अधिकांश मेटा पोस्ट पढ़ा, लगता है कि चीजें हैं, अफसोस, अभी भी मैला है। हालांकि, शायद यह सबसे अच्छा होगा, जब बाइट्स में एपीएल को चुनौती देने के लिए बाइट्स में चुनौती दी जाती है, लेकिन कहीं-कहीं एन्कोडिंग का इस्तेमाल किया जाता है।

— मटनवार्क

Answer 2

हास्केल - 217 185 182 बाइट्स

import Data.List
r g n m|m==n=max(head(g m)+1)((reverse.(0:).nub.sort$g(m-1)++g(m+1))!!1):g m|1<3=g m
j x=(-1)-minimum(0:(map(foldl r(\_->[0])x)[-1024..1024]>>=(tail>>=zipWith(-))))

उपयोग:

j [1,2,1,2,1,2,1,2,2,2,2,1,0]

यह फ़ंक्शन किसी अन्य फ़ंक्शन का निर्माण करता है जो किसी दिए गए x-स्थिति के लिए चुंबक y-पदों की सूची देता है। इसके साथ, यह सभी x-पदों -1024 .. 1024 के अंतराल की गणना करता है और अधिकतम लेता है (संपादित करें: अब मैं न्यूनतम ले रहा हूं, क्योंकि अंतराल नकारात्मक हैं: संख्या जितनी बड़ी खाई कम है)।

Comments

चतुर दृष्टिकोण! आशा है कि आप बुरा नहीं मानेंगे कि मैं इसे थोड़ा नीचे कर दूंगा।

— मटनवार्क

@MtnViewMark: बिल्कुल नहीं। मुझे बचाने के लिए 3 और बाइट्स मिले हैं: ऐसा न flipकरें -, नकारात्मक संख्याओं के साथ जाएं और ले जाएं minimum।

— नीमी

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

— मटनवार्क

Answer 3

जावास्क्रिप्ट, 201 193

F=P=>{m=[];for(p of P){s=2;c=m[p]=m[p]||[];for(i=1e4;~i&&s;i--){if((m[p-1]||[])[i]||(m[p+1]||[])[i])s--;if(c[i-1]) s=0}c[++i]=1}g=-1;m.map(c=>{ d=0;for(i in c){g=i-d>g?i-d:g;d=++i} });return g}

एफ ([1,1,2,2,2,2,2,1]] === 2

या पठनीय संस्करण

F=P=>{
  m=[];  // magnet positions
  for(p of P){ // every dropped magnet
    s=2; // initial speed
    c=m[p]=m[p]||[]; // column where magnet is dropping
    for(i=1e4;~i&&s;i--){ // continue until at floor or zero speed
      if((m[p-1]||[])[i]||(m[p+1]||[])[i])s--;  // magnet on either side, decrease speed
      if(c[i-1]) s=0; // magnet is directly below
    }
    c[++i]=1;
  }
  g=-1; // maximum gap
  m.map(c=>{ 
          d=0;for(i in c){g=i-d>g?i-d:g;d=++i;} 
       });
  return g;
};

Answer 4

पायथन 2.7, 327

from itertools import * 
s=input()
if s:m=min(s);l=[[] for _ in range(max(s)-m+3)]
for t in s:
    i=t-m+1;r=l[i];c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:];j=len(c)-c.index(1)-1-len(r) if any(c) else 0;l[i]=r+[0]*j+[1]
print -1 if not s else max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

व्हाइट स्पेस गोल्फिंग से पहले, ऐसा दिखता है:

from itertools import * 
s=input()
if s:
    m=min(s)
    l=[[] for _ in range(max(s)-m+3)]
for t in s:
    i=t-m+1;r=l[i]
    c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:]
    j=len(c)-c.index(1)-1-len(r) if any(c) else 0
    l[i]=r+[0]*j+[1]
print -1 if not s else max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

यहाँ अधिक जटिल लाइनों की व्याख्या है, ज्यादातर मेरे अपने लाभ के लिए।

l=[[] for _ in range(max(s)-m+3)] 

यह लंबाई अधिकतम (ड्रॉप्स) -मिन (ड्रॉप्स) की खाली सूची की एक सरणी का निर्माण करता है और साथ ही दोनों ओर एक प्लेसहोल्डर है। मैं हमेशा [[]] * K को खाली सूचियों की एक सरणी बनाने के लिए लिखना चाहता हूं, लेकिन यह K बिंदुओं को एक ही खाली सूची बनाता है।

c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:] 

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

j=len(c)-c.index(1)-1-len(r) if any(c) else 0 
l[i]=r+[0]*j+[1]

पहले कॉलम i की लंबाई और दूसरे कॉलम की स्थिति के बीच अंतर की गणना करें। यदि अंतर सकारात्मक है, तो जोड़ने से पहले कॉलम 1 में कई शून्य जोड़ दें। कोई भी गैर-संख्यात्मक संख्या [0] खाली सूची है।

max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

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

Answer 5

जावा - 281 बाइट्स

बहुत सीधा।

पहले यह एक सरणी में मूर्तिकला का निर्माण करता है

तब यह सबसे बड़ा अंतर पाता है।

int a(int[]b){
        int[][]d=new int[9999][9999];
        int g,r,t,y=-1;
        for(int c:b){
            c+=5000;
            g=0;
            for(r=9998;r>=0;r--){
                if(r==0||d[c][r-1]==1){d[c][r]=1;break;}
                if((d[c-1][r]==1||d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}
            }
        }
        for(int[] k:d){
            t=0;
            for(int i:k){
                if(i==0)t++;
                else{if(t>y)y=t;t=0;}
            }
        }
        return y;
    }

छोटा -

int a(int[]b){int[][]d=new int[9999][9999];int g,r,t,y=-1;for(int c:b){c+=5000;g=0;for(r=9998;r>=0;r--){if(r==0||d[c][r-1]==1){d[c][r]=1;break;}if((d[c-1][r]==1||d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}}}for(int[] k:d){t=0;for(int i:k){if(i==0)t++;else{if(t>y)y=t;t=0;}}}return y;}

Comments

आप पहले से बदल कर एक बाइट बचा सकता है ||के साथ |। इसके अलावा, yयह मुद्रण के बजाय 9 बाइट बचाता है।

— यपनिप

@ यिप्पन, धन्यवाद! BTW, आपका पहला कथन ArrayIndexOutOfBounds अपवाद (-1) को फेंक देता है। (मेरे पास बिटकॉइन ऑपरेटरों के साथ बहुत अनुभव नहीं है)

— स्ट्रेच

यह लगभग 1.5 साल का है, लेकिन आप इसे कुछ और कर सकते हैं: ( 272 बाइट्स ) int a(int[]b){int z=9999,d[][]=new int[z][z],g,r,t,y=-1;for(int c:b){c+=z/2;g=0;for(r=z;--r>-2;){if(r==0||d[c][r-1]==1){d[c][r]=1;break;}if((d[c-1][r]==1|d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}}}for(int[]k:d){t=0;for(int i:k){if(i==0)t++;else{if(t>y)y=t;t=0;}}}return y;}:। परिवर्तनों का सारांश: z=9999जोड़ा और उपयोग किया गया है; intऔर int[][]क्षेत्र आरंभीकरण को एक में मिला दिया गया है; दूसरे ||द्वारा प्रतिस्थापित किया जाता है |; for(r=9998;r>=0;r--)बदल दिया गया हैfor(r=z;--r>-2;)

— केविन क्रूज़सेन