Me ama, no me ama

Este sencillo juego para niños es antiguo, pero sigue siendo popular. Ya que estamos viviendo en el siglo XXI, ¡digitalicemoslo!

Especificación

El programa no debe ingresar nada, a menos que esté utilizando un lenguaje que no pueda generar semilla aleatoria; en ese caso, puede tomar la semilla como entrada. Su tarea es escribir un programa que genere aleatoriamente un total de 3 a 20 líneas inclusive: "Me ama ..." y "No me ama ..." por turnos, como en el juego (y una línea adicional; mantenga leyendo).

Sin embargo, hay algunas restricciones. Cada línea debe ir seguida de nueva línea. La primera línea debe ser "Me ama ...". La última línea ("Me ama" o "No me ama") debe terminar con un signo de exclamación o un solo punto, respectivamente. Después de la última línea, debe generar un corazón ( <3) o un corazón roto ( </3) en la nueva línea, dependiendo de si "Me ama". o "No me ama". Fue la última oración.

Se permiten espacios en blanco al final.

Salida de ejemplo

Salida:

Me
ama ... No
me
ama ... Me ama ... No
me ama ... ¡Me ama!
<3

Otra salida:

Me
ama ... No
me
ama ... Me ama ... No me ama.
</ 3

Este es el código de golf , por lo que gana la entrada más corta.

Además, mi primer desafío :) ¡Buena suerte!

Pyth, 54 53 51 50 48 bytes

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

CJam, 53 50 49 bytes

Gracias a Dennis por guardar 1 byte.

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

Pruébalo aquí.

Explicación

El código simplemente descarga la cadena en bits y piezas en la pila, que se imprime automáticamente al final del programa:

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 (actualmente no válido)

Simplemente porque. Agregaré una versión sin golf más tarde.

Código

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

Pseudocódigo

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"

Muestra

Cuando se ejecuta, el programa ingresa a una sesión interactiva en espera de entrada. La entrada debe ser un número. Este número se usa como semilla.

Semilla: 1 (el número aleatorio es 5, toma 218,168,042 operaciones)

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

Semilla: 3 (número aleatorio es 20, toma 463,253,048 operaciones)

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

Te sugiero que no siembres 6, ya que se necesitan 2,105,900,375iteraciones para calcular el resultado :).

Compilar / Correr

Necesita un intérprete rápido para esto. Ningún intérprete en línea que he probado podría manejar la velocidad de ejecución. Los ips (iteraciones por segundo) deberían ser más que 100,000,000. Entonces se me ocurrió otra solución.

Este es un compilador Brainfuck to C escrito en Brainfuck. Puede usar cualquier intérprete en línea para transpilar mi código a C. puro. Sugiero usar brainfuck.tk . Pegue mi código en la entrada stdin, pegue este código en la entrada de código:

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

Descargue la fuente y compílela:

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

También puede ejecutar una copia del código C en línea aquí: vía. CodingGround .

Optimizaciones

Todavía queda trabajo por hacer, pero la reutilización de la célula es casi óptima.

Observaciones

Puedes usar palabras o frases como semilla:

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 bytes

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

Pitón, 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]

Utiliza el en from random import*lugar de import randomy en randintlugar de randrangeguardar algunos bytes. Probablemente quedan algunos bytes para jugar al golf.

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)

Este fue un reto pequeño pero divertido. Es posible acortar más. ¡Gracias a Mwr247 por algunos trucos para salvar bytes!

Versión alternativa con 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 nombres incorporados. Oh bien. Sugerencias bienvenidas!

Perl, 85

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

Ruby, 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))))

Esto solo funciona en lisps que no comprueban una secuencia adecuada (por ejemplo, cmucl, sbcl, clisp) ccl verificará la circularidad y el error en el nivel de seguridad predeterminado. ecl se repetirá para siempre.

Explicación:

#1=(1 0 . #1#)genera una lista circular que contiene 1y 0y subseqse usa para hacer una lista de longitud [3,20] (esta es la única parte no portátil, ya subseqque el estándar solo lo requiere para trabajar en listas apropiadas (es decir, no circulares)).

Nuestro formato ahora opera en una lista 1 0 1 0...de longitud [3,20]

Explicación de las formatdirectivas:

~{ itera sobre esta lista

~[seguido de cualquier número de ~;y terminado con ~]seleccionará el enésimo elemento, en función del valor del argumento de formato. Esto se usa aquí para que el primer elemento en un ~[sea ​​el caso "me ama no" y el segundo el caso "me ama". Tenga en cuenta que con ~[un separador de ~:;selecciona un caso predeterminado.

~#[funciona como, ~[excepto que el argumento es el número de argumentos restantes. 0 argumentos restantes significa que estamos al final, el caso predeterminado es imprimir...

~:* realiza una copia de seguridad de la posición de la lista de argumentos, lo que nos permite imprimir el avance correcto.

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

Sin golf:

# 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

Shell de UNIX, 193 bytes

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

• volteado i%2==0ai%2<1
• recortadas { ... }apoyos para for-loop, movido edeclaración de bucle
• condicionales reordenados
• Se eliminaron los modificadores y paréntesis innecesarios, el Randomuso reelaborado y el incremento parai

Nota: nueva línea se agrega a continuación para formatear en este sitio, el recuento anterior es para una sola línea.

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

Sin golf:

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, 109106 caracteres (108 bytes)

(con un poco de ♥♥♥ trampa ♥♥♥)

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

También hay un punto Unicode de corazón roto en 1f494, pero tuve dificultades para encontrar una fuente que lo implemente.

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]

Son 39 bytes solo para obtener el número aleatorio.

Muchas gracias a muddyfish , fryamtheeggman y orlp por su ayuda.

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"

_{Editar: en realidad es más corto para incluir explícitamente en "Loves me"lugar de declarar$l}

_{Edit2: olvidé que puedo jugar al golf for()haciendo ductos ... durr ...}

No está nada mal. Utiliza bloques de ejecución de código en línea $(...)para ajustar dinámicamente la cadena impresa a medida que for()avanzamos. Tenga en cuenta que debido a que esto utiliza un implícito Get-delante Randompara guardar un par de bytes, esto puede funcionar extremadamente lento en ciertas versiones de PowerShell. Referencia

Ampliado a continuación para aclaración:

# 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

En C ++ ... porque ... ¿Por qué no? :)

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

En Vivo: 210 193 184 168

Solo espero que alguno de mis cambios no dependa de la plataforma.

Gracias a Ben Voigt por la ayuda. Además, gracias a todos los comentarios, fueron muy útiles.

Groovy, 110 bytes

Un maravilloso tipo de amor:

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]

Observe que a todos les Loves me( not)?sigue ...una nueva línea, excepto la última. Así que esto parece un trabajo para join.

R, 141 132 128 114 111 109 bytes

Código

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

Sin golf

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)

Me inspiré en el código de Eric Brooks .

Edición 1: ahora el código genera correctamente la última puntuación como lo señala Martin
Edición 2: cambió el bucle for a una muestra e incluyó los corazones dentro de la última cadena de línea.
Edición 3: se eliminó {}y cambió +(x==k)*2a +2*!x<k
Edición 4: Volver al ciclo for y se eliminó ()de (i%%2)+1
Edición 5: se escribió me4 veces y se eliminósep=""

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

Ediciones 1,2: Codificar las dos opciones explícitamente es ahorrar espacio.

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

(Con formateo)

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

Sin golf:

$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 para pyth y cjam ... wow :)

MSL, 178 176 156 154 bytes

Edición 1: se cambió == 0a < 1
Edición 2: se eliminaron espacios en blanco innecesarios, ¡gracias AlexA!
Edición 3: paréntesis eliminados

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

Versión legible:

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

La respuesta ha sido golfizada.

C # (160)

El código está inspirado en la respuesta de hjk , el crédito va para él.

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

Sin golf:

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

Probablemente se pueda jugar mucho más al golf, pero aquí está por ahora:

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

Explicación del código y sin golf:

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

Editar: Cortó algunos espacios en blanco.

Jelly , 55 bytes (¿no compite?)

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

Pruébalo en línea!

Como de costumbre, Jelly apesta con cuerdas.

PowerShell , 85 88 bytes

+3 bytes gracias Veskah: Ese es un buen punto.

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

Pruébalo en línea!