Opis wyzwania

W tym wyzwaniu traktujemy tylko lovei hatejako uczucia. Jeśli chcemy wypowiedzieć wyrażenie porządku N, przełączamy się między nimi (zaczynając od 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.

Wzór jest następujący dla każdej dodatniej liczby całkowitej N. Biorąc pod uwagę N, wypowiedz odpowiednie odczucie wyrażenia porządku N.

Notatki

• Kropka ( .) na końcu wyrażenia jest obowiązkowa,
• Dozwolone są końcowe i wiodące białe znaki (w tym znaki nowej linii),
• Dane wyjściowe dla wartości dodatnich lub niecałkowitych Nsą niezdefiniowane,
• Jest to wyzwanie dla golfistów , dlatego ustaw swój kod tak krótko, jak to możliwe!

Python, 54 bajty

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

• Python 2: Ideone!
• Python 3: Ideone!

CJam , 36 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajty

Dzięki @Leaky Nun za uratowanie 11 bajtów i dodanie 4 bajtów!
Dzięki @YSC za uratowanie bajtu!

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

Wypróbuj na Ideone

JavaScript (ES6), 75 73 70 bajtów

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

Zapisano 2 bajty dzięki Neilowi
Zapisano 3 bajty dzięki Whothehellisthat

Test

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 bajtów

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

Program testów bez golfa

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

Mathematica, 63 bajty

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

Galaretka , 25 bajtów

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

Wypróbuj online!

Wyjaśnienie

                             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 bajtów

Zaoszczędzono 5 bajtów dzięki Adnan .

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

Wyjaśnienie

“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

Wypróbuj online!

R, 79 bajtów

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

Na szczęście w R domyślnym separatorem dla catspacji jest spacja.

(Edytowane z oryginalnej 73-bajtowej wersji, która nie całkiem rozwiązała problem).

Siatkówka , 42 38 bajtów

Dzięki Leaky Nun za pomoc w grze w golfa!

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

Dane wejściowe są przyjmowane jednostkowo.

Wypróbuj online!

Wyjaśnienie

11
1I love n

Zamień każdą parę 1s na 1I love n.

1
I hate n

Zamień pozostałe 1s na I hate n.

n$
it.
n
that 

Zamień nna końcu linii na it.i co drugi n na that .

JavaScript (ES5), 99 94 bajtów

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

Zaoszczędź 5 bajtów dzięki Leaky Nun.

OLD 99 bajtowe rozwiązanie:

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

Kolejne 98-bajtowe rozwiązanie:

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

Mój kod przed minifikacją:

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 bajtów

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

PowerShell v2 +, 64 bajty

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

Raczej proste. Pętle z 1góry na wkład $args[0], przy czym każdy wprowadzania iteracji jednej 'I love'lub 'I hate'w rurociągu, w oparciu o pseudo trójskładnikowymi za modulo-2 (IE, naprzemiennie tam i z powrotem, począwszy 'I hate'). Ciągi te są obudowane w parens i -joined z ' that 'do smush je ze sobą, a następnie ciąg konkatenacji ' it.'na końcu.

Przypadki testowe

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 bajtów

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

Niestety nie udało mi się znaleźć sposobu, aby uniknąć powtórzenia „tego, co ja”, a przynajmniej nie można tego zrobić w mniej niż 7 bajtach.

edycja: zapisane 2 bajty dzięki @ Jörg Hülsermann

Perl, 62 54 50 bajtów

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

(kredyt dla @Ton Hospel )

Demo: http://ideone.com/zrM27p

Poprzednie rozwiązania:

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

(kredyt dla @Dada )

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

Pierwsze rozwiązanie (tylko to było moje)

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

W częściach:

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

Demo: http://ideone.com/mosnVz

Bash + coreutils, 106 bajtów:

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

Po prostu tworzy sekwencję rozpoczynającą 1się od liczby całkowitej wejściowej włącznie, używając seqwbudowanego, a następnie iteruje ją jeden po drugim, najpierw wypisując, hatejeśli wartość zmiennej iteracyjnej i, nie jest podzielna przez 2i w loveżaden inny sposób. W tej samej iteracji wybiera wyjście, thatjeśli inie jest równe wartości wejściowej, i w it.przeciwnym razie.

Wypróbuj online! (Ideone)

///, 60 57 bajtów

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

-3 bajty dzięki m-chrzan

Wejście unarne z końcowym nowym wierszem.

Wypróbuj online!

R, 92 90 bajtów

Adaptacja R odpowiedzi pytona @Leaky Nun. Praca z ciągami w języku R jest nużąca jak zawsze.

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

Prawdopodobnie można to jednak pograć w golfa.

Edycja: zapisano 2 bajty, zmieniając:

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

C, 96 bajtów

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

Nie widziałem powyższego rozwiązania z Uwolnienie jądra helu, które jest lepsze.

MATL , 37 bajtów

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

Wypróbuj online!

Wyjaśnienie

Kod opiera się na następującym odwzorowaniu liczb na ciągi znaków:

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

Program popycha do ciągu liczb w trzech grupach: 2, 0, 3; Następnie 2, 1, 3; Następnie 2, 0, 3; ... tyle razy ile danych wejściowych n. Następnie finał 3jest przekształcany w a 4, mapowanie jest stosowane do przekształcania liczb na ciągi, a ciągi są łączone za pomocą spacji jako separatora.

:                         % 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 bajtów

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 bajtów

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

Rekurencyjnie konstruuje ciąg, używając opcjonalnego parametru, aby śledzić, która nienawiść / miłość i ile dołączyć.

-2 bajty od tej wskazówki do sprawdzania parzystości / nieparzystości liczby.

Brak opcjonalnego rozwiązania parametru, 87 86 84 bajtów

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

Ten robi to samo, z wyjątkiem tego, który określa nienawiść / miłość do dołączenia na podstawie tego, czy parametr jest dodatni czy ujemny. Każda iteracja parametru zbliża się do zera, naprzemiennie.

Czw. 100 bajtów

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

Traktuje dane wejściowe jako jednoargumentowe. (Ciąg n #s)

Pyke, 36 bajtów

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

Wypróbuj tutaj!

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

Również 36 bajtów

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

Wypróbuj tutaj! ( XZamiast tego używa linku I, powinno to działać dla tej samej ilości bajtów offline, gdzie można dosłownie użyć tych bajtów. Online \rzostaje automatycznie zastąpione \n)

> <> (Ryba), 82 bajtów

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

Wątpię, że jest bardzo wydajny, ale wydaje się, że mniej więcej działa. Dane wejściowe są -vprzekazywane przez stos początkowy, co daje wynik 85 bajtów, jeśli podasz rozmiar argumentu wymaganego do tego.

Wypróbuj online!

Lua, 75 bajtów

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

/// , 68 bajtów

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

Wprowadź unarne - dodaj więcej 1s w ostatniej sekcji.

Wypróbuj online!

dc, 75 bajtów

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

Naprawdę po prostu drukujemy po jednym kawałku sznurka na raz i nie pozostawiamy żadnych śmieci na stosie. To świetnie, nie musimy marnować żadnych bajtów zajmujących się rejestrem naszego licznika.

?                              #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 bajtów

Myślałem, że dodam rozwiązanie Julii:

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