Liebt mich, liebt mich nicht

Dieses einfache Kinderspiel ist alt, aber immer noch beliebt. Da wir jetzt im 21. Jahrhundert leben, sollten wir es digitalisieren!

Spezifikation

Das Programm darf keine Eingaben vornehmen, es sei denn, Sie verwenden eine Sprache, die keinen zufälligen Startwert erzeugen kann. In diesem Fall dürfen Sie den Startwert als Eingabe verwenden. Ihre Aufgabe ist es, ein Programm zu schreiben, das zufällig insgesamt 3 bis 20 Zeilen einschließlich ausgibt: "Liebt mich ..." und "Liebt mich nicht ..." abwechselnd wie im Spiel (und eine zusätzliche Zeile; behalten Sie bei lesen).

Es gibt jedoch einige Einschränkungen. Auf jede Zeile sollte eine neue Zeile folgen. Die erste Zeile muss "liebt mich ..." sein. Die letzte Zeile (entweder "Liebt mich" oder "Liebt mich nicht") sollte mit einem Ausrufezeichen bzw. einem einzelnen Punkt enden. Nach der letzten Zeile müssen Sie in der neuen Zeile entweder ein Herz ( <3) oder ein gebrochenes Herz ( </3) ausgeben , je nachdem, ob "Loves me!" oder "liebt mich nicht." war der letzte Satz.

Nachgestellte Leerzeichen sind erlaubt.

Beispielausgabe

Ausgabe:

Liebt mich ...
liebt mich nicht ...
liebt mich ...
liebt mich nicht ...
liebt mich!
<3

Ein weiterer Ausgang:

Liebt mich ...
liebt mich nicht ...
liebt mich ...
liebt mich nicht.
</ 3

Dies ist das Code-Golf , also gewinnt der kürzeste Eintrag!

Auch meine erste Herausforderung :) Viel Glück!

Pyth, 54 53 51 50 48 Bytes

pj+*3\.bm+W~!Z"Loves me"" not"+3O18@".!"Z%hZ"</3

CJam, 53 50 49 Bytes

Vielen Dank an Dennis für das Speichern von 1 Byte.

Imr3+{"Loves me"X!:X" not"*'.3*N}*&"!."X=N'<'/X*3

Teste es hier.

Erläuterung

Der Code legt die Zeichenfolge einfach in kleinen Stücken auf den Stapel, der am Ende des Programms automatisch gedruckt wird:

Imr3+         e# Generate a random number in [3,20]
{             e# Execute this block that many times.
  "Loves me"  e#   Push "Loves me", we always need that.
  X!:X        e#   Toggle X (initially 1) between 0 and 1 and leave it on the stack.
  " not"*     e#   Repeat " not" that many times, removing it on every other line.
  '.3*N       e#   Push "..." and a newline.
}*
&             e# Set intersection of "..." and newline, turning them into an empty array.
"!."X=        e# Select "!" or "." based on the last value of X.
N'<           e# Push a newline and "<".
'/X*          e# Include "/" or not depending on the last value of X.
3             e# Push a 3.

Brainfuck, 2766 Bytes (derzeit ungültig)

Nur weil. Ich werde später eine ungolfed Version hinzufügen.

Code

>+<+[>[>[-]+<-]>[<+>>+[->,----------[<+>[>>>>>>>>>+<<<<<<<<<-]>>>>>>>>>[>+<<<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]]<]<-]>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>>>[<<<<<<<<<<+>>>>>>>>>>-]>[<<<<<<<<<<+>>>>>>>>>>-]<<<<<<<<+++++++[<+++++++++++>-]<[<<[>>>>>>>>>>+<<<<<<<+<<<-]>>>[<<<+>>>-]<<[>>>>>>>>>+<<<<<<<+>+<<<-]>>>[<<<+>>>-]<[>>>>>>>>+[<<<<<<<+>+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]+<[>-<[-]]>[>>>>>+<<<<<-]<<-]<-]++++++[>++++++++<-]>-[<<[>>>>>>>>>+<<<<<<<<+<-]>[<+>-]>-]<<<[-]>[-]+++++[<+++++>-]<[>>>>>>>>>>>+[<<<<<<<<<<+>+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]+<[>-<[-]]>[>>>>>>>>+<<<<<<<<-]<<-]++++++[>>>>>>>>>>+++++++++<<<<<<<<<<-]>>>>>>>>>>[<<+<<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>>>>[-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[-]++++++++++++++++++++<<[<<<+>>>-]>>[<<<<<<<<+>+<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>>-<<<[-]]<<<[-]>>>>>>>>[-]<[>+<<<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>>>>[-]+++<<<[<<<<<+>>>>>-]>>>[<<<<<<<<<<<+>+<<+>>>>>>>>>>>>-]<<<<<<<<<<<<[>>>>>>>>>>>>+<<<<<<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]<[>>>>>>>>-<<<<<<<<[-]]>>>[-]>>>[<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>-<<<<<<<[-]]>>>>>>>>>[<<<<<<<<<+>+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]<[>>>>>>>[-]-<<<<<<<[-]]>>>>>>>[>>>>>>+<<<<<<<<<<<<<<<->>>>>>>>>[-]]<<<<<<<<-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>+++++++++++[>+++++++>++++++++++>+++++++++>+++>++++<<<<<-]>-.>+.+++++++.>++.<---.>>-.<<------.>.>>++...[-]<[-]<[-]<[-]<[-]<++++++++++.[-]>>>>>>>[-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>->[-]<[>+<-][-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[-]<<[<<<<<<+>>>>>>-]->>[<<<<<<<<-<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>[>>>>>>+<<<<<<[-]]<->>>>>>>[<<<<<<<->>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[>>>>>>>>+<<<<<<<<<<<<<<<<<->>>>>>>>>[-]]<<<<<<<<-]<[>[-]+<-]>[<+>>++++++[>++++++++++<-]>.---------.[-]<<<-<->>-]>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>+++++++++++[>+++++++>++++++++++>+++++++++>+++>++++<<<<<-]>-.>+.+++++++.>++.<---.>>-.<<------.>.>.<<+.+.+++++.>>>++...[-]<[-]<[-]<[-]<[-]<++++++++++.[-]>>>>>>>[-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>->[-]<[>+<-][-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[-]<<[<<<<<<+>>>>>>-]->>[<<<<<<<<-<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>[>>>>>>+<<<<<<[-]]<->>>>>>>[<<<<<<<->>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[>>>>>>>+<<<<<<<<<<<<<<<<->>>>>>>>>[-]]<<<<<<<<-]<[>[-]+<-]>[<+>>++++++[>++++++++++<-]>.-------------.++++.<<<<->>-]<<]

Pseudocode

loop
    get a random byte
until random byte is >2 and <21

point to byte
[
    output "Loves me..."
    decrease byte by 1
    if byte is 0
        output "<3"
        exit
    eif
    output "Loves me not..."
    decrease byte by 1
]
output "</3"

Stichprobe

Beim Ausführen tritt das Programm in eine interaktive Sitzung ein, die auf Eingabe wartet. Die Eingabe sollte eine Zahl sein. Diese Nummer wird als Startwert verwendet.

Seed: 1 (Zufallszahl ist 5, benötigt 218.168.042 Operationen)

1              
Loves me...    
Loves me not...
Loves me...    
Loves me not...
Loves me...    
<3             

Seed: 3 (Zufallszahl ist 20, dauert 463.253.048 Operationen)

3
Loves me...
Loves me not...
(...)
Loves me...
Loves me not...
</3

Ich würde vorschlagen, dass Sie nicht mit Seeding arbeiten 6, da es 2,105,900,375Iterationen braucht , um das Ergebnis zu berechnen :).

Kompilieren / Laufen

Sie benötigen dafür einen schnellen Dolmetscher. Kein von mir getesteter Online-Interpreter kann mit der Ausführungsgeschwindigkeit umgehen. Die ips (Iterationen pro Sekunde) sollten mehr als sein 100,000,000. Also habe ich mir eine andere Lösung ausgedacht.

Dies ist ein in Brainfuck geschriebener Brainfuck to C-Compiler. Sie können jeden Online-Interpreter verwenden, um meinen Code in reines C umzuwandeln . Ich schlage vor, brainfuck.tk zu verwenden . Fügen Sie meinen Code in die stdin-Eingabe ein und fügen Sie diesen Code in die Code-Eingabe ein:

+++[>+++++<-]>>+<[>>++++>++>+++++>+++++>+>>+<++[++<]>---]>++++.>>>.+++++.>------.<--.+++++++++.>+.+.<<<<---.[>]<<.<<<.-------.>++++.<+++++.+.>-----.>+.<++++.>>++.>-----.<<<-----.+++++.-------.<--.<<<.>>>.<<+.>------.-..--.+++.-----<++.<--[>+<-]>>>>>--.--.<++++.>>-.<<<.>>>--.>.<<<<-----.>----.++++++++.----<+.+++++++++>>--.+.++<<<<.[>]<.>>,[>>+++[<+++++++>-]<[<[-[-<]]>>[>]<-]<[<+++++>-[<+++>-[<-->-[<+++>-[<++++[>[->>]<[>>]<<-]>[<+++>-[<--->-[<++++>-[<+++[>[-[-[-[->>]]]]<[>>]<<-]>[<+>-[<->-[<++>-[<[-]>-]]]]]]]]]]]]]<[-[-[>+<-]>]<[<<<<.>+++.+.+++.-------.>---.++.<.>-.++<<<<.[>]>>>>>>>>>]<[[<]>++.--[>]>>>>>>>>]<[<<++..-->>>>>>]<[<<..>>>>>]<[<<..-.+>>>>]<[<<++..---.+>>>]<[<<<.>>.>>>>>]<[<<<<-----.+++++>.----.+++.+>---.<<<-.[>]>]<[<<<<.-----.>++++.<++.+++>----.>---.<<<.-[>]]<[<<<<<----.>>.<<.+++++.>>>+.++>.>>]<.>]>,]<<<<<.<+.>++++.<----.>>---.<<<-.>>>+.>.>.[<]>++.[>]<.>[.---->.---,....]

Laden Sie den Quellcode herunter und kompilieren Sie ihn:

gcc.exe -c main.c -o main.o
gcc.exe main.o -o loveme.exe

Sie können eine Kopie des C-Codes auch online hier ausführen: über. CodingGround .

Optimierungen

Es gibt noch einiges zu tun, aber die Wiederverwendung der Zellen ist nahezu optimal.

Bemerkungen

Sie können Wörter oder Ausdrücke als Startwert verwenden:

Programming Puzzles & Code Golf
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
Loves me not...
Loves me...
<3

Javascript (ES6), 119 104 99 98 Byte

for(i=new Date%18+3,s=i&1?`!
<3`:`.
</3`;i--;)s=`...
Loves me`+(i&1?' not':'')+s
alert(s.slice(4))

Python, 147

from random import*;t=randint(3,20)
print"\n".join("LLoovveess  mmee  n o t"[i%2::2].strip()+"..."*(i<t-1)for i in range(t))+"!.\n\n<<3/ 3"[t%2::2]

Verwendet from random import*statt import randomund randintstatt randrange, um ein paar Bytes zu sparen. Es sind wahrscheinlich noch ein paar Bytes zum Golfen übrig.

Javascript (ES6), 110 102 Bytes

a='';for(i=j=new Date%18+3;i--;)a+='Loves me'+(j-i&1?'':' not')+(i?`...
`:j&1?`!
<3`:`.
</3`);alert(a)

Dies war eine kurze, aber lustige kleine Herausforderung. Es kann möglich sein, mehr zu verkürzen. Vielen Dank an Mwr247 für einige Tricks zum Speichern von Bytes!

Alternative Version mit repeat()105 Bytes:

a='';for(i=j=new Date%18+3;i;)a+='Loves me'+' not'.repeat(j-i--&1)+(i?`...
`:j&1?`!
<3`:`.
</3`);alert(a)

Darn JS 5 + -char eingebaute Namen. Naja. Vorschläge willkommen!

Perl, 85

print$_?'...
':'','Loves me',$c=$_%2?' not':''for 0..3+rand 18;print$c?'.
</3':'!
<3'

Rubin, 91 Bytes

(n=3+rand(18)).times{|i|puts"Loves me"+[""," not"][i%2]+(i<n-1?"...":i%2>0?".
</3":"!
<3")}

Common Lisp 106 104 Bytes

(format t"~{Loves me~[ not~]~#[~:*~[.~%</~;!~%<~]3~:;...~]~%~}"(subseq'#1=(1 0 . #1#)0(+ 3(random 18))))

Dies funktioniert nur bei LISPS, bei denen keine ordnungsgemäße Sequenz überprüft wird (z. B. cmucl, sbcl, clisp). Ccl überprüft die Standardsicherheitsstufe auf Zirkularität und Fehler. ecl wird für immer loopen.

Erläuterung:

#1=(1 0 . #1#)generiert eine zirkuläre Liste mit 1und 0und subseqwird verwendet, um eine Liste mit der Länge [3,20] zu erstellen (dies ist der einzige nicht tragbare Teil, der subseqnur vom Standard für die Arbeit an richtigen (dh nicht zirkulären) Listen verlangt wird).

Unser Format arbeitet jetzt mit einer Liste 1 0 1 0...von Längen [3,20]

Erklärung der formatRichtlinien:

~{ Durchläuft diese Liste

~[gefolgt von einer beliebigen Anzahl von ~;und beendet mit ~]wird das N-te Element basierend auf dem Wert des Format-Arguments ausgewählt. Dies wird hier verwendet, damit der erste Punkt in einem ~[Fall "liebt mich nicht" und der zweite "liebt mich" ist. Beachten Sie, dass mit ~[einem Trennzeichen von ~:;ein Standardfall ausgewählt wird.

~#[funktioniert so, ~[außer dass das Argument die Anzahl der verbleibenden Argumente ist. 0 verbleibende Argumente bedeuten, dass wir am Ende sind. Standardmäßig wird gedruckt...

~:* Sichert die Argumentliste um eine Position, sodass wir den richtigen Trailer ausdrucken können.

Julia, 98 Bytes

r=rand(3:20)
for i=1:r println("Loves me"*(i%2>0?" not":"")*(i<r?"...":i%2>0?".\n</3":"!\n<3"))end

Ungolfed:

# Define a random number 3 ≤ r ≤ 20
r = rand(3:20)

for i = 1:r
    # The loveless lines occur when i is even
    println("Loves me" *
            (i % 2 > 0 ? " not" : "") *
            (i < r ? "..." : i % 2 > 0 ? ".\n</3" : "!\n<3"))
end

UNIX-Shell, 193 Byte

t=$(seq 2 19|shuf|head -1)
l=t
p=...
while [ $t -ge 0 ];do
case $l:$t in t:0)p=!;h=\<3;;f:0)p=.;h=\</3;;esac
case $l in t)l=f;n=;; f)l=t;n=\ not;;esac
t=$((t-1))
echo Loves me$n$p
done
echo $h

Java, 210 209 203 200 177 Bytes

• drehte sich i%2==0zui%2<1
• gekürzte { ... }Klammern für for-loop, verschobene eDeklaration in Schleife
• Nachbestellte Konditionen
• Modifikatoren und unnötige Klammern entfernt, RandomVerwendung überarbeitet und Inkrement füri

Hinweis: Für die Formatierung auf dieser Site wird unten eine neue Zeile hinzugefügt. Die oben angegebene Anzahl gilt für eine einzelne Zeile.

class F{public static void main(String[]a){for(int e=3+(int)(Math.random()*18),i=0;++i<=e;)
System.out.println("Loves me"+(i%2>0?i<e?"...":"!\n<3":" not."+(i<e?"..":"\n</3")));}}

Ungolfed:

class F {
    public static void main(String[] a) {
        for (int e = 3 + (int) (Math.random() * 18), i = 0; ++i <= e; )
            System.out.println("Loves me" + (i % 2 > 0 ? i < e ? "..." : "!\n<3"
                    : " not." + (i < e ? ".." : "\n</3")));
    }
}

C, 123, 121, 109 106 Zeichen (108 Bytes)

(mit ein wenig ♥♥♥ betrügen ♥♥♥)

O;main(o){for(o=time(O)%18+3;o-O++;printf("Loves me%s%s\n",O&1?"":" not",o-O?"...":O%2?"!\n♥":".\n</3"));}

Es gibt auch einen Unicode-Punkt mit gebrochenem Herzen bei 1f494, aber ich hatte Schwierigkeiten, eine Schriftart zu finden, die ihn implementiert.

Python 2, 161 159 156 144 Bytes

from random import*;a=randrange(3,21)
for i in range(a):print'Loves me'+i%2*' not'+('...'if i!=a-1 else'.'if i%2 else'!')
print['<3','</3'][i%2]

Es sind 39 Bytes, nur um die Zufallszahl zu erhalten.

Ein großes Dankeschön an muddyfish , fryamtheeggman und orlp für ihre Hilfe.

PYG , 109 Bytes

a=RR(3,21)
for i in R(a):P('Loves me'+i%2*' not'+('...'if i!=a-1 else'.'if i%2 else'!'))
P(['<3','</3'][i%2])

PowerShell, 121 119 111 Bytes

$i=2..19|Random;1..$i|%{"Loves me$(if(!($_%2)){" not"})..."};"Loves me$(if(!($i%2)){"!`n<"}else{" not.`n</"})3"

_{Bearbeiten - eigentlich kürzer, um explizit einzuschließen, "Loves me"anstatt zu deklarieren$l}

_{Edit2 - habe vergessen, dass ich for()Loops durch Pipelining golfen kann ... durr ...}

Nicht zu schäbig. Verwendet Inline-Codeausführungsblöcke $(...), um die gedruckte Zeichenfolge dynamisch anzupassen, wenn eine for()Schleife ausgeführt wird. Beachten Sie, dass dies bei bestimmten PowerShell-Versionen extrem langsam sein kann , da dies ein implizites Get-Vorzeichen verwendet Random, um ein paar Bytes zu speichern. Referenz

Zur Verdeutlichung weiter unten erweitert:

# Create a collection of (2,3,4,...18,19) and pipe it as input to Get-Random
$i = 2..19 | Get-Random

# Create a collection of (1,2,...$i-1,$i) and pipe it to seed a ForEach-Object loop
1..$i | ForEach-Object {
  if(!($_%2)) {
    # If the input number is even, we're on an even line
    Write-Output "Loves me not..."
  }
  Else {
    # The input number is odd
    Write-Output "Loves me..."
  }
}
If(!($i%2)) {
  # Our random number is odd
  Write-Output "Loves me!"
  Write-Output "<3"
}
Else {
  # Our random number is even
  Write-Output "Loves me not."
  Write-Output "</3"
}

C ++, 210 193 184 168 Bytes

In C ++ .. weil .. Warum nicht? :)

#include <iostream>
main(){auto&c=std::cout;srand(time(0));int i,j=3+rand()%18;while(i++<j)c<<"Loves me"<<(i%2?"":" not")<<(i==j?"":"...\n");c<<(j%2?"!\n<3":".\n</3");}

Leben: 210 193 184 168

Hoffe nur, dass meine Änderungen nicht plattformabhängig sind.

Vielen Dank an Ben Voigt für die Hilfe. Auch dank all der Kommentare waren sie sehr hilfreich.

Groovy, 110 Bytes

Eine starke Art von Liebe:

int r=Math.random()*18;print((0..r+2).collect{"Loves me"+" not"*(it%2)}.join('...\n')+['!\n<3','.\n</3'][r%2])

Python 2, 117 Bytes

from random import*
n=randint(3,20)
print"...\n".join("Loves me"+i%2*" not"for i in range(n))+[".\n</3","!\n<3"][n%2]

Beachten Sie, dass jeder Loves me( not)?von gefolgt ist ...und ein Newline, mit Ausnahme des letzten. Das sieht also nach einem Job für aus join.

R, 141 132 128 114 111 109 Bytes

Code

k=sample(3:23,1);for(i in 1:k)cat("Loves",c("me not...\n","me...\n","me not.\n</3","me!\n<3")[1+i%%2+2*!i<k])

Ungolfed

k <- sample(3:23, 1)        # Generates random "k" number from 3 to 23
for(i in 1:k) {             # Loop this block increasing i from 1 until k by 1
  cat                       # Concatenate and paste everything inside this block
  ("Loves",                 # Push "Loves" on every iterations of the loop
      c(                    # Create a vector of strings
        "me not...\n",      # Push string to the index "1" of vector
        "me...\n",          #   to the index "2"
        "me not.\n</3",     #   to the index "3"
        "me!\n<3"           #   to the index "4"
        )[1+i%%2            # Subset the vector by the index (1 or 2)
          +2*!i<k])}        #   if final iteration of loop then index += 2 (3 or 4)

Ich habe mich von Eric Brooks Code inspirieren lassen .

Edit 1: Der Code gibt nun die letzte Interpunktion korrekt aus, wie von Martin hervorgehoben.
Edit 2: Die for-Schleife wurde in eine sapply-Schleife geändert und die Herzen in die letzte Zeilenfolge eingefügt.
Edit 3: Entfernte die {}und änderte sich +(x==k)*2zu +2*!x<k
Edit 4: Zurück zur for-Schleife und entfernte die ()aus (i%%2)+1
Edit 5: Schrieb me4 mal und entfernte diesep=""

R, 119 111 105 Bytes

x<-sample(3:20,1);cat(rep(c("Loves me...\n","Loves me not...\n"),x)[1:x]);cat(ifelse(x%%2==1,"<3","</3"))

Bearbeitungen 1,2: Das explizite Codieren der beiden Optionen spart Platz.

C 226 Bytes

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void main(){srand(time(NULL));int i=rand()%18+3;int j;for(j=0;j<i;j++)printf("Loves me%s%s\n",(j%2)?" not":"",(j==i-1)?(j%2)?".":"!":"...");printf("<%s3\n",(j%2)?"":"/");}

(Mit Formatierung)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    srand(time(NULL));
    int i = rand()%18 + 3;
    int j;
    for (j = 0; j < i; j++)
        printf("Loves me%s%s\n", (j % 2) ? " not" : "", (j==i-1) ? (j % 2) ? "." : "!" : "...");
    printf("<%s3\n", (j%2) ? "" : "/");
    return 0;
}

Python 2, 115 Bytes

from random import*
n=randint(2,20)
print'...\n'.join('Loves me'+i%2*' not'for i in range(n))+'.!\n\n<</33'[n%2::2]

PHP, 191 187 146 165 Bytes

$x=rand(5,22);for($i=2;++$i<=$x;){echo"\nLoves me";if($i%2<1)echo" not";if($i<$x)echo"...";if($i==$x&&$i%2<1){echo".\n</3\n";}elseif($i==$x&&$i%2>0){echo"!\n<3\n";}}

Ungolfed:

$x=rand(5,22);
for($i=2;++$i<=$x;){
    echo "\nLoves me";
    if($i%2<1) echo " not";
    if($i<$x) echo "...";
    if($i==$x && $i%2<1){
        echo ".\n</3\n";
    }
    elseif($i==$x && $i%2>0){
        echo "!\n<3\n";
    }
}

48,49 bytes für pyth und cjam ... wow :)

mSL, 178 176 156 154 Bytes

Edit 1: Geändert == 0zu < 1
Edit 2: Unnötiges Leerzeichen entfernt, danke AlexA!
Edit 3: Klammern entfernt

alias l {
var %n 1
while %n <= $rand(3,20) {
var %m $+(Love me,$iif($calc(%n % 2) < 1,$chr(32) $+ not),...)
echo %m
inc %n
}
echo $iif(n isin %m,</3,<3)
}

Perl, 97 Bytes

$_='She loves me...
'x(3+rand 18);s/(me.*?)me/$1me not/gs;s/e...
$/e!
<3/;s/t...
$/t.
<\/3/;print

Lesbare Version:

$_="She loves me...\n"x(3+rand 18);
s/(me.*?)me/$1me not/gs;
s/e...$/e!\n<3/;
s/t...$/t.\n<\/3/;
print

Hassium , 265 Bytes

func main(){rnd=new Random();times=rnd.next(3,21);println("Loves me...");for(x=0;x<times-1;x++){if(x%2==0)println("Loves me not...");else println("Loves me...");}if((times-1)%2==0){println("Loves me not.");println("</3");}else{println("Loves me!");println("<3");}}

Die Antwort wurde golfen.

C # (160)

Der Code ist inspiriert von der Antwort von hjk , Kredit geht an ihn.

class P{static void Main(){for(int e=3+new Random().Next(0,18),i=0;++i<=e;)Console.WriteLine("Loves me"+(i%2>0?i<e?"...":"!\n<3":" not."+(i<e?"..":"\n</3")));}}

Ungolfed:

class P
{
    private static void Main()
    {
        for (int e = 3 + new Random().Next(0, 18), i = 0; ++i <= e;)
            Console.WriteLine("Loves me" + (i % 2 > 0 ? i < e ? "..." : "!\n<3" : " not." + (i < e ? ".." : "\n</3")));
    }
}

Lua, 137 132 Bytes

Vermutlich kann man noch viel mehr Golf spielen, aber hier ist es erstmal:

t=math.random(3,20)for i=1,t do io.write(i%2==0 and"Loves me"or"Loves me not")print(i==t and(i%2==0 and"!\n<3"or".\n</3")or"...")end

Codeerklärung und ungolfed:

t=math.random(3,20) --Generates a random number between 1 and 30. We need to assign it to a variable to check if the loop is over later.
for i=1,t do
  io.write(i%2==0 and"Loves me"or"Loves me not") --If i%2 is 0 write without a newline Loves me, if not print Loves me not.
  print(i==t and (i%2==0 and"!\n<3" or ".\n</3") or "...") --If it is not the end of the loop, put ..., else if we ended on an even print ! a newline, and then a heart, but if we ended on an odd put ., a newline and a broken heart :(
end

Edit: Abgehacktes Leerzeichen.

Jelly , 55 Bytes (nicht konkurrierend?)

“¢zḞzƘFq»,;¥“ not”ṁ18X+2¤j“...¶”µċ⁷Ḃ©”/ẋ;3⁾¶<;®ị⁾.!¤;⁸;

Probieren Sie es online!

Wie immer saugt Jelly an Fäden.

Power , 85 88 Bytes

+3 Bytes danke Veskah: Das ist ein guter Punkt.

0..(1..19|Random)|%{($l='Loves me')+' not'*($n=$_%2)+'...'}
$l+('!
<3',' not.
</3')[!$n]

Probieren Sie es online!