Progruzzle & Colf


76

Вы когда-нибудь мечтали создать классные хештеги в твиттере, такие как #brexit или #brangelina ? этот гольф для тебя.


Напишите программу, которая принимает две строки A & B в качестве входных данных и объединяет их в соответствии со следующим алгоритмом:

  1. let n- количество групп гласных в A (например, britainимеет 2 группы гласных: iв позиции 3 и aiв позиции 5).
    • если n = 1: усечь A, начиная с первой позиции группы гласных (пример: bill=> b)
    • если n> 1: обрезать A, начиная с его n-1группы гласных (пример: programming=> progr, britain=> br)
  2. удалить все согласные в начале буквы B ( jennifer=> ennifer)
  3. объединить модифицированные A & B

Гласные есть aeiou; согласные есть bcdfghjklmnpqrstvwxyz.

вход

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

Примеры

brad + angelina      => brangelina
britain + exit       => brexit
ben + jennifer       => bennifer
brangelina + exit    => brangelexit
bill + hillary       => billary
angelina + brad      => angelad
programming + puzzle => progruzzle
code + golf          => colf
out + go             => o

65
Новый тест? donald trump,
Стьюи Гриффин

5
Это по сути портмантея .
mbomb007


1
@ETHproductions, кажется, производит очень разные комбинации, такие какDjango + Angular = Djular
Pureferret

Что такое «n-1-я позиция гласной группы»
l4m2

Ответы:


24

Рубин, 44 43 40 + 1 = 41 байт

+1 байт за -pфлаг. Принимает разделенный пробелами ввод в STDIN.
-1 байт благодаря Мартину Эндеру
-2 байт благодаря гистократу

sub /([aeiou]+([^aeiou]*)){,2} \g<2>/,""

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

GNU sed, 39 37 + 1 = 38 байт

+1 байт за -Eфлаг. Принимает разделенный пробелами ввод в STDIN.
-1 байт благодаря Мартину Эндеру

s/([aeiou]+[^aeiou]*){,2} [^aeiou]*//

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

Не публикуйте это как отдельный ответ, потому что это буквально одно и то же решение.


Хорошее регулярное выражение! Не возражаете, если я использую часть этого в своем ответе JS?
ETHпродукция

Конечно, сходи с ума.
Джордан

3
Вы можете сыграть в regex немного больше, запечатлев в [^aeiou]качестве подвыражения:/([aeiou]+([^aeiou]*)){,2} \g<2>/
гистократ,


1
@Anko Смотрите "Специальные призывы" в этом ответе . TL; DR: только количество байтов в дополнение к вызову по умолчанию. По умолчанию вызова для Рубина ruby -e "...". Для этого это ruby -pe "...", так что он добавляет только один байт.
Джордан,

12

MATL, 31 30 байт

t13Y2XJmFwhdl=fql_):)itJmYsg)h

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

объяснение

t       % Implicitly grab the input and duplicate it
13Y2    % Push the string literal 'aeiouAEIOU'
XJ      % Store this in clipboard J for later use
m       % Check which characters from the input are vowels (true for vowel)
Fwh     % Prepend FALSE to this logical array
dl=     % Compute the difference and find where we went from not-vowel to vowel
f       % Find the indices of these transitions
q       % Subtract 1 to get the location of the last consonant in each transition
l_)     % Get the next-to-last one of these
:)      % Grab the first string up to this location

% Now for the second component!

it      % Explicitly grab the input and duplicate
J       % Retrieve the string literal 'aeiouAEIOU' from clipboard J
m       % Find where the vowels are (true for vowel)
Ys      % Compute the cumulative sum along the array. The result will be 0
        % for all characters before the first vowel and non-zero after
g)      % Convert to logical and use this as an index so any characters
        % after the first value are retrieved

% Now to combine them

h       % Horizontally concatenate the first and second pieces together
        % Implicitly display the result

1
Я всегда приветствую счастливый код
Андрас Дик

12

JavaScript (ES6), 81 73 72 байта

Сохранено 8 байт благодаря @Jordan, 1 благодаря @DavidConrad

a=>b=>a.match(/.*?(?=(?:[aeiou]+[^aeiou]*){1,2}$)/)+b.match(/[aeiou].*/)

Даже если .matchвозвращает массив, array+arrayвозвращает строку с конкатенацией содержимого массивов (т.е. [0]+[1]возвращает "01").

Тестовый фрагмент

Отличное решение Jordan для Ruby будет содержать 53 байта в JS:

x=>x.replace(/([aeiou]+[^aeiou]*){1,2} [^aeiou]*/,"")

Может, просто выбросить бит совпадения и использовать замену?
Конор О'Брайен

@ ConorO'Brien Это похоже на воровство ответа Джордана: /
ETHproductions

Вы буквально читаете мои мысли. И да, это правда
Конор О'Брайен

1
Карри экономит (a,b)=>до a=>b=>1 байта.
Дэвид Конрад

7

Желе , 23 22 байта

eۯcT
ǵḟ‘-ị’
Ç⁸ḣ⁹ÑḢ⁹ṫ

TryItOnline

Как?

eۯcT    - Link 1, vowel indexes: s   e.g. "colouring"
  Øc     - yield vowels, "AEIOUaeiou"
e€       - in for each                     [0,1,0,1,1,0,1,0,0]
    T    - truthy indexes (1-based)        [2,4,5,7]

ǵḟ‘-ị’  - Link 2, n-1th or only vowel group index start - 1: s
 µ       - monadic chain separation
Ç        - call last link (1) as a monad   [2,4,5,7]
   ‘     - increment                       [3,5,6,8]
  ḟ      - filter out                      [2,4,7]
    -    - -1
     ị   - index value                     [4]
               (Jelly is 1-based and has modular indexing,
                so the last but one item is at index -1,
                and when there is only 1 item in the list it is also at index -1)
      ’  - decrement                       [3]

Ç⁸ḣ⁹ÑḢ⁹ṫ - Main link: a, b                      e.g. "colouring", "pencils"
Ç        - call last link (2) as a monad with a      [3]
 ⁸       - link's left argument, a
  ḣ      - head a[:y]                                "col"
   ⁹  ⁹  - link's right argument, b
    Ñ    - call next link (1) as a monad                          [2,5]
     Ḣ   - pop head                                               [2]
       ṫ - tail b[y-1:]                                           "encils"
         - implicit print                            "colencils"

Красиво объяснил!
Pureferret

5

PowerShell v2 +, 76 байт

param($n,$m)($n-replace'([aeiou]+[^aeiou]*){1,2}$')+($m-replace'^[^aeiou]*')

Видимо это популярное регулярное выражение ... ;-)

Использует -replaceоператор для извлечения соответствующих частей, затем объединяет результаты в строку. Добавляет a $к первому, чтобы убедиться, что мы потянем конец строки, и добавим a ^ко второму, чтобы убедиться, что мы вытянули переднюю часть строки.


4

Сетчатка , 35 байт

([aeiou]+[^aeiou]*){1,2} [^aeiou]*

Попробуйте онлайн! (Первая строка включает набор тестов, разделенных переводом строки.)

Просто удаляет все совпадения регулярного выражения в первой строке.


1
Есть ли планы добавить классы гласных и не гласных? ;-)
ETHproductions

@ETHproductions Если я когда-нибудь смогу реализовать свой собственный вариант регулярного выражения (или, по крайней мере, сделать его так, чтобы его можно было перенести в регулярное выражение .NET), конечно! : P
Мартин Эндер

Ruby может делать обратные ссылки на шаблоны (тот же шаблон, который может соответствовать разной последовательности символов). Это было бы полезно здесь. Например, соответствующие скобки сопоставляются /^((\(\g<1>\))*)$/в Ruby.
Джон Дворжак

1
@JanDvorak Жаль, что Retina написана на .NET, а? ;) Я действительно рассматривал возможность связать его с github.com/ltrzesniewski/pcre-net, чтобы вы могли переключать варианты, но пока не дошел до этого, а некоторые другие функции все больше полагаются на специфическое поведение .NET.
Мартин Эндер

1
Время отказаться от специфического поведения .net и переписать все на Ruby? Руби лучше в любом случае :-)
Джон Дворак

4

Корица, 23 байта

0000000: 64d3 884e 4ccd cc2f 8dd5 8e8e 8330 b434  d..NL../.....0.4
0000010: b108 d92b c0d9 00                        ...+...

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

объяснение

Это распаковывает d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, что dвыбирает все, что соответствует этому регулярному выражению. (Обратите внимание, что игрок в гольф Джордана d([aeiou]+[^aeiou]*){,2} [^aeiou]*сжимает до 24 байт из-за отсутствия повторяющихся элементов для сжатия.)


Будет d[aeiou]+[^aeiou]*[aeiou]*[^aeiou]* [^aeiou]*короче?
ETHproductions

@ETHproductions Я попробовал это, это было то же самое число байтов :(
спагетто

3

PHP, 95 байт

$t="aeiou]";echo($p=preg_filter)("#([$t+[^$t*){1,2}$#","",$argv[1]).$p("#^[^$t*#","",$argv[2]);

с preg_match вместо preg_filter 110 байт

$t="aeiou]";($p=preg_match)("#(.*?)([$t+[^$t*){1,2}$#",$argv[1],$m);$p("#[$t.*#",$argv[2],$n);echo$m[1].$n[0];

1
Вы можете использовать +вместо {1,2}.
Тит

@Titus более важно было устранить ошибку в 1 случае, и теперь я могу попытаться устранить ее
Йорг Хюльсерманн

Используйте, $v=aeiou;чтобы сохранить еще 3.
Тит

@ У меня была та же идея, но с небольшим вариантом. Спасибо
Йорг Хюльсерманн

3

Луа, 66 байт

$ cat merge.lua
print(((...):gsub(("[]+[^]*[]*[^]*+[^]*"):gsub("]","aeiou]"),"")))
$ lua merge.lua brad+angelina
brangelina
$ lua merge.lua programming+puzzle
progruzzle



2

Lithp , 65 байт

#X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") ""))

Это в основном порт ответа JavaScript выше, на моем функциональном языке программирования Lisp.

Пример использования:

(
    % Note, you can define this as a function, or assign it to a variable
    % and use the call function instead.
    (def f #X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") "")))
    (print (f "programming puzzle"))
)

Онлайн переводчика пока нет. Я предоставлю один в ближайшее время. Это не составит труда, мой язык написан на JavaScript.

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

node run.js l_src/progruzzle-colf.lithp

2

Haskell, 111 108 байт

v x=elem x"aeiou"
d=dropWhile
e=d v
k=d$not.v
r=reverse
f a|c<-e.k.e.k$a,""/=c=c|1<3=e.k$a
a!b=(r.f.r)a++k b

Это решение без регулярных выражений оказалось дольше, чем ожидалось. Всё равно в идеале.



1

Japt , 18 байт

r/\v+\V*){1,2} \V*

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

Прямой порт короткого решения JS, которое в свою очередь является портом решения Jordan для Ruby .

Как это устроено

Ur/\v+\V*){1,2} \V*/

Ur    Replace on the input...
/\v+\V*){1,2} \V*/  this regex with empty string.
      \v == [AEIOUaeiou], \V == [^AEIOUaeiou], `g` flag is on by default in Japt
      so the uncompressed regex is roughly /([aeiou]+[^aeiou]*){1,2} [^aeiou]*/g.
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.