讨厌/爱的难题

30

挑战说明

在这一挑战中，我们仅将love和hate视为情感。如果我们想表达一种有序的感觉表达N，我们将在这两者之间交替（以开头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.

每个正整数都遵循该模式N。给定N，输出命令的对应感表达N。

笔记

  • .表达式末尾的句号（）是强制性的，
  • 尾随空格和前导空格（包括换行符）是允许的，
  • 非正数或非整数N的输出未定义，
  • 这是一个代码挑战，所以请使您的代码尽可能短！
code-golf  string 
— hoo
source
— Leaky Nun
1
相当困惑。所以是order输入和expression输出？
— Whothehellisthat
2
@Whothehellisthat是的，完全是。（欢迎使用PPCG！：））
— 马丁·恩德
@Whothehellisthat：是的。您可以通过stdin进行输入，尽管定义方法（函数）通常会更短，如下面的提交所示。
— shooqie '16
1
我讨厌我爱这个问题及其答案！
— Arkiliknam'9

Answers:

21

Python，54个字节

lambda n:("I hate that I love that "*n)[:12*n-5]+"it."
— 漏尼姑
source
移植到Haskell：f n=take(12*n-5)(cycle"I hate that I love that ")++"it."（56个字节）
— xnor
15

CJam，36个字节

ri{"hatlov"3/='IS@"e that "}/2<"it."

在线尝试！

说明

ri            e# Read input and convert to integer N.
{             e# For each i from 0 to N-1...
  "hatlov"3/  e#   Push ["hat" "lov"].
  =           e#   Use i as a cyclic index into this array to alternate between
              e#   "hat" and "lov".
  'IS         e#   Push character 'I' and a space.
  @           e#   Pull "hat" or "lov" on top of it.
  "e that "   e#   Push "e that "
}/
2<            e#   Truncate the last "e that " to just "e ".
"it."         e#   Push "it."
— 马丁·恩德
source
7

C，83 76 75 74字节

感谢@Leaky Nun保存11个字节并添加4个字节！
感谢@YSC节省了一个字节！

i;f(n){for(i=0;n--;)printf("I %se %s",i++%2?"lov":"hat",n?"that ":"it.");}

在Ideone上尝试

— 贝特塞格
source
1
i=0;while(n--)-> for(i=0;n--;)保存1个字符。
— YSC
6

Javascript（ES6），75 73 70字节

n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

感谢Neil，
节省了2个字节感谢Whothehellisthat，节省了3个字节

测试

let f =
n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
展开摘要

— Arnauld
source
保存3个字节：['I hate','I love'][i&1]->i&1?'I love':'I hate'
— Whothehellisthat
@Whothehellisthat-谢谢！我想念那个。
— Arnauld
5

Java 8，91字节

i->{for(int j=0;j++<i;)System.out.printf("I %se %s",j%2>0?"hat":"lov",j<i?"that ":"it.");};

非高尔夫球测试程序

public static void main(String[] args) {
    Consumer<Integer> c = i -> {
        for (int j = 0; j++ < i;) {
            System.out.printf("I %se %s", j % 2 > 0 ? "hat" : "lov", j < i ? "that " : "it.");
        }
    };

    c.accept(1);
    c.accept(2);
    c.accept(3);
}
— 肖恩·怀德（Shaun Wild）
source
为什么不删除空格？c=i->for(...)
— shooqie '16
我只是忘记了。
— 肖恩·
很好，你击败了我。+1，可能比我的回答要短。PS：我将其表示为“ Java 8”，而不仅仅是“ Java”。但是，这不是强制性的，只是我个人的喜好，因为我通常用Java 7编写答案（并且由于Java 9是传入的）。
— 凯文·克鲁伊森
@KevinCruijssen你每次都告诉我;）很好
— 肖恩·
@SeanBean好吧，通常我已经有了Java 7的答案，而您发布的答案更短，那么大多数时候就可以解决更多的问题。; P（虽然这次我找不到任何使它更短的东西。但是也许其他人也可以这样做。）
— Kevin Cruijssen
5

果冻，25个字节

“ṅɠT5“£ẏkg⁷»ṁj“¥ıQ»ṙ1“it.

在线尝试！

说明

                             Input: n, a number.
“ṅɠT5“£ẏkg⁷»                 Compressed string array [' I hate', ' I love']
            ṁ                Cycle for n repetitions.
             j“¥ıQ»          Join by compressed string ' that'.
                   ṙ1        Rotate left once: move the initial space to the end.
                     “it.    Implicitly print the result, then print 'it.'
— 林恩
source
我需要对此进行解释。
— 史蒂文H.
4

05AB1E，34 32 27字节

感谢Adnan节省了5个字节。

“I«¢€Š I„΀Š “×¹12*5-£…it.«

说明

“I«¢€Š I„΀Š “               # "I hate that I love that "
              ×              # repeat input nr of times
               ¹12*5-£       # take the first input*12-5 chars of string above
                      …it.«  # append "it."
                             # implicitly display

在线尝试！

— 艾米尼亚
source
4

R，79个字节

n=scan();for(i in n:1)cat(if((i+n)%%2)"I love"else"I hate",if(i>1)"that "else"it.")

幸运的是，在R中，默认的分隔符cat是空格。

（由最初的73字节版本编辑，但不能完全解决问题。）

— JDL
source
巧妙地使用for循环和%%。+1
— Billywob '16
2

视网膜，42 38字节

感谢Leaky Nun帮助我打高尔夫球！

11
1I love n
1
I hate n
n$
it.
n
that

一元输入。

在线尝试！

说明

11
1I love n

更换每对1s的1I love n。

1
I hate n

用替换其余1的I hate n。

n$
it.
n
that

将n行尾的替换为，it.每隔n替换为that 。

— 商务猫
source
您可以更节省四乘落下l：retina.tryitonline.net/...
— 马丁安德
@MartinEnder：我想我要你忍受那个编辑了：P
— 商业猫
1
时间戳记说您迟到了9秒。：P
— Martin Ender
1

Javascript（ES5），99 94字节

function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}

感谢Leaky Nun，节省了5个字节。

99字节旧解决方案：

function(c){for(d="",b=0;b<c;++b)d+=(0==b%2?"I hate":"I love")+" "+(b==c-1?"it.":"that ");return d}

另一个98字节的解决方案：

function(d){for(c=[],b=0;b<d;++b)c.push(["love","hate"][b%2]);return"I "+c.join(" that I ")+" it"}

缩小之前的代码：

function a(n){
  var hate="I hate",love="I love",it="it ",that="that ",out="";
  for(var i=0;i<n;++i){out+=(i%2==0?hate:love)+" "+(i==n-1?it+".":that)}return out;
}
— 保罗·施密茨
source
1
function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}
— Leaky Nun
1

Haskell，70个字节

g 1="I hate";g n=g(n-1)++" that "++cycle["I love",g 1]!!n
(++" it.").g
— 达米安
source
1

PowerShell v2 +，64字节

((1..$args[0]|%{('I love','I hate')[$_%2]})-join' that ')+' it.'

相当简单。从循环1至输入$args[0]，每次迭代放置任一'I love'或'I hate'管道上的，基于伪三元为模2（即，其交替前后开始'I hate'）。这些字符串被封装在括号中，并-join与' that '它们混合在一起，然后最后进行字符串连接' it.'。

测试用例

PS C:\Tools\Scripts\golfing> 1..5|%{.\hate-love-conundrum.ps1 $_}
I hate it.
I hate that I love it.
I hate that I love that I hate it.
I hate that I love that I hate that I love it.
I hate that I love that I hate that I love that I hate it.
— AdmBorkBork
source
1

php，64 62字节

<?=str_pad("",$argv[1]*12-5,"I hate that I love that ")."it.";

不幸的是，我想不出一种方法来避免重复“ I”，或者至少没有办法在少于7个字节的情况下做到这一点。

编辑：由于@JörgHülsermann而节省了2个字节

— 用户名
source
1

Perl，62 54 50字节

$_="I xe tx "x$_;s/tx $/it./;s/x/++$.%4?hat:lov/ge

（致@Ton Hospel）

演示：http：//ideone.com/zrM27p

先前的解决方案：

$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./

（致@Dada）

与运行 perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'

第一个解决方案（只有这是我的）

for$x(1..<>){$_.=' I '.($x%2?hat:lov).'e that'}s/\w+$/it./;say

部分：

for $x (1..<>) {
   $_ .= ' I '.($x % 2 ? hat : lov).'e that'
}
s/\w+$/it./;
say

演示：http：//ideone.com/mosnVz

— 铝
source
嗨，欢迎来到PPCG。好答案。这里虽然是一个较短的溶液（54个字节）： perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'。
— 达达
这部分是$@++&1什么意思？对于@+perldoc来说，“在当前活动的动态范围内保留最后一次成功子匹配的结尾的偏移量”对我来说意义不大。据我了解，您可以在标量上下文中使用此数组（$ @ +-是否要对其取消引用？）以获取元素数，然后添加（+）匹配的字符串（＆1）。不，不，我知道我不应该发布到PPCG上，因为它太晦涩了：D
— Al.G.
$@只是一个标量（我本可以使用$x或其他任何标量），++是增量运算符，并且与&1大致相同%2。因此基本上与相同$x++%2。
— 达达
因此，您使用的@是标量变量名称；＆1用于“和”最后一位以检查它是否是偶数（而不是我所认为的反向引用）。好的，现在明白了，谢谢。
— Al.G.
不错的解决方案。您可以通过使用$|-- 拨动键代替$@++%2
— Ton Hospel
1

Bash + coreutils，106个字节：

for i in `seq $1`;{ printf "I %s %s " `((i%2>0))&&echo hate||echo love` `((i==$1))&&echo it.||echo that`;}

简单地创建一个序列开始在1直到并包括输入整数使用seq内置的，然后通过它一个接一个地遍历，第一输出hate如果迭代变量的值，i是不被整除2和love其它。在同一迭代中，that如果i不等于输入值，则选择输出，it.否则选择。

在线尝试！（爱迪生）

— 卡普
source
最好将命令替换项直接放在printf的字符串中，并且不使用格式说明符。比较是否i%2大于0 是没有意义的。在您反转列表中的命令后，可以使用小于比代替i==$1：for i in `seq $1`;{ printf "I `((i%2))&&echo hat||echo lov`e `((i<$1))&&echo that||echo it.` ";}。顺便说一句，由于使用，我们通常将此类解决方案标记为Bash + coreutils seq。
— manatwork's
1

///，60 57字节

/!/I hate //T/that //
/it.//00/!TI love T//Tit./it.//0/!/

-m chrzan -3个字节

用尾随新行输入一元。

在线尝试！

— 杂种
source
您可以添加/T/that /到开始和替换的所有实例that 用T。
— m-chrzan '16
0

R，92 90字节

@Leaky Nun的python答案的R改编。像以往一样，在R中使用字符串很麻烦。

n=scan();cat(rep(strsplit("I hate that I love that ","")[[1]],n)[6:(n*12)-5],"it.",sep="")

不过，这可能会打得更远。

编辑：通过更改来保存2个字节：

[1:((n*12)-5)]至 [6:(n*12)-5]

— 比利沃伯
source
相反，循环更好。请参阅我的替代R解决方案。
— JDL
0

C，96字节

c;f(i){printf("I hate");for(;c<i+1/2-1;c++)printf(" that I %s",c&1?"hate":"love");puts(" it.");}

我没有从释放氦核中得到更好的上述解决方案。

— 克莱布朗
source
0

MATL，37字节

:"2@o3]Qv'hate I that it. love'Ybw)Zc

在线尝试！

说明

该代码基于以下从数字到字符串的映射：

0: 'love'
1: 'hate'
2: 'I'
3: 'that'
4: 'it.'

该方案推动数字来三个一组的字符串：2，0，3，然后2，1，3; 然后2，0，3; ...输入的次数n。之后，将final 3转换为4，将映射应用于将数字转换为字符串，然后使用空格作为分隔符将字符串连接在一起。

:                         % Input n implicitly. Push range [1 2 ... n]
"                         % For each
  2                       %   Push 2
  @o                      %   Iteration index modulo 2: pushes 0 or 1
  3                       %   Push 3
]                         % End
Q                         % Add 1 to the last 3
v                         % Concatenate stack contents into a numeric column vector
'hate I that it. love'    % Push this string
Yb                        % Split at spaces. Gives a cell array of five strings
w                         % Swap to move numeric vector to top
)                         % Index cell array of strings with that vector. Indexing
                          % is 1-based and modular, so 0 refers to the last string.
                          % This gives a cell array of (repeated) strings
Zc                        % Join those strings by spaces. Display implicitly
— 路易斯·门多
source
0

JavaScript（ES6），68个字节

f=(n,i)=>n?(i?' that I ':'I ')+(i&1?'love':'hate')+f(n-1,-~i):' it.'

document.write('<pre>'+[ 1, 2, 3, 4, 10, 100 ].map(c=>c+': '+f(c)).join`\n`);
展开摘要

— 用户名
source
0

C＃，85 83字节

string f(int n,int m=2)=>"I "+(1>m%2?"hat":"lov")+(m>n?"e it.":"e that "+f(n,m+1));

使用可选参数以递归方式构造字符串，以跟踪哪个恨/爱以及要添加的恨/爱。

此技巧的 -2个字节，用于检查数字的偶数/奇数。

无可选参数解决方案，87 86 84字节

string h(int n)=>"I "+(0<n?"hat":"lov")+(2>n&-2<n?"e it.":"e that "+h(0<n?~n+2:~n));

除了根据参数是正数还是负数确定要附加的恨/爱之外，此功能的作用相同。每次迭代时，参数都接近零，符号交替。

— 牛奶
source
0

周，100字节

@::=:::
>##::=>$.
$::=~I hate that I love 
>.#::=>&#
&::=~that 
>#<::=~I hate it.
>.<::=~it.
::=
>@<

将输入作为一元。（一串n #s）

— 超级汤姆
source
0

Pyke，36个字节

2/"I hate ""I love "]*"that "J"it."+

在这里尝试！

2/                                   -    input/2
                     *               -   ^ * v
  "I hate ""I love "]                -    ["I hate ", "I love "]
                      "that "J       -  "that ".join(^)
                              "it."+ - ^+"it."

也是36个字节

12*5+.daෆ   ű   l5d+12"I ":Q*<"it."+

在这里尝试！（链接使用X代替I，这应该在脱机状态下可以使用相同数量的字节，而您实际上可以使用这些字节。在线\r会自动替换为\n）

— 蓝色
source
0

> <>（鱼），82字节

' I'oov.2coo<;oooo' it.'<
'ahv'v>'et'
oop26<^ooooo^o' that I '^!?:-1oo
'ol^'^>'ev'

怀疑它的效率很高，但似乎或多或少都起作用。输入是通过起始堆栈进行的，如果包括执行此操作-v所需的参数大小，则得分为85字节。

在线尝试！

— 卡勒姆·克尔（Callum Kerr）
source
0

Lua，75字节

n=io.read();print(('I hate that I love that '):rep(n):sub(1,n*12-5)..'it.')
— 约格·赫尔瑟曼
source
1
最好使用实例方法来代替静态方法：('I hate that I love that '):rep(n):sub(1,n*12-5)。如果连接“它”，它将看起来更好。到最后，因为print()输出的参数由制表符分隔。
— manatwork's
1
';' 不需要io.read（）和print之间的参数，并且arg [2]是lua脚本的有效输入法，它是第一个命令行参数。
— ATaco
0

///，68字节

/@/1\/#love //%/hate//#/that I //%1i/% i//I %1/I % //1@#% //@/I %1it.

以一元形式输入- 1在最后一节中添加更多。

在线尝试！

— m-chrzan
source
0

dc，75个字节

?[1-lbP[I lov]P]sa[e that ]sb[[e it.]Pq]sc[1-[I hat]Pd2%1=ad1>clbPlxx]dsxx

在这里，我们实际上只是一次打印一串字符串，而没有在堆栈上留下任何垃圾。太好了，我们不需要浪费任何字节来处理计数器的寄存器。

?                              #Input, works as our decrement counter
[1-lbP[I lov]P]sa              #Macro 'a' decrements our counter, prints string 'b', 
                               #then prints 'I lov'
[e that ]sb                    #String 'b'
[[e it.]Pq]sc                  #Macro 'c' prints the tail end of our message and quits
[1-                            #I'll unfold our main macro here; first step is to 
                               #decrement our counter
   [I hat]P                    #We always start by hating 'it,' no conditional needed
           d2%1=a              #Check the oddness of our counter; execute 'a' if odd
                 d1>c          #Check our counter; If we're done, execute 'c'
                     lbPlxx]   #Otherwise, print 'b' again and start this macro ('x') over
dsxx                           #Stores the above macro as 'x' and runs it.
— h
source
0

朱莉娅91字节

以为我添加了朱莉娅解决方案：

f(N)=string("I hate ",join(["that I love that I hate " for _ in 1:N-1])[1:12*(N-1)],"it."))
— nyro_0
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.