Kocha mnie, Kocha mnie nie

Ta prosta gra dla dzieci jest stara, ale wciąż popularna. Ponieważ żyjemy teraz w 21 wieku, dokonajmy digitalizacji!

Specyfikacja

Program nie może pobierać danych wejściowych, chyba że używasz języka, który nie może wygenerować losowego materiału źródłowego - w takim przypadku możesz wziąć dane źródłowe jako dane wejściowe. Twoim zadaniem jest napisanie programu, który wygeneruje losowo łącznie 3 do 20 wierszy łącznie: „Kocha mnie ...” i „Kocha mnie nie ...” po kolei, jak w grze (i jedna dodatkowa linia; zachowaj czytanie).

Istnieją jednak pewne ograniczenia. Po każdej linii powinna następować nowa linia. Pierwszy wiersz musi brzmieć „Loves me ...”. Ostatni wiersz („Loves me” lub „Loves me not”) powinien kończyć się odpowiednio wykrzyknikiem lub pojedynczą kropką. Po ostatnim wierszu musisz wypisać serce ( <3) lub złamane serce ( </3) w nowym wierszu, w zależności od tego, czy „Loves me!” lub „Nie kocha mnie”. było ostatnie zdanie.

Końcowe białe znaki są dozwolone.

Przykładowy wynik

Wynik:

Kocha mnie ...
Kocha mnie nie ...
Kocha mnie ...
Kocha mnie nie ...
Kocha mnie!
<3

Kolejne wyjście:

Kocha mnie ...
Kocha mnie nie ...
Kocha mnie ...
Kocha mnie nie.
</ 3

To jest golf golfowy , więc wygrywa najkrótszy wpis!

Także moje pierwsze wyzwanie :) Powodzenia!

Pyth, 54 53 51 50 48 bajtów

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

CJam, 53 50 49 bajtów

Dzięki Dennisowi za zaoszczędzenie 1 bajtu.

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

Sprawdź to tutaj.

Wyjaśnienie

Kod po prostu zrzuca ciąg w kawałkach na stos, który jest drukowany automatycznie na końcu programu:

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 bajtów (obecnie nieprawidłowy)

Właśnie dlatego. Później dodam wersję bez golfa.

Kod

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

Pseudo kod

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"

Próba

Po uruchomieniu program wchodzi w interaktywną sesję oczekującą na dane wejściowe. Dane wejściowe powinny być liczbą. Ta liczba jest używana jako ziarno.

Seed: 1 (losowa liczba to 5, zajmuje 218 168 042 operacji)

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

Seed: 3 (losowa liczba to 20, zajmuje 463 253 048 operacji)

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

Sugeruję, abyś nie używał nasion 6, ponieważ 2,105,900,375obliczenia wyniku wymagają iteracji :).

Kompilowanie / uruchamianie

Potrzebujesz do tego szybkiego tłumacza. Żaden testowany przeze mnie interpreter online nie byłby w stanie obsłużyć szybkości wykonywania. Ips (liczba iteracji na sekundę) powinna być większa niż 100,000,000. Więc wymyśliłem inne rozwiązanie.

To jest kompilator Brainfuck to C napisany w Brainfuck. Możesz użyć dowolnego interpretera internetowego do transponowania mojego kodu do czystego C. Sugeruję użycie brainfuck.tk . Wklej mój kod na wejściu stdin, wklej ten kod na wejściu kodu:

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

Pobierz źródło i skompiluj je:

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

Możesz również uruchomić kopię kodu C online tutaj: via. CodingGround .

Optymalizacje

Nadal jest wiele do zrobienia, ale ponowne użycie komórki jest prawie optymalne.

Uwagi

Możesz użyć słów lub wyrażeń jako materiału siewnego:

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 bajtów

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]

Używa from random import*zamiast import randomi randintzamiast, randrangeaby zapisać kilka bajtów. Prawdopodobnie zostało jeszcze kilka bajtów.

JavaScript (ES6), 110 102 bajtów

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

To było krótkie, ale zabawne małe wyzwanie. Możliwe może być dalsze skrócenie. Dzięki Mwr247 za kilka sztuczek oszczędzających bajty!

Alternatywna wersja repeat(), 105 bajtów:

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 wbudowane nazwy. No cóż. Sugestie mile widziane!

Perl, 85

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

Ruby, 91 bajtów

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

Common Lisp 106 104 bajtów

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

Działa to tylko na seplenienie, które nie sprawdza prawidłowej sekwencji (np. Cmucl, sbcl, clisp) ccl sprawdzi, czy ma cykliczność i wystąpi błąd na domyślnym poziomie bezpieczeństwa. ecl zapętli się na zawsze.

Wyjaśnienie:

#1=(1 0 . #1#)generuje listę zawierającą okrągłą 1i 0i subseqjest używany do listy długości [3,20] (to jest tylko część nie przenośny, ponieważ subseqwymagana jest tylko przez standard do pracy na odpowiednich (np nieokrągłych) listy).

Nasz format działa teraz na liście 1 0 1 0...długości [3,20]

Objaśnienie formatdyrektyw:

~{ przechodzi przez tę listę

~[po którym następuje dowolna liczba ~;i zakończona ~]znakiem wybierze Nty element na podstawie wartości argumentu format. Używa się go tutaj, aby pierwszą pozycją w ~[etui była „kocha mnie nie”, a drugą „kocha mnie”. Zauważ, że ~[separatorem ~:;wybiera domyślną wielkość liter.

~#[działa jak ~[z wyjątkiem tego, że argument jest liczbą pozostałych argumentów. 0 pozostałych argumentów oznacza, że ​​jesteśmy na końcu, domyślnym przypadkiem jest wydruk...

~:* tworzy kopię zapasową listy argumentów o jedną pozycję, co pozwala nam wydrukować poprawny zwiastun.

Julia, 98 bajtów

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

Nie golfowany:

# 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

Powłoka UNIX, 193 bajty

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 bajtów

• odwrócił się i%2==0doi%2<1
• przycięte { ... }szelki dla pętli for, przeniesiono edeklarację do pętli
• ponownie zamówione warunkowe
• usunięto modyfikatory i niepotrzebne nawiasy, przerobiono Randomużycie i przyrost dlai

Uwaga: poniżej dodano nową linię do formatowania w tej witrynie, powyższa liczba dotyczy jednej linii.

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

Nie golfowany:

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 znaków (108 bajtów)

(z odrobiną oszukiwania ♥♥♥ ♥♥♥)

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

Istnieje również punkt Unicode złamanego serca na 1f494, ale miałem trudności ze znalezieniem czcionki, która go implementuje.

Python 2, 161 159 156 144 bajtów

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]

To 39 bajtów, aby uzyskać losową liczbę.

Ogromne podziękowania dla błotniaków , fryamtheeggman i orlp za ich pomoc.

PYG , 109 bajtów

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 bajtów

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

_{Edycja - w rzeczywistości krótszy, aby wyraźnie zawierać, "Loves me"a nie deklarować$l}

_{Edycja2 - zapomniałem, że mogę grać w golfa w for()pętli przez potokowanie ...}

Nieźle. Używa wbudowanych bloków wykonania kodu, $(...)aby dynamicznie dopasowywać drukowany ciąg znaków podczas for()zapętlania. Zauważ, że ponieważ używa to ukrytego Get-przed, Randomaby zaoszczędzić kilka bajtów, może to działać bardzo wolno w niektórych wersjach PowerShell. Odniesienie

Rozszerzono poniżej w celu wyjaśnienia:

# 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 bajtów

W C ++ .. ponieważ .. Dlaczego nie? :)

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

Relacja na żywo: 210 193 184 168

Mam tylko nadzieję, że żadna z moich zmian nie zależy od platformy.

Dzięki Ben Voigt za pomoc. Ponadto, dzięki wszystkim komentarzom, były bardzo pomocne.

Groovy, 110 bajtów

Groovy rodzaj miłości:

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 bajtów

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]

Zauważ, że po każdym Loves me( not)?następuje ...i nowa linia, z wyjątkiem ostatniej. To wygląda na pracę join.

R, 141 132 128 114 111 109 bajtów

Kod

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

Bez golfa

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)

Czerpałem inspirację z kodu Erica Brooksa .

Edycja 1: Teraz kod poprawnie wyświetla ostatnią interpunkcję, jak wskazał Martin
Edycja 2: Zmieniłem pętlę for na sapply i umieściłem serca w ciągu ostatniego wiersza.
Edycja 3: Usunąłem {}i zmieniłem +(x==k)*2na +2*!x<k
Edycja 4: Wróć do pętli for i usunąłem ()z (i%%2)+1
Edycja 5: Napisałem me4 razy i usunąłemsep=""

R, 119 111 105 bajtów

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

Edycje 1,2: Bezpośrednie kodowanie dwóch opcji oszczędza miejsce.

C 226 bajtów

#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)?"":"/");}

(Z formatowaniem)

#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 bajtów

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 bajtów

$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";}}

Nie golfowany:

$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 bajtów na pyth i cjam ... wow :)

mSL, 178 176 156 154 bajtów

Edycja 1: Zmieniono == 0na < 1
Edycja 2: Usunięto niepotrzebne białe znaki, dzięki AlexA!
Edycja 3: Usunięto nawiasy

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 bajtów

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

Wersja do odczytu:

$_="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

Sód , 265 bajtów

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

Odpowiedź została zagrana w golfa.

C # (160)

Kod jest inspirowany odpowiedzią od hjk , podziękowania należą się mu.

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

Nie golfowany:

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 bajtów

Prawdopodobnie można grać w golfa o wiele więcej, ale teraz jest na razie:

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

Wyjaśnienie kodu i nieprzypisane:

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

Edycja: Odciąłem trochę białych znaków.

Galaretka , 55 bajtów (niekonkuruje?)

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

Wypróbuj online!

Jak zwykle galaretka ssie sznurki.

PowerShell , 85 88 bajtów

+3 bajty dzięki Veskah: To dobra uwaga.

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

Wypróbuj online!