Descripción del desafío

En este desafío, solo consideramos lovey hatecomo sentimientos. Si queremos pronunciar una expresión de orden de sentimientoN , alternamos entre estos dos (comenzando por 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.

El patrón sigue para cada entero positivo N. Dado N, da salida a la expresión de sentimiento correspondiente del orden N.

Notas

• El punto ( .) al final de la expresión es obligatorio,
• Se permiten espacios en blanco al inicio y al final (incluidas las nuevas líneas),
• La salida para un no positivo o no entero Nno está definida,
• Este es un desafío de código de golf , ¡así que haga su código lo más corto posible!

Python, 54 bytes

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

• Python 2: ¡ Ideónalo!
• Python 3: ¡ Ideónalo!

CJam , 36 bytes

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

Pruébalo en línea!

Explicación

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

¡Gracias a @Leaky Nun por guardar 11 bytes y agregar 4 bytes!
¡Gracias a @YSC por guardar un byte!

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

Pruébalo en Ideone

Javascript (ES6), 75 73 70 bytes

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

Guardado 2 bytes gracias a Neil
Guardado 3 bytes gracias a Whothehellisthat

Prueba

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

Programa de prueba sin 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 bytes

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

Jalea , 25 bytes

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

Pruébalo en línea!

Explicación

                             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

Guardado 5 bytes gracias a Adnan .

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

Explicación

“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

Pruébalo en línea!

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.")

Afortunadamente en R, el separador predeterminado para cates un espacio.

(Editado de la versión original de 73 bytes que no resolvió el problema).

Retina , 42 38 bytes

¡Gracias a Leaky Nun por ayudarme a jugar golf!

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

La entrada se toma en unario.

Pruébalo en línea!

Explicación

11
1I love n

Reemplace cada par de 1s con 1I love n.

1
I hate n

Reemplace los 1s restantes con I hate n.

n$
it.
n
that 

Reemplace el nal final de la línea con it.y cada dos n con that .

Javascript (ES5), 99 94 bytes

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

Guardado 5 bytes gracias a Leaky Nun.

VIEJA solución de 99 bytes:

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

Otra solución de 98 bytes:

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

Mi código antes de la minificación:

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 bytes

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

Más bien sencillo. Bucles desde 1hasta la entrada $args[0], cada iteración colocando 'I love'o'I hate' en la tubería, en base a un pseudoternario para módulo 2 (es decir, alterna de un lado a otro, comenzando con 'I hate'). Esas cadenas se encapsulan en parens y -joined con ' that 'al SMUSH juntos, entonces la concatenación de cadenas ' it.'en el extremo.

Casos de prueba

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.";

Desafortunadamente, no pude encontrar una manera de evitar repetir el "que yo", o al menos no hay forma de hacerlo en menos de 7 bytes.

editar: guardado 2 bytes gracias a @ Jörg Hülsermann

Perl, 62 54 50 bytes

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

(crédito a @Ton Hospel )

Demostración: http://ideone.com/zrM27p

Soluciones anteriores:

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

(crédito a @Dada )

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

Primera solución (solo esto fue mío)

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

En partes:

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

Demostración: 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`;}

Simplemente crea una secuencia que comienza en 1e incluye el entero de entrada usando el seqincorporado, y luego lo itera uno por uno, primero generando hatesi el valor de la variable de iteración i, no es divisible por 2y de lo lovecontrario. En la misma iteración, elige la salida thatsi ino es igual al valor de entrada, y de lo it.contrario.

¡Pruébelo en línea! (Ideone)

///, 60 57 bytes

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

-3 bytes gracias a m-chrzan

Entrada en unario con nueva línea final.

Pruébalo en línea!

R, 92 90 bytes

Una adaptación R de la respuesta de Python de @Leaky Nun. Trabajar con cadenas en R es tedioso como siempre.

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

Sin embargo, esto probablemente podría jugarse más.

Editar: guardado 2 bytes cambiando:

[1:((n*12)-5)]a [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.");}

No vi la solución anterior al liberar Helium Nuclei, que es mejor.

MATL , 37 bytes

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

Pruébalo en línea!

Explicación

El código se basa en la siguiente asignación de números a cadenas:

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

El programa empuja números a la cadena en grupos de tres: 2, 0, 3; entonces 2, 1, 3; entonces 2, 0, 3; ... tantas veces como la entrada n. Después de eso, el final 3se transforma en a 4, la asignación se aplica para transformar los números en cadenas, y las cadenas se unen utilizando el espacio como separador.

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

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

Construye recursivamente la cadena, utilizando un parámetro opcional para realizar un seguimiento de qué odio / amor y cuántos agregar.

-2 bytes de este consejo para verificar la paridad / impar de un número.

Sin solución de parámetro opcional, 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));

Éste hace lo mismo, excepto que determina qué odio / amor agregar en función de si el parámetro es positivo o negativo. Cada iteración el parámetro se acerca a cero, signo alterno.

Jue 100 bytes

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

Toma la entrada como unario. (Una cadena de n #s)

Pyke, 36 bytes

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

Pruébalo aquí!

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

También 36 bytes

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

Pruébalo aquí! (El enlace usa en Xlugar de I, esto debería funcionar para la misma cantidad de bytes sin conexión donde literalmente puede usar esos bytes. En línea \rse reemplaza automáticamente con \n)

> <> (Pez), 82 Bytes

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

Dudo que sea muy eficiente, pero parece funcionar más o menos. La entrada se realiza a través de la pila inicial, lo que hace que la puntuación sea de 85 Bytes si incluye el tamaño del -vargumento requerido para hacerlo.

Pruébalo en línea!

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.

Entrada en unario: agregue más 1 s en la última sección.

Pruébalo en línea!

dc, 75 bytes

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

Realmente solo estamos imprimiendo un trozo de cadena a la vez aquí, y no dejando basura en la pila. Esto es genial, no necesitamos desperdiciar ningún byte relacionado con un registro para nuestro contador.

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

Pensé agregar una solución de julia:

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