Да но нет да


46

Недавно мой коллега прислал мне следующий фрагмент JavaScript в шутку:

let butScript = (nrOfButs) => {
    for(var i = 0; i < nrOfButs; i++){
        if(i % 3 == 0){
            console.log("Yeah")
        }
        if(i % 2 == 0){
            console.log("But")
        }
        if(i % 3 == 1){
            console.log("No")
        }
    }
}

Поскольку код был написан в рабочее время, очевидно, это была огромная трата ресурсов компании. Чтобы предотвратить подобные случаи в будущем, мы должны минимизировать потери рабочего времени. И поскольку общеизвестно, что более короткие программы пишутся быстрее, мы должны сделать этот код максимально коротким!

вход

Одно неотрицательное целое число. Вы не должны обрабатывать ошибочные данные.

Выход

Ваша программа должна выдавать результат, идентичный приведенному выше сценарию. Вы должны вывести одно слово на строку, и количество слов должно соответствовать исходному сценарию.

Допустимо включать непропускаемые символы пробела в конце каждой строки (но не в начале), поскольку они невидимы. Один дополнительный символ новой строки допустим в самом конце вывода.

Примеры

Input: 0
Output:


Input: 1
Output:
Yeah
But

Input: 2
Output:
Yeah
But
No

Input: 10
Output:
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah

3
Можем ли мы вернуть список строк?
Джо Кинг,

10
Должно быть интересно работать с таким забавным парнем! : s На чуть более серьезном замечании: nrOfButsпеременная довольно плохо названа и вводит в заблуждение. Хороший простой вызов в любом случае.
Арно

10
Получим ли мы бонус, если последняя строка - «Бог не может поверить, что ты только что сказал это!»
Ciaran_McCarthy

3
@EriktheOutgolfer ifпадение падения и продолжить в текущем цикле, если их условие было выполнено.
Дзайма

4
Самый австралийский кодегольф еще? За исключением того, что это должно быть "Нах"
Nacht - Восстановить Монику

Ответы:


48

Excel, 78 байт

Предполагается ввод в ячейку A1, и что форматирование Wordwrap включено для ячейки. Используйте Alt + Enter, чтобы добавить перевод строки внутри строки и отметить пробел. Только обрабатывает ввод до 3570 из-за ограничения функции REPT (удачи, хотя получаю клетку такой высокой высоты).

=LEFT(REPT("Yeah
But
No      
But     
Yeah    
But
No           
",595),A1*9)

Перепечатка, с периодами для пробелов

=LEFT(REPT("Yeah
But
No......
But.....
Yeah....
But
No...........
",595),A1*9)

Как это работает: шаблон повторяется каждые 6 чисел:

0 = Yeah and But      Yeah + linefeed + But + linefeed
1 = No                No + 6 whitespace + line feed
2 = But               But + 5 whitespace + linefeed
3 = Yeah              Yeah + 4 whitespace + linefeed
4 = But and No        But + linefeed + No + 3 whitespace
5 = Blank             8 whitespace + linefeed

Каждый из них может быть выражен 9 символами, поэтому строка состоит из 54 символов (9 * 6), а затем повторяется настолько, насколько позволяет Excel. Затем он принимает левые 9 * (количество входных) символов в качестве вывода.

Перевод строки для «но и никого» ставится после пробела, так что «Да» для № 6, № 12 (и т. Д.) Форматируется слева, а не справа, и чтобы в каждую 6-ю строку не добавлялся пустой перевод строки. для этого пункта.

Выход


1
У меня нет возможности проверить это, но ваше описание делает его правильным. Можете ли вы добавить несколько примеров пар ввода / вывода? Один из самых нелепых языков, но, тем не менее, отличный ответ.
максимум

16
@maxb Нельзя быть таким смешным, когда бьешь другие языки.
Кита

1
Отличное объяснение и очень классная техника. Работает и в LibreOffice Calc, но может потребоваться немного поиграть с форматированием. +1
ElPedro

20

JavaScript (ES6), 59 57 байт

f=n=>n?f(n-1)+[s=n&1?`But
`:'',`Yeah
`+s,s+`No
`][n%3]:''

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

Как?

Мы используем рекурсивную функцию, которая идет от до а не от до .1 0 n - 1n10n1

В результате тесты отключены на по сравнению с эталонным кодом:1

  • если , выведите «Да»n1(mod3)
  • если , выведите «Но»n1(mod2)
  • если , выведите «Нет»n2(mod3)

Это позволяет нам хранить более простой случай в качестве первой записи нашего массива поиска, где мы можем определить : переменную, содержащую либо пустую строку, либо.сn0(mod3)s"But\n"

Две другие записи определены как "Yeah\n" + sи s + "No\n"соответственно.

Примечание: итерируя от до , мы могли бы точно так же определить в первой записи, но это стоило бы две дополнительные скобки .0 летn10s

комментарии

f = n =>            // n = input
  n ?               // if n is not equal to 0:
    f(n - 1) +      //   prepend the result of a recursive call with n - 1
    [               //   define our lookup array:
      s = n & 1 ?   //     1st entry: if n is odd:
        `But\n`     //       set s to "But"
      :             //     else:
        '',         //       set s to an empty string
      `Yeah\n` + s, //     2nd entry: "Yeah" followed by s
      s + `No\n`    //     3rd entry: s followed by "No"
    ][n % 3]        //   append the correct entry for this iteration
  :                 // else:
    ''              //   return an empty string and stop recursion

16

LOLCODE , 257 байтов

HAI 1.2
I HAS A B
GIMMEH B
B IS NOW A NUMBR
I HAS A C ITZ 0
IM IN YR L UPPIN YR C TIL BOTH SAEM B AN C
I HAS A D ITZ MOD OF C AN 3
D
WTF?
OMG 0
VISIBLE "Yeah"
OIC
MOD OF C AN 2
WTF?
OMG 0
VISIBLE "But"
OIC
D
WTF?
OMG 1
VISIBLE "No"
OIC
IM OUTTA YR L
KTHXBYE

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


2
Это выглядит потрясающе (я бы не хотел кодировать это!), Но в тестовом случае 10 2-е "Нет" и 3-е "Но" переворачиваются ... Так что да, но нет: D
seadoggie01

2
Ой, думал, что я мог бы оптимизировать там. Это сложный шаблон. Я исправил это сейчас.
JosiahRyanW

1
Мне нравится, как это читается
LocustHorde

4
Относится ли VISIBLE "But"программа к отсутствию брюк?
JDL

12

Пробелы , 315 304 300 277 276 байт

Благодаря @JoKing за -11 байт (сокращение количества используемых меток с 8 до 7) и -24 байт (изменение общего потока программы и уменьшение количества используемых меток в процессе).

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve][N
T   S S N
_If_negative_jump_to_Label_PRINT][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S N
_Push_2][T  S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_SKIP_NO][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N][N
S S T   N
_Create_Label_SKIP_NO][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  S N
_Push_2][T  S T T   _Modulo][N
T   S S S N
_If_0_jump_to_Label_SKIP_BUT][S S T T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   S S N
_Push_12_t][S S S T T   S T N
_Push_13_u][S S T   T   S S T   T   S N
_Push_-38_B][N
S S S S N
_Create_Label_RETURN_FROM_BUT][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   T   T   _Retrieve][S S S T  N
_Push_1][T  S S T   _Subtract][T    T   S _Store][T T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][N
T   S S T   N
_If_0_jump_to_Label_YEAH][N
S N
N
_Jump_to_Label_LOOP][N
S S S T N
_Create_Label_YEAH][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S N
_Push_0_h][S S T    T   T   T   N
_Push_-7_a][S S T   T   T   N
_Push_-3_e][S S T   T   T   T   T   N
_Push_-15_Y][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    T   S T S S S N
_Push_104][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.
[..._some_action]добавлено только для пояснения.

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).

Пробельные символы определенно не являются подходящим языком для этой задачи. В Whitespace оба цикла и операторы if создаются с метками и переходами к меткам, и, поскольку они не являются случаями if-elseif-else, а являются множественными случаями if, это означает, что я придется каждый раз возвращаться назад, делая его довольно длинным, это означает, что мне придется немного изменить проверки, чтобы пропустить некоторые отпечатки (спасибо @JoKing ).

Объяснение в псевдокоде:

Read STDIN as integer, and store it in the heap
Start LOOP:
  Integer i = retrieve integer from heap
  If(i is negative):
    Call function PRINT
  If(i modulo-3 is NOT 2):
    Jump to Label SKIP_NO
  Push "\noN" to the stack
  Label: SKIP_NO
  If(i modulo-2 is 0):
    Jump to Label SKIP_BUT
  Push "\ntuB" to the stack
  Label: SKIP_BUT
  i = i - 1
  Replace i in the heap with this updated value
  If(i modulo-3 is 0):
    Call function YEAH
  Go to next iteration of LOOP

function YEAH:
  Push "\nhaeY" to the stack
  Go to next iteration of LOOP

function PRINT:
  Print top of the stack as character to STDOUT
  Go to next iteration of LOOP (which will enter the if and then
                                comes back to this PRINT again)

Дополнительное объяснение:

Как правило, он переходит от ввода к нулю, нажимая на новую строку, и слово переворачивается (поэтому в порядке "\ noN", "\ ntuB", "\ nhaeY" вместо "Да \ n", "Но \ n" "," Нет \ n "). И после того, как ввод зацикливается на 0 и все символы находятся в стеке, он будет печатать эти символы в обратном порядке (поэтому правильный порядок вывода).

Однако, более подробно: хотя нам нужно печатать слова в диапазоне (input, 0], [input, 0)вместо этого в цикле будет цикл . По этой if(i%3 == 2)причине мы можем использовать проверку для «\ noN» (или фактически if(i%3 != 2)пропустить нажатие «\ noN»), и мы используем проверку if(i%2 != 1)для «\ ntuB» (или фактически if(i%2 == 0)пропустить нажатие «\ ntuB») ). Только после этих двух проверок мы уменьшаем итерацию iна 1. Затем выполняем проверку, if(i%3 == 0)нажимая «\ nhaeY», как в примере кода JS в описании вызова. Пропуск с проверками if-not вместо перехода к метке и возврата с метки с сохраненными if-проверками 23 байта.

Кроме того, в пробелах символьные значения хранятся в стеке в качестве значений Юникода (то есть 10для новых строк, 65для «A», 97для «a» и т. Д.). Поскольку для печати символов мне уже нужно циклически перемещаться по стеку, я также могу использовать подсказку для пробелов, чтобы уменьшить количество байтов, добавив константу к числовым значениям, прежде чем печатать их в виде символов.
В 104данном случае эта константа генерируется с помощью этой Java-программы, которую я также использовал, чтобы сыграть еще один мой ответ в Whitespace . Это также причина, почему эта часть кода:

[S S T  T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N]

имеет значения -94для новой строки, 7для 'o' и -26для 'N'. Поскольку добавление константы 104правильно дать наши ценности Юникода 10, 111и 78для этих символов соответственно.


1
Я наверняка не ожидал ответа «Пробел». Отличная работа!
максимум

@maxb Спасибо! К сожалению, это немного дольше, чем ожидалось, из-за 8 ярлыков, которые ему требуются ... Но я уже рад, что это работает. :)
Кевин Круйссен

Не могли бы вы вдвое сократить метки, перейдя к следующему оператору if, если условие ложно? напримерif i modulo-3 != 1 jump to next if else push NO
Джо Кинг

1
@JoKing А, подожди, я неправильно понял часть твоего псевдокода. Моя первая проблема о том, что не нужно искать iдо if(i is 0) call PRINTистины, но другая - проверять iперед вычитанием и пропускать отпечатки. Довольно умный на самом деле. Будем продолжать его реализацию.
Кевин Круйссен,

1
Что ж, если вы перейдете к началу цикла, он снова выполнит оператор if и вернется обратно к функции print. Может быть, это сохранит байт, если вы измените метку цикла на пустую метку
Джо Кинг,


11

Perl 6 , 63 50 байт

{<<"Yeah But"No But Yeah"But No">>[^$_ X%6].words}

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

Блок анонимного кода, который принимает число и возвращает список строк

Объяснение:

{                                                }   # Anonymous code block
 <<"Yeah But"No But Yeah"But No">>  # Create the list of strings:
                                     # Yeah But
                                     # No
                                     # But
                                     # Yeah
                                     # But No
                                  [       ]  # Index into this list
                                   ^$_  # The range from 0 to n-1
                                       X%6  # All modulo 6
                                           .words  # Convert the list to a string 
                                                   # Which joins by spaces
                                                   # And split by whitespace


8

05AB1E (наследие) , 27 25 24 байта

Сохранено 1 байт благодаря Кевину Круйссену .

F”¥æ€³€¸”#N3ÖNÈN3%‚‚˜Ï`»

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

объяснение

F                          # for N in [0 ... input] do:
 ”¥æ€³€¸”#                 # push ['Yeah', 'But', 'No']
          N3Ö              # push N % 3 == 0
             NÈ            # push N % 2 == 0
               N3%         # push N % 3
                  ‚‚˜      # add the 3 numbers to a list
                     Ï     # keep only the strings whose corresponding value  
                           # in the int list is true (1)
                      `»   # push strings separately to stack and join stack on newlines

Черт, ты побил меня этим. Собирался опубликовать ответ. Ваш в любом случае короче, так что +1 от меня .. Хорошее использование ×, не думал об этом!
Кевин Круйссен

Ух, я бы с удовольствием объяснил это. Мой личный рекорд был 44 байта в CJam.
максимум

@maxb: я конечно добавлю объяснение. Я просто проверяю, могу ли я сначала
сыграть в

Вы можете удалить Θтеперь то, что вы больше не используете ×, так как Ïбудете смотреть только на 1s, поэтому он игнорирует 2(и, 0конечно,).
Кевин Круйссен,

@KevinCruijssen: Спасибо! Не уверен, как я это пропустил: P
Emigna


6

Python 2 , 97 95 92 90 83 81 байт

lambda n:[w for i in range(n)for w in'Yeah','But','No'if('N'in w)==i%(3-(w<'N'))]

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

-2 байта, благодаря овсу


Python 3 , 92 90 85 83 байта

lambda n:[w for i in range(n)for w in['Yeah','But','No']if('N'in w)==i%(3-(w<'N'))]

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

-4 байта, благодаря овс

-4 байта, спасибо Джо Кингу


86 байтов путем объединения двух и возвращения в виде списка строк
Джо Кинг,

@JoKing Спасибо, не знал, что я мог бы вернуться вместо печати, когда написал это.
TFeld

82 байта : len(w)<3-> 'N'in w, 81 байт : len(w)%2->(w<'N')
ovs


6

Groovy (функция), 79 байтов

С момента первоначальной отправки моего ответа я просмотрел некоторые исторические дискуссии о том, что представляет собой подходящий ответ. Поскольку кажется общепринятым предоставлять в Java только метод (включая декларации возвращаемого типа и параметров), вот более короткий метод Groovy, ответом которого является возвращаемое значение метода. Использование defозначает, что возвращаемый тип выводится.

def a(int n){n?a(--n)+(n%3?'':'Yeah\n')+(n%2?'':'But\n')+(n%3==1?'No\n':''):''}

В отличие от исходного ответа ниже, который повторяется от 0 до n-1, этот вызывает себя от n до 1, но уменьшает ввод для остальной части строки в рекурсивном вызове.

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

Groovy (программа), 87 байт

Groovy скрипты не требуют определенного общего импорта, так что это может быть программой печати ответа на STDOUT Java без необходимости объявлять System.out.до того print. Он также предоставляет некоторые распространенные служебные методы, такие как этот, toLong()что позволяет нам достаточно разумно анализировать входной аргумент.

По сути, ответ Java 10, но с использованием более короткого синтаксиса цикла Groovy и способности оценивать правдивые утверждения.

args[0].toLong().times{print((it%3?'':'Yeah\n')+(it%2?'':'But\n')+(it%3==1?'No\n':''))}

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


Добро пожаловать в PPCG! Отличный первый ответ! Я не кодировал Groovy самостоятельно, но могу ли я предложить запустить ваш код на TIO ? Таким образом, это может быть подтверждено другими и понравится всем.
более

1
@maxb Спасибо! Я добавил один :)
archangel.mjj

Хороший первый ответ, а также добро пожаловать в PPCG.
ElPedro

5

Сетчатка 0.8.2 , 45 байт

.+
$*
1
$`Yeah¶$`But¶$`11No¶
+`11B
B
111

A`1

Попробуйте онлайн! Объяснение:

.+
$*

Преобразовать ввод в унарный.

1
$`Yeah¶$`But¶$`11No¶

Для каждого целого числа 0...n-1сгенерируйте три строки текста, по одной для каждого слова, каждая с i 1s перед ним, за исключением No, у которого есть два дополнительных 1s, так что мы вычисляем, (i+2)%3==0что эквивалентно i%3==1.

+`11B
B

Удалить пары 1s перед Bs.

111

Удалите 1s в группах по три везде.

A`1

Удалить все строки, которые все еще имеют 1.


О, теперь, когда я вижу, 11No¶как рассчитать (i+2)%3==0(так что все три - проверки if ==0), это выглядит настолько очевидным, но я бы сам не подумал об этом, так что это на самом деле довольно изобретательно. +1 от меня, хороший ответ!
Кевин Круйссен,

5

Java 10, 100 99 байт

n->{for(int i=0;i<n;)System.out.print((i%3<1?"Yeah\n":"")+(i%2<1?"But\n":"")+(++i%3>1?"No\n":""));}

-1 байт благодаря @ OlivierGrégoire .

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

Объяснение:

n->{                   // Method with integer parameter and no return-type
  for(int i=0;i<n;)    //  Loop `i` in the range [0, `n`)
    System.out.print(  //   Print to STDOUT:
      (i%3<1?          //    If `i` is divisible by 3:
        "Yeah\n"       //     Print "Yeah" with newline
      :"")+(i%2<1?     //    If `i` is even:
        "But\n"        //     Print "But" with newline
      :"")+(++i%3>1?   //    If `i` modulo-3 is 1:
        "No\n"         //     Print "No" with newline
      :                //    If none of the above three if's applied to the current `i`:
       ""));}          //     Print nothing for the current `i`

1
++i%3>1скорее всего сэкономит вам байт
Оливье Грегуар,

@ OlivierGrégoire А, конечно. Спасибо!
Кевин Круйссен

5

Powershell, 75 74 72 67 66 байт

-1 байт благодаря TessellatingHeckler

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

Тестовый сценарий и объяснение:

$f = {

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

# 1. repeat the string $n times
# 2. split by space
# 3. get elements from 1 to $n
# some elements are multiline strings, some elements are $null:
# ($null,"Yeah`nBut","But","No","But","Yeah","But`nNo",$null,...)
# 4. remove $null elements from result array

}

# Output results
@(
    0,1,2,10
) | % {
    &$f $_
    "======"
}

# Advanced test
@(
    ,(0,'')
    ,(1,'Yeah But')
    ,(2,'Yeah But No')
    ,(3,'Yeah But No But')
    ,(4,'Yeah But No But Yeah')
    ,(5,'Yeah But No But Yeah But No')
    ,(6,'Yeah But No But Yeah But No')
    ,(7,'Yeah But No But Yeah But No Yeah But')
    ,(8,'Yeah But No But Yeah But No Yeah But No')
    ,(9,'Yeah But No But Yeah But No Yeah But No But')
    ,(10,'Yeah But No But Yeah But No Yeah But No But Yeah')
    ,(20,'Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No')
) | % {
    $n,$e = $_
    $r = &$f $n
    $r = $r-split"`n"       # simplify test string
    "$($e-eq$r): $n : $r"
}

Выход:

======
Yeah
But
======
Yeah
But
No
======
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah
======
True: 0 :
True: 1 : Yeah But
True: 2 : Yeah But No
True: 3 : Yeah But No But
True: 4 : Yeah But No But Yeah
True: 5 : Yeah But No But Yeah But No
True: 6 : Yeah But No But Yeah But No
True: 7 : Yeah But No But Yeah But No Yeah But
True: 8 : Yeah But No But Yeah But No Yeah But No
True: 9 : Yeah But No But Yeah But No Yeah But No But
True: 10 : Yeah But No But Yeah But No Yeah But No But Yeah
True: 20 : Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No

Простой скрипт, 72 байта:

$args|?{$_}|%{0..--$_|%{@('Yeah')[$_%3]
@('But')[$_%2]
@{1='No'}[$_%3]}}

1
Отличный ответ! Можно ли добавить какой-либо вывод к ответу, поскольку он не включает онлайн-переводчика?
максимум

Ответ скрипта не возвращается ======. Он генерирует Yeah,But,Noтолько строки. Тестовый скрипт показывает разделитель для более удобного чтения только результатов.
Маззи

Это использование хеш-таблицы является умным. Мне нужно это запомнить.
AdmBorkBork


1
@mazzy Я могу переформулировать твои слова, но все равно не могу превзойти 67 (замените два \ n реальными символами новой строки)(" Yeah\nBut No But Yeah But\nNo "*($j="$args")|% s*t 32)[1..$j]-ne''
TessellatingHeckler

4

Haskell , 71 байт

f n=[1..n]>>=(3?1)"Yeah"<>(2?1)"But"<>(3?2)"No"
(a?b)c n=[c|n`mod`a==b]

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

объяснение

Довольно просто, сохранил два байта, используя [1..n]вместо них [0..n-1]и скорректировав оставшиеся: Оператор (?)test принимает четыре аргумента, возвращая пустой список или предоставленную строку в виде одиночного значения, если результат верен.

Выражая четвертый аргумент, (?)мы можем использовать (<>)конкатенацию результатов каждой функции, а именно:

(3?1)"Yeah" <> (2?1)"But" <> (3?2)"No"  \i-> (3?1)"Yeah" i ++ (2?1)"But" i ++ (3?2)"No" i

4

C # (интерактивный компилятор Visual C #) , 105 99 94 96 89 байт

i=>{for(int x=0;x<i;)Write((x%3<1?"Yeah\n":"")+(x%2<1?"But\n":"")+(x++%3==1?"No\n":""));}

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


4
Удаление интерполяции, как это, экономит 7 байтов.
Эминья,

@Emigna Спасибо за подсказку, изменил ответ
auhmaan

1
x++%3==1?может быть ++x%3>1?. Кто-то другой просто дал мне подсказку по моему ответу на Java, но то же самое относится и к вашему ответу на C #. :)
Кевин Круйссен

4

Пип , 37 35 33 байта

"But 
Yeah
No
"<>5@:^[t2io02x]@<a

(Обратите внимание на пробел после But.) Принимает ввод в качестве аргумента командной строки. Попробуйте онлайн!

объяснение

Это объяснение для предыдущей версии - см. Ниже список изменений

Вдохновлен Perl 6 Джо Кинга . Мы строим этот список:

[
 "Yeah
 But
 ";
 "No
 ";
 "But
 ";
 "Yeah
 ";
 "But
 No
 ";
 ""
]

и вывести первые его aэлементы с помощью циклического индексирования.

[t2io02x]R,3["But""Yeah""No"].n@<:a
                                     i is 0; o is 1; t is 10; x is ""; n is newline;
                                     a is 1st cmdline arg (implicit)
[       ]                            Construct this list of scalars:
 t                                    10
  2                                   2
   i                                  0
    o                                 1
     02                               02
       x                              <empty string>
         R                           Treating each of these as a string, we're going to
                                     replace:
          ,3                          0, 1, and 2 (respectively)
                                     with the corresponding values from this list:
            ["But""Yeah""No"].n       These strings, each with a newline appended
                                     We now have constructed the list shown above
                               @<:a  Take the first a elements from this list, with
                                     cyclical indexing (the : is for parsing reasons)
                                     Concatenate them together and print (implicit)

Обновление: я понял, что мне не нужно использовать замену, чтобы изменить 0/1/2 на строки - я могу использовать эти числа для непосредственного индексирования в списке. Чтобы сделать это, мы должны убедиться, что многозначные числа разбиты на списки их цифр (в противном случае мы будем выбирать индекс 10 вместо индексов 1 и 0). К счастью, использование произвольно вложенного списка в качестве индекса в Pip работает, как и ожидалось, давая (вложенный) список результатов. Для ввода 3 мы получаем эту последовательность данных (где _представляет новую строку):

"But _Yeah_No_"<>5                       ["But _"; "Yeah_"; "No_"]
                     [t2io02x]           [10; 2; 0; 1; 02; ""]
                              @<a        [10; 2; 0]
                    ^                    [[1; 0]; [2]; [0]]
                  @:                     [["Yeah_"; "But _"]; ["No_"]; ["But _"]]

Как и прежде, окончательный результат объединяется и печатается автоматически.


4

Атташе , 48 байт

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota

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

объяснение

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota   input: an integer
      {                                  }=>Iota   over each number from 0 to that integer exclusive
       Mask[             ,$Yeah'$But'$No]          select values from that array according to:
            _%3'2'3                                    whether or not the input mod 3, 2, 3
                   =0'0'1                              is 0, 0, 1
Flat##                                             flatten the intermediate results

4

C (gcc) , 77 71 74 72 69 байт

Здесь уже есть лучший ответ на C, но этот рекурсивный, и мне потребовалось некоторое время, чтобы разобраться, поэтому я публикую его.

До 69 байтов благодаря @ceilingcat и @JonathanFrech

(Я никогда не думаю использовать n- ~ -i вместо n-i + 1)

i;f(n){i=n&&n-i>=~n/6&&f(n,i++,puts(i%7%4?i%7%2?"But":"No":"Yeah"));}

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


@JonathanFrech Хорошо, но не работает ни для нуля, ни для 5
cleblanc

@cleblanc Ой, прости. Не понял ... По крайней мере удаление jспасло вам два байта.
Джонатан Фрех

1
70 байтов - включая один сохраненный байт @ floorcat.
Джонатан Фрех

1
n-~-iэквивалентно n-i+1- нет i<n+1- и поэтому фактически не сохраняет никаких байтов ...
Джонатан Фрех

3

Руби, 69 72 74 Б

->y{puts *(1..y).map{|i|[i%3==1&&:Yeah,i%2>0&&:But,i%3>1&&:No]-[!0]}}

Очень простой ответ, проверяющий более короткий, рекурсивный метод прямо сейчас.

Сохранено два байта благодаря @BWO :)

Сохранены еще три байта с использованием символов вместо строк


3

Python 3, 93 байта

[print("Yeah\n"*(i%3<1)+"But\n"*(i%2<1)+"No\n"*(i%3==1),end="")for i in range(int(input()))]

Это не совсем лучшее решение, но это мое мнение.

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


1
Если у вас уже есть выражение, которое вы можете использовать в понимании списка, но ваше понимание списка существует только для того, чтобы вызвать побочные эффекты этого выражения, простой цикл for требует меньше байтов.
Джонатан Фрех

3

R 65 байт

cat(c("yeah","but","no")[c(3,1:3,2,1,2)][1:scan()%%7+1],sep="\n")

В связи с тем , что мы тиражированием немного испорчена программой (она пропускает каждый четвертую «но» - он должен был использовать %4 == 1и %4 == 3вместо %3условий), мы должны использовать неудобный вызов cи работать в базе семь. Тем не менее, он короче, чем LOLCODE ...

(Я надеялся, что (3,1,2,3,2,1,2) или подобная перестановка может lhгде-то появиться в наборе данных, но это не похоже на это)


3

sed -E ,179 150 байт

/^0/!s:$:g:
:l;y:abcdefg:bcdefga:
/[ae]/iYeah
/[bdf]/iBut
/[cg]/iNo
s:.$:-&:;:s;s:0-:-9:;ts;h
y:123456789:012345678:;G
s:.*(.)-.*\n(.*).-:\2\1:;tl;c\ 

Самым сложным было не построить список, а проанализировать десятичное число.

2 байта могут быть сохранены, если перевод строки в конце не требуется: c\ d.

Все еще требует оптимизации.

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

объяснение

/^0/!                            | if the input number doesn`t begin with a '0'…
     s:$:g:                      | …then append a 'g' to it and proceed
                                 |
:l;                              | loop label 'l':
   y:abcdefg:bcdefga:            | shift all occurences of [abcdef] 1 letter forward, and all 'g'-s to 'a'-s
                                 |
/[ae]/                           | if there`s an 'a' or 'e' in the input…
      iYeah                      | …output 'Yeah'
                                 |
/[bdf]/                          | if there`s a 'b' or 'd' or 'f' in the input…
       iBut                      | …output 'But'
                                 |
/[cg]/                           | if there`s a 'c' or 'g' in the input…
      iNo                        | …output 'No' 
                                 |
s:.$:-&:;                        | insert '-' before the last character
         :s;                     | loop label 's':
            s:0-:-9:;            | transform the next consecutive '0' in the end of the number to '9', if any
                     ts;         | loop to 's' if more consecutive zeroes are available
                        h        | copy the result to the temporary buffer
                                 |
y:123456789:012345678:;          | decrement all digits except '0' (N.B.: digits, not numbers)
                       G         | append the temporary buffer to the result
                                 |
s:.*(.)-.*\n(.*).-:\2\1:;        | cut and replace the digit left to the last consecutive 0 in the original
                                 | number pasted from the temporary buffer, then discard all other digits decremented
                         tl;     | …then loop to 'l' if the number is ≥0
                            c\   | insert a carriage return and exit

Можете ли вы добавить некоторые объяснения, пожалуйста?
user285259

1
@ user285259 Готово.
hidefromkgb


2

F #, 108 106 байт

let v p=seq{for i=1 to p do
 if i%3=1 then yield"Yeah"
 if i%2=1 then yield"But"
 if i%3=2 then yield"No"}

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

-2 байта изменяются с i=0 to p-1на i=1 to pи корректируются по модулю. Кроме того, довольно просто.


1
Я получаю какую-то ошибку сборки для ссылки TIO, возможно, синтаксическую ошибку в тестируемом коде?
максимум

Спасибо за это. Мое оригинальное решение печаталось прямо на консоли, но затем я попытался вернуть последовательность, и она оказалась короче примерно на 2 байта. Поэтому я изменил код в TIO, но забыл обновить нижний колонтитул - который все еще ожидал, что vфункция распечатает все.
Ciaran_McCarthy

2
Бритье 2 байта с i=1 to p(и корректирующие модули, естественно). Обратные диапазоны пусты. :)

Приятно! Я добавил это. Спасибо! :)
Ciaran_McCarthy

2

PHP, 65 68 байт

while($i<$argn)echo["Yeah
"][$i%3],["But
"][$i%2],["No
"][~-$i++%3];

Запустите как трубу с -nRили попробуйте онлайн .


Выглядит хорошо, но выдает дополнительную новую
строку

@maxb Спасибо за подсказку. Я мог бы исправить это с помощью 9 дополнительных байтов; но другой подход короче.
Тит

2

VBA (Excel), 105, 101, 99 байт

Изменить: -4 байта от Keeta! Спасибо!

Редактировать 2: -2 байта от Chronocidal! Woot! (Понял, что тестовые случаи работали только на 10. Исправлено сейчас)

Да, в этот раз Excel победил VBA. Без разницы. (Мы идем за тобой)

d=vbCr:For i=1To[a1]:a=i Mod 3:?IIf(a=1,"Yeah"+d,"")IIf(i/2=i\2,"","But"+d)IIf(a=2,"No"+d,"");:Next

^ Это вставляется в окно Immediate и выводит в окно отладки

Ungolfed

d = vbCr
'For 1 to the value in A1 (using 0 gave extra values, and VBA skips the for loop if 0)
For i = 1 To [a1]    'aka: Range("A1").value
    a = i mod 3
    '? is the same as Print (Debug.Print when not in the Immediate Window)
    Print IIf(a = 1, "Yeah" + d, "") _ '<-- Just a line continuation
          'Keeta taught me that the \ operator is division with truncation,
          '     so if they are equal then there is no remainder!
          IIf(i / 2 = i \ 2, "", "But" + d) _
          IIf(a = 2, "No" + d, "");
    'Print usually prints a newline, but it still outputs if the string is blank...
    '   So we append a newline -if true- and use a semi-colon to kill the newline
Next

@Keeta хорошая идея, но нет ... Если вы посмотрите на мой первый код, я использую [a1], что означает Range / cell .value :) Я должен был прояснить это, хотя это было объяснением, извините: /
seadoggie01

1
Да, я видел это и пытался удалить комментарий. Как насчет использования i / 3 = i \ 3 вместо i mod 3 = 0 (и то же самое для mod 2 = 0). Не пробовал, но сработает ли?
Кита

@Keeta Я никогда не видел оператора \ раньше ... Хотя я так не думаю, он возвращает значение деления без остатка ... как и противоположность
моду,

Один - целочисленное деление, а другой - число с плавающей точкой. 7/3 = 2,3333, где 7 \ 3 = 2 (усеченное деление). 6/3 должно быть 2, а 6 \ 3 также должно быть 2, поэтому оно должно работать всякий раз, когда остаток равен нулю (я думаю).
Keeta

1
VBA автоматически объединяет выходные данные функций, поэтому вы можете &IIf(..)
перебрасывать

2

Желе , 22 байта

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ

Монадическая ссылка, выдающая список строк (что, по-видимому, разрешено в комментариях)

Попробуйте онлайн! (нижний колонтитул вызывает Link используяÇи соединяется с использованием новых строк,Yпоскольку неявная печать в Jelly разбивает все вместе, если это возможно)

Как?

2×3=6

Теперь обратите внимание, что первые шесть значений:

["Yeah", "But"]
["No"]
["But"]
["Yeah"]
["But", "No"]
[]

Таким образом, в результирующем списке строк эти значения должны быть повторены (или усечены) до длины, nобъединенной вместе.

Теперь обратите внимание, что набор мощности "Yeah", "But", "No":

[]
["Yeah"]
["But"]
["No"]
["Yeah", "But"]
["Yeah", "No"]
["But", "No"]
["Yeah", "But", "No"]

Таким образом, каждый период представляет собой эти 1-индексированные значения набора мощности "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Код создает этот список, формирует его по длине n, индексирует в power-set, а затем удаляет внутренние списки (что также удаляет пустые строки, поскольку строки являются списками в Jelly) ...

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ - Link: integer, n   e.g. 10
5                      - literal five            5
 R                     - range                   [1,2,3,4,5]
   7                   - literal seven           7
  ż                    - zip together            [[1,7],[2],[3],[4],[5]]
    F                  - flatten                 [1,7,2,3,4,5]
     Ṛ                 - reverse                 [5,4,3,2,7,1]
      ṁ                - mould like (n)          [5,4,3,2,7,1,5,4,3,2]
                    ¤  - nilad followed by link(s) as a nilad:
        “'⁴\ÆẓNƇ»      -   compressed string     "Yeah But No"
                 Ḳ     -   split at spaces       ["Yeah","But","No"]
                  ŒP   -   power-set             [[],["Yeah"],["But"],["No"],["Yeah","But"],["Yeah","No"],["But","No"],["Yeah","But","No"]]
       ị               - index into              [["Yeah","But"],["No"],["But"],["Yeah"],["But","No"],[],["Yeah","But"],["No"],["But"],["Yeah"]]
                     Ẏ - tighten                 ["Yeah","But","No","But","Yeah","But","No","Yeah","But","No","But","Yeah"]

Я сомневаюсь, что это станет короче, чем это. Фантастический ответ и отличное объяснение, молодец!
максимум

2

Python 2 , 93 92 83 байта

lambda i:''.join('Yeah\n'*(x%3<1)+'But\n'*(x%2<1)+'No\n'*(x%3==1)for x in range(i))

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

Огромные 9 байтов сохранены благодаря @Jonathan Frech


Вы можете использовать повторение строк вместо индексации кортежа - ('','Yeah\n')[x%3<1]эквивалентно "Yeah\n"*(x%3<1).
Джонатан Фрех,

@JonathanFrech - очень круто! Подобная техника может быть применена и в других случаях. Большое спасибо!
ElPedro
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.