क्या यह तार वर्ग है?

44

निम्न स्थितियों को पूरा करने पर एक स्ट्रिंग को वर्ग माना जाता है:

  • प्रत्येक पंक्ति में समान वर्ण होते हैं
  • प्रत्येक पंक्ति पर वर्णों की संख्या पंक्तियों की संख्या के बराबर होती है।

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो यह निर्धारित करता है कि दिया गया इनपुट स्ट्रिंग एक वर्ग है या नहीं।

आपको एलएफ, सीआर या सीआरएलएफ की अपनी पसंद से इनपुट की आवश्यकता हो सकती है।

न्यूलाइन वर्ण (ओं) को रेखा की लंबाई का हिस्सा नहीं माना जाता है।

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

इनपुट एक स्ट्रिंग या 1 डी चार सरणी है; यह तार की सूची नहीं है।

आप मान सकते हैं कि इनपुट गैर-रिक्त है और केवल रिक्त स्थान सहित ASCII शामिल हैं।

आपको वर्ग स्ट्रिंग्स के लिए एक सत्य मान और अन्य स्ट्रिंग्स के लिए एक मिथ्या एक आउटपुट करना होगा।

सत्य परीक्षण के मामले:

foo
बार
baz

।

.s।
.ss
.s।
(s अंतरिक्ष का प्रतिनिधित्व करता है)

एस एस
एस एस
(s अंतरिक्ष का प्रतिनिधित्व करता है)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

झूठे परीक्षण के मामले:

..
।

।


।

....


....

4444
333
22

333
333

abc.def.ghi

कुछ झूठे मामलों में अतिरिक्त खाली लाइनों पर ध्यान दें।

यह कोड-गोल्फ है - सबसे कम बाइट्स जीतता है!

code-golf  string  ascii-art  decision-problem 
— पावेल
स्रोत
भाषा डिजाइन की संभावित डुप्लिकेट : 2-डी पैटर्न मिलान । समस्या # 5 इस प्रश्न के समान है।
— mbomb007
1
@ mbomb007 मुझे लगता है कि अलग-अलग जीत मानदंड इसे डुप्लिकेट नहीं बनाते हैं? "गोल्फनेस" मतदान के मानदंडों में से एक था, लेकिन मुझे नहीं लगता कि इस सवाल का जवाब यहां के लोगों पर काफी हद तक दिखाई देगा।
— FryAmTheEggman
2
@ mbomb007 मैं इस प्रश्न को खुला छोड़ने के लिए मतदान कर रहा हूं क्योंकि यह अन्य प्रश्न का सबसेट है, अन्य प्रश्न विशेष रूप से उस प्रश्न के लिए बनाई गई भाषाओं तक ही सीमित है।
— ETHproductions
2
@ mbomb007: यह कोई डुप्लिकेट नहीं है, क्योंकि यह प्रश्न आपको मौजूदा भाषा में उत्तर देने के बजाय, प्रश्न का उत्तर देने के उद्देश्य से एक भाषा डिजाइन करने के लिए कहता है। यहां बहुत कम उत्तर कानूनी होंगे।
1
@ mbomb007: इस चुनौती को बंद करने का कोई कारण नहीं है , और लोगों को पहले से मौजूद भाषाओं में अपने उत्तर पोस्ट करने के लिए कहीं नहीं दिया गया है। यह संभवतः अन्य चुनौती को बंद करने के लिए एक तर्क हो सकता है (क्योंकि यह इस एक का केवल एक अधिक प्रतिबंधात्मक संस्करण है), हालांकि मैं इसे एक खराब तर्क मानता हूं और मानता हूं कि दोनों को खुला छोड़ दिया जाना चाहिए।

जवाबों:

19

ब्रेकीलॉग (2), 3 बाइट्स

ṇẹṁ

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

पूरा कार्यक्रम। सच्चाई के true.लिए आउटपुट , false.फाल्सी के लिए।

व्याख्या

ṇẹṁ
ṇ     Split {standard input} into lines
 ẹ    Split {each line} into basic elements {in this case, characters}
  ṁ   Assert that the result is square

ṁजब इसे जोड़ा गया था तो मैं बिलिन की उपयोगिता के बारे में थोड़ा उलझन में था, लेकिन मैं वास्तव में इस बात से इनकार नहीं कर सकता कि यह यहाँ उपयोगी है ...

ब्रेकीलॉग (2), 7 बाइट्स

ṇẹ.\l~l

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

गैर-निर्मित समाधान। फिर भी सभी अन्य प्रविष्टियों को धड़कता है, जैसा कि लेखन के समय। संपादित करें: काफी नहीं, जब मैं यह लिख रहा था, तब बराबर-लंबाई वाली जेली प्रविष्टि मिली और टाइमस्टैम्प टाईब्रेक के माध्यम से इसे हराया।

व्याख्या

ṇẹ.\l~l
ṇ         Split {standard input} into lines
 ẹ        Split {each line} into basic elements {in this case, characters}
   \l     Assert that the result is rectangular, and the number of columns
  .  ~l     is equal to the number of rows
1
नौकरी के लिए सही उपकरण!
— पावेल
10
ṁ= "परिणाम चौक है":
— बाहर निकोल
5
थोड़ी देर पहले एक चुनौती थी कि मैं एक मुखर-वर्ग लिखने के लिए संघर्ष कर रहा था (यह .\l~lउस समय कुछ ऐसा था, सिवाय इसके कि बैकस्लैश कमांड, जो अन्य बातों के अलावा यह कहता है कि इसका इनपुट आयताकार है , टूट गया था; ध्यान दें कि भले ही हम इसके ṁसाथ बदलें .\l~l, यह अभी भी यहां सबसे छोटा कार्यक्रम है; यह सोचने के लिए, मैं इसे पोस्ट में जोड़ दूंगा)। बैकस्लैश कमांड निश्चित हो गई, लेकिन भाषा लेखक ने एक ही समय में एक जोर-वर्ग जोड़ने का फैसला किया। मैं सोच रहा था "निश्चित रूप से वह फिर कभी नहीं आने वाला है"। जाहिरा तौर पर मैं गलत था।
2
@Phoenix: भाषा का संस्करण संख्या, यह Brachylog v1 में काम नहीं करेगा। ज्यादातर लोग सिर्फ "ब्रिचलॉग" कहते हैं (जैसे कि ज्यादातर लोग "पर्ल 5" के बजाय "पर्ल" कहते हैं), लेकिन मैं थोड़ी देर पहले आदत में पड़ गया क्योंकि मैं दुर्लभ अवसरों पर ब्रैकलॉग v1 का उपयोग करता हूं।
2
@iFreilicht यह बुरा है क्योंकि यह अब तक की हर दूसरी गोल्फिंग भाषा को प्रभावित करता है।
— निकोल आउटफर गोल्फ
21

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

x=input().split('\n')
print{len(x)}==set(map(len,x))

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

— छड़ी
स्रोत
4
मुझे इस तथ्य से प्यार है कि यह गोल्फ और पठनीय दोनों है।
— jpmc26
आपको इसकी आवश्यकता नहीं है '\n', बस इसे खाली छोड़ दें (क्योंकि इनपुट में कोई स्थान और टैब नहीं हैं)।
— 12431234123412341234123
@ 12431234123412341234123 नहीं, यह वर्ग स्ट्रिंग्स के लिए काम नहीं करता है जिसमें रिक्त स्थान हैं !!!
— श्री एक्सकोडर
@ Mr.Xcoder रिक्त स्थान के साथ काम करना चाहिए? जैसा कि मैंने समझा कि इनपुट में कभी रिक्त स्थान नहीं हैं।
— 12431234123412341234123
आप चश्मे को गलत समझते हैं: आप मान सकते हैं कि इनपुट गैर-रिक्त है और केवल मुद्रण योग्य ASCII शामिल है। , और
— व्हॉट्सएप
14

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

s=>!(s=s.split`
`).some(x=>x.length-s.length)
  • 1 बाइट ने ETHproductions को धन्यवाद दिया

व्याख्या

  1. स्ट्रिंग को न्यूलाइन्स पर एक ऐरे में विभाजित करें।
  2. सरणी पर लूप।
  3. प्रत्येक पंक्ति की लंबाई से सरणी की लंबाई घटाएं।
  4. यदि किसी भी रेखा के लिए एक गैर-शून्य (यानी, सत्य) मान लौटाया जाता है, तो स्ट्रिंग वर्गाकार नहीं होती है।
  5. trueस्क्वायर और falseनहीं के लिए प्राप्त करने के लिए लूप के परिणाम को नापें ।

कोशिश करो

f=
s=>!(s=s.split`
`).some(x=>x.length-s.length)
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value=`foo
bar
baz`)
<textarea id=i></textarea><pre id=o>
स्निपेट का विस्तार करें

— झबरा
स्रोत
3
मुझे लगता है कि आप एक बाइट को बचा सकते हैंs=>!(s=s.split`\n`).some(x=>x.length-s.length)
— ETHproductions
धन्यवाद, @ETHproductions मुझे !someहाथ से बाहर निकलने की एक भयानक आदत है , सिर्फ इसलिए कि यह लंबाई के समान है every।
— शैगी
9

05AB1E , 10 8 बाइट्स

¶¡€gDgQP

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

-2 रिले के लिए धन्यवाद, यह मूल रूप से उसका जवाब है ।_

Code       # Explanation                  | Truthy Example          | Falsy Example
-----------#------------------------------+-------------------------+--------------
¶¡         # Split on newlines            | [['aaa','aaa','aaa']]   | [['aa']]
  €g       # Get length of each           | [[3,3,3]]               | [[2]]
    D      # Dupe                         | [[3,3,3],[3,3,3]]       | [[2],[2]]
     g     # Get length                   | [[3,3,3],3]             | [[2],1]
      Q    # Check equality               | [[1,1,1]]               | [[0]]
       P   # Take product                 | 1                       | 0
— जादू ऑक्टोपस Urn
स्रोत
@ रिले आह, अच्छा कैच, मेरा मूल विचार आपके पास जो कुछ था लेकिन थोड़ा अलग था उसकी तर्ज पर अधिक था। दो और बार Iterated किया और मेरी गणित त्रुटि को नहीं पकड़ा।
— मैजिक ऑक्टोपस Urn
मुझे नहीं लगता कि "हेडर" इनपुट पर एक वैध रूप है।
— पावेल
@Phoenix क्या यह बेहतर है?
— मैजिक ऑक्टोपस Urn
1
इनपुट को इस तरह से तीन उद्धरणों के साथ लिया जा सकता है ।
— अदनान
1
यदि आपको प्रत्येक की लंबाई मिलती है तो आप इससे बच सकते हैं s। इस तरह¶¡€gDgQP
— रिले
9

हास्केल, 38 34 बाइट्स

l=length
(all=<<(.l).(==).l).lines

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

पॉइंटफ्री संस्करण f s = all ((==length (lines s)).length) (lines s), अर्थात इनपुट को लाइनों में विभाजित करें और जांचें कि क्या प्रत्येक पंक्ति की लंबाई लाइनों की संख्या के बराबर है।

संपादित करें: 4 बाइट्स के लिए @xnor को धन्यवाद।

— nimi
स्रोत
1
मुझे लगता है कि आप कटौती करने के allलिए उपयोग कर सकते हैं । mapand.
— 20
9

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

ỴµL;L€E

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

व्याख्या

Ỵµ       Split the input on newline and use as input in the second link     
  L      Get the number of list items
   ;     And append to that
    L€   A list with the legth of each list item
      E  Check to see if all items are equal.
— steenbergh
स्रोत
1
आपका TIO लिंक इंगित करता है कि कोई अनुगामी न्यूलाइन नहीं होनी चाहिए।
— पावेल
@Phoenix फिक्स्ड / रिवर्टेड ...
— steenbergh
यह सिर्फ यह देखने के लिए जांचता है कि क्या सभी लाइनें समान लंबाई की हैं - यह वास्तव में न्यूलाइन गणना को बिल्कुल भी ध्यान में नहीं रखता है। जब आप ई परमाणु तक पहुंचते हैं, तो आपके पास लाइन की लंबाई की एक सूची होती है और बस इतना ही।
— तितर बितर
@Christian तय और छोटा। क्षमा करें, भ्रम की स्थिति से
— निपटने के
9

जाप , 9 बाइट्स

=Ur.Q)¥Uy

इसे ऑनलाइन टेस्ट करें!

व्याख्या

 =Ur.Q)¥ Uy
U=Ur.Q)==Uy
             // Implicit: U = input string, Q = quotation mark
U=    )      // Set U to
  Ur.Q       //   U with each non-newline (/./g) replaced with a quotation mark.
       ==Uy  // Return U == U transposed. U is padded to a rectangle with spaces before
             // transposing; if U was not a rectangle before, or the sides are not of
             // equal length, the result will not be the same as U.
             // Implicit: output result of last expression

इस चुनौती के पोस्ट होने के तुरंत बाद लागू की गई कुछ सुविधाओं का उपयोग करते हुए, यह 6 बाइट्स हो सकते हैं:

r.Q
¥y

इसे ऑनलाइन टेस्ट करें!

व्याख्या

       // Implicit: U = input string
r.Q    // Replace each non-newline (/./g) in U with a quotation mark.
       // Newline: set U to the result.
¥      // Return U ==
 y     //   U transposed.
       // Implicit: output result of last expression
— ETHproductions
स्रोत
दुनिया में आप इतनी जल्दी कैसे हैं?
— पूरी तरह से
@totallyhuman मैं उस प्रश्न को देखने के लिए हुआ जो इसे पोस्ट किया गया था, और एक एल्गोरिथ्म के साथ आने में मुझे दो मिनट लगे। उसके बाद बस लागू करना और पोस्ट करना था। (इसके अलावा मेरे पास वापस पाने के लिए चीजें हैं)
— ETHproductions
अच्छा :) मुझे पता yथा कि समाधान था, लेकिन मेरा कुछ और बाइट्स में आ रहा था।
— शगुन
" इस चुनौती को पोस्ट किए जाने के तुरंत बाद कार्यान्वित कुछ सुविधाओं का उपयोग करना " - अब आप इसे अपने asnwer के रूप में पोस्ट कर सकते हैं।
— झबरा
7

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

.
.
^(.(.)*)(?<-2>¶\1)*$(?(2).)

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

— नील
स्रोत
दुर्भाग्य से, यह इस टेस्टकेस के लिए सही आउटपुट है ।
— क्रिति लिथोस
@KritiiLithos मेरा मानना ​​है कि सबमिशन के लिए इनपुट में एक अनुगामी न्यूलाइन की आवश्यकता होती है, जिसकी अनुमति है।
— पावेल
इसके अलावा मेरा मानना \S\n;है कि पहली पंक्ति के बजाय का उपयोग एक बाइट बचाता है
— क्रिति लिथोस
@KritixiLithos वास्तव में जगह .के साथ .दो, लेकिन धन्यवाद बचाता है।
— नील
@ नील यह वाकई बहुत चालाक है!
— कृति लीथोस
6

भूसी , 6 बाइट्स

S≡T'a¶

एक स्ट्रिंग लेता है और 1या तो प्रिंट करता है 0। इसे ऑनलाइन आज़माएं! पहली लाइन परीक्षण के मामलों में पुनरावृत्त होती है; यदि आप किसी एकल मान पर परीक्षण करना चाहते हैं तो उसे निकाल दें।

व्याख्या

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

उच्च स्तर पर, कार्यक्रम इस तरह काम करता है:

S≡T'a¶  Define a function:
     ¶  split on newlines,
  T'a   transpose and pad to rectangle using character 'a',
 ≡      check if this has the same shape as
S       the split input.

फ़ंक्शन ≡वास्तव में जांचता है कि क्या दो सरणियों का आकार समान है और सत्य तत्वों का समान वितरण है। हस्क में, अशक्त बाइट को छोड़कर सभी वर्ण सत्य हैं, और यह हमारे इनपुट में नहीं होगा। इसके अलावा, Sहै एस Combinator , एक समारोह के रूप में आदानों दो काम करता है, यहाँ लेता है ≡और T'aएक नया समारोह है कि नक्शे, और रिटर्न xके लिए ≡(x)(T'a x)। के परिणाम के Sसाथ बना है , और उस फ़ंक्शन को इनपुट पर स्पष्ट रूप से लागू किया गया है।

हस्क को कैसे पता है कि यह Sअगले फ़ंक्शन पर लागू होना चाहिए , लेकिन इसकी बाईं ओर फ़ंक्शन के साथ बनाया जाना चाहिए? सरल: यह बस हर व्याख्या की कोशिश करता है और उस प्रकार को चुनता है जहां प्रकार समझ में आते हैं। यह भूसी प्रलेखन में अधिक विस्तार से समझाया गया है ।

— Zgarb
स्रोत
5

शुद्ध बैश (कोई उपयोगिता नहीं), 55

mapfile -t a
for l in ${a[@]};{
((c+=${#l}^${#a[@]}))
}
  • mapfile इनपुट को सरणी में पढ़ता है a
  • फिर सरणी के तत्वों की संख्या को प्रत्येक पंक्ति की लंबाई के साथ XORed किया जाता है, और राशि ली जाती है। एक पूर्ण वर्ग के लिए, प्रत्येक XOR परिणाम (और इस प्रकार योग) 0. किसी भी चीज़ के लिए, परिणाम> 0 होगा।

इसका विपरीत अर्थ शेल रिटर्न कोड (जांच के साथ echo $?) के रूप में दिया गया है - सही वर्ग 1 है, कुछ और 0 है।

इसे ऑनलाइन ट्रू (सत्य) करें ।

इसे ऑनलाइन (झूठा) आज़माएं ।

Eval-भागने-विस्तार नरक का उपयोग करते हुए पिछला उत्तर, 78:

mapfile -t a
echo $[0$(eval eval echo +\\$\{#a[{0..$[${#a[@]}-1]}]}^${#a[@]})]

इसे ऑनलाइन ट्रू (सत्य) करें ।

इसे ऑनलाइन (झूठा) आज़माएं ।

— डिजिटल आघात
स्रोत
5

पर्ल 6 , 27 बाइट्स

{.lines==all .lines».comb}

टेस्ट कि क्या इनपुट स्ट्रिंग में लाइनों की संख्या प्रत्येक लाइन पर वर्णों की संख्या के बराबर है।

— शॉन
स्रोत
क्या यह नई-रेखा के चरित्र को अनदेखा करता है?
— खालेद।
हां, .linesविधि द्वारा नई सीमाएं नहीं लौटाई जाती हैं ।
— सीन
4

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

CImL1.z

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

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

— FryAmTheEggman
स्रोत
4

जावा (ओपनजेडके 8) ,96 91 90 87 बाइट्स

-5 बाइट्स @KevinCruijssen
-1 बाइट की बदौलत -LethalCoder
-2 बाइट्स की बदौलत @ OlivierGrégoire को धन्यवाद 

a->java.util.Arrays.stream(a.split("\n")).allMatch(x->x.length()==a.split("\n").length)

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

— बैशफुल बेलुगा
स्रोत
1
आप अंतरिक्ष String[]sको हटा सकते हैं और आप -3 बाइट्स ,0के .split("\\n");लिए निकाल सकते हैं । और अर्धविराम / ;बहुत अंत में आपको गिनती नहीं करनी होगी, ताकि एक और -1। ओह, और आपको सामने वाले को शामिल करना java.util.होगा Arraysमुझे डर है। आयात / उपयोग बाइट-गिनती का भी हिस्सा हैं।
— केविन क्रूज़सेन
1
चूंकि आप शामिल करना भूल गए हैं java.util., बस एक नियमित रूप से लूप इस तरह for(String x:s)if(x.length()!=s.length)return 0>1;return 1>0;से छोटा लगता है return java.util.Arrays.stream(s).anyMatch(l->l.length()!=s.length);।
— केविन क्रूज़सेन
2
क्या यह सिर्फ नहीं है \n?
— TheLethalCoder
1
इसको दोहराना a.split("\n")वास्तव में कम है! a->java.util.Arrays.stream(a.split("\n")).allMatch(x->x.length()==a.split("\n").length)
— ओलिवियर ग्रेजायर
2
हम्म् ... कुछ और के बीच मौजूद हैं lengऔर th()। तो जाहिर है, वे पहले 60 वें चार के बाद दिखाई देते हैं, फिर हर 20 अक्षर के।
— ओलिवियर ग्रामेइयर
3

05AB1E , 7 बाइट्स

|€gDgQP

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

— आउटग्रॉफर को एरिक करें
स्रोत
धोखा देने वाले इमो की तरह, जो मूल रूप nसे 1 के बजाय इनपुट ले रहा है और मेरे मूल उत्तर ने काम क्यों नहीं किया।
— मैजिक ऑक्टोपस Urn
@carusocomputing नहीं, का |अर्थ है "इनपुट के बाकी हिस्सों को ले लो और newlines द्वारा विभाजित करें" जो किसी भी तरह से कई इनपुट लेने का नहीं है। आपको बस एक इनपुट के रूप में STDIN का इलाज करना है।
— आउटगोल्फर
3

आर , 57 बाइट्स

function(s)all(nchar(n<-strsplit(s,'
')[[1]])==length(n))

एक अनाम फ़ंक्शन; न्यूलाइन्स पर विभाजन, प्रत्येक लाइन की लंबाई की गणना करता है, और जांचता है कि क्या सभी लाइनों की संख्या के समान हैं।

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

— ग्यूसेप
स्रोत
3

MATL , 14 12 बाइट्स

10H&XXot&n=h

इनपुट स्ट्रिंग को स्ट्रिंग समवर्ती ( [...]) का उपयोग करके परिभाषित किया गया है और 10एलएफ का प्रतिनिधित्व करने के लिए कोड बिंदु के साथ । उदाहरण के लिए, ['aaa' 10 'bb']Matl में व्याख्या की है के रूप में स्ट्रिंग 'aaa'कोड बिंदु के साथ चरित्र के साथ concatenated 10तार के साथ concatenated 'bb'।

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

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

व्याख्या

इनपुट पर विचार करें ['4444' 10 '333' 10 '22']।

10H   % Push 10 (code point of LF). Push 2
      % STACK: 10, 2
&XX   % Regexp with three arguments. First argument is implicit input (string);
      % second is 2, which indicates that we want to split the input; third is
      % 10, which is the character to split on. The result is a cell array of
      % matched strings
      % STACK: {'4444', '333', '22'}
o     % Concatenate into a numeric 2D array of code points, right-padding with
      % zeros if needed
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0]
t&n   % Duplicate. Push number of rows and number of columns
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 3, 4
=     % Are they equal?
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 0
h     % Concatenate into a row vector (in column-major order). Implicit display
      % STACK: [52 51 50 52 51 50 52 51 0 52 0 0 0]
— लुइस मेंडो
स्रोत
3

आर, 35 बाइट्स

all(nchar(x<-scan(,""))==length(x))

स्टड से इनपुट लेता है। जाँचता है कि प्रत्येक पंक्ति में वर्णों की संख्या कुल पंक्तियों के बराबर है। वापसी TRUEया FALSEउपयुक्त के रूप में।

— rturnbull
स्रोत
ध्यान दें कि इनपुट को उद्धरण में लपेटने की आवश्यकता है या यह प्रत्येक पंक्ति के भीतर रिक्त स्थान पर टूट सकता है।
— Giuseppe
2

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

s=>(a=s.split`
`,a.every(l=>l.length==a.length))
— kamoroso94
स्रोत
2

QBIC , 43 बाइट्स

{_?~_lA||h=h+1┘g=g+_lA|~g%_lA||_Xp]\_xg/h=h

मुझे, इस चुनौती पर जाने के लिए QBasic व्युत्पन्न को कितना कम मिला, मैं खुश हूं।

स्पष्टीकरण:

{_?       DO infinitely: ask the user for input, store as A$
~    |    IF
 _lA|       The length of A$   (implicitly <> 0)
h=h+1     Add 1 to our line counter
┘         (syntactic linebreak)
g=g+_lA|  Add the length of this line to the running total of line lengths
~      |  IF
 g%_lA|     The length of the running total modulo the length of the last string
            yields anything but 0, there is a discrepancy between earlier line
            lengths and this one.
_Xp]      THEN QUIT, printing 0, end IF
\         ELSE (refers to the LEN(A$), user didn't input anything.
_xg/h=h   QUIT (the inf. loop) printing -1 if the root of the chars is the row count
            or 0 if not.
— steenbergh
स्रोत
2

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

qCC.z.z

प्रदर्शन

ट्रंकेशन के साथ इनपुट को दो बार स्थानांतरित करें, फिर जांचें कि क्या परिणाम मूल के समान है।

— isaacg
स्रोत
2

रूबी, 50 बाइट्स

s=$<.read.split $/,-1;p [s.size]==s.map(&:size)|[]

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

व्याख्या

  1. न्यूलाइन पर ऐरे में स्प्लिट इनपुट।
  2. दावा करें कि इस सारणी में केवल एक सरणी है, इस सरणी के सभी तत्वों के सभी uniq (खाली सरणी के साथ सेट संघ) युक्त सरणी के बराबर है।
— IngoAlbers
स्रोत
1
एक चरित्र को बचाएं .split($/,-1);->.split $/,-1;
— क्रिस्टोफर
का उपयोग करके अधिक सहेजें linesके बजाय readऔर उसके बाद split(लेकिन फिर आप के लिए 1 जोड़ने के लिए sizeक्योंकि लाइनों अनुगामी न्यू लाइन शामिल हैं)
— जीबी
1

क्लोजर, 58 बाइट्स

#(let[s(re-seq #"[^\n]+"%)c count](apply =(c s)(map c s)))

कुछ अधिक जादुई देखने के लिए उत्सुक एक नई अनुगामी की आवश्यकता है।

— NikoNyrh
स्रोत
1

एपीएल (डायलॉग) , 17 बाइट्स

⎕ML←3कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है। सीआर का उपयोग करता है।

↓∘⎕FMT≡⎕TC[2]∘≠⊂⊢

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

↓∘⎕FMT [है] स्प्लिट-इन-लाइन एफ या एम एक टी टेड-इन-ए-स्क्वायर तर्क

≡ के समान

⎕TC[2]∘≠ इन-ग्रुप्स ऑफ-नॉन-न्यूलाइन * -चट्रर्स

⊂ विभाजित

⊢ बहस?

* T erminal C ontrol वर्णों की सूची का दूसरा तत्व ।

संस्करण 16.0 में, एक लिख सकते हैं ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢के साथ ⎕ML←1।

— एडम
स्रोत
जिज्ञासु, क्या है ⎕ML?
— पावेल
1
@Phoenix में Dyalog एपीएल और एपीएल +, एम igration एल evel आईबीएम की APL2 की दिशा में द्वंद्वात्मक आंदोलन के लिए एक किसी न किसी उपाय है। संख्या जितनी अधिक होती है, एपीएल 2 जैसी भाषा उतनी ही अधिक बनती है। APL2 से दूसरे APL में प्रवास करने वाले ⎕MLलोगों को उच्च के साथ चलना पड़ता है , जबकि अन्य APL के साथ शुरू होने वाले लोग कम के साथ चलते हैं ⎕ML।
— अदम
1

पॉवरशेल, 64 बाइट्स

अन्य गैर-गोल्फ भाषा के उत्तर के समान (विभाजित, लाइन की लंबाई, लाइनों की संख्या) दृष्टिकोण, लेकिन कोई अच्छा नक्शा () समकक्ष नहीं है, इसलिए यह पंक्ति की एक सरणी है जिसकी छोर पर टैग की गई लाइनों की संख्या है, फिर वह सरणी समूहीकृत है। वर्गों की तरह बाहर आते हैं 3,3,3,3 -> 1 group, all line lengths and line count were equalऔर गैर-वर्गों की तरह बाहर आते हैं 3,2,1 -> 3 groups, वर्ग में कुछ असमान था:

$f={@(@(($L="$args"-split"`n")|% le*)+$L.Count|group).Count-eq1}

न्यूलाइन लिनक्स-स्टाइल एंडिंग्स की आवश्यकता है, कोई अनुगामी न्यूलाइन नहीं। जैसे

$Ttests = @(@'
foo
bar
baz
'@,
'.',
@'
aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
'@
)
$Ttests = $Ttests | foreach {$_ -replace "`r"}

$Ttests | % { & $f $_ }

(और आप झूठे परीक्षणों के लिए समान कर सकते हैं, लेकिन मैं इसे यहां नहीं डालूंगा क्योंकि उनमें से अधिक है)। @प्रतीकों के जोड़े की आवश्यकता तब होती है जब इनपुट एकल होता है '.'अन्यथा इसे विभाजित करने से एक स्ट्रिंग की एक सरणी नहीं बनती है यह सिर्फ एक स्ट्रिंग बनाता है, और फिर सरणी संयोजन 1,1इसे आउटपुट नहीं करता है 2।

मुझे आशा है कि यह सभी वर्णों को 'a' से बदलने के लिए छोटा होगा, और फिर 1 से इनपुट लंबाई तक ब्रूट बल को सभी वर्गों 'a' में देखें और देखें कि क्या किसी इनपुट से मेल खाता है। एक बार जब मैंने पिछले परम () और .Length और -join और -replace को 81 बाइट्स में समाप्त किया है:

$f={param($s)!!(1..$s.Length|?{,('a'*$_)*$_-join"`n"-eq($s-replace"[^`n]",'a')})}
— TessellatingHeckler
स्रोत
1

पीस , 11 बाइट्स

e`.|_./+/.+

1वर्गों के लिए और 0गैर-वर्गों के लिए प्रिंट । इसे ऑनलाइन आज़माएं!

व्याख्या

ग्रिम ट्यूटोरियल पेज पर एक विस्तृत विवरण पाया जा सकता है , जो इस सटीक कार्यक्रम को उदाहरण के रूप में शामिल करने के लिए होता है।

e`.|_./+/.+
e`            Match entire input against pattern:
  .           A single character
   |          OR
    _         a recursive match of this pattern
     ./+      with one column of characters on its right
        /     and below that
         .+   one row of characters.
— Zgarb
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.