Descrizione della sfida

In questa sfida, consideriamo solo lovee hatecome sentimenti. Se vogliamo pronunciare un'espressione sentimentale di ordine N, alterniamo questi due (a partire da 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.

Il modello segue per ogni numero intero positivo N. Dato N, emetti l'espressione sentimentale corrispondente dell'ordine N.

Gli appunti

• Lo stop completo ( .) alla fine dell'espressione è obbligatorio,
• Sono consentiti gli spazi bianchi finali e iniziali (incluse le nuove righe),
• L'output per un valore non positivo o non intero Nnon è definito,
• Questa è una sfida di code-golf , quindi rendi il tuo codice il più breve possibile!

Python, 54 byte

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

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

CJam , 36 byte

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

Provalo online!

Spiegazione

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

Grazie a @Leaky Nun per aver salvato 11 byte e aggiunto 4 byte!
Grazie a @YSC per aver salvato un byte!

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

Provalo su Ideone

Javascript (ES6), 75 73 70 byte

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

Salvato 2 byte grazie a Neil
Salvato 3 byte grazie a 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 byte

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

Programma di prova non golfato

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 byte

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

Gelatina , 25 byte

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

Provalo online!

Spiegazione

                             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

5 byte salvati grazie ad Adnan .

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

Spiegazione

“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

Provalo online!

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

Fortunatamente in R, il separatore predefinito per catè uno spazio.

(Modificato dalla versione originale a 73 byte che non risolveva completamente il problema.)

Retina , 42 38 byte

Grazie a Leaky Nun per avermi aiutato a giocare a golf!

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

L'input è preso in unario.

Provalo online!

Spiegazione

11
1I love n

Sostituisci ogni coppia di 1s con 1I love n.

1
I hate n

Sostituire le rimanenti 1con I hate n.

n$
it.
n
that 

Sostituisci il nalla fine della riga con it.e ogni altro n con 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}

5 byte salvati grazie a Leaky Nun.

VECCHIA soluzione da 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}

Un'altra soluzione a 98 byte:

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

Il mio codice prima della minificazione:

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

Piuttosto semplice. Passa da 1un input $args[0]all'altro, ogni iterazione posiziona una 'I love'o 'I hate'sulla pipeline, sulla base di uno pseudo-ternario per modulo-2 (ovvero, si alterna avanti e indietro, a partire da 'I hate'). Queste stringhe sono incapsulate in parentesi -joined ' that 'edite per metterle insieme, quindi concatenare le stringhe ' it.'alla fine.

Casi 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 byte

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

Sfortunatamente non sono riuscito a trovare un modo per evitare di ripetere l '"io", o almeno un modo per farlo in meno di 7 byte.

modifica: salvato 2 byte grazie a @ Jörg Hülsermann

Perl, 62 54 50 byte

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

(credito a @Ton Hospel )

Demo: http://ideone.com/zrM27p

Soluzioni precedenti:

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

(credito a @Dada )

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

Prima soluzione (solo questa era mia)

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

In parti:

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

Demo: 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`;}

Crea semplicemente una sequenza che inizia 1fino a e include l'intero di input usando l' seqintegrato, e quindi scorre attraverso di esso uno per uno, emettendo prima hatese il valore della variabile di iterazione i, non è divisibile per 2e lovealtrimenti. Nella stessa iterazione, sceglie quindi di emettere thatse inon è uguale al valore di input, e it.altrimenti.

Provalo online! (Ideone)

///, 60 57 byte

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

-3 byte grazie a m-chrzan

Input in unario con nuova riga finale.

Provalo online!

R, 92 90 byte

Un adattamento R della risposta del pitone di @Leaky Nun. Lavorare con le stringhe in R è noioso come sempre.

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

Questo potrebbe probabilmente essere ulteriormente approfondito.

Modifica: salvato 2 byte modificando:

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

Non ho visto la soluzione di cui sopra Rilascio dell'elio nucleare che è migliore.

MATL , 37 byte

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

Provalo online!

Spiegazione

Il codice si basa sul seguente mapping dai numeri alle stringhe:

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

Il programma spinge numeri alla stringa in gruppi di tre: 2, 0, 3; poi 2, 1, 3; poi 2, 0, 3; ... tante volte quanto l'ingresso n. Successivamente, il finale 3viene trasformato in a 4, la mappatura viene applicata per trasformare i numeri in stringhe e le stringhe vengono unite utilizzando lo spazio come separatore.

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

Costruisce ricorsivamente la stringa, usando un parametro opzionale per tenere traccia di quale odio / amore e quanti aggiungere.

-2 byte da questo suggerimento per verificare l'uniformità / stranezza di un numero.

Nessuna soluzione di parametro opzionale, 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));

Questo fa la stessa cosa tranne che determina quale odio / amore aggiungere in base al fatto che il parametro sia positivo o negativo. Ogni iterazione il parametro si avvicina a zero, alternando segno.

Quindi, 100 byte

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

Accetta input come unario. (Una stringa di n #s)

Pyke, 36 byte

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

Provalo qui!

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

Anche 36 byte

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

Provalo qui! (Link utilizza Xinvece di I, questo dovrebbe funzionare per la stessa quantità di byte offline dove puoi letteralmente usare quei byte. Online \rviene automaticamente sostituito con \n)

> <> (Pesce), 82 byte

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

Il dubbio è molto efficiente, ma sembra funzionare più o meno. L'input avviene tramite lo stack iniziale, il che rende il punteggio di 85 byte se si include la dimensione -vdell'argomento richiesto per farlo.

Provalo online!

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.

Input in unary - aggiungi altro 1 s nell'ultima sezione.

Provalo online!

dc, 75 byte

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

Qui stiamo davvero solo stampando un pezzo di spago alla volta, senza lasciare immondizia nella pila. Questo è grandioso, non abbiamo bisogno di sprecare alcun byte relativo a un registro per il nostro contatore.

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

Ho pensato di aggiungere una soluzione julia:

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