दूषित वर्ग

Question

परिचय

चलो निम्नलिखित वर्ग का निरीक्षण करते हैं, जिसमें केवल अंक होते हैं 0 - 9:

1034
4167
8414
3542

इस वर्ग का बाहरी आवरण है:

1034
4  7
8  4
3542

इसमें शून्य होता है, इसलिए हमें बाहरी आवरण को छीलने की आवश्यकता होती है , जिससे:

16
41

इस वर्ग का बाहरी आवरण है:

16
41

इसमें कोई शून्य नहीं है और इसलिए यह एक गैर-दूषित वर्ग है। तो मूल रूप से, गैर-दूषित वर्ग की परिभाषा तब होती है जब वर्ग के बाहरी आवरण में शून्य नहीं होता है ।

काम

किसी भी उचित प्रारूप में अंकों के एक वर्ग (केवल गैर-नकारात्मक पूर्णांक युक्त) को देखते हुए, किसी भी उचित प्रारूप में बाहरी शेल को लगातार छीलने से सबसे बड़ा गैर-दूषित वर्ग का उत्पादन होता है ।

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

टेस्ट केस 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

टेस्ट केस 2:

Input         Output

123           123
204           204
346           346

टेस्ट केस 3:

Input         Output

101           1
010           
101           

टेस्ट केस 4:

Input         Output

000           (none)
000
000

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

Comments

क्या मैं उदाहरण 416\n841\n354\n(नीचे-बाएँ कोने) नहीं बना सकता?

— लीक नून

ठीक है, आपने कहा " सबसे बड़ा गैर-दूषित वर्ग "

— लीक नून

क्या त्रुटि की अनुमति है?

— लीक नून

@ केनीलाऊ आप पिछले परीक्षण मामले में मतलब है? हां, जब तक यह आउटपुट 0या ऐसा कुछ नहीं करता है।

— अदनान

"संख्याओं के वर्ग" को "अंकों के वर्ग" के रूप में बेहतर कहा जाएगा

— मेगो

Answer 1

जेली , 19 16 बाइट्स

Fœ^F}P
ḊṖZµ⁺⁸ßç?

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

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

ḊṖZµ⁺⁸ßç?  Main link. Argument: M (2D list)

Ḋ          Dequeue; remove the first row.
 Ṗ         Pop; remove the last row.
  Z        Zip; transpose rows with columns.
   µ       Combine the chain to the left into a link.
    ⁺      Copy the link, executing it twice.
           The copy removes the first and last column and restores the orientation.
       ç?  If the helper link returns a non-zero integer:
     ⁸       Return M unmodified.
      ß      Else, recursively call the main link on the "peeled" M.


Fœ^F}P     Helper link. Arguments: P ("peeled" M), M (unmodified)

F          Flatten P.
   F}      Flatten M.
 œ^        Perform multiset symmetric difference, removing the elements of P from
           the elements of M, respecting multiplicities, leaving precisely the
           elements of the outer shell.
     P     Return the product of the remaining elements.

Answer 2

जावास्क्रिप्ट, 105 97 बाइट्स

@Patrick रॉबर्ट्स के लिए 8 बाइट्स का धन्यवाद!

l=a=>a.slice(1,-1)
p=a=>l(a).map(l)
c=a=>a.join``.replace(/[^0]/g,"")
s=a=>c(p(a))<c(a)?s(p(a)):a

फ़ंक्शन को परिभाषित करता है s, जो इनपुट के रूप में पूर्णांक का 2 डी सरणी प्रदान करने पर पूर्णांक का 2 डी सरणी देता है।

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

• फ़ंक्शन l: एक सरणी दी गई है a, इसकी पहली और अंतिम सूचियों के बिना एक प्रति लौटाता है।

• फ़ंक्शन p: एक 2 डी सरणी दी a, lपहली और आखिरी पंक्ति को हटाने के लिए कॉल करता है, फिर प्रत्येक शेष पंक्ति कॉल के lलिए मुट्ठी और आखिरी कॉलम को हटाता है। यह प्याज को छीलने का काम करता है।

• फ़ंक्शन c: एक 2 डी सरणी दिया जाता है a, एक स्ट्रिंग देता है जिसमें केवल 0कड़े रूप में एस होता है a।

• फ़ंक्शन s: एक 2 डी सरणी दिया , द्वारा दिए गए सरणी के छिलके के रूप में और सरणी पर ही aकॉल करता है। इन स्ट्रिंग्स की तुलना लक्सिकोग्राफिक रूप से यह निर्धारित करने के लिए करता है कि छिलके का रूप मूल से कम है या नहीं । यदि ऐसा होता है, तो मूल दूषित होता है, इसलिए छील के रूप में पुनरावर्ती कॉल करें । अन्यथा मूल वापस कर दें।cp0s

Comments

आप निकाल सकते हैं a.lengthसे endकी बहस array.sliceमें lऔर 8 बाइट्स सहेजें। endएक नकारात्मक सूचकांक होने की अनुमति है।

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

Answer 3

रेटिना , 60 57 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। अनुगामी लाइनफीड महत्वपूर्ण है।

+`(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)(^.+¶|¶.+$|.?\b.?)

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

व्याख्या

अनुगामी लाइनफीड के कारण, यह regex के सभी मिलानों को खोजता है `और इनपुट से हटा देता है। अग्रणी के कारण +यह बार-बार किया जाता है जब तक कि आउटपुट बदलना बंद नहीं हो जाता है (जो होगा क्योंकि रेगेक्स मिलान बंद कर देगा)।

रेगेक्स ही के लिए, इसमें दो भाग होते हैं:

(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)

यह हिस्सा जांचता है कि 0बाहरी शेल में कहीं है या नहीं । यह रेगेक्स इंजन के "कर्सर" को एक लुकबाइंड के साथ स्ट्रिंग की शुरुआत में ले जाकर करता है (हम [^_]अंकों और लाइनफीड दोनों का मिलान करने के लिए उपयोग करते हैं ):

(?<=...^[^_]*)

और फिर उस स्थिति से हम 0पहली पंक्ति में या तो लाइनफीड के निकट, या अंतिम पंक्ति में खोजने के लिए एक लुकहेड का उपयोग करते हैं :

(?=.*0|[^_]+(¶0|0¶|0.*$))

फिर वास्तविक मैच में पहली पंक्ति (इसकी अनुरेखण लाइनफीड सहित), अंतिम पंक्ति (इसके प्रमुख लाइनफीड सहित) या एक पंक्ति का पहला या अंतिम चरित्र शामिल होगा, जहां हम लाइन की \bशुरुआत / अंत के रूप में शब्द सीमा का दुरुपयोग करते हैं। लंगर:

(^.+¶|¶.+$|.?\b.?)

Answer 4

MATL , 26 21 बाइट्स

t"t5LY)y5LZ)h?}6Lt3$)

इनपुट निम्न प्रारूप में है

[1 0 3 4; 4 1 6 7; 8 4 1 4; 3 5 4 2]

तो अन्य चार परीक्षण मामले हैं

[1 2 3 4; 2 3 4 5; 3 4 5 6; 4 5 6 7]
[1 0 1; 0 1 0; 1 0 1]
[1 2 3; 2 0 4; 3 4 6]
[0 0 0; 0 0 0; 0 0 0]

कार्यक्रम अंतिम परीक्षण के मामले में त्रुटियों, लेकिन सही उत्पादन (जो कुछ भी नहीं है) पैदा करता है। @ ध्यान देने के लिए धन्यवाद @ डेनिस!

इसे ऑनलाइन आज़माएं! । या सभी परीक्षण मामलों को सत्यापित करें (इसमें रैपिंग कोड शामिल है)।

व्याख्या

यह इनपुट मैट्रिक्स में कॉलम की संख्या के रूप में कई बार पुनरावृत्त करता है, जो कि पर्याप्त से अधिक है। प्रत्येक पुनरावृत्ति पर, शेल को हटा दिया जाता है या इसके मूल्यों के आधार पर रखा जाता है।

t            % Take a matrix as input. Duplicate
"            % For each column (i.e. repeat that many times)
  t5LY)      %   Duplicate top of the stack. Extract first and last rows
  y5LZ)      %   Duplicate the element below the top. Extract first and last columns
  h          %   Concatenate the two arrays into a row vector
  ?          %   If all its entries are non-zero: do nothing
  }          %   Else
    6Lt3$)   %     Get the central part
             % End if, end for. Implicitly display

Answer 5

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

.W}\0.-`H`JutCPG2HJ

परीक्षण सूट

.W}\0.-`H`JutCPG2HJ
.W                     While the first function returns true, apply the second
                       function, starting with the input.
           u    2H     Apply the following twice to the input:
              PG       Remove the last row
             C         Transpose
            t          Remove the first row
                       This removes the outermost shell.
          J            Save it to J
         `             Stringify the matrix
       `H              Stringify the input
     .-                Multiset difference
  }\0                  Check if there is a '0' in the resulting string.
                  J    If that succeeds, update the current value to J.
                       When it fails, return the current value.

Answer 6

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

f=s=>/^.*0|0\n|\n0|0.*$/.test(s)?f(s.replace(/^.*\n?|.(.*).|\n.*$/g,"$1")):s

प्रत्येक पंक्ति को अलग करने वाली newlines के साथ एक स्ट्रिंग के रूप में इनपुट लेता है (लेकिन कोई अग्रणी या अनुगामी न्यूलाइन नहीं)। स्पष्टीकरण: /^.*0|0\n|\n0|0.*$/एक regexp है जो दूषित वर्गों से मेल खाता है, जबकि /^.*\n?|.(.*).|\n.*$/वर्ग के उन हिस्सों से मेल खाता है जिन्हें हटाए जाने की आवश्यकता होती है, इसके अलावा (.*)जिन्हें रखने की आवश्यकता होती है। (यह न्यूलाइन कैरेक्टर के लिए आगे या पीछे देखने से कम है।)

Answer 7

पर्ल 5, 63 + 3 = 66 बाइट्स

$_=<>;s/\A.*\n?|^.|.$|\n.*\Z//mg while/\A.*0|0$|^0|0.*\Z/;print

-0ध्वज की आवश्यकता है । इनपुट में एक अनुगामी न्यूलाइन वर्ण नहीं होना चाहिए ।

Answer 8

पाइके, 29 बाइट्स

"D3lt%sBR,"2*ER3*I
/)tOmtmOr;

यहाँ यह कोशिश करो!

इसके अलावा 29 बाइट्स

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

यहाँ यह कोशिश करो!

Comments

मुझे दोनों लिंक में त्रुटियां हैं। क्या हमें "रन" दबाने से पहले कुछ भी करने की ज़रूरत है!

— लुइस मेन्डो

मुझे शायद यह उल्लेख करना चाहिए कि भागते समय हमेशा एक त्रुटि होगी। उत्पादन दूसरी पंक्ति कहीं पर है (यह वास्तव में मुद्रित और त्रुटि संदेश का हिस्सा नहीं है)

— ब्लू

Answer 9

पायथ , 31 30 बाइट्स

L+hbeb.W!*F+1iRTs+yHyMHPtmPtdZ

परीक्षण सूट। (अंतिम परीक्षण की त्रुटियां)

सुधार: बाहरी लूप चिमटा एक समारोह ( L+hbeb) का हिस्सा बना दिया ।

पिछला 31-बाइट संस्करण:

.W!*F+1iRTs++hHm+hdedHeHPtmPtdZ

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

कोड मूल रूप से है: जबकि आउटर्सहेल का उत्पाद शून्य है, इसे छीलें।

आइए हम मुख्य कोड का विश्लेषण करें (क्यू यहाँ निहित है):

.W<lambda:H><lambda:Z>Q

Q(इनपुट) से शुरू करें , whileपहला लैम्ब्डा, दूसरा लैम्ब्डा प्रदर्शन करें।

पहला भाग लैम्ब्डा में होगा H:

!*F+1iRTs++hHm+hdedHeH

दूसरे भाग होगा लैम्ब्डा में Z:

PtmPtdZ

पहला भाग

!*F+1iRTs++hHm+hdedHeH

आइए हम इसका विश्लेषण करें:

s++hHm+hdedHeH

s++             Concatenate:
   hH              1. the first row
     m+hdedH       2. the first and last item of each row
            eH     3. the last row

चूंकि पायथ उपसर्ग संकेतन का उपयोग करता है , इसलिए इसका मूल्यांकन किया जाएगा:

!*F+1iRT

     iRT  Convert each to integer
 *F+1     Product
!         Negate. If any element of the outer shell is zero, this would return 1.

दूसरा भाग

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Answer 10

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

NestWhile[#[[a=2;;-2,a]]&,#,Count[{#[[b={1,-1}]],#[[;;,b]]},0,3]>0&]~Check~{}&

अनाम फ़ंक्शन, मैट्रिक्स के रूप में इनपुट लेता है। निष्पादन के दौरान होने वाली किसी भी त्रुटि को अनदेखा करें।