M'aime, ne m'aime pas

Ce jeu pour enfants simple est vieux, mais toujours populaire. Puisque nous vivons au 21ème siècle maintenant, numérisons-le!

spécification

Le programme ne doit prendre aucune entrée, sauf si vous utilisez une langue qui ne peut pas générer une graine aléatoire - dans ce cas, vous êtes autorisé à prendre la graine en tant qu'entrée. Votre tâche consiste à écrire un programme produisant de manière aléatoire un total de 3 à 20 lignes: "Loves me ..." et "Loves me not ..." à tour de rôle, comme dans le jeu (et une ligne supplémentaire; gardez en train de lire).

Cependant, il y a quelques restrictions. Chaque ligne doit être suivie par newline. La première ligne doit être "m'aime ...". La dernière ligne ("Loves me" ou "Loves me not") doit se terminer par un point d'exclamation ou un seul point, respectivement. Après la dernière ligne, vous devez indiquer un cœur ( <3) ou un cœur brisé ( </3) dans la nouvelle ligne, selon que "Loves me!" ou "m'aime pas." était la dernière phrase.

Les espaces de fin sont autorisés.

Exemple de sortie

Sortie:

M'aime ... ne
m'aime pas ...
m'aime ... ne
m'aime pas ...
m'aime!
<3

Une autre sortie:

M'aime ... ne
m'aime pas ...
m'aime ... ne
m'aime pas
</ 3

C'est le code-golf , donc l'entrée la plus courte gagne!

Aussi, mon premier défi :) Bonne chance!

Pyth, 54 53 51 50 48 octets

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

CJam, 53 50 49 octets

Merci à Dennis d'avoir sauvegardé 1 octet.

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

Testez-le ici.

Explication

Le code dépose simplement la chaîne en morceaux sur la pile, qui est automatiquement imprimée à la fin du programme:

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 octets (actuellement non valide)

Juste parce que. J'ajouterai une version sans golf plus tard.

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"

Échantillon

Lorsqu'il est exécuté, le programme entre dans une session interactive en attente de saisie. L'entrée devrait être un nombre. Ce numéro est utilisé comme une graine.

Graine: 1 (le nombre aléatoire est 5, prend 218,168,042 opérations)

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

Graine: 3 (le nombre aléatoire est 20, prend 463,253,048 opérations)

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

Je suggérerais de ne pas semer avec 6, car il faut des 2,105,900,375itérations pour calculer le résultat :).

Compilation / exécution

Vous avez besoin d'un interprète rapide pour cela. Aucun interprète en ligne que j'ai testé ne pouvait gérer la vitesse d'exécution. Les ips (itérations par seconde) devraient être plus que 100,000,000. Alors je suis venu avec une autre solution.

Ceci est un compilateur Brainfuck to C écrit en Brainfuck. Vous pouvez utiliser n’importe quel interprète en ligne pour transpiler mon code en C pur. Je suggère d’utiliser brainfuck.tk . Collez mon code dans l'entrée stdin, après ce code dans l'entrée de code:

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

Téléchargez le source et compilez-le:

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

Vous pouvez également exécuter une copie du code C en ligne ici: via. CodingGround .

Optimisations

Il reste encore du travail à faire, mais la réutilisation des cellules est presque optimale.

Remarques

Vous pouvez utiliser des mots ou des phrases comme une graine:

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 octets

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]

Utilise le from random import*au lieu de import randomet randintau lieu de randrangesauvegarder quelques octets. Il reste probablement quelques octets pour jouer au golf.

Javascript (ES6), 110 102 octets

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

C'était un petit défi court mais amusant. Il peut être possible de raccourcir davantage. Merci à Mwr247 pour quelques astuces pour économiser des octets!

Version alternative utilisant repeat()105 octets:

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 noms intégrés. Tant pis. Suggestions bienvenues!

Perl, 85

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

Ruby, 91 octets

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

Common Lisp 106, 104 octets

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

Cela ne fonctionne que sur les listes qui ne vérifient pas une séquence correcte (par exemple, cmucl, sbcl, clisp). Ccl vérifie la circularité et les erreurs au niveau de sécurité par défaut. ecl sera en boucle pour toujours.

Explication:

#1=(1 0 . #1#)génère une liste circulaire contenant 1et 0et subseqest utilisé pour créer une liste de longueur [3,20] (il s'agit de la seule partie non portable, comme le subseqprévoit uniquement la norme pour pouvoir travailler sur des listes appropriées (c'est-à-dire non circulaires)).

Notre format fonctionne maintenant sur une liste 1 0 1 0...de longueur [3,20]

Explication des formatdirectives:

~{ itère sur cette liste

~[suivi d'un nombre quelconque ~;et terminé par ~]sélectionnera le Nième élément, en fonction de la valeur de l'argument de format. Ceci est utilisé ici pour que le premier élément d'un ~[sera le cas "m'aime pas" et le second le cas "m'aime". Notez que avec ~[un séparateur de ~:;sélectionne un cas par défaut.

~#[fonctionne comme ~[si l'argument est le nombre d'arguments restants. 0 argument restant signifie que nous sommes à la fin, le cas par défaut est d'imprimer...

~:* sauvegarde la position d’une liste d’arguments, ce qui nous permet d’imprimer la bonne bande-annonce.

Julia, 98 octets

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

Shell UNIX, 193 octets

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 octets

• retourné i%2==0ài%2<1
• parés { ... }accolades pour for-loop, propose la edéclaration de boucle
• conditionnels réordonnés
• Suppression des modificateurs et des parenthèses inutiles, Randomutilisation repensée et incrémentationi

Remarque: la nouvelle ligne est ajoutée ci-dessous pour le formatage sur ce site. Le nombre indiqué ci-dessus correspond à une seule ligne.

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 caractères (108 octets)

(avec un peu de tricherie ♥♥♥ ♥♥♥)

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

Il existe également un point Unicode au cœur brisé situé à 1f494, mais j’ai eu du mal à trouver une police qui le mette en œuvre.

Python 2, 161 159 156 144 octets

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]

C'est 39 octets juste pour obtenir le nombre aléatoire.

Un grand merci à Muddyfish , fryamtheeggman et orlp pour leur aide.

PYG , 109 octets

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 octets

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

_{Edit - en fait plus court pour inclure explicitement "Loves me"plutôt que de déclarer$l}

_{Edit2 - J'ai oublié que je peux jouer au golf en for()boucle ... durr ...}

Pas trop mal. Utilise des blocs d'exécution de code en ligne $(...)pour ajuster de manière dynamique la chaîne imprimée lorsque nous sommes en for()boucle. Notez que, dans la mesure où il utilise implicitement Get-avant Randompour enregistrer quelques octets, il est possible que cela fonctionne extrêmement lentement sur certaines versions de PowerShell. Référence

Développé ci-dessous pour clarification:

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

En C ++ .. parce que .. Pourquoi pas? :)

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

Vivre: 210 193 184 168

Espérons que mes modifications ne dépendent pas de la plate-forme.

Merci à Ben Voigt pour l'aide. De plus, grâce à tous les commentaires, ils ont été très utiles.

Groovy, 110 octets

Un genre d'amour groovy:

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 octets

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]

Observez que tous Loves me( not)?sont suivis de ...et d’une nouvelle ligne, à l’exception de la dernière. Donc, cela ressemble à un travail pour join.

R, 141 132 128 114 111 111 109 octets

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)

Je me suis inspiré du code d' Eric Brooks .

Éditer 1: le code affiche correctement la dernière ponctuation indiquée par Martin
Éditer 2: modifiez la boucle for en une sapply et incluez les cœurs dans la dernière chaîne.
Éditer 3: Supprimé {}et modifié +(x==k)*2en +2*!x<k
Édition 4: Retour à la boucle for et enlevé ()de (i%%2)+1
Éditer 5: Écrit me4 fois et enlevé lesep=""

R, 119 111 105 octets

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

Éditions 1,2: Coder les deux options de manière explicite est un gain de place.

C 226 octets

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

(Avec mise en forme)

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

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 octets

$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 octets pour pyth et cjam ... wow :)

mSL, 178 176 156 154 octets

Modifier 1: modifié == 0pour < 1
modifier 2: Suppression des espaces inutiles, merci AlexA!
Edition 3: parenthèses supprimées

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 octets

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

Version lisible:

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

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 réponse a été golfée.

C # (160)

Le code est inspiré par la réponse de hjk , le crédit lui revient.

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 octets

On peut probablement jouer beaucoup plus au golf, mais le voici pour le moment:

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

Explication de code et non golfée:

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: coupé quelques espaces.

Gelée , 55 octets (non compétitif?)

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

Essayez-le en ligne!

Comme d'habitude, Jelly suce avec des ficelles.

PowerShell , 85 88 octets

+3 octets merci Veskah: C'est un bon point.

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

Essayez-le en ligne!