Hass / Liebe Rätsel

30

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!
code-golf  string 
— shooqie
quelle
— Undichte Nonne
1
Ziemlich verwirrt. Also ist orderdie Eingabe und expressiondie Ausgabe?
— Whothehellisthat
2
@Whothehellisthat Ja genau. (Willkommen bei PPCG! :))
— Martin Ender
@Whothehellisthat: Ja. Sie können Eingaben über stdin vornehmen, obwohl es oft kürzer ist, eine Methode (Funktion) zu definieren, wie Sie in den folgenden Übermittlungen sehen können.
— Shooqie
1
Ich hasse es, dass ich diese Frage und ihre Antworten liebe!
— Arkiliknam

Antworten:

21

Python, 54 Bytes

lambda n:("I hate that I love that "*n)[:12*n-5]+"it."
— Undichte Nonne
quelle
Portiert nach Haskell: f n=take(12*n-5)(cycle"I hate that I love that ")++"it."(56 Bytes)
— 1.
15

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."
— Martin Ender
quelle
7

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

— betseg
quelle
1
i=0;while(n--)-> for(i=0;n--;)spart 1 Zeichen
— YSC
6

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))
Erweitern Sie das Snippet

— Arnauld
quelle
Speichern Sie 3 Bytes: ['I hate','I love'][i&1]->i&1?'I love':'I hate'
— Whothehellisthat
@Whothehellisthat - Danke! Das habe ich verpasst.
— Arnauld
5

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);
}
— Shaun Wild
quelle
Warum nicht das Leerzeichen entfernen? c=i->for(...)
— Shooqie
Ich habe es einfach vergessen.
— Shaun Wild
Schön, dass du mich geschlagen hast. +1 Und wahrscheinlich kürzer als meine Antwort wäre. PS: Ich würde dies als "Java 8" anstatt nur "Java" angeben. Nicht zwingend erforderlich, nur persönliche Präferenz von mir, da ich meine Antworten normalerweise in Java 7 schreibe (und Java 9 eingeht).
— Kevin Cruijssen
@ KevinCruijssen Du sagst mir das jedes Mal;) Gut
— Shaun Wild
@SeanBean Naja, normalerweise habe ich meine Java 7 Antwort schon und du postest eine kürzere Antwort, die dann meistens noch mehr golfen werden kann. ; P (Dieses Mal kann ich nichts finden, um es kürzer zu machen. Aber vielleicht kann es jemand anderes.)
— Kevin Cruijssen
5

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.'
— Lynn
quelle
Ich brauche eine Erklärung dafür.
— Steven H.
4

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!

— Emigna
quelle
4

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

— JDL
quelle
Ordentliche Benutzung der forSchleife und %%. +1
— Billywob
2

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 .

— Geschäfts-Katze
quelle
Sie können vier weitere sparen, indem Sie Folgendes löschenl : retina.tryitonline.net/…
— Martin Ender
@MartinEnder: Ich glaube, ich habe dich dazu überredet: P
— Business Cat
1
Zeitstempel sagen, dass Sie 9 Sekunden zu spät waren. : P
— Martin Ender
1

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;
}
— Paul Schmitz
quelle
1
function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}
— Undichte Nonne
1

Haskell, 70 Bytes

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

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.
— AdmBorkBork
quelle
1

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

— user59178
quelle
1

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

— Al.G.
quelle
Hallo und willkommen bei PPCG. Gute Antwort. Hier ist eine kürzere Lösung obwohl (54 Byte): perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'.
— Dada
Was bedeutet dieser Teil $@++&1? Denn @+perldoc sagt "hält die Offsets der Enden der letzten erfolgreichen Submatches im aktuell aktiven dynamischen Bereich", was für mich wenig sinnvoll ist. Soweit ich weiß, verwenden Sie dieses Array im skalaren Kontext ($ @ + - dereferenzieren Sie es?), Um die Anzahl der Elemente zu ermitteln, und fügen Sie dann die übereinstimmende Zeichenfolge (& 1) hinzu (+). Nein, nein, nein, ich wusste, ich hätte nicht auf PPCG posten sollen. Es ist zu verschleiert: D
— Al.G.
$@ist nur ein Skalar (ich hätte auch $xeinen anderen Skalar verwenden können), ++ist der Inkrementoperator und &1ist ungefähr der gleiche wie %2. Es ist also im Grunde dasselbe wie $x++%2.
— Dada
Sie verwenden also einen @skalaren Variablennamen. & 1 für "und" das letzte Bit, um zu überprüfen, ob es gerade ist (und keine Rückbeziehung, wie ich dachte). Ok jetzt verstanden, danke.
— Al.G.
Gute Lösung. Sie können ein paar Bytes mehr gewinnen, indem Sie $|-- als Umschalter anstelle von$@++%2
— Ton Hospel
1

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)

— R. Kap
quelle
Setzen Sie die Befehlsersetzungen lieber direkt in printfdie Zeichenfolge ein und verwenden Sie keine Formatbezeichner. Ist sinnlos zu vergleichen , ob i%2größer ist als 0 ich Ihnen die Befehle in der Liste umkehren, können Sie weniger verwenden als Vergleich statt i==$1: for i in `seq $1`;{ printf "I `((i%2))&&echo hat||echo lov`e `((i<$1))&&echo that||echo it.` ";}. Im Übrigen bezeichnen wir solche Lösungen in der Regel als Bash + Coreutils, weil die Verwendung von seq.
— Manatwork
1

/// 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!

— Akrolith
quelle
Sie können /T/that /am Anfang hinzufügen und alle Instanzen von that durch ersetzen T.
— m-chrzan
0

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]

— Billywob
quelle
Es ist besser, stattdessen eine Schleife auszuführen. siehe meine alternative R-Lösung.
— JDL
0

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.

— Cleblanc
quelle
0

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
— Luis Mendo
quelle
0

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`);
Erweitern Sie das Snippet

— user81655
quelle
0

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.

— Milch
quelle
0

Thue, 100 Bytes

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

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

— MegaTom
quelle
0

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)

— Blau
quelle
0

> <> (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!

— Callum Kerr
quelle
0

Lua, 75 Bytes

n=io.read();print(('I hate that I love that '):rep(n):sub(1,n*12-5)..'it.')
— Jörg Hülsermann
quelle
1
Anstelle von statischen Methoden besser zu nutzen Instanzmethoden: ('I hate that I love that '):rep(n):sub(1,n*12-5). Und würde schöner aussehen, wenn Sie "es" verketten. bis zum Ende, weil print()seine Parameter durch Tabulator getrennt ausgibt.
— Manatwork
1
Das ';' zwischen io.read () und print wird nicht benötigt, und arg [2] ist eine gültige Eingabemethode für Lua-Skripte, bei der es sich um das erste Befehlszeilenargument handelt.
— ATaco
0

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.
— brhfl
quelle
0

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."))
— nyro_0
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.