Herausforderungsbeschreibung

In dieser Herausforderung betrachten wir nur loveund hateals Gefühle. Wenn wir einen Gefühlsausdruck der Ordnung aussprechen wollen N, wechseln wir zwischen diesen beiden (beginnend mit 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.

Das Muster folgt für jede positive ganze Zahl N. Geben Sie Nden entsprechenden Gefühlsausdruck der Ordnung aus N.

Anmerkungen

• Punkt ( .) am Ende des Ausdrucks ist obligatorisch,
• Nachgestellte und führende Leerzeichen (einschließlich Zeilenumbrüche) sind zulässig.
• Die Ausgabe für eine nicht positive oder nicht ganzzahlige Zahl Nist undefiniert.
• Dies ist eine Code-Golf- Herausforderung, also mach deinen Code so kurz wie möglich!

Python, 54 Bytes

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

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

CJam , 36 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

Vielen Dank an @Leaky Nun für das Speichern von 11 Bytes und das Hinzufügen von 4 Bytes!
Vielen Dank an @YSC für das Speichern eines Bytes!

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

Probieren Sie es auf Ideone

Javascript (ES6), 75 73 70 Bytes

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

2 Bytes dank Neil
gespeichert 3 Bytes dank Whothehellisthat gespeichert

Prüfung

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 Bytes

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

Ungolfed-Testprogramm

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 Bytes

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

Gelee , 25 Bytes

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

Probieren Sie es online!

Erläuterung

                             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 Bytes

5 Bytes gespart dank Adnan .

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

Erläuterung

“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

Probieren Sie es online!

R, 79 Bytes

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

Glücklicherweise ist in R das Standardtrennzeichen für catein Leerzeichen.

(Bearbeitet von der ursprünglichen 73-Byte-Version, die das Problem nicht ganz gelöst hat.)

Netzhaut , 42 38 Bytes

Vielen Dank an Leaky Nun, die mir geholfen hat, Golf zu spielen!

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

Die Eingabe erfolgt unär.

Probieren Sie es online!

Erläuterung

11
1I love n

Ersetzen Sie jedes Paar von 1s durch 1I love n.

1
I hate n

Ersetzen Sie die verbleibenden 1s durch I hate n.

n$
it.
n
that 

Ersetzen Sie das nam Ende der Zeile mit it.und alle anderen n mit that .

Javascript (ES5), 99 bis 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}

5 Bytes dank Leaky Nun gespeichert.

ALTE 99-Byte-Lösung:

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

Eine weitere 98-Byte-Lösung:

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

Mein Code vor der Verkleinerung:

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 Bytes

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.'

Eher unkompliziert. Schleifen von 1bis zur Eingabe $args[0], wobei jede Iteration entweder 'I love'oder 'I hate'in der Pipeline platziert wird, basierend auf einem Pseudoternär für Modulo-2 (dh abwechselnd vor und zurück, beginnend mit 'I hate'). Diese Zeichenketten werden in Pars gekapselt und -joined mit ' that 'ihnen zusammen smush, dann String - Verkettung ' it.'am Ende.

Testfälle

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 Bytes

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

Leider konnte ich es nicht vermeiden, das "Ich" zu wiederholen, oder zumindest nicht in weniger als 7 Bytes.

edit: 2 Bytes gespart dank @ Jörg Hülsermann

Perl, 62 54 50 Bytes

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

( Dank an @Ton Hospel )

Demo: http://ideone.com/zrM27p

Bisherige Lösungen:

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

(Gutschrift an @Dada )

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

Erste Lösung (nur das war meins)

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

In Teilen:

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

Demo: http://ideone.com/mosnVz

Bash + Coreutils, 106 Bytes:

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

Erstellt einfach eine Sequenz, die mit der integrierten Funktion 1bis einschließlich der Eingabe-Ganzzahl beginnt seq, und durchläuft sie dann nacheinander. Dabei wird zunächst ausgegeben, hateob der Wert der Iterationsvariablen,, inicht durch 2und durch teilbar ist love. In derselben Iteration wählt es dann die Ausgabe, thatwenn inicht gleich dem Eingabewert ist, und it.andernfalls.

Probieren Sie es online! (Ideone)

/// 60 57 Bytes

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

-3 Bytes dank m-chrzan

Eingabe in unary mit nachfolgender neuer Zeile.

Probieren Sie es online!

R 92 90 Bytes

Eine R-Adaption von @Leaky Nuns Python-Antwort. Das Arbeiten mit Strings in R ist wie immer mühsam.

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

Dies könnte aber wahrscheinlich weiter golfen werden.

Bearbeiten: 2 Bytes gespeichert durch Ändern von:

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

C 96 Bytes

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

Ich habe die obige Lösung von Releasing Helium Nuclei nicht gesehen, was besser ist.

MATL , 37 Bytes

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

Probieren Sie es online!

Erläuterung

Der Code basiert auf der folgenden Zuordnung von Zahlen zu Zeichenfolgen:

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

Das Programm schiebt Zahlen auf den String in Gruppen von drei: 2, 0, 3; dann 2, 1, 3; dann 2, 0, 3; ... so oft wie die Eingabe n. Danach wird das Finale 3in ein umgewandelt 4, die Zuordnung wird angewendet, um Zahlen in Zeichenfolgen umzuwandeln, und die Zeichenfolgen werden unter Verwendung von Leerzeichen als Trennzeichen verbunden.

:                         % 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 Bytes

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

Erstellt die Zeichenfolge rekursiv mit einem optionalen Parameter, um festzustellen, welcher Hass / welche Liebe und wie viele angehängt werden sollen.

-2 Bytes von diesem Tipp zum Überprüfen der Ebenheit / Ungerade einer Zahl.

Keine optionale Parameterlösung, 87 86 84 Bytes

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

Dieser tut dasselbe, außer dass er bestimmt, welcher Hass / welche Liebe angehängt werden soll, basierend darauf, ob der Parameter positiv oder negativ ist. Bei jeder Iteration nähert sich der Parameter dem Vorzeichen Null.

Thue, 100 Bytes

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

Nimmt Eingaben als unär. (Eine Zeichenfolge von n #s)

Pyke, 36 Bytes

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

Probieren Sie es hier aus!

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

Auch 36 Bytes

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

Probieren Sie es hier aus! (Link verwendet Xstatt I, dies sollte für die gleiche Anzahl von Bytes offline funktionieren, wo Sie diese Bytes buchstäblich verwenden können. Online \rwird automatisch ersetzt durch \n)

> <> (Fisch), 82 Bytes

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

Zweifel, es ist sehr effizient, aber es scheint mehr oder weniger zu funktionieren. Die Eingabe erfolgt über den Startstapel, wodurch die Punktzahl 85 Bytes beträgt, wenn Sie die Größe des dafür -verforderlichen Arguments angeben.

Probieren Sie es online!

Lua, 75 Bytes

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

/// 68 Bytes

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

Eingabe in unary - fügen Sie 1im letzten Abschnitt weitere s hinzu.

Probieren Sie es online!

Gleichstrom, 75 Bytes

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

Wir drucken hier wirklich nur einen Strang nach dem anderen und hinterlassen keinen Müll auf dem Stapel. Das ist großartig, wir müssen keine Bytes verschwenden, die mit einem Register für unseren Zähler zu tun haben.

?                              #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 Bytes

Dachte ich füge eine julia Lösung hinzu:

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