Ненависть / любовь загадка

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 
— shooqie
источник
— Утренняя монахиня
1
Весьма смущен. Так есть orderвход и expressionвыход?
— Кто сказал, что
2
@Whothehellisthat Да, именно так. (Добро пожаловать в PPCG! :))
— Мартин Эндер
@Whothehellisthat: Да. Вы можете использовать ввод через stdin, хотя зачастую для определения метода (функции) короче, как вы можете видеть в представленных ниже материалах.
— shooqie
1
Я ненавижу, что я люблю этот вопрос и его ответы!
— Аркиликнам

Ответы:

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."
— Мартин Эндер
источник
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

— betseg
источник
1
i=0;while(n--)-> for(i=0;n--;)сохраняет 1 символ
— СМУ
6

Javascript (ES6), 75 73 70 байт

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

Сохранено 2 байта благодаря Нейлу
Сохранено 3 байта благодаря Whothehellisthat

Тест

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
источник
Сохранить 3 байта: ['I hate','I love'][i&1]->i&1?'I love':'I hate'
— Whothehellist, который
@Whothehellisthat - Спасибо! Я скучал по этому.
— Арно
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.");};

Тестовая программа Ungolfed

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);
}
— Шон Уайлд
источник
Почему бы не удалить пробелы? c=i->for(...)
— shooqie
Я просто забыл.
— Шон Уайлд,
Хорошо, вы меня опередили. +1 И наверное короче мой ответ будет. PS: я бы обозначил это как «Java 8» вместо просто «Java». Не обязательно, однако, просто личное предпочтение от меня, так как я обычно пишу свои ответы на Java 7 (и так как Java 9 поступает).
— Кевин Круйссен
@KevinCruijssen Вы говорите мне это каждый раз;) отлично
— Shaun Wild
@SeanBean Ну, обычно у меня уже есть мой ответ на Java 7, и вы публикуете более короткий ответ, который в большинстве случаев может быть еще более удачным. ; P (На этот раз я не могу найти что-то, чтобы сделать его короче. Но, возможно, кто-то другой может сделать это.)
— Кевин Круйссен
5

Mathematica, 63 байта

"I love"["I hate"][[#~Mod~2]]&~Array~#~Riffle~" that "<>" it."&
— Мартин Эндер
источник
1
Я люблю извлечение головы там, действительно умный.
— Симмонс
@ASimmons Это на самом деле довольно старый трюк (который я даже не придумал сам), но я определенно не могу использовать его достаточно часто. ;)
— Мартин Эндер
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.'
— Линн
источник
Мне нужно объяснение для этого.
— Стивен Х.
4

05AB1E , 34 32 27 байт

Сохранено 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

Попробуйте онлайн!

— Emigna
источник
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
источник
Аккуратное использование forцикла и %%. +1
— Billywob
2

Retina , 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

Заменить оставшиеся 1s на I hate n.

n$
it.
n
that

Замените nв конце строки на it.все остальные n на that .

— Бизнес Кот
источник
Вы можете сэкономить еще четыре, опустив l: retina.tryitonline.net/…
— Мартин Эндер
@MartinEnder: Я думаю, что я вас ниндзя отредактировал: P
— Business Cat
1
Отметки времени говорят, что вы опоздали на 9 секунд. : P
— Мартин Эндер
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}

Сохранено 5 байтов благодаря Leaky Nun.

Старое 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;
}
— Пол Шмитц
источник
1
function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}
— Утренняя монахиня
1

Haskell, 70 байт

g 1="I hate";g n=g(n-1)++" that "++cycle["I love",g 1]!!n
(++" it.").g
— Damien
источник
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 'к smush их вместе, а затем конкатенации ' 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
источник
1

php, 64 62 байта

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

К сожалению, я не мог найти способ избежать повторения «того, что я», или, по крайней мере, не сделать это менее чем за 7 байтов.

редактирование: сохранено 2 байта благодаря @ Jörg Hülsermann

— user59178
источник
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

— Al.G.
источник
Привет и добро пожаловать в PPCG. Хороший ответ. Вот короче решение , хотя (54 байта): perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'.
— Дада
Что означает эта часть $@++&1? Для @+perldoc говорит «держит смещения концов последних успешных submatches в настоящее время активной динамической рамки» , который не имеет большого смысла для меня. Как я понимаю, вы используете этот массив в скалярном контексте ($ @ + - вы разыменовываете его?), Чтобы получить количество элементов, а затем добавить (+) соответствующую строку (& 1). Нет, нет, я знал, что не должен был публиковаться в PPCG, он слишком запутан: D
— Al.G.
$@это просто скаляр (я мог бы использовать $xили любой другой скаляр), ++является оператором приращения, и &1примерно так же, как %2. Так что это в основном так же, как $x++%2.
— Дада
Итак, вы используете @для скалярного имени переменной; & 1 для "и" последний бит, чтобы проверить, является ли он четным (а не обратная ссылка, как я думал). Хорошо, теперь понял, спасибо.
— Ал.Г.
Хорошее решение. Вы можете получить еще несколько байтов, используя $|-- вместо этого$@++%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.иначе.

Попробуйте онлайн! (Ideone)

— Р. Кап
источник
Лучше поместить подстановки команд непосредственно в 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.
— Манатворк
1

///, 60 57 байт

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

-3 байта благодаря m-chrzan

Ввод в унарном виде с завершающей новой строкой.

Попробуйте онлайн!

— акролит
источник
Вы можете добавить /T/that /в начало и заменить все экземпляры that с T.
— m-chrzan
0

R, 92 90 байт

R-адаптация ответа Python @Leaky Nun. Работа со строками в 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]

— Billywob
источник
Лучше работает вместо этого; см. мое альтернативное решение 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.");}

Я не видел вышеупомянутое решение от выпуска ядер гелия, что лучше.

— cleblanc
источник
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. После этого финал 3преобразуется в a 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
— Луис Мендо
источник
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`);
Развернуть фрагмент

— user81655
источник
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));

Этот делает то же самое, за исключением того, что определяет, какую ненависть / любовь добавлять, основываясь на том, является ли параметр положительным или отрицательным. На каждой итерации параметр приближается к нулю, знакопеременный знак.

— молоко
источник
0

Чт, 100 байт

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

Принимает ввод как унарный. (Строка из n #s)

— MegaTom
источник
0

Пайк, 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)

— синий
источник
0

> <> (Рыба), 82 байта

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

Сомневаюсь, что это очень эффективно, но, похоже, работает более или менее. Ввод осуществляется через начальный стек, который составляет 85 байт, если вы указали размер -vаргумента, необходимый для этого.

Попробуйте онлайн!

— Каллум Керр
источник
0

Луа, 75 байт

n=io.read();print(('I hate that I love that '):rep(n):sub(1,n*12-5)..'it.')
— Йорг Хюльсерманн
источник
1
Вместо того , чтобы статические методы более совершенные методы использования экземпляра: ('I hate that I love that '):rep(n):sub(1,n*12-5). И выглядел бы лучше, если бы вы связали "это". до конца, потому что print()выводит свои параметры через таб.
— Манатворк
1
';' между io.read () и print нет необходимости, и arg [2] является допустимым методом ввода для сценариев lua, который является первым аргументом командной строки.
— ATaco
0

постоянный ток, 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.
— brhfl
источник
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
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.