एक हाइकु तीन पंक्तियों वाली एक कविता है, जिसमें क्रमशः 5/7/5 शब्दांश संख्या होती है।

एक हाइकु-डब्ल्यू तीन पंक्तियों के साथ क्रमशः 5/7/5 शब्द गणना के साथ कविता है।

चुनौती

एक प्रोग्राम है जो वापस आ जाएगी लिखें सच है, तो इनपुट है एक हाइकू-डब्ल्यू, और झूठी नहीं तो।

एक वैध हाइकू-डब्ल्यू इनपुट में 3 लाइनें शामिल होनी चाहिए, जो एक नई रेखा से अलग होती है।

पंक्ति 1 में 5 शब्द शामिल होने चाहिए, प्रत्येक शब्द एक स्थान से अलग होता है।
पंक्ति 2 में 7 शब्द शामिल होने चाहिए, प्रत्येक शब्द एक स्थान से अलग होता है।
पंक्ति 3 में 5 शब्द शामिल होने चाहिए, प्रत्येक शब्द एक स्थान से अलग होता है।

उदाहरण

The man in the suit
is the same man from the store.
He is a cool guy.

परिणाम: सच है

Whitecaps on the bay:
A broken signboard banging
In the April wind.

परिणाम: गलत

नियम

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

code-golf decision-problem

— DomTheDeveloper
स्रोत

1

क्या हाइकू-डब्ल्यू में हमेशा 3 लाइनें होंगी?

— कृतिका लिथोस

1

हाँ। यदि इनपुट में 3 से अधिक या कम लाइनें हैं, तो प्रोग्राम को गलत वापस लौटना चाहिए ।

— DOMTheDeveloper

5

क्या कभी किसी लाइन पर अग्रणी या अनुगामी स्थान होगा? या कई रिक्त स्थान शब्दों को अलग कर रहे हैं?

— ग्रेग मार्टिन

8

वैसे, इस तरह के स्पष्टीकरण सैंडबॉक्स में प्रस्तावित प्रश्नों को पोस्ट करने का एक प्राथमिक कारण है । :)

— ग्रेग मार्टिन

11

सबमिशन के लिए बोनस अंक जहां कोड ही हाइकू-डब्ल्यू है।

— ग्लोरफाइंडेल

25

जावास्क्रिप्ट (ईएस 6), 73 72 64 63 54 42 39 बाइट्स

13 बाइट बचाने के लिए नील को धन्यवाद

a=>a.map(b=>b.split` `.length)=='5,7,5'

व्याख्या

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

— ल्यूक
स्रोत

1

%और *इसकी एक ही मिसाल है, इसलिए आपको ()एस की जरूरत नहीं है , हालांकि मुझे लगता है कि (d*2|5)यह भी काम कर सकता है। इसके अलावा, आप एकल के साथ भाग सकते हैं &, हालांकि मुझे लगता है कि आप इसका उपयोग करके भी सुधार कर सकते हैं (b...).length==3>b.some(...length-...)।

— नील

कोष्ठक के बारे में टिप के लिए धन्यवाद। इसके अलावा, मैंने अपना दृष्टिकोण बदल दिया है, इसलिए मैं स्पष्ट रूप से लंबाई की जांच नहीं करता हूं।

— ल्यूक

1

आह, उस मामले में, गणना के साथ परेशान मत करो, बस उपयोग करें a=>a.map(c=>c.split .length)=='5,7,5'।

— नील

हे, तुम सही हो। मुझे यह सोचना चाहिए था ...

— ल्यूक

आपको अभी भी ज़रूरत नहीं है +''- ==यदि अन्य तर्क एक स्ट्रिंग है तो इसे स्ट्रिंग करता है।

— नील

12

AWK (GNU Awk), 24, 30, 28, 20 बाइट्स

golfed

517253==$0=q=q NF NR

ट्रू के लिए "517253" आउटपुट करेगा , और फाल्स के लिए खाली स्ट्रिंग ।

Awk में, कोई भी नॉनजेरो न्यूमेरिक वैल्यू या कोई भी नॉनमोटर स्ट्रिंग वैल्यू सही है। कोई अन्य मान (शून्य या शून्य स्ट्रिंग, "") गलत है

GNU Awk उपयोगकर्ता गाइड

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

प्रत्येक अवाक कथन (नियम) में एक संबद्ध क्रिया के साथ एक पैटर्न (या अभिव्यक्ति) होता है:

pattern {action}

Awk लाइन द्वारा इनपुट लाइन पढ़ेंगे (रिकॉर्ड द्वारा रिकॉर्ड) और पैटर्न अभिव्यक्ति का मूल्यांकन करके यह देखने के लिए कि क्या इसी कार्रवाई को लागू किया जाना है।

ऊपर दिया गया कोड एक स्टैंडअलोन Awk एक्सप्रेशन (पैटर्न) w / o एक्शन ब्लॉक है, जो {print $0}उस स्थिति में निहित है ।

इसे दाएं-बाएं पढ़ा जाना चाहिए:

q=q NF NR

संलग्न एक एन की भूरा रंग एफ ields (शब्द) और एन के भूरा रंग आर ecords (यानी वर्तमान पंक्ति संख्या), चर करने के लिए क्यू ।

इस तरह, जब उचित हाइकू-डब्ल्यू को संसाधित किया जाता है, तो क्यू को सेट किया जाएगा:

51 - लाइन # 1 पर (5 शब्द)
5172 - ऑन लाइन # 2 (5 शब्द + 7 शब्द)
517253 - लाइन # 3 पर (5 शब्द + 7 शब्द + 5 शब्द)

$0=q

Q के $ 0 (जो डिफ़ॉल्ट रूप से संपूर्ण वर्तमान लाइन / रिकॉर्ड रखता है) के लिए नए गणना किए गए मान को असाइन करें ।

517253==$0

एक उचित हाइकु-वे (517253) के लिए "हस्ताक्षर" के साथ इसकी तुलना करें, अगर कोई मैच होता है, तो पूरी अभिव्यक्ति "सच" का मूल्यांकन करती है और इसी क्रिया (निहित print $0) को चलाया जाता है, जिसे stdout (True) में "517253" भेजा जाता है। , अन्यथा आउटपुट खाली (गलत) होगा।

ध्यान दें कि यह हाइकु-डब्ल्यू को ठीक से पहचान लेगा, भले ही इसके बाद कचरे की एक मनमानी संख्या हो, लेकिन मेरा मानना है कि यह ठीक है, जैसे:

इनपुट के रूप में स्ट्रिंग्स की लंबाई -3 सूची भी स्वीकार्य है।

(अर्थात हम इनपुट को 3 लाइन लंबा मान सकते हैं)

परीक्षा

>awk '517253==$0=q=q NF NR'<<EOF
The man in the suit
is the same man from the store.
He is a cool guy.
EOF

517253

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत

2

यदि इनपुट में 575 शब्दों से युक्त एक लाइन होती है, या 57 और 5 शब्दों वाली दो पंक्तियाँ होती हैं, आदि

— लिन

@ लियन, सच है, जब तक यह तय नहीं हो जाता है, तब तक इसे दबाए रखें।

— जेपेलिन

@Lynn, अब समाधान हो गया होगा

— टसेपेल्लिन

1

बहुत चतुर तय! :)

— लिन

9

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

lambda l:[s.count(' ')for s in l]==[4,6,4]

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

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

जैसा कि हम गारंटी देते हैं कि कोई प्रमुख या अनुगामी स्थान नहीं होगा, और केवल एक ही स्थान प्रत्येक शब्द को अलग करेगा, हम प्रत्येक पंक्ति में रिक्त स्थान की गणना करके w-हाइकु को सत्यापित कर सकते हैं।

हम ऐसा एक सूची की समझ में करते हैं, जिससे अंतरिक्ष की गिनती की सूची बनाई जा सके। यदि यह एक सही हाइकू है, तो इसे देखना चाहिए [4, 6, 4], इसलिए हम इसे इस से तुलना करते हैं और परिणाम वापस करते हैं।

— FlipTack
स्रोत

यदि आप केवल पायथन 2 का समर्थन करने के साथ ठीक हैं, तो आप दो बाइट्स बचा सकते हैं map(str.count,l,' '):।

— तिजोरी

8

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

ċ€⁶⁼“¥©¥‘

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

व्याख्या

ċ€⁶⁼“¥©¥‘  Input: length-3 list of strings
 €         For each string
ċ ⁶          Count the number of spaces
    “¥©¥‘  Convert string to code page indices, makes [4, 6, 4]
   ⁼       Match

— मील की दूरी पर
स्रोत

इसके अलावा ċ€⁶⁼4,6,4और ċ€⁶⁼464D¤... मुझे कुछ भी कम नहीं मिल रहा है, हालांकि। (ओह, तुम यह भी फ्लिप कर सकते हैं: 464D⁼ċ€⁶$)

— लिन

ċ€⁶Ḍ=4648. के लिए ठीक काम करता है

— जोनाथन एलन

वास्तव में, नहीं , यह खेद नहीं है ।

— जोनाथन एलन

7

बैच, 102 बाइट्स

@echo off
call:c&&call:c 2||exit/b
:c
set/an=%1+5
set/ps=
for %%W in (%s%)do set/an-=1
exit/b%n%

जैसे ही यह शब्दों की गलत संख्या के साथ एक पंक्ति पढ़ता है, गैर-शून्य त्रुटि के साथ बाहर निकलता है।

— नील
स्रोत

1

...... अच्छी तरह से बकवास

— tbodt

7

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

{4,6,4}==Count@" "/@#&

इनपुट और लौटने Trueया के रूप में वर्णों की सूची की सूची ले रहा है False। बस मायने रखता है कि पात्रों की प्रत्येक सूची में कितने रिक्त स्थान हैं, जो चुनौती के नियमों के तहत प्रत्येक पंक्ति में शब्दों की संख्या के साथ पूरी तरह से सहसंबंधित हैं।

पिछला सबमिशन:

मैथेमेटिका, 31 बाइट्स

Length/@StringSplit/@#=={5,7,5}&

इनपुट और रिटर्न के रूप में स्ट्रिंग्स की एक सूची लेने का कार्य करें Trueया False।

— ग्रेग मार्टिन
स्रोत

6

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

f l=[sum[1|' '<-c]|c<-l]==[4,6,4]

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

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

— nimi
स्रोत

बिंदु छोटा है f l=[sum[1|' '<-c]|c<-l]==[4,6,4]:।

— xnor

6

रेटिना , 12 बाइट्स

M%` 
^4¶6¶4$

(पहली पंक्ति के बाद एक अनुगामी स्थान है)

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

M%` - प्रत्येक पंक्ति में रिक्त स्थान की संख्या गिनें।
- M - मैच मोड - मैचों की संख्या प्रिंट करें।
- % - प्रत्येक पंक्ति के लिए
- ` - अलग विन्यास और रेगेक्स पैटर्न
- - बस एक जगह।
^4¶6¶4$ - 4, 6, और 4 रिक्त स्थान होना चाहिए, और बिल्कुल तीन लाइनें।
- ¶नई कहानियों से मेल खाता है। बाकी एक सरल नियमित अभिव्यक्ति है।

अमान्य के 1लिए मान्य इनपुट के लिए प्रिंट 0।

— कोबी
स्रोत

4

पायथन, 58 44 बाइट्स

lambda h:[len(l.split())for l in h]==[5,7,5]

-14 tbodt द्वारा

— sagiksp
स्रोत

आपको स्ट्रिंग्स की लंबाई 3 सूची के रूप में इनपुट लेने की अनुमति है। आप उपयोग करके खर्च किए गए बाइट्स बचा सकते हैं split("\n")।

— मील

44 बाइट्स:lambda h:[len(l.split())for l in h]==[5,7,5]

— tbodt

किसी ने इसे

— चार्ली

4

पर्ल , 26 बाइट्स

-apझंडे के लिए कोड + 2 बाइट्स के 24 बाइट्स ।

$m.=@F}{$_=$m==575&$.==3

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

— बापू
स्रोत

4

अजगर, 9 बाइट्स

qj464T/R;

एक प्रोग्राम जो "quoted strings"और प्रिंट की सूची Trueया Falseउपयुक्त के रूप में इनपुट लेता है।

परीक्षण सूट

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

qj464T/R;   Program. Input: Q
qj464T/R;Q  Implicit variable fill
     T      Are the base-10
 j          digits
  464       of 464
q           equal
      /     to the number
        ;   of spaces
       R    in each string
         Q  in the input?
            Implicitly print

— TheBikingViking
स्रोत

4

जाप , 11 बाइट्स

@ETHproductions की बदौलत बहुत सारे बाइट्स बचाए

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

®¸lÃ¥"5,7,5

इसे ऑनलाइन चलाएं!

— ओलिवर
स्रोत

4

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

"$args"-replace'\S'-match'^(    )
\1  
\1$'

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

व्याख्या

इनपुट को एक नई लाइन के रूप में अलग किए गए स्ट्रिंग के रूप में लेता है।

सभी गैर-व्हाट्सएप को हटा देता है, फिर यह देखने के लिए जांच करता है कि यह "4 स्पेस, न्यूलाइन, 6 स्पेस, न्यूलाइन, 4 स्पेस न्यूलाइन" से बिल्कुल मेल खाता है, एक रेग्क्स का उपयोग करके।

कैप्चर समूह 4 स्थानों से मेल खाता है, बैकरेन्स का \1तात्पर्य है। Newlines स्ट्रिंग में एम्बेडेड हैं। ध्यान दें कि रेगेक्स की दूसरी पंक्ति में बैकरेक्शन के बाद दो स्थान होते हैं।

— briantist
स्रोत

1

यह एक दिलचस्प aproach है!

— इस्माईल मिगुएल

4

Pyke, 11 9 बाइट्स

dL/uq

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

dL/       -  map(i.count(" "), input)
        q - ^ == V
   u  -  [4, 6, 4]

uबाइट के बाद निम्नलिखित बाइट्स हैं:0x03 0x04 0x06 0x04

— नीला
स्रोत

3

जे, 12 बाइट्स

4 6 4=#@;:@>

इनपुट स्ट्रिंग्स की एक बॉक्सिंग सूची है।

व्याख्या

यह एक कांटा है जिसमें लगातार बाएं टाइन होते हैं। यह समतुल्य, के #@;:@>साथ समानता के लिए सही परिणाम के परिणाम की जाँच करता है 4 6 4। सही समय प्रत्येक ( >) को अनबॉक्स करता है , फिर ( @) प्रत्येक स्ट्रिंग को शब्दों में परिवर्तित करता है ( ;:), फिर ( @) प्रत्येक की लंबाई ( ) लेता है #।

— कोनोर ओ ब्रायन
स्रोत

3

आर, 48 बाइट्स

all(stringr::str_count(scan(,"")," ")==c(4,6,4))

स्टड से 3-लंबाई वर्ण वेक्टर पढ़ता है और रिक्त स्थान की संख्या की गणना करके काम करता है। उन रिक्त स्थान की संख्या की गणना करने के लिए हम पैकेज str_countसे उपयोग करते हैं stringrजो रेगेक्स पैटर्न के आधार पर होने वाली घटनाओं को गिन सकते हैं।

पैकेज का उपयोग किए बिना एक वैकल्पिक दृष्टिकोण हो सकता है:

all(sapply(scan(,""),function(x)length(el(strsplit(x," "))))==c(5,7,5))

— Billywob
स्रोत

पहली बार मैंने पहले कभी देखा है el, इसके लिए धन्यवाद।

— बीएलटी

3

C 142 बाइट्स

void f(){char *c;l=3;s[3]={0};while(l>0){if(*c==' ')s[l-1]++;if((*c=getchar())=='\n'){l--;}}printf("%d",(s[0]==4 && s[1]==6 && s[2]==4)?1:0);}

Ungolfed संस्करण:

void f()
{
  char *c;
  c = (char *)malloc(sizeof(char)); 
  int l=3;
  int s[3]= {0};


  while(l>0)
  {  
    if(*c==' ')
    s[l-1]++;

    if( (*c=getchar())=='\n')
    {    
      l--;
    }   
  }
  printf("%d",(s[0]==4 && s[1]==6 && s[2]==4)?1:0);
}

5/7/5 अनुक्रम में 0 के लिए 1 लौटाता है।

एक सकारात्मक परीक्षण:

— हाबिल टॉम
स्रोत

3

सी ++, 357 बाइट्स

कोड गोल्फ में नए की तरह, लेकिन यह सबसे अच्छा मैं जल्दी कर सकता है

#include <iostream>
using namespace std;
int n(std::string s)
{
    int b = 0;
    for(char c: s)
        if(c == ' ') b++;
    cout << "C = " << b;
    return b;
}
int main()
{
    string a, b, c;
    getline(cin, a);
    getline(cin, b);
    getline(cin, c);
    if(n(a)==4 && n(b)==6 && n(c)==4)
        cout<<'1';
    else cout << '0';
    return 0;
}

— रिकार्डो इग्लेसियस
स्रोत

4

PPCG में आपका स्वागत है! कोड गोल्फ का लक्ष्य आपके कोड को यथासंभव कम करना है; एक अच्छा पहला कदम सभी अनावश्यक व्हाट्सएप को दूर करना होगा।

— ETHproductions

3

रूबी 1.9.3

गोल्फ नहीं है, लेकिन खुद हाइकू-डब्ल्यू है

def haiku_w(input)
  lines = input.split("\n")
  lengths = lines.map(&:split).map(&:length)
  lengths.eql?([5,7,5])
end

या ...

lines equals input split (newlines)
lengths equals lines map split map length
lengths equals five seven five?

दुर्भाग्य से किसी भी लाइन पर प्रमुख व्हाट्सएप के साथ काम नहीं करता है, लेकिन अनुगामी के साथ सामना करता है।

— ymbirtt
स्रोत

2

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

संपादित @Dada से प्रतिक्रिया के बाद 7 बाइट्स के योग के साथ सही किया। धन्यवाद!

i,j=input,''
for x in i():j+=`len(x.split())`+' '
i(j=='5 7 5 ')

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

सबसे लंबे समय तक पायथन का सबसे छोटा जवाब नहीं है, लेकिन मैं input()उत्पादन को प्रदर्शित करने और एक printबयान को बचाने के लिए हाल ही में सीखे गए नए ट्रिक का उपयोग करना चाहता था । इनपुट के रूप में लाइनों की एक सूची लेता है। टर्मिनल में प्रोग्राम (अपवाद के साथ) को समाप्त करने के लिए Ctrl C (या उस मामले के लिए किसी अन्य कुंजी-प्रेस) की आवश्यकता होती है, लेकिन TIO पर बिना ठीक काम करता है।

— ElPedro
स्रोत

4

यह इस तरह के मामलों में विफल हो जाएगा ।

— दादा

मैं आपको @ दादा को दे दूंगा। यह एक गंभीर परीक्षण मामला है :)

— El49edro

आपके परीक्षण मामले के साथ सही और परीक्षण किया गया।

— एलपेड्रो

2

MATL, 16 बाइट्स

"@Y:Ybn&h][ACA]=

इनपुट स्ट्रिंग्स का एक सेल ऐरे है और एक ट्रू या फाल्सी एरे देता है ।

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

व्याख्या

        % Implicitly grab input
"       % For each element in the cell array
@Y:Yb   % Split it on spaces
n       % Count the number of elements
&h      % Horizontally concatenate everything on the stack
[ACA]   % Create the array [5 7 5]
=       % Perform an element-wise equality
        % Implicitly display the truthy/falsey array

— Suever
स्रोत

2

MATLAB / ऑक्टेव, 38 बाइट्स

@(x)cellfun(@(y)sum(y==32),x)==[4 6 4]

यह समाधान इनपुट के रूप में स्ट्रिंग्स के सेल सरणी को स्वीकार करता है, प्रत्येक पंक्ति में रिक्त स्थान की संख्या की गणना करता है और फिर परिणाम की सरणी से तुलना करता है [4 6 4]और एक सत्य (सभी मान 1 हैं) या फ़ल्सी (कोई मान शून्य है) सरणी देता है।

ऑनलाइन डेमो

— Suever
स्रोत

2

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

{.lines».words~~(5,7,5)}

— SMLS
स्रोत

2

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

#(=(for[l %](count(filter #{\ }l)))'(4 6 4))

इनपुट स्ट्रिंग्स की सूची है। फ़ंक्शन केवल रिक्त स्थान पाता है और उन्हें गिनता है। यह व्याख्या हाइकु है। :)

— NikoNyrh
स्रोत

2

जावा 7, 154 बाइट्स

class M{public static void main(String[]a){System.out.print(a.length==3&&a[0].split(" ").length==5&a[1].split(" ").length==7&a[2].split(" ").length==5);}}

कार्यक्रम की आवश्यकता और तीन पंक्तियों से कम या अधिक होने की संभावना, स्वयं जावा की वाचालता का भी उल्लेख नहीं करती है, इस 'गोल्फ' कोड को बहुत बड़ा होने का कारण बनता है।

Ungolfed:

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

class M{
  public static void main(String[] a){
    System.out.print(a.length == 3
        && a[0].split(" ").length == 5
         & a[1].split(" ").length == 7
         & a[2].split(" ").length == 5);
  }
}

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

2

SimpleTemplate, 77 बाइट्स

अफसोस की बात है, नियमित अभिव्यक्ति aproach सबसे कम है।

{@if"@^([^\s]+ ?){5}\s([^\s]+ ?){7}\s([^\s]+ ?){5}+$@"is matchesargv}{@echo1}

यह आवश्यक है कि टेक्स्ट को पहले तर्क के रूप में दिया जाए, जिसमें * NIX- शैली की नई सुर्खियाँ हों। यह विंडोज-शैली की नई लाइनों के साथ काम नहीं करेगा।

Ungolfed:

{@if "@^([^\s]+ ?){5}\s([^\s]+ ?){7}\s([^\s]+ ?){5}+$@"is matches argv}
    {@echo 1}
{@/}

नॉन-रेगेक्स आधारित, 114 बाय

{@setR 1}{@eachargv asL keyK}{@php$DATA[L]=count(explode(' ',$DATA[L]))!=5+2*($DATA[K]&1)}{@set*R R,L}{@/}{@echoR}

इसके लिए यह आवश्यक है कि प्रत्येक लाइन फ़ंक्शन के तर्क के रूप में दी गई हो।

Ungolfed:

{@set result 1}
{@each argv as line key k}
    {@php $DATA['line'] = count(explode(' ', $DATA['line'])) != 5+2*( $DATA['k'] & 1 )}
    {@set* result result, line}
{@/}
{@echo result}

— इस्माइल मिगुएल
स्रोत

2

स्टैक्ड, 22 बाइट्स

[' 'eq sum]map(4 6 4)=

स्टैक के शीर्ष से इनपुट को वर्ण स्ट्रिंग की सूची के रूप में लेता है, जैसे:

($'The man in the suit' $'is the same man from the store.' $'He is a cool guy.')

व्याख्या

[' 'eq sum]map(4 6 4)=
[         ]map          map the following function over each item
 ' 'eq                  vectorized equality with ' '
       sum              summed
              (4 6 4)=  is equal to (4 6 4)

— कोनोर ओ ब्रायन
स्रोत

2

जावा (ओपनजेडके) , 82 बाइट्स

-2 बाइट्स @ corvus_192 को धन्यवाद!

s->s[0].split(" ").length==5&s[2].split(" ").length==5&s[1].split(" ").length==7

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

यह देखने में तो बहुत अच्छा लगता है लेकिन बिना बिल्ट मैप फंक्शन के मैं अच्छा रास्ता नहीं खोज सकता। सरणी के माध्यम से Iterating कुछ बाइट्स लंबा है, जैसा कि धाराओं का उपयोग करके एक मानचित्र फ़ंक्शन लिख रहा है।

लैम्ब्डा अभिव्यक्ति स्ट्रिंग्स की एक सरणी लेता है और एक बूलियन देता है।

— पावेल
स्रोत

क्या होगा यदि आपके पास इनपुट के रूप में केवल दो लाइनें हैं, या चार?

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

@ केविनक्रूजसेन सेशन के अनुसार, "एक इनपुट के रूप में स्ट्रिंग्स की लंबाई -3 सूची भी स्वीकार्य है"। मेरा कार्यक्रम लाइनों की लंबाई -3 सूची लेता है।

— पावेल

यदि आप फोन करते हैं Arrays.stream, तो आप एक नक्शा समारोह प्राप्त कर सकते हैं , लेकिन यह काफी लंबा है कि यह उपयोग करने के लायक नहीं हो सकता है (विशेषकर यदि आपको आयात करने की आवश्यकता है Arrays)

— Pokechu22

@ Pokechu22 हाँ मैंने कोशिश की कि, अभी भी लंबे समय तक समाप्त हो।

— पावेल

आप दो बाइट्स बचाने &के &&लिए उपयोग कर सकते हैं

— corvus_192

2

स्माइलबासिक, 96 94 बाइट्स

INPUT A$,B$,C$?C(A$,4)*C(B$,6)*C(C$,4)DEF C(S,E)WHILE""<S
INC N,POP(S)<"!
WEND
RETURN N==E
END

— 12Me21
स्रोत

1

आर, 100 बाइट्स

f<-function(a){all(sapply(a,function(x){length(grep(" ",as.list(strsplit(x,"")[[1]])))})==c(4,6,4))}

एक तर्क के रूप में तार की लंबाई -3 सूची ले जाता है। संभवतः आगे गोल्फ नहीं होगी क्योंकि आगे गोल्फिंग इसे @ बिलीवॉब के उत्तर में बदल देता है।

— बीएलटी
स्रोत

हाइकू-डब्ल्यू डिटेक्टर लिखें

चुनौती

उदाहरण

नियम

जावास्क्रिप्ट (ईएस 6), 73 72 64 63 54 42 39 बाइट्स

व्याख्या

AWK (GNU Awk), 24, 30, 28, 20 बाइट्स

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

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

व्याख्या

बैच, 102 बाइट्स

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

मैथेमेटिका, 31 बाइट्स

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

रेटिना , 12 बाइट्स

पायथन, 58 44 बाइट्स

पर्ल , 26 बाइट्स

अजगर, 9 बाइट्स

जाप , 11 बाइट्स

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

व्याख्या

Pyke, 11 9 बाइट्स

जे, 12 बाइट्स

व्याख्या

आर, 48 बाइट्स

C 142 बाइट्स

सी ++, 357 बाइट्स

रूबी 1.9.3

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

MATL, 16 बाइट्स

MATLAB / ऑक्टेव, 38 बाइट्स

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

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

जावा 7, 154 बाइट्स

SimpleTemplate, 77 बाइट्स

स्टैक्ड, 22 बाइट्स

व्याख्या

जावा (ओपनजेडके) , 82 बाइट्स

स्माइलबासिक, 96 94 बाइट्स

आर, 100 बाइट्स