नॉनवेज और उनके पड़ोसियों को रखें

Question

स्टैक ओवरफ्लो में इस सवाल से लिया गया । कुछ कोने के मामलों को संबोधित करने वाले परीक्षण इनपुट का सुझाव देने के लिए @ मीलों और @ दादा का भी धन्यवाद।

चुनौती

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

समान रूप से, एक प्रविष्टि या तो रखी जानी चाहिए अगर यह एक नॉनज़ेरो है या यदि यह एक शून्य है जो तुरंत नॉनज़ेरो मान के करीब है।

जो प्रविष्टियाँ रखी गई हैं उन्हें आउटपुट में बनाए रखना चाहिए जो इनपुट में है।

उदाहरण

दिया हुआ

[2 0 4 -3 0 0 0 3 0 0 2 0 0]

उन मानों को हटाया जाना चाहिए जिन्हें एक के साथ चिह्नित किया गया है x:

[2 0 4 -3 0 x 0 3 0 0 2 0 x]

और इसलिए आउटपुट होना चाहिए

[2 0 4 -3 0 0 3 0 0 2 0]

नियम

इनपुट ऐरे खाली हो सकता है (और फिर आउटपुट भी खाली होना चाहिए)।

इनपुट और आउटपुट प्रारूप हमेशा की तरह लचीले होते हैं: सरणी, सूची, स्ट्रिंग, या कुछ भी जो उचित है।

कोड गोल्फ, सबसे कम।

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

[2 0 4 -3 0 0 0 3 0 0 2 0 0] -> [2 0 4 -3 0 0 3 0 0 2 0]
[] -> []
[1] -> [1]
[4 3 8 5 -6] -> [4 3 8 5 -6]
[4 3 8 0 5 -6] -> [4 3 8 0 5 -6]
[0] -> []
[0 0] -> []
[0 0 0 0] -> []
[0 0 0 8 0 1 0 0] -> [0 8 0 1 0]
[-5 0 5] -> [-5 0 5]
[50 0] -> [50 0]

Comments

क्या मैं _2इसके बजाय उपयोग कर सकता हूं -2? काफी कुछ भाषाएँ उस प्रारूप का उपयोग करती हैं।

— लीक नून

क्या हमारे पास होगा -0?

— लीक

@LeakyNun 1 हां 2 नहीं

— लुइस

क्या कभी संख्या में अग्रणी शून्य होंगे? पसंद है [010 0 0 01 1]?

— फ्राइअमईएग्गमैन

@FryAmTheEggman नोप

— लुइस

Answer 1

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

a=>a.filter((e,i)=>e|a[i-1]|a[i+1])

दो अतिरिक्त बाइट्स के लिए भी फ़्लोट पर काम करता है।

Answer 2

पायथन, 50 बाइट्स

f=lambda l,*p:l and l[:any(l[:2]+p)]+f(l[1:],l[0])

एक पुनरावर्ती कार्य जो एक नलिका लेता है। यदि पहले दो तत्वों या पिछली बार से संग्रहीत पिछले मूल्य के बीच एक नॉनज़ेरो मान है, तो पहला तत्व शामिल है। फिर, पहले तत्व को हटाता है और पुनरावृत्ति करता है। पिछला तत्व सिंगलटन-सूची में संग्रहीत है p, जो स्वचालित रूप से सूची में पैक होता है और खाली के रूप में शुरू होता है (डेनिस के साथ 3 बाइट्स के लिए धन्यवाद)।

---

55 बाइट्स:

lambda l:[t[1]for t in zip([0]+l,l,l[1:]+[0])if any(t)]

सूची के सभी लंबाई -3 हिस्सा बनाता है, पहले शुरू और अंत पर शून्य डालते हैं, और उन सभी के मिडिल्स तत्व लेते हैं जो सभी शून्य नहीं हैं।

एक पुनरावृत्त दृष्टिकोण लंबा हो गया (58 बाइट्स)

a=0;b,*l=input()
for x in l+[0]:a|b|x and print(b);a,b=b,x

यह ठीक से काम नहीं करता है क्योंकि b,*lअजगर 3 की जरूरत है, लेकिन पायथन 3 inputएक स्ट्रिंग देता है। इनिशियलाइज़ेशन भी बदसूरत है। शायद एक समान पुनरावर्ती दृष्टिकोण काम करेगा।

दुर्भाग्य से, की अनुक्रमण विधि

lambda l:[x for i,x in enumerate(l)if any(l[i-1:i+2])]

काम नहीं करता है क्योंकि सूची के अंत के रूप में l[-1:2]व्याख्या -1करता है, इसकी शुरुआत से पहले एक बिंदु नहीं।

Answer 3

हास्केल, 55 48 बाइट्स

h x=[b|a:b:c:_<-scanr(:)[0]$0:x,any(/=0)[a,b,c]]

प्रयोग उदाहरण: h [0,0,0,8,0,1,0,0]-> [0,8,0,1,0]।

scanrशुरू और अंत में xएक अतिरिक्त के साथ इनपुट सूची का पुनर्निर्माण करता है 0। प्रत्येक चरण में हम 3 तत्वों से मेल खाते हैं और मध्य को एक रखते हैं यदि कम से कम एक गैर-शून्य तत्व हो।

धन्यवाद स्विच करके 7 बाइट्स के लिए @xnor zip3लिए scanr।

Comments

यह करना अच्छा होगा h x=[snd t|t<-zip3(0:x)x$tail x++[0],(0,0,0)/=t], लेकिन मुझे लगता है कि वास्तव में 3-ट्यूपल का दूसरा तत्व प्राप्त करने का कोई छोटा रास्ता नहीं है।

— xnor

A : a की scanतुलना में त्रिगुणों को प्राप्त करने के लिए छोटा हो जाता है । zip3h x=[b|a:b:c:_<-scanr(:)[0]$0:x,any(/=0)[a,b,c]]

— xnor

Answer 4

मतलाब, 29 27 बाइट्स

इनपुट में एक 1*nमैट्रिक्स शामिल होना चाहिए (जहां n=0संभव है)। (यह 0*0मैट्रिस के लिए एक त्रुटि फेंक देगा ।)

@(a)a(conv(a.*a,1:3,'s')>0) 

बातचीत सफलता की कुंजी है।

Comments

's'के बजाय 'same'<-: - डी

— लुइस मेंडो

यह चाल

— बिल्डिंस

मैंने उस ट्रिक को देखा है, यहां तक ​​कि गैर-गोल्फिंग प्रश्नों के लिए, ध्वज के साथ 'UniformOutpout'(स्पष्ट रूप से)। लेकिन मैं इस बारे में नहीं जानता था

— लुइस मेंडो

के ~~aबजाय आप का उपयोग कर सकते हैं a.*a?

— feersum

@ Faersum Matlab दुर्भाग्य से logicalसरणियों को मना कर दिया । यह अक्सर अंतर्निर्मित अंतर्वस्तु के लिए एक समस्या है जो कि मटलब में ही नहीं लिखी गई है। अन्यथा तार्किक सरणियाँ बहुत संख्यावानों की तरह व्यवहार करती हैं। यह ऑक्टेव सोचा में काम कर सकते हैं, लेकिन मैं इसे इस समय स्थापित नहीं है।

— दोष

Answer 5

जे, 17 14 बाइट्स

#~0<3+/\0,~0,|

@ ज़गर्ब की मदद से 3 बाइट्स बचाए।

प्रयोग

   f =: #~0<3+/\0,~0,|
   f 2 0 4 _3 0 0 0 3 0 0 2 0 0
2 0 4 _3 0 0 3 0 0 2 0
   f ''

   f 0 0 0 8 0 1 0 0
0 8 0 1 0

व्याख्या

#~0<3+/\0,~0,|  Input: array A
             |  Get the absolute value of each in A
           0,   Prepend a 0
        0,~     Append a 0
    3  \        For each subarray of size 3, left to right
     +/           Reduce it using addition to find the sum
  0<            Test if each sum is greater than one
                (Converts positive values to one with zero remaining zero)
#~              Select the values from A using the previous as a mask and return

इसे यहाँ आज़माएँ।

Comments

के 0<स्थान पर काम करेगा 0~:?

— जर्गर्ब

@ ज़र्ब 3 आकार के इन्फिक्स संसाधित होने के बाद या तो सकारात्मक या नकारात्मक हो सकते हैं।

— मील

अह, मैं नकारात्मक मूल्यों के बारे में भूल गया।

— जर्गर्ब

Answer 6

MATL , 8 बाइट्स

tg3:Z+g)

आउटपुट एक स्ट्रिंग है जिसमें रिक्त स्थान द्वारा अलग किए गए नंबर होते हैं। आउटपुट पर एक खाली सरणी को कुछ भी नहीं (यहां तक ​​कि एक नई पंक्ति नहीं) के रूप में प्रदर्शित किया जाता है।

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

व्याख्या

कोड इनपुट को तार्किक प्रकार में परिवर्तित करता है, अर्थात नॉनज़ेरो प्रविष्टियाँ बन जाती हैं true(या 1) और शून्य प्रविष्टियाँ बन जाती हैं false(या 0)। यह तब कर्नेल के साथ सजाया जाता है [1 2 3]। एक नॉनज़ेरो वैल्यू उस स्थिति में और उसके पड़ोसी पदों पर नॉनज़रो परिणाम का कारण बनता है। तार्किक में परिवर्तित करने से trueउन मानों को प्राप्त होता है जिन्हें रखा जाना चाहिए, इसलिए उस इनपुट को अनुक्रमणित करना जिससे वांछित उत्पादन होता है।

t    % Input array implicitly. Duplicate
g    % Convert to logical: nonzero becomes true, zero becomes false
3:   % Push array [1 2 3]
Z+   % Convolution, keeping size of first input
g    % Convert to logical
)    % Index into original array. Implicitly display

Answer 7

जोल्फ, 14 बाइट्स

अब जब मुझे लगता है कि, जोल्फ गोल्फ की भाषाओं का जावा है। sighs इसे यहाँ आज़माएँ।

ψxd||H.nwS.nhS

व्याख्या

ψxd||H.nwS.nhS
ψxd             filter input over this function
   ||           or with three args
     H           the element
      .nwS       the previous element
          .nhS   or the next element

Answer 8

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

lambda s:[t[1]for t in zip([0]+s,s,s[1:]+[0])if any(t)]

Comments

वाह। मुझे नहीं पता कि आपने इससे पहले @xnor उत्तर देखा था, लेकिन आपके पास एक ही कोड है, जिसमें एकमात्र अंतर लैम्ब्डा का नाम है। यदि आपने उसके कोड का उपयोग किया है, तो उसे श्रेय दें, यदि नहीं, तो क्या संयोग है!

— थियो

किसी के कोड को नहीं देखा।

— रूटट्वो

@ टी.लुकिन यह वास्तव में एक ही कोड के साथ आने के लिए असामान्य नहीं है। आप इस अराजकता गोल्फ, जहां कोड की समय सीमा तक छिपा हुआ है पर होने देख सकते हैं, और कई लोगों की तरह ही समाधान पर अभिसरण इस एक ।

— xnor

Answer 9

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

0,0jo3\Tị

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

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

0,0jo3\Tị  Main link. Argument: A (array)

0,0        Yield [0, 0].
   j       Join, separating with A. This prepends and appends a 0 to A.
    o3\    Reduce each group of three adjacent integers by logical OR.
       T   Truth; get the indices of all truthy results.
        ị  At-index; retrieve the elements of A at those indices.

Answer 10

पर्ल, 34 + 1 ( -pध्वज) = 35 बाइट्स

s/([^1-9]0 |^)\K0 ?(?=0|$)//&&redo

जरूरत -p झंडा चलाने के लिए। संख्या की एक सूची के रूप में लेता है। उदाहरण के लिए :

perl -pe 's/([^1-9]0 |^)\K0 ?(?=0|$)//&&redo' <<< "0 0 0 8 0 1 0 0
0 0 0
-5 0 5"

Comments

मैं 5अगर मैं इनपुट 50 0।

— feersum

@ फॉर्सम तय, धन्यवाद

— दादा

Answer 11

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

p%(h:t)=[h|any(/=0)$p:h:take 1t]++h%t
p%e=e
(0%)

पिछले तत्व को देखता है p, पहला तत्व h, और उसके बाद का तत्व (यदि कोई हो), और यदि कोई गैर-शून्य हो, तो पहले तत्व को प्रस्तुत करता है h।

हालत any(/=0)$p:h:take 1tलंबी है, विशेष रूप से take 1t। मैं इसे छोटा करने का तरीका खोजूंगा, शायद पैटर्न मिलान के द्वारा।

Answer 12

रेटिना , 42 35 33 बाइट्स

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

(<? ^ =। \ b0) 0 (? = $ | 0)

 +

^ | $

अंतिम पंक्ति आवश्यक है।

एक बार में सभी टेस्टकेस का सत्यापन करें। (सभी टेस्टकेस को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

ऐसा करने के लिए एकदम सही भाषा लगती है ... फिर भी अधिकांश उत्तरों से हार मिली।

Comments

मैं सिर्फ I / O फॉर्मेट से कोष्ठक खोदूंगा।

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

Answer 13

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

ArrayFilter[If[#.#>0,#[[2]],Nothing]&,#,1]&

Answer 14

सी, 96 बाइट्स

f()पूर्णांक की सूची के लिए एक सूचक के साथ कॉल करें , और सूची के आकार के लिए एक सूचक। सूची और आकार को संशोधित किया गया है।

i,t,e,m;f(int*p,int*n){int*s=p;for(i=m=e=0;i++<*n;s+=t=m+*s||i<*n&&p[1],e+=t,m=*p++)*s=*p;*n=e;}

इसे आइडोन पर आज़माएं ।

Comments

K & R पैरामीटर शैली अक्सर छोटी होती है, लेकिन यहां नहीं - f(int*p,int*n)एक बाइट बचाता है। या sएक 3 पैरामीटर के रूप में परिभाषित करें (यह पारित नहीं है। यह ठीक है)।

— ugoren

Answer 15

ब्रेकीलॉग , 44 38 बाइट्स

,0gL:?:Lc:1fzbh.
~c[A:.:B],[0:0:0]'.l3

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

यह भाषा चीजों को साबित करने के रूप में अच्छी है, जो कि हम उपयोग करेंगे।

विधेय 0 (मुख्य विधेय)

,0gL:?:Lc:1fzbh.
 0gL               [0] = L    (assignment works both ways)
   L:?:Lc          [L:input:L] = temp
         :1f       find all solutions of predicate 1 with temp as input
            zbh.   then transpose and take the middle row and assign to output

1 समर्पित करें (सहायक विधेय)

~c[A:.:B],[0:0:0]'.l3
~c[A:.:B]                 input is in the form of [A:output:B]
         ,                and
          [0:0:0]'.       output is not [0:0:0]
                  .l3     and length of output is 3

Answer 16

इमेज प्रोसेसिंग टूलबॉक्स के साथ मतलाब, 27 बाइट्स

@(a)a(~imerode(~a,~~(1:3)))

यह एक अनाम फ़ंक्शन है।

उदाहरण का उपयोग करें:

>> @(a)a(~imerode(~a,~~(1:3)))
ans = 
    @(a)a(~imerode(~a,~~(1:3)))
>> ans([0 0 0 8 0 1 0 0])
ans =
     0     8     0     1     0

Comments

मैंने imerodeभी सोचा था , लेकिन मेरे संस्करण मेरे वर्तमान से अधिक लंबे समय तक बने रहे, अच्छा काम =)

— त्रुटी

Answer 17

बाश + GNU बर्तन, 25

grep -vC1 ^0|grep -v \\-$

इनपुट को न्यूलाइन-सेपरेटेड लिस्ट के रूप में स्वीकार करता है।

Ideone - परीक्षण ड्राइवर कोड के साथ / अलग-अलग और newline- अलग / से परिवर्तित करके सभी टेस्टकेस को एक साथ चलाने के लिए जोड़ा गया।

Answer 18

चेडर , 78 बाइट्स

a->([[]]+a.map((e,i)->e|(i?a[i-1]:0)|(i-a.len+1?a[i+1]:0)?[e]:[])).reduce((+))

परीक्षण सूट।

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

उदाहरण के लिए, [0,0,0,8,0,1,0,0]बन जाता है [[],[],[0],[8],[0],[1],[0],[]], और तब संक्षिप्त सरणी होगी [0,8,0,1,0]।

Comments

.reduce((+))->.sum

— डाउनग्वेट

@Downgoat आपने उसे कब ठीक किया?

— लीकी नून

ओह, माफ करना, कोई बात नहीं। मुझे लगा कि आप सरणी को समेट रहे हैं। सरणियों में शामिल नहीं हो रहा है

— डाउन एंजेट

Answer 19

एपीएल, 14 बाइट्स

{⍵/⍨×3∨/0,⍵,0}

परीक्षा:

      {⍵/⍨×3∨/0,⍵,0}2 0 4 ¯3 0 0 0 3 0 0 2 0 0
2 0 4 ¯3 0 0 3 0 0 2 0

स्पष्टीकरण:

• 0,⍵,0: add की शुरुआत और अंत में एक शून्य जोड़ें
• ×3∨/: तीन समीपवर्ती संख्याओं के प्रत्येक समूह के GCD का चिन्ह ज्ञात करें (यह 0 होगा यदि वे सभी शून्य और 1 अन्यथा हैं)।
• ⍵/⍨: ⍵ से सभी आइटम का चयन करें जिसके लिए परिणाम 1 था।

Answer 20

रूबी 2.x, 63 बाइट्स

f=->(x){x.select.with_index{|y,i|x[i-1].to_i|y|x[i+1].to_i!=0}}

क्रेडिट जहां यह कारण है, यह अनिवार्य रूप से नील के बेहतर ईएस 6 उत्तर का एक बंदरगाह है।

यह मेरा पहला पीसीजी सबमिशन भी है। वाह।

Answer 21

ब्रेन-फ्लैक 142 बाइट्स

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

(<()>)(()){{}([]<([]){{}({}<>)<>({}<>)<>({}<>)<>(<>({}<>)<>({}<>)<>({})<>){{}((<()>))}{}{}([][()])}{}{}<>{}([]){{}({}<>)<>([])}{}<>>[[]])}{}{}

व्याख्या

(<()>)                    #Pad the top with an extra zero
(()){{}([]<...>[[]])}{}   #Until the stack height remains the same
 ([]){{}...([][()])}{}    #Until the stack height is one
  ({}<>)<>                #Move the top three to the other stack
  ({}<>)<>
  ({}<>)<>
  (...)                   #Push the sum of the top three
   <>({}<>)               #Move the second and third back
   <>({}<>)
   <>({})<>               #Leave the top of the stack
  {{}...}{}               #If the sum is not zero
   ((<()>))               #Add a buffer to the top of the stack
  {}                      #Pop the buffer/middle value
 {}                       #Remove extra zero
 <>                       #Switch to the off stack
 {}                       #Remove extra zero
 ([]){{}({}<>)<>([])}{}<> #Move the entire off stack back

Comments

लिंक खाली है। आप कोड और इनपुट पेस्ट कर सकते हैं, "सेव" दबा सकते हैं और परिणामी लिंक का उपयोग कर सकते हैं

— लुइस मेंडो

@LuisMendo दुर्भाग्य से मैं ट्रायिटोनलाइन का उपयोग नहीं कर सकता, इसलिए मैं सिर्फ यूआरएल से जुड़ा हुआ हूं।

— गेहूं जादूगर

आप ट्राइटनलाइन क्यों नहीं पहुँच सकते?

— DJMcMayhem

@DJMcMayhem मेरे ब्राउज़र में जावास्क्रिप्ट नहीं था। <s> मैं अब इसे ठीक करूंगा। </ s> मैं देख रहा हूं कि आप पहले ही ऐसा कर चुके हैं कि धन्यवाद।

— गेहूं जादूगर