Mô tả thử thách

Trong thử thách này, chúng tôi chỉ xem xét lovevà hatenhư là cảm xúc. Nếu chúng ta muốn nói ra một biểu hiện cảm giác về trật tự N, chúng ta sẽ xen kẽ giữa hai điều này (bắt đầu bằng hate):

order | expression

1       I hate it.
2       I hate that I love it.
3       I hate that I love that I hate it.
4       I hate that I love that I hate that I love it.

Các mẫu sau cho mỗi số nguyên dương N. Cho N, xuất ra biểu thức cảm giác sửa chữa trật tự N.

Ghi chú

• Dừng hoàn toàn ( .) ở cuối biểu thức là bắt buộc,
• Trailing và khoảng trắng hàng đầu (bao gồm cả dòng mới) được cho phép,
• Đầu ra cho một số nguyên không dương hoặc không nguyên Nkhông được xác định,
• Đây là một thử thách chơi gôn , vì vậy hãy viết mã của bạn càng ngắn càng tốt!

Python, 54 byte

lambda n:("I hate that I love that "*n)[:12*n-5]+"it."

• Python 2: Tôi nghĩ vậy!
• Python 3: Tôi nghĩ vậy!

CJam , 36 byte

ri{"hatlov"3/='IS@"e that "}/2<"it."

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

Giải trình

ri            e# Read input and convert to integer N.
{             e# For each i from 0 to N-1...
  "hatlov"3/  e#   Push ["hat" "lov"].
  =           e#   Use i as a cyclic index into this array to alternate between
              e#   "hat" and "lov".
  'IS         e#   Push character 'I' and a space.
  @           e#   Pull "hat" or "lov" on top of it.
  "e that "   e#   Push "e that "
}/
2<            e#   Truncate the last "e that " to just "e ".
"it."         e#   Push "it."

C, 83 76 75 74 byte

Cảm ơn @Leaky Nun vì đã lưu 11 byte và thêm 4 byte!
Cảm ơn @YSC vì đã tiết kiệm một byte!

i;f(n){for(i=0;n--;)printf("I %se %s",i++%2?"lov":"hat",n?"that ":"it.");}

Hãy thử nó trên Ideone

Javascript (ES6), 75 73 70 byte

n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

Đã lưu 2 byte nhờ Neil
Lưu 3 byte nhờ Whothehellisthat

Kiểm tra

let f =
n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))

Java 8, 91 byte

i->{for(int j=0;j++<i;)System.out.printf("I %se %s",j%2>0?"hat":"lov",j<i?"that ":"it.");};

Chương trình kiểm tra Ungolfed

public static void main(String[] args) {
    Consumer<Integer> c = i -> {
        for (int j = 0; j++ < i;) {
            System.out.printf("I %se %s", j % 2 > 0 ? "hat" : "lov", j < i ? "that " : "it.");
        }
    };

    c.accept(1);
    c.accept(2);
    c.accept(3);
}

Toán học, 63 byte

"I love"["I hate"][[#~Mod~2]]&~Array~#~Riffle~" that "<>" it."&

Thạch , 25 byte

“ṅɠT5“£ẏkg⁷»ṁj“¥ıQ»ṙ1“it.

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

Giải trình

                             Input: n, a number.
“ṅɠT5“£ẏkg⁷»                 Compressed string array [' I hate', ' I love']
            ṁ                Cycle for n repetitions.
             j“¥ıQ»          Join by compressed string ' that'.
                   ṙ1        Rotate left once: move the initial space to the end.
                     “it.    Implicitly print the result, then print 'it.'

05AB1E , 34 32 27 byte

Đã lưu 5 byte nhờ Adnan .

“I«¢€Š I„΀Š “×¹12*5-£…it.«

Giải trình

“I«¢€Š I„΀Š “               # "I hate that I love that "
              ×              # repeat input nr of times
               ¹12*5-£       # take the first input*12-5 chars of string above
                      …it.«  # append "it."
                             # implicitly display

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

R, 79 byte

n=scan();for(i in n:1)cat(if((i+n)%%2)"I love"else"I hate",if(i>1)"that "else"it.")

May mắn thay trong R, dấu phân cách mặc định cho catlà một khoảng trắng.

(Được chỉnh sửa từ phiên bản 73 byte ban đầu không giải quyết được vấn đề.)

Võng mạc , 42 38 byte

Cảm ơn Leaky Nun đã giúp tôi chơi golf!

11
1I love n
1
I hate n
n$
it.
n
that 

Đầu vào được thực hiện trong unary.

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

Giải trình

11
1I love n

Thay thế mọi cặp 1s bằng 1I love n.

1
I hate n

Thay thế các 1s còn lại bằng I hate n.

n$
it.
n
that 

Thay thế nở cuối dòng bằng it.và mọi n khác bằng that .

Javascript (ES5), 99 94 byte

function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}

Đã lưu 5 byte nhờ Leaky Nun.

Giải pháp OLD 99 byte:

function(c){for(d="",b=0;b<c;++b)d+=(0==b%2?"I hate":"I love")+" "+(b==c-1?"it.":"that ");return d}

Một giải pháp 98 byte khác:

function(d){for(c=[],b=0;b<d;++b)c.push(["love","hate"][b%2]);return"I "+c.join(" that I ")+" it"}

Mã của tôi trước khi thu nhỏ:

function a(n){
  var hate="I hate",love="I love",it="it ",that="that ",out="";
  for(var i=0;i<n;++i){out+=(i%2==0?hate:love)+" "+(i==n-1?it+".":that)}return out;
}

Haskell, 70 byte

g 1="I hate";g n=g(n-1)++" that "++cycle["I love",g 1]!!n
(++" it.").g

PowerShell v2 +, 64 byte

((1..$args[0]|%{('I love','I hate')[$_%2]})-join' that ')+' it.'

Khá đơn giản. Các vòng lặp từ 1lên đến đầu vào $args[0], mỗi lần lặp đặt 'I love'hoặc 'I hate'trên đường ống, dựa trên giả ba cho modulo-2 (nghĩa là nó thay đổi qua lại, bắt đầu bằng 'I hate'). Các chuỗi đó được gói gọn trong parens và -joined với ' that 'để làm nhòe chúng lại với nhau, sau đó nối chuỗi ' it.'ở cuối.

Các trường hợp thử nghiệm

PS C:\Tools\Scripts\golfing> 1..5|%{.\hate-love-conundrum.ps1 $_}
I hate it.
I hate that I love it.
I hate that I love that I hate it.
I hate that I love that I hate that I love it.
I hate that I love that I hate that I love that I hate it.

php, 64 62 byte

<?=str_pad("",$argv[1]*12-5,"I hate that I love that ")."it.";

Thật không may, tôi không thể tìm ra cách để tránh lặp lại "cái tôi" đó, hoặc ít nhất là không có cách nào để làm điều đó trong ít hơn 7 byte.

chỉnh sửa: đã lưu 2 byte nhờ @ Jörg Hülsermann

Perl, 62 54 50 byte

$_="I xe tx "x$_;s/tx $/it./;s/x/++$.%4?hat:lov/ge

(ghi có vào @TonMedel )

Bản trình diễn: http://ideone.com/zrM27p

Giải pháp trước đây:

$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./

(ghi có vào @Dada )

Chạy với perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'

Giải pháp đầu tiên (chỉ có điều này là của tôi)

for$x(1..<>){$_.=' I '.($x%2?hat:lov).'e that'}s/\w+$/it./;say

Trong các bộ phận:

for $x (1..<>) {
   $_ .= ' I '.($x % 2 ? hat : lov).'e that'
}
s/\w+$/it./;
say

Bản trình diễn: http://ideone.com/mosnVz

Bash + coreutils, 106 byte:

for i in `seq $1`;{ printf "I %s %s " `((i%2>0))&&echo hate||echo love` `((i==$1))&&echo it.||echo that`;}

Đơn giản chỉ cần tạo một chuỗi bắt đầu từ 1tối đa và bao gồm số nguyên đầu vào bằng cách sử dụng tích seqhợp và sau đó lặp qua từng cái một, đầu tiên xuất ra hatenếu giá trị của biến lặp i, không thể chia hết 2và lovengược lại. Trong cùng một lần lặp, sau đó nó chọn đầu ra thatnếu ikhông bằng giá trị đầu vào, và it.ngược lại.

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

///, 60 57 byte

/!/I hate //T/that //
/it.//00/!TI love T//Tit./it.//0/!/

-3 byte nhờ m-chrzan

Đầu vào trong unary với dòng mới.

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

R, 92 90 byte

Một bản phóng tác R của câu trả lời trăn của @Leaky Nun. Làm việc với các chuỗi trong R là tẻ nhạt như mọi khi.

n=scan();cat(rep(strsplit("I hate that I love that ","")[[1]],n)[6:(n*12)-5],"it.",sep="")

Điều này có thể có thể được chơi golf hơn mặc dù.

Chỉnh sửa: đã lưu 2 byte bằng cách thay đổi:

[1:((n*12)-5)]đến [6:(n*12)-5]

C, 96 byte

c;f(i){printf("I hate");for(;c<i+1/2-1;c++)printf(" that I %s",c&1?"hate":"love");puts(" it.");}

Tôi đã không thấy giải pháp trên từ Phát hành Helium Nuclei thì tốt hơn.

MATL , 37 byte

:"2@o3]Qv'hate I that it. love'Ybw)Zc

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

Giải trình

Mã này dựa trên ánh xạ sau từ số sang chuỗi:

0: 'love'
1: 'hate'
2: 'I'
3: 'that'
4: 'it.'

Chương trình đẩy số vào chuỗi trong nhóm của ba: 2, 0, 3; sau đó 2, 1, 3; sau đó 2, 0, 3; ... nhiều lần như đầu vào n. Sau đó, trận chung kết 3được chuyển thành a 4, ánh xạ được áp dụng để chuyển đổi số thành chuỗi và chuỗi được nối bằng cách sử dụng khoảng trắng làm dấu phân cách.

:                         % Input n implicitly. Push range [1 2 ... n]
"                         % For each
  2                       %   Push 2
  @o                      %   Iteration index modulo 2: pushes 0 or 1
  3                       %   Push 3
]                         % End
Q                         % Add 1 to the last 3
v                         % Concatenate stack contents into a numeric column vector
'hate I that it. love'    % Push this string
Yb                        % Split at spaces. Gives a cell array of five strings
w                         % Swap to move numeric vector to top
)                         % Index cell array of strings with that vector. Indexing
                          % is 1-based and modular, so 0 refers to the last string.
                          % This gives a cell array of (repeated) strings
Zc                        % Join those strings by spaces. Display implicitly

JavaScript (ES6), 68 byte

f=(n,i)=>n?(i?' that I ':'I ')+(i&1?'love':'hate')+f(n-1,-~i):' it.'

document.write('<pre>'+[ 1, 2, 3, 4, 10, 100 ].map(c=>c+': '+f(c)).join`\n`);

C #, 85 83 byte

string f(int n,int m=2)=>"I "+(1>m%2?"hat":"lov")+(m>n?"e it.":"e that "+f(n,m+1));

Xây dựng đệ quy chuỗi, sử dụng một tham số tùy chọn để theo dõi sự ghét / yêu nào và bao nhiêu để nối thêm.

-2 byte từ mẹo này để kiểm tra độ chẵn / lẻ của một số.

Không có giải pháp tham số tùy chọn, 87 86 84 byte

string h(int n)=>"I "+(0<n?"hat":"lov")+(2>n&-2<n?"e it.":"e that "+h(0<n?~n+2:~n));

Điều này thực hiện điều tương tự ngoại trừ xác định ghét / thích nào để nối thêm dựa trên tham số đó là dương hay âm. Mỗi lần lặp tham số tiến đến 0, dấu xen kẽ.

Thứ ba, 100 byte

@::=:::
>##::=>$.
$::=~I hate that I love 
>.#::=>&#
&::=~that 
>#<::=~I hate it.
>.<::=~it.
::=
>@<

Đưa đầu vào là unary. (Một chuỗi n #s)

Pyke, 36 byte

2/"I hate ""I love "]*"that "J"it."+

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

2/                                   -    input/2
                     *               -   ^ * v
  "I hate ""I love "]                -    ["I hate ", "I love "]
                      "that "J       -  "that ".join(^)
                              "it."+ - ^+"it."

Cũng 36 byte

12*5+.daෆ   ű   l5d+12"I ":Q*<"it."+

Hãy thử nó ở đây! (Liên kết sử dụng Xthay vì I, điều này sẽ hoạt động với cùng một lượng byte ngoại tuyến nơi bạn có thể sử dụng các byte đó theo nghĩa đen. Trực tuyến \rđược tự động thay thế bằng \n)

> <> (Cá), 82 byte

' I'oov.2coo<;oooo' it.'<
'ahv'v>'et'
oop26<^ooooo^o' that I '^!?:-1oo
'ol^'^>'ev'

Nghi ngờ nó rất hiệu quả, nhưng nó dường như ít nhiều làm việc. Đầu vào là thông qua ngăn xếp bắt đầu, làm cho số điểm 85 Byte nếu bạn bao gồm kích thước của -vđối số được yêu cầu để làm như vậy.

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

Lua, 75 byte

n=io.read();print(('I hate that I love that '):rep(n):sub(1,n*12-5)..'it.')

/// , 68 byte

/@/1\/#love //%/hate//#/that I //%1i/% i//I %1/I % //1@#% //@/I %1it.

Đầu vào trong unary - thêm 1s trong phần cuối.

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

dc, 75 byte

?[1-lbP[I lov]P]sa[e that ]sb[[e it.]Pq]sc[1-[I hat]Pd2%1=ad1>clbPlxx]dsxx

Chúng tôi thực sự chỉ in một đoạn chuỗi tại một thời điểm ở đây và không để lại bất kỳ rác nào trên ngăn xếp. Điều này thật tuyệt, chúng ta không cần lãng phí bất kỳ byte nào liên quan đến một thanh ghi cho bộ đếm của chúng ta.

?                              #Input, works as our decrement counter
[1-lbP[I lov]P]sa              #Macro 'a' decrements our counter, prints string 'b', 
                               #then prints 'I lov'
[e that ]sb                    #String 'b'
[[e it.]Pq]sc                  #Macro 'c' prints the tail end of our message and quits
[1-                            #I'll unfold our main macro here; first step is to 
                               #decrement our counter
   [I hat]P                    #We always start by hating 'it,' no conditional needed
           d2%1=a              #Check the oddness of our counter; execute 'a' if odd
                 d1>c          #Check our counter; If we're done, execute 'c'
                     lbPlxx]   #Otherwise, print 'b' again and start this macro ('x') over
dsxx                           #Stores the above macro as 'x' and runs it.

Julia, 91 byte

Nghĩ rằng tôi thêm một giải pháp julia:

f(N)=string("I hate ",join(["that I love that I hate " for _ in 1:N-1])[1:12*(N-1)],"it."))