Description du défi

Dans ce défi, nous considérons uniquement loveet en hatetant que sentiments. Si nous voulons prononcer une expression sentimentale d'ordre N, nous alternons entre ces deux (à commencer par 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.

Le modèle suit pour chaque entier positif N. Étant donné N, affichez l'expression de sentiment d'ordre correspondant N.

Remarques

• Le point .final ( ) à la fin de l'expression est obligatoire,
• Les espaces de fin et de début (y compris les sauts de ligne) sont autorisés,
• La sortie pour un non positif ou non entier Nn'est pas définie,
• C'est un défi de code-golf , alors faites votre code aussi court que possible!

Python, 54 octets

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

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

CJam , 36 octets

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

Essayez-le en ligne!

Explication

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 octets

Merci à @Leaky Nun d'avoir sauvé 11 octets et ajouté 4 octets!
Merci à @YSC d'avoir enregistré un octet!

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

Essayez-le sur Ideone

Javascript (ES6), 75 73 70 octets

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

Enregistré 2 octets grâce à Neil
Enregistré 3 octets grâce à Whothehellisthat

Tester

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 octets

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

Programme de test non golfé

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 octets

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

Gelée , 25 octets

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

Essayez-le en ligne!

Explication

                             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 octets

Enregistré 5 octets grâce à Adnan .

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

Explication

“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

Essayez-le en ligne!

R, 79 octets

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

Heureusement dans R, le séparateur par défaut pour catest un espace.

(Modifié à partir de la version originale de 73 octets qui n'a pas tout à fait résolu le problème.)

Rétine , 42 38 octets

Merci à Leaky Nun de m'avoir aidé à jouer au golf!

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

L'entrée est prise en unaire.

Essayez-le en ligne!

Explication

11
1I love n

Remplacez chaque paire de 1s par 1I love n.

1
I hate n

Remplacez les 1s restants par I hate n.

n$
it.
n
that 

Remplacez le nà la fin de la ligne par it.et tous les autres n par that .

Javascript (ES5), 99 94 octets

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

5 octets enregistrés grâce à Leaky Nun.

Ancienne solution à 99 octets:

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

Une autre solution de 98 octets:

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

Mon code avant minification:

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 octets

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

PowerShell v2 +, 64 octets

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

Plutôt simple. Les boucles de 1haut à l'entrée $args[0], chaque itération de mise en place ou l' autre 'I love'ou 'I hate'sur le pipeline, en fonction d'un pseudo-ternaire de modulo-2 ( à savoir, il alterne d' avant en arrière, en commençant par 'I hate'). Ces chaînes sont encapsulées dans des parenthèses et éditées -joinavec ' that 'pour les mélanger ensemble, puis la concaténation des chaînes ' it.'à la fin.

Cas de test

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 octets

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

Malheureusement, je n'ai pas pu trouver un moyen d'éviter de répéter le "que je", ou du moins aucun moyen de le faire en moins de 7 octets.

edit: sauvé 2 octets grâce à @ Jörg Hülsermann

Perl, 62 54 50 octets

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

(crédit à @Ton Hospel )

Démo: http://ideone.com/zrM27p

Solutions précédentes:

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

(crédit à @Dada )

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

Première solution (seulement c'était la mienne)

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

En partie:

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

Démo: http://ideone.com/mosnVz

Bash + coreutils, 106 octets:

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

Crée simplement une séquence commençant 1jusqu'à et incluant l'entier d'entrée à l'aide de la fonction seqintégrée, puis l'itère une par une, en émettant d'abord hatesi la valeur de la variable d'itération `` i, n'est pas divisible par 2ou loveautrement. Dans la même itération, il choisit alors de sortir thatsi in'est pas égal à la valeur d'entrée, et it.sinon.

Essayez-le en ligne! (Ideone)

///, 60 57 octets

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

-3 octets grâce à m-chrzan

Entrée en unaire avec une nouvelle ligne de fin.

Essayez-le en ligne!

R, 92 90 octets

Une adaptation R de la réponse python de @Leaky Nun. Travailler avec des chaînes dans R est fastidieux comme toujours.

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

Cela pourrait probablement être joué plus loin.

Edit: enregistré 2 octets en changeant:

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

C, 96 octets

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

Je n'ai pas vu la solution ci-dessus de Releasing Helium Nuclei qui est meilleure.

MATL , 37 octets

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

Essayez-le en ligne!

Explication

Le code est basé sur le mappage suivant des nombres aux chaînes:

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

Le programme pousse les numéros à la chaîne en groupes de trois: 2, 0, 3; puis 2, 1, 3; puis 2, 0, 3; ... autant de fois que l'entrée n. Après cela, la finale 3est transformée en a 4, le mappage est appliqué pour transformer les nombres en chaînes et les chaînes sont jointes en utilisant l'espace comme séparateur.

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

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 octets

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

Construit récursivement la chaîne, en utilisant un paramètre facultatif pour garder une trace de la haine / de l'amour et du nombre à ajouter.

-2 octets de cette astuce pour vérifier la régularité / impair d'un nombre.

Pas de solution de paramètres en option, 87 86 84 octets

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

Celui-ci fait la même chose, sauf détermine la haine / l'amour à ajouter selon que le paramètre est positif ou négatif. À chaque itération, le paramètre se rapproche de zéro, signe alterné.

Jeu, 100 octets

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

Prend l'entrée comme unaire. (Une chaîne de n #s)

Pyke, 36 octets

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

Essayez-le ici!

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

Aussi 36 octets

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

Essayez-le ici! (Link utilise à la Xplace de I, cela devrait fonctionner pour la même quantité d'octets hors ligne où vous pouvez littéralement utiliser ces octets. Online \rest automatiquement remplacé par \n)

> <> (Poisson), 82 octets

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

Je doute que ce soit très efficace, mais cela semble plus ou moins fonctionner. L'entrée se fait via la pile de départ, ce qui fait le score de 85 octets si vous incluez la taille de la-v argument requis pour le faire.

Essayez-le en ligne!

Lua, 75 octets

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

/// , 68 octets

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

Entrée en unaire - ajoutez plus de 1s dans la dernière section.

Essayez-le en ligne!

dc, 75 octets

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

Nous imprimons vraiment un morceau de chaîne à la fois ici, et ne laissons aucun déchet sur la pile. C'est super, nous n'avons pas besoin de gaspiller d'octets avec un registre pour notre compteur.

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

Je pensais ajouter une solution julia:

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