ऊर्ध्वाधर स्लाइस का निर्धारण

Question

एक छवि को देखते हुए, आउटपुट [एक पूर्ण ऊर्ध्वाधर अनुभाग के पिक्सल में चौड़ाई] ¹ (यदि कोई मौजूद है)। यदि कोई ऊर्ध्वाधर खंड मौजूद नहीं है, तो आउटपुट 0।

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

^{1. सन्निहित की संख्या, सभी सफेद कॉलम}

---

आप ऐसा मान सकते हैं

• कोई छवि 1000 वर्ग पिक्सेल से बड़ी नहीं होगी

• प्रति चित्र में एक से अधिक पूर्ण ऊर्ध्वाधर खंड नहीं होंगे

---

उदाहरण

इनपुट:

आउटपुट:

50
57
0
0

यहां पहले दो उदाहरण दिए गए हैं, (पीले रंग में) अपने वर्गों को दिखाने के लिए:

Comments

क्या बीच में काले रंग के द्वीप हो सकते हैं ताकि कई ऊर्ध्वाधर खंड हों?

— xnor

@xnor: प्रति चित्र पर केवल एक पूर्ण लंबवत खंड होगा। मैं इसे कल्पना में जोड़ दूंगा।

— ज़च गेट्स

मेरा कोड पहले परीक्षण मामले के लिए 50 आउटपुट कर रहा है, लेकिन अंतिम 3 के लिए सही संख्या, कॉलम 233 से 282 (= 50 पिक्सल) तक ऊर्ध्वाधर स्लाइस के साथ। क्या आप पुष्टि कर सकते हैं कि 48 सही संख्या है?

— डेविड

@ डेविड: मुझे कॉलम 232 से 282 (विशेष) में सही स्लाइस दिखाई देता है। मेरा मानना ​​है कि आप सही हैं।

— ज़च गेट्स

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

— 2

Answer 1

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

PS

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

अगर मैं एक छवि को इनकोड करता हूं:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

इस तरह एक नेस्टेड सरणी में:

[[0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0],...]

फिर Pसभी पंक्ति वैक्टर के तत्व-वार उत्पाद को लेता है, और Sपरिणाम में सभी को समेटता है, ऊर्ध्वाधर स्लाइस की लंबाई को बढ़ाता है। (यह केवल इसलिए काम करता है क्योंकि इसमें केवल एक सन्निहित टुकड़ा होने की गारंटी है।) हमारे मामले में, इसका उत्तर है 3।

Comments

ಠ_ಠ गोल्फ का यह स्तर मुझे चकित करता है।

— Addison Crump

जब कोई सन्निहित स्लाइस नहीं है, तो इसके लिए आउटपुट क्या है? (वैध इनपुट)

— Addison Crump

psMATL में भी काम करता है!

— डेविड

फिर सभी 1s का कोई कॉलम नहीं होगा , जिसका अर्थ Pहोगा कि [0,0,0...0], Sउम्म की 0उम्मीद के अनुसार परिणाम होगा ।

— लिन

@ डेविड इसे पोस्ट करें? आप की आवश्यकता हो सकती Xpsहै, हालांकि, अगर छवि एक ही पंक्ति हो सकता है (या कम से कम आकार हो, तो ओपी पूछना)

— लुइस Mendo

Answer 2

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

+/×⌿

Try it here.

यह मेरा पहला APL उत्तर है!

बाइट्स बचाने के लिए @ jimmy23013 और @NBZ को धन्यवाद!

Comments

यह कोई फ़ंक्शन नहीं है। (+/×/⍉)काम नहीं करता है।

— jimmy23013

लेकिन आप उपयोग कर सकते हैं (+/×⌿)और यह 1 बाइट छोटा है।

— jimmy23013

कोष्ठकों को हटाकर एक और 2 बाइट्स सहेजें। अन्य एपीएल उत्तरों के बहुत से बस एक अनाम फ़ंक्शन ट्रेन है जिसे नाम दिया जाना चाहिए या इसका उपयोग किया जाना चाहिए:+/×⌿ f←+/×⌿ f picture

— Adám

Answer 3

बैश + आम उपयोगिताओं, 17

rs -Tc|grep -vc 0

यदि आप छवि-प्रसंस्करण केgrep लिए उपयोग नहीं कर रहे हैं , तो आप इसे गलत कर रहे हैं ;-)।

यह rsट्रांसपोज़ेशन करने के लिए उपयोगिता का उपयोग करता है। rsहै OSX में बंडल , लेकिन की तरह कुछ के साथ सबसे अधिक लिनक्स में स्थापना की आवश्यकता होगी sudo apt-get install rs।

इनपुट कॉलम TABअलग किए जाते हैं, और पंक्तियों को अलग किया जाता है:

0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0   
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   1   0   0   0   
0   0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0   
0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0   0   
0   0   0   1   1   1   1   1   1   1   1   1   1   1   1   1   1   0   0   
0   0   0   0   0   0   1   1   1   1   1   1   0   0   0   0   0   0   0   
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   0   0   0   0   
0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0

यदि आप चाहें, तो आप इस प्रारूप में इमेजमागिक और (GNU) सेड के साथ उदाहरण इनपुट इमेज को प्रीप्रोसेस कर सकते हैं। उदाहरण के लिए:

$ for img in "AmXiR.jpg" "vb2Yt.jpg" "1V7QD.jpg" "MqcDJ.jpg" ; do
>     convert -depth 1 "$img" xpm:- | \
>     sed -nr '/pixels/{:l;n;/}/q;s/^"(.*)",?$/\1/;y/ ./01/;s/./&\t/g;p;bl}' | \
>     rs -Tc|grep -vc 0
> done
50
57
0
0
$

Answer 4

पर्ल, 21 22 बाइट्स

निश्चित संस्करण

के लिए +2 शामिल है -lp( -lछोड़ा जा सकता है और अभी भी एक वैध समाधान होगा, लेकिन यह अंतिम नई पंक्ति के बिना बदसूरत है)

STDIN पर 1 या 0 के 0 या अधिक लाइनों के अनुक्रम दें। जब तक आप उपयोग कर सकते हैं, तब तक आप रिक्त स्थान या अल्पविराम या अंकों के बीच जो भी उपयोग कर सकते हैं जोड़ सकते हैं।

$a|=~$_}{$_=$a=~y;\xce;

यह दिखाया गया है, लेकिन \xceदावा किए गए स्कोर को प्राप्त करने के लिए शाब्दिक बाइट मान द्वारा प्रतिस्थापित किया जाता है

यदि कई ऊर्ध्वाधर खंड हैं, तो यह सभी खंड चौड़ाई का योग देता है। आप की चौड़ाई चाहते हैं एक ऊर्ध्वाधर खंड उपयोग

$a|=~$_}{$a=~/\xce+/;$_="@+"-"@-"

पुराना संस्करण

मैंने मूल रूप से चुनौती को गलत समझा और एक कार्यक्रम लागू किया, जो कि यदि एक खड़ी रेखा मौजूद है, तो यह सच या गलत है। यहाँ कोड और स्पष्टीकरण इस पुराने संस्करण के लिए हैं

$a|=~$_}{$_|=~$a=~1

अगर केवल मैं लगभग सही समरूपता के लिए बाईं ओर 1 = ~ जोड़ सकता था ... मुझे लगता है कि निकटतम होगा

1=>$a|=~$_}{$_|=~$a=~1

व्याख्या

$a|=~$_     The bitwise operators in perl (&, |, ^, ~) also work on strings by 
            working on the sequence of byte values. The digits "0" and "1" happen
            to have the same ASCII value differing only in the last bit which is
            0 for "0" and 1 for "1". So I would really like to do an "&" here.
            Unfortunately "&" of two different length strings shortens the result
            to the shortest of the strings and my accumulator starts as an empty 
            string. The "|" of two strings however extends to the longest string.
            So instead I will apply De Morgan's law and use "|" on the
            complemented byte string 
}{          Standard perl golf trick. "-p code" transforms to (simplified)
            "while (<>) { code; print }". So if code is "code1 } { code2" this
            becomes "while (<>) { code1 } {code2; print }". So you can use code1
            for the loop operation, use code2 for the final calculation and get a
            free print by assigning to $_
$_|=~$a=~1  I would like to match the accumulator with the bit complement of "1",
            but $a=~~1 doesn't work because the 1 is not a string but a number.
            $a=~~"1" would work but is too long. Next up is complementing $a back
            and matching with 1, so $_=~$a=~1. That also doesn't work since the
            first =~ will be interpreted as a string match insteads of equals
            followed by complement. Easily solved by writing it as $_= ~a=~1. But
            if I am going to give up a byte I can at least have some fun with it.
            Using $_|= also makes the parse work and has the advantage that the
            failure case will give 0 instead of an empty string, which looks
            nicer. It also makes the code look very symmetric. I can also bring
            out the symmetry more by putting 1=> in front (which evaluates 1
            before the assignment and then immediately discards it)

Answer 5

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

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

lambda c:sum(map(all,zip(*c)))

@Lynn से परीक्षण छवि का उपयोग करना:

>>> image = [[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]]
>>> func = lambda c:sum(map(all,zip(*c)))
>>> func(image)
3

Answer 6

अजगर, ५

s*VFQ

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

यह लिन के एल्गोरिथ्म का उपयोग करता है, लेकिन मैंने इसे केवल पोस्ट करने का फैसला किया है कि कैसे पायथ में गोल्फ वेक्टर ऑपरेशन को दिखाया जाए। यहाँ चाल "चीनी" सिंटैक्स हेल्पर्स को चेन करना है Vऔर Fताकि वेक्टर ऑपरेशन के रूप में गुना लागू हो। मुड़ा हुआ ऑपरेटर निश्चित रूप से गुणा का होता है, और फिर अंतिम उत्तर प्राप्त करने के लिए परिणाम को अभिव्यक्त किया जाता है।

Answer 7

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

a=>a[s=0].map((_,i)=>s+=a.every(b=>b[i]))|s
a=>a[s=0].map((_,i)=>s+=!a.some(b=>b[i]))|s

@ लिन के जेली जवाब पर आधारित है, हालांकि का उपयोग करके everyया के someबजाय गोल्फ से reduce। पहला संस्करण काले = 0 को एन्कोड करता है जबकि दूसरा काला = 1 को एन्कोड करता है।

संपादित करें: @ edc65 के लिए 2 और बाइट्स सहेजे गए।

Comments

उपयोग करने की कोशिश करेंmap

— कैलक्यूलेटर

यह मेरी गिनती में 45 है। और आपने पर्याप्त प्रयास नहीं किया क्योंकि यह 43 हो सकता है।

— edc65

a => [a = s = 0] .map ((_, i) => s + =! a.some (b => b [i]) | s

— edc65

@ edc65 ठीक है, आप जानते हैं कि कंप्यूटिंग की दो कठिन समस्याएं कैश अमान्य हैं, नामकरण और एक-एक करके त्रुटियां ...

— नील

Answer 8

जे , 5 6 बाइट्स

बूलियन मैट्रिक्स को तर्क के रूप में लेता है।

[:+/*/

यह मेरा पहला J उत्तर है! (1 was वर्षों के लिए गलत था ...)

*/ स्तंभ उत्पाद

+/ योग

[: टोपी (प्लेसहोल्डर के रूप में कार्य करता है क्योंकि +/बाएं तर्क नहीं लेना चाहिए)

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

Answer 9

सीजेएम, 7 बाइट्स

q~:.*:+

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

q~      e# read input and evaluate: push nested array
:.*     e# fold vectorized product over nested array: element-wise product of rows
:+      e# fold addition over array: compute its sum

Answer 10

गणितज्ञ २४

Length@Cases[Total@#,0]&

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

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

और इस मामले में आउटपुट:

1

Comments

या Length[Total@#~Cases~0]&फिर एक ही बाइट काउंट

— कैलकुलेटर

1 और 0 मैथेमेटिका में सत्य या मिथ्या नहीं हैं (और यदि वे असाइनमेंट होते तो शायद दूसरा रास्ता होता)।

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

Answer 11

S, 7 चार्ट / 9 बाइट्स

⨭МƟïⓜ⨴$

Try it here (Firefox only).

यह @ लिन का महान एल्गोरिथ्म है, लेकिन मैंने इसे स्वतंत्र रूप से पाया। (मुझे लगा कि इसके लिए कहीं एक बिल्डिन था, फिर भी देख रहा था: P)

व्याख्या

МƟïइनपुट सरणी को स्थानांतरित ⓜ⨴$करता है , प्रत्येक आंतरिक वेक्टर को अपने उत्पाद में बदल देता है, और ⨭परिणामी सरणी को भेजता है।

Answer 12

जाप , 6 4 बाइट्स

1सफेद 0होने और काले होने के साथ, एक पंक्ति के रूप में इनपुट लेता है ।

y xe

• 2 बाइट्स ETH की बदौलत बच गए ।

झसे आज़माओ

---

व्याख्या

y xe
          :Implicit input of array U.
y         :Transpose.
   e      :Map over each sub-array, checking if every element is truthy.
  x       :Reduce by summing, converting booleans to 1 or 0.
          :Implicit output of resulting integer.

Comments

मुझे लगता है कि आप y x_×5 के लिए कर सकते हैं । वास्तव में, के eरूप में अच्छी तरह से काम करता है ×, इसलिए y xe4 :-)

— ETHproductions

उस सप्ताह के अंत में टिप्पणी याद आती है, @ETHproductions - धन्यवाद :)

— झबरा