Description du défi
Dans ce défi, nous considérons uniquement love
et en hate
tant que sentiments. Si nous voulons prononcer une expression sentimentale d'ordre N
, nous alternons entre ces deux (à commencer par 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.
Le modèle suit pour chaque entier positif N
. Étant donné N
, affichez l'expression de sentiment d'ordre correspondant N
.
Remarques
- Le point
.
final ( ) à la fin de l'expression est obligatoire, - Les espaces de fin et de début (y compris les sauts de ligne) sont autorisés,
- La sortie pour un non positif ou non entier
N
n'est pas définie, - C'est un défi de code-golf , alors faites votre code aussi court que possible!
order
l'entrée etexpression
la sortie?Réponses:
Python, 54 octets
la source
f n=take(12*n-5)(cycle"I hate that I love that ")++"it."
(56 octets)CJam , 36 octets
Essayez-le en ligne!
Explication
la source
C,
83767574 octetsMerci à @Leaky Nun d'avoir sauvé 11 octets et ajouté 4 octets!
Merci à @YSC d'avoir enregistré un octet!
Essayez-le sur Ideone
la source
i=0;while(n--)
->for(i=0;n--;)
enregistre 1 car.Javascript (ES6),
757370 octetsEnregistré 2 octets grâce à Neil
Enregistré 3 octets grâce à Whothehellisthat
Tester
la source
['I hate','I love'][i&1]
->i&1?'I love':'I hate'
Java 8, 91 octets
Programme de test non golfé
la source
c=i->for(...)
Mathematica, 63 octets
la source
Gelée , 25 octets
Essayez-le en ligne!
Explication
la source
05AB1E ,
343227 octetsEnregistré 5 octets grâce à Adnan .
Explication
Essayez-le en ligne!
la source
R, 79 octets
Heureusement dans R, le séparateur par défaut pour
cat
est un espace.(Modifié à partir de la version originale de 73 octets qui n'a pas tout à fait résolu le problème.)
la source
for
boucle et%%
. +1Rétine ,
4238 octetsMerci à Leaky Nun de m'avoir aidé à jouer au golf!
L'entrée est prise en unaire.
Essayez-le en ligne!
Explication
Remplacez chaque paire de
1
s par1I love n
.Remplacez les
1
s restants parI hate n
.Remplacez le
n
à la fin de la ligne parit.
et tous les autres n parthat
.la source
l
: retina.tryitonline.net/…Javascript (ES5),
9994 octets5 octets enregistrés grâce à Leaky Nun.
Ancienne solution à 99 octets:
Une autre solution de 98 octets:
Mon code avant minification:
la source
function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}
Haskell, 70 octets
la source
PowerShell v2 +, 64 octets
Plutôt simple. Les boucles de
1
haut à l'entrée$args[0]
, chaque itération de mise en place ou l' autre'I love'
ou'I hate'
sur le pipeline, en fonction d'un pseudo-ternaire de modulo-2 ( à savoir, il alterne d' avant en arrière, en commençant par'I hate'
). Ces chaînes sont encapsulées dans des parenthèses et éditées-join
avec' that '
pour les mélanger ensemble, puis la concaténation des chaînes' it.'
à la fin.Cas de test
la source
php,
6462 octetsMalheureusement, je n'ai pas pu trouver un moyen d'éviter de répéter le "que je", ou du moins aucun moyen de le faire en moins de 7 octets.
edit: sauvé 2 octets grâce à @ Jörg Hülsermann
la source
Perl,
625450 octets(crédit à @Ton Hospel )
Démo: http://ideone.com/zrM27p
Solutions précédentes:
(crédit à @Dada )
Courir avec
perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'
Première solution (seulement c'était la mienne)
En partie:
Démo: http://ideone.com/mosnVz
la source
perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'
.$@++&1
? Car@+
perldoc dit "détient les décalages des extrémités des derniers sous-matchs réussis dans la portée dynamique actuellement active", ce qui n'a pas beaucoup de sens pour moi. Si je comprends bien, vous utilisez ce tableau dans un contexte scalaire ($ @ + - le déréférencez-vous?) Pour obtenir le nombre d'éléments, puis ajoutez (+) la chaîne correspondante (& 1). Non non non je savais que je n'aurais pas dû poster sur PPCG c'est trop obscur: D$@
est juste un scalaire (j'aurais pu utiliser$x
ou tout autre scalaire),++
est l'opérateur d'incrémentation, et&1
est à peu près le même que%2
. C'est donc essentiellement la même chose que$x++%2
.@
le nom de variable scalaire; & 1 pour "et" le dernier bit pour vérifier s'il est pair (et pas une référence arrière comme je le pensais). Ok compris maintenant, merci.$|--
comme bascule au lieu de$@++%2
Bash + coreutils, 106 octets:
Crée simplement une séquence commençant
1
jusqu'à et incluant l'entier d'entrée à l'aide de la fonctionseq
intégrée, puis l'itère une par une, en émettant d'abordhate
si la valeur de la variable d'itération ``i
, n'est pas divisible par2
oulove
autrement. Dans la même itération, il choisit alors de sortirthat
sii
n'est pas égal à la valeur d'entrée, etit.
sinon.Essayez-le en ligne! (Ideone)
la source
printf
la chaîne de et n'utilisez aucun spécificateur de format. Est inutile de comparer sii%2
est supérieure à 0. Je vous inversez les commandes dans la liste, vous pouvez utiliser moins de comparaison au lieu dei==$1
:for i in `seq $1`;{ printf "I `((i%2))&&echo hat||echo lov`e `((i<$1))&&echo that||echo it.` ";}
. Soit dit en passant, nous étiquetons généralement ces solutions comme Bash + coreutils, car l'utilisation deseq
.///,
6057 octets-3 octets grâce à m-chrzan
Entrée en unaire avec une nouvelle ligne de fin.
Essayez-le en ligne!
la source
/T/that /
au début et remplacer toutes les instances dethat
parT
.R,
9290 octetsUne adaptation R de la réponse python de @Leaky Nun. Travailler avec des chaînes dans R est fastidieux comme toujours.
Cela pourrait probablement être joué plus loin.
Edit: enregistré 2 octets en changeant:
[1:((n*12)-5)]
à[6:(n*12)-5]
la source
C, 96 octets
Je n'ai pas vu la solution ci-dessus de Releasing Helium Nuclei qui est meilleure.
la source
MATL , 37 octets
Essayez-le en ligne!
Explication
Le code est basé sur le mappage suivant des nombres aux chaînes:
Le programme pousse les numéros à la chaîne en groupes de trois:
2
,0
,3
; puis2
,1
,3
; puis2
,0
,3
; ... autant de fois que l'entréen
. Après cela, la finale3
est transformée en a4
, le mappage est appliqué pour transformer les nombres en chaînes et les chaînes sont jointes en utilisant l'espace comme séparateur.la source
JavaScript (ES6), 68 octets
la source
C #,
8583 octetsConstruit récursivement la chaîne, en utilisant un paramètre facultatif pour garder une trace de la haine / de l'amour et du nombre à ajouter.
-2 octets de cette astuce pour vérifier la régularité / impair d'un nombre.
Pas de solution de paramètres en option,
878684 octetsCelui-ci fait la même chose, sauf détermine la haine / l'amour à ajouter selon que le paramètre est positif ou négatif. À chaque itération, le paramètre se rapproche de zéro, signe alterné.
la source
Jeu, 100 octets
Prend l'entrée comme unaire. (Une chaîne de n
#
s)la source
Pyke, 36 octets
Essayez-le ici!
Aussi 36 octets
Essayez-le ici! (Link utilise à la
X
place deI
, cela devrait fonctionner pour la même quantité d'octets hors ligne où vous pouvez littéralement utiliser ces octets. Online\r
est automatiquement remplacé par\n
)la source
> <> (Poisson), 82 octets
Je doute que ce soit très efficace, mais cela semble plus ou moins fonctionner. L'entrée se fait via la pile de départ, ce qui fait le score de 85 octets si vous incluez la taille de la
-v
argument requis pour le faire.Essayez-le en ligne!
la source
Lua, 75 octets
la source
('I hate that I love that '):rep(n):sub(1,n*12-5)
. Et ce serait plus joli si vous concaténiez "ça". à la fin, carprint()
sort ses paramètres séparés par tabulation./// , 68 octets
Entrée en unaire - ajoutez plus de
1
s dans la dernière section.Essayez-le en ligne!
la source
dc, 75 octets
Nous imprimons vraiment un morceau de chaîne à la fois ici, et ne laissons aucun déchet sur la pile. C'est super, nous n'avons pas besoin de gaspiller d'octets avec un registre pour notre compteur.
la source
Julia, 91 octets
Je pensais ajouter une solution julia:
la source