Một haiku là một bài thơ với ba dòng, với một 5/7/5 âm tiết đếm, tương ứng.

Một haiku-w là bài thơ có ba dòng, với số lượng từ 5/7/5 tương ứng.

Thử thách

Viết chương trình sẽ trả về true nếu đầu vào là haiku-w và false nếu không.

Một đầu vào haiku-w hợp lệ phải bao gồm 3 dòng, cách nhau bởi một dòng mới.

• Dòng 1 phải bao gồm 5 từ, mỗi từ cách nhau một khoảng trắng.
• Dòng 2 phải bao gồm 7 từ, mỗi từ cách nhau một khoảng trắng.
• Dòng 3 phải bao gồm 5 từ, mỗi từ cách nhau một khoảng trắng.

Ví dụ

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

Kết quả: Đúng

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

Kết quả: Sai

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.
• Tiêu chuẩn mã lỗ golf áp dụng. Gian lận bị cấm.
• Các giá trị trả về boolean khác, như 1và 0, được chấp nhận.
• Một danh sách dài 3 chuỗi làm đầu vào cũng được chấp nhận.
• Các đầu vào haiku-w hợp lệ không được có khoảng trắng ở đầu hoặc cuối hoặc nhiều khoảng cách giữa các từ.

JavaScript (ES6), 73 72 64 63 54 42 39 byte

Cảm ơn Neil vì đã tiết kiệm được 13 byte

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

Giải trình

Đây là một hàm mũi tên béo lấy một chuỗi các chuỗi làm đối số. Nó thay thế mỗi dòng bằng số từ của nó. Nếu nó là một haiku-w, abây giờ chứa một mảng năm, bảy và năm một lần nữa. Vì JavaScript không cho phép chúng ta so sánh 2 mảng cùng một lúc, nên mảng được chuyển đổi thành chuỗi trước, sau đó được so sánh. Điều này dẫn đến một boolean được trả lại.

AWK (GNU Awk), 24, 30, 28, 20 byte

Chơi gôn

517253==$0=q=q NF NR

Sẽ xuất "517253" cho True và chuỗi rỗng cho Sai .

Trong awk, bất kỳ giá trị số khác không hoặc bất kỳ giá trị chuỗi không trống nào là đúng. Mọi giá trị khác (không hoặc chuỗi null, "") là sai

Hướng dẫn sử dụng GNU Awk

Làm thế nào nó hoạt động

Mỗi câu lệnh awk (quy tắc) bao gồm một mẫu (hoặc biểu thức) với một hành động liên quan:

pattern {action}

Awk sẽ đọc dòng đầu vào theo dòng (ghi theo bản ghi) và đánh giá biểu thức mẫu để xem nếu một hành động tương ứng sẽ được gọi.

Mã ở trên là một biểu thức (mẫu) Awk độc lập với khối hành động, được ngụ ý {print $0}trong trường hợp đó.

Nó nên được đọc từ phải sang trái:

q=q NF NR

Nối một số N của F ields (từ) và N umber của R ecords (tức là số dòng hiện tại), vào biến q .

Theo cách này, khi xử lý Haiku-w thích hợp, q sẽ được đặt thành:

• 51 - trên dòng số 1 (5 từ)
• 5172 - trên dòng # 2 (5 từ + 7 từ)
• 517253 - trên dòng số 3 (5 từ + 7 từ + 5 từ)

$0=q

Gán giá trị mới được tính của q thành $ 0 (giữ toàn bộ dòng / bản ghi hiện tại theo mặc định).

517253==$0

So sánh nó với "chữ ký" cho một Haiku-w thích hợp (517253), nếu có một kết quả khớp, toàn bộ biểu thức sẽ đánh giá là "đúng" và một hành động tương ứng (ẩn print $0) được chạy, gửi "517253" tới thiết bị xuất chuẩn (Đúng) , nếu không đầu ra sẽ trống (Sai).

Lưu ý rằng điều này sẽ nhận ra đúng một Haiku-w, ngay cả khi nó được theo sau bởi một số dòng rác tùy ý, nhưng tôi tin rằng nó vẫn ổn, như:

Một danh sách dài 3 chuỗi làm đầu vào cũng được chấp nhận.

(tức là chúng ta có thể giả sử đầu vào dài 3 dòng)

Kiểm tra

>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

Dùng thử trực tuyến!

Python , 42 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là một danh sách các dòng, với các từ được phân tách bằng khoảng trắng đơn.

Vì chúng tôi đảm bảo sẽ không có khoảng trắng ở đầu hoặc cuối và chỉ có các khoảng trắng duy nhất tách biệt từng từ, chúng tôi có thể xác minh w-haiku bằng cách chỉ cần đếm khoảng trắng trong mỗi dòng.

Chúng tôi làm điều này trong một sự hiểu biết danh sách, để tạo ra một danh sách đếm không gian. Nếu đó là một haiku chính xác, nó sẽ trông như thế [4, 6, 4], vì vậy chúng tôi so sánh nó với điều này và trả về kết quả.

Thạch , 10 9 byte

ċ€⁶⁼“¥©¥‘

Hãy thử trực tuyến!

Giải trình

ċ€⁶⁼“¥©¥‘  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

Mẻ, 102 byte

@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%

Thoát với lỗi không bằng 0 ngay khi nó đọc một dòng có số lượng từ sai.

Toán học, 21 byte

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

Hàm không tên lấy danh sách các danh sách các ký tự làm đầu vào và trả về Truehoặc False. Đơn giản chỉ cần đếm có bao nhiêu khoảng trắng trong mỗi danh sách các ký tự, theo quy tắc của thử thách tương quan hoàn hảo với số lượng từ trong mỗi dòng.

Trình trước:

Toán học, 31 byte

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

Hàm không tên lấy danh sách các chuỗi làm đầu vào và trả về Truehoặc False.

Haskell, 34 33 byte

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

Hãy thử trực tuyến! .

Chỉnh sửa: cảm ơn @xnor cho một byte!

Võng mạc , 12 byte

M%` 
^4¶6¶4$

(có một khoảng trống sau dòng đầu tiên)

Hãy thử trực tuyến!

• M%`  - Đếm số lượng khoảng trắng trong mỗi dòng.

  • M - Chế độ khớp - in số lượng trận đấu.
  • % - cho mỗi dòng
  • ` - cấu hình và mẫu regex riêng biệt
  •   - chỉ là một không gian.

• ^4¶6¶4$ - Cần có 4, 6 và 4 khoảng trắng, và chính xác ba dòng.

  • ¶phù hợp với dòng mới. Phần còn lại là một biểu thức chính quy đơn giản.

In 1cho đầu vào hợp lệ, 0không hợp lệ.

Python, 58 44 byte

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

-14 bởi tbodt

Perl , 26 byte

24 byte mã + 2 byte cho -apcờ.

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

Hãy thử trực tuyến!

Bình thường, 9 byte

qj464T/R;

Một chương trình lấy đầu vào của một danh sách "quoted strings"và in Truehoặc Falsekhi thích hợp.

Bộ kiểm tra

Làm thế nào nó hoạt động

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

Japt , 11 byte

Đã lưu rất nhiều byte nhờ @ETHproductions

Điều này có một mảng ba chuỗi làm đầu vào.

®¸lÃ¥"5,7,5

Chạy nó trực tuyến!

PowerShell , 43 byte

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

Hãy thử trực tuyến!

Giải trình

Đưa đầu vào dưới dạng một chuỗi phân tách dòng mới.

Xóa tất cả các khoảng trắng, sau đó kiểm tra xem nó có khớp chính xác với "4 khoảng trắng, dòng mới, 6 khoảng trắng, dòng mới, 4 dòng mới" bằng cách sử dụng biểu thức chính quy.

Nhóm chụp phù hợp với 4 không gian, độ phản chiếu \1đề cập đến điều đó. Dòng mới được nhúng trong chuỗi. Lưu ý dòng thứ hai của regex chứa hai khoảng trắng sau phản hồi.

Pyke, 11 9 byte

dL/uq

Hãy thử nó ở đây!

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

Sau ubyte có các byte sau:0x03 0x04 0x06 0x04

J, 12 byte

4 6 4=#@;:@>

Đầu vào là một danh sách các chuỗi.

Giải trình

Đây là một ngã ba với một tine trái không đổi. Điều này kiểm tra kết quả của tine phải #@;:@>, cho sự bình đẳng với 4 6 4. Đúng thời điểm bỏ hộp từng ( >), sau đó ( @) chuyển đổi từng chuỗi thành các từ ( ;:), sau đó ( @) lấy độ dài của mỗi ( #).

R, 48 byte

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

Đọc một vectơ ký tự dài 3 từ stdin và hoạt động bằng cách đếm số lượng khoảng trắng. Để đếm số lượng không gian chúng tôi sử dụng str_counttừ stringrgói có thể đếm số lần xuất hiện dựa trên mẫu biểu thức chính quy.

Một cách tiếp cận khác mà không sử dụng các gói có thể là:

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

C 142 byte

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);}

Phiên bản bị đánh cắp:

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);
}

Trả về 1 cho chuỗi 5/7/5 khác 0.

Một thử nghiệm tích cực:

C ++, 357 byte

Sắp xếp mới cho mã golf, nhưng đây là cách tốt nhất tôi có thể làm nhanh chóng

#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;
}

Ruby 1.9.3

Không chơi gôn, nhưng bản thân nó là một haiku-w

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

hoặc là...

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

Thật không may, không hoạt động với khoảng trắng hàng đầu trên bất kỳ dòng nào, nhưng không đối phó với dấu vết.

Python 2 , 57 64 byte

Chỉnh sửa Đã sửa với việc thêm 7 byte sau phản hồi từ @Dada. Cảm ơn!

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

Hãy thử trực tuyến!

Không phải là câu trả lời Python ngắn nhất trong một chặng đường dài mà chỉ muốn sử dụng thủ thuật mới mà tôi đã học gần đây về việc sử dụng input()để hiển thị đầu ra và lưu một printcâu lệnh. Đưa ra một danh sách các dòng làm đầu vào. Yêu cầu Ctrl C (hoặc bất kỳ phím bấm nào khác cho vấn đề đó) để chấm dứt chương trình (có ngoại lệ) trong một thiết bị đầu cuối nhưng hoạt động tốt mà không cần trên TIO.

MATL, 16 byte

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

Đầu vào là một mảng ô của chuỗi và trả về một mảng trung thực hoặc falsey .

Dùng thử trực tuyến

Giải trình

        % 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

MATLAB / Octave, 38 byte

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

Giải pháp này chấp nhận một chuỗi ô là chuỗi đầu vào, đếm số khoảng trắng trong mỗi dòng và sau đó so sánh kết quả với mảng [4 6 4]và mang lại một mảng trung thực (tất cả các giá trị là 1) hoặc falsey (bất kỳ giá trị nào đều bằng 0).

Bản demo trực tuyến

Perl 6 , 25 byte

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

Clojure, 44 byte

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

Đầu vào là danh sách các chuỗi. Hàm chỉ tìm thấy khoảng trắng và đếm chúng. Giải thích này là một Haiku. :)

Java 7, 154 byte

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);}}

Yêu cầu chương trình và tiềm năng của việc có ít hơn hoặc nhiều hơn ba dòng, không đề cập đến tính chính xác của Java, khiến cho mã 'được đánh gôn' này trở nên khá lớn ..

Ung dung:

Hãy thử nó ở đây.

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);
  }
}

SimpleTemplate, 77 byte

Đáng buồn thay, aproach biểu hiện thường xuyên là ngắn nhất.

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

Yêu cầu văn bản được đưa ra làm đối số đầu tiên, với các dòng mới * kiểu NIX. Điều này sẽ không hoạt động với các dòng mới theo phong cách Windows.

Ung dung:

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

Không dựa trên regex, 114 tạm biệt

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

Điều này đòi hỏi mỗi dòng được đưa ra làm đối số cho hàm.

Ung dung:

{@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}

Xếp chồng lên nhau, 22 byte

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

Lấy đầu vào từ đầu ngăn xếp dưới dạng danh sách các chuỗi ký tự, như sau:

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

Giải trình

[' '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)

Java (OpenJDK) , 82 byte

-2 byte nhờ @ corvus_192!

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

Hãy thử trực tuyến!

Nó trông có thể chơi được nhưng không có chức năng bản đồ dựng sẵn, tôi không thể tìm thấy một cách hay. Lặp lại qua mảng dài hơn một vài byte, như đang viết một hàm bản đồ bằng cách sử dụng các luồng.

Biểu thức Lambda lấy một mảng của Chuỗi và trả về Boolean.

SmileBASIC, 96 94 byte

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

R, 100 byte

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

Lấy làm đối số một danh sách dài 3 chuỗi. Có lẽ sẽ không được đánh gôn thêm nữa vì việc đánh gôn tiếp tục biến nó thành câu trả lời của @ Billywob.