Rövarspråket

Rövarspråket - игра в слова, в которую играют шведские дети из книг Астрид Линдгрен о Калле Бломквист.

Основные правила следующие (из Википедии):

• Каждый согласный (орфография имеет значение, а не произношение) удваивается, и между ними вставляется o.
• Гласные остаются без изменений.

Несколько примеров:

• "привет" -> "hohelollolo"
• "Min svävare är full med ål" -> "MoMinon sosvovävovarore äror fofulollol momedod ålol"

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

Буква «у» в этом случае воспринимается как согласная, как и в большинстве случаев.

Твое задание:

Напишите программу для преобразования строки шведских букв, введенных через функцию или через stdin, в ее эквивалент Rövarspråket. Самый короткий ответ в байтах побеждает!

Сетчатка , 14 + 5 = 19 байт

Retina - это язык, который по сути является регулярным выражением .NET с минимальными накладными расходами. Код для этой программы состоит из двух файлов:

i`[b-z-[eiou]]

$0o$0

Это читает входной сигнал на STDIN и печатает выходной сигнал на STDOUT.

Если вы называете файлы pattern.rgxи replacement.rpl, вы можете запустить программу просто как

echo "hello" | ./Retina pattern.rgx replacement.rpl

объяснение

Это довольно просто, но в любом случае позвольте мне добавить некоторые объяснения (в основном о том, как работает Retina). Если Retina вызывается с двумя файлами, предполагается, что она автоматически работает в «режиме замены», где первый файл является регулярным выражением, а второй файл - шаблоном.

Сетчатка может быть настроена (которая включает в себя RegexOptionsи другие параметры), добавив регулярное выражение `и строку конфигурации. В этом случае я даю только то, iчто является обычным модификатором регулярных выражений для нечувствительности к регистру.

Что касается самого регулярного выражения, оно использует вычитание класса символов .NET для соответствия любому согласному в диапазоне ASCII. Замена затем просто записывает совпадение дважды с oпромежуточным.

Использование Unix KSH 27 28 32 27 байт (или 21, если мы учитываем только команду sed)

Спасибо за предложения других :) Ценю.

.. Я взялся за это:

sed 's/[^AEIOUÅÄÖ ]/&o&/ig'

(разрешено для пробелов и шведских символов)

echo "hello" | sed 's/[BCDFGHJ-NP-TV-Z]/&o&/ig'
hohelollolo
echo "HELLO" | sed 's/[BCDFGHJ-NP-TV-Z]/&o&/ig'
HoHELoLLoLO
echo "QuIcKlY Now" | sed 's/[BCDFGHJ-NP-TV-Z]/&o&/ig'
QoQuIcocKoKlolYoY NoNowow

CJam, 32 30 байт

q{_eu'[,66>"EIOU"-#)g{'o1$}*}/

Это полная программа чтения из STDIN и печати в STDOUT. Он работает для произвольного ввода Unicode и рассматривает следующие 42 символа как согласные:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Проверьте это здесь.

объяснение

q                              "Slurp STDIN.";
 {                          }/ "For each character...";
  _eu                          "Duplicate and convert to upper case.";
     '[,66>                    "Get a string from B to Z using range and slice.";
           "EIOU"-             "Remove the remaining four vowels.";
                  #            "Find the position of the character in this string or
                                -1 if the character can't be found.";
                   )g          "Increment, take signum, which gives 1 for consonants, 
                                and 0 otherwise.";
                     {    }*   "Repeat this block that many times, i.e. do nothing for
                                non-consonants.";
                      'o       "Push an 'o'.";
                        1$     "Copy the current character.";

JavaScript, 59 57 55 44 байта

s=>s.replace(/(?![eiou])[b-z]/gi,"$&o$&")

Спасибо Masterzagh за напоминание о том, что функция также будет приемлемой, и за его совет по регулярным выражениям относительно обратных ссылок без захвата!

Более длинная версия с вводом / выводом:

alert(prompt().replace(/(?![eiou])[b-z]/gi,"$&o$&"));

Отображает окно с предложением ввести строку, а затем показывает диалоговое окно, содержащее выходные данные Rövarspråket. Код использует регулярное выражение для удвоения согласных и вставки os.

Mathematica, 84 73 72 байта

StringReplace[#,a:RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]":>a<>"o"<>a]&

Объяснение:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" является регулярным выражением, совпадающим со всеми согласными без учета регистра.
• a:*..*:>a<>"o"<>a создает отложенное правило, чтобы связать эти согласные с a и заменяющее его на окружающее себя.
• Наконец, StringReplace[#,*..*]&создает чистую функцию, применяющую это правило к каждой соответствующей букве в своем аргументе.

Юлия, 46 44 байта

t->replace(t,r"(?![eiou])[b-z]"i,s->s*"o"*s)

Это создает анонимную функцию, которая принимает один строковый ввод и печатает эквивалент Rövarspråket. Чтобы назвать его, дайте ему имя, например f=t->....

Здесь не так много всего, кроме пробелов после запятых replace().

Здесь мы используем 3 аргумента в replace()функции: входную строку, регулярное выражение для определения подстрок и замены. Юлия обозначает шаблоны регулярных выраженийr"..." . Добавление iк концу делает его нечувствительным к регистру. Это конкретное регулярное выражение соответствует согласным. Если для замены используется функция, выводом является та функция, которая применяется к каждой совпадающей подстроке. Функция, которую мы здесь используем, принимает строку sи возвращает ее sos, поскольку *выполняет конкатенацию строк в Julia. Таким образом, конечным результатом является входная строка с каждым согласным, удвоенным с «o» между ними.

Примеры:

julia> f("Min svävare är full med ål")
"MoMinon sosvovävovarore äror fofulollol momedod ålol"

julia> f("hello")
"hohelollolo"

julia> f("Rövarspråket")
"RoRövovarorsospoproråkoketot"

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

Изменить: Сохранено 2 байта благодаря Мартин Бюттнер!

Haskell, 81 байт

x n|elem n"bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"=[n,'o',n]|1<2=[n]
f=(>>=x)

Использование: f "Hello there!"-> "HoHelollolo tothoherore!".

Я не могу умно построить список согласных без дорогих imports. Даже для преобразования буквы в нижний регистр требуется больше байтов, чем просто перечисление прописных и строчных согласных.

Ява 8, 45

Используйте в качестве лямбда-функции. Использует регулярное выражение.

a->a.replaceAll("(?i)[b-z&&[^eiou]]","$0o$0")

Попробуй здесь

Perl, 33 байта

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

$_=<>;s/[^aeiou\W]/$&o$&/gi;print

Прошло много времени с тех пор, как я использовал регулярные выражения Perl, поэтому, возможно, это можно улучшить.

$_=<>;                              This takes input from STDIN `<>` and stores
                                    it into the default variable $_
      s/          /     /gi;        This is a case-(i)nsentive, (g)lobal, 
                                    (s)ubstitution regex.  Since no other
                                    variable is specified, it is applied to
                                    the default variable $_.
        [^aeiou\W]                  This matches any single character that 
                                    is a consonant, by using a double-
                                    negative ^\W to match only alphanumeric 
                                    characters excluding vowels.  Accented 
                                    vowels are not considered alphanumeric 
                                    by Perl.
                   $&o$&            This forms the replacement.  $& contains the 
                                    match (the consonant), so this replaces each 
                                    consonant with two copies of itself with 
                                    an 'o' in between.
                            print   This prints the result.  With no arguments, 
                                    it prints $_ by default.

C (версия ideone.com) - 133

Хорошо, это огромно. Но у C нет регулярных выражений. Пожалуйста, скажите мне, если вы видите что-то, что может сделать его короче ...

#define x (*c<66||*c>90)&&(*c<98||*c>122)||strchr("EIOUeiou",*c)?"":
c[2];main(){while(0<(*c=getchar()))printf("%s%s%s",c,x"o",x c);}

Пакет Windows, 235 байт

@echo off
setlocal enabledelayedexpansion
set d=qwrtypsdfghjklzxcvbnm
set #=%1
:x
if defined # (
for /l %%i in (0,1,20)do (
set m=!d:~%%i,1!
if /i !m!==%#:~0,1% set g=!g!!m!o)
set g=!g!%#:~0,1%
set #=%#:~1%
goto x)
echo %g%

Использование:

script.bat hello

Выход:

hohelollolo

Возможно, вы удивляетесь, почему я не установил для d значение «aoui», проверка на наличие неравных требует выхода из цикла. Не все, что должно работать, работает, в пакетном режиме. Скрипт обрабатывает 1 слово символов [как они появляются на вашей клавиатуре]. Все пробелы и новые строки, которые все еще присутствуют, необходимы для запуска скрипта.

Требуется Windows XP или выше. Не проверено в Windows 8 и выше.

PowerShell - 35 байт

Просто для того, чтобы показать, что PowerShell может иногда конкурировать и с этим, и с беззастенчивым похищением регулярных выражений из ответа Retina Мартина Бюттнера:

%{$_-replace'[b-z-[eiou]]','$0o$0'}

принимает ввод строки из стандартного ввода

Pyth - 28 байт

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

FNzpk+N?+\oN}rNZ-{G{"aeiou"k

Объяснение скоро.

Попробуй это здесь .

Клип 10 , 30

gx"((?i)[b-z&&[^eiou]])""$1o$1

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

Pyth, 25 24 23

sm+d*+\od}rd0-G"aeoui"z

Запустите это здесь.

Python, 61

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

import re;f=lambda s:re.sub('(?i)(?![eiou])([b-z])',r'\1o\1',s)

Запустите его здесь: http://repl.it/fQ5

Ссылка на обратную: /codegolf//a/48182/34718

К, 38 символов

f:{,/(1+2*~(_x)in"aeiouåäö ")#'x,'"o"}

-1 f"Min svävare är full med ål";
MoMinon sosvovävovarore äror fofulollol momedod ålol

К, 31 байт

,/{(x,"o",x;x)9>" aeiouåäö"?x}'

Простое решение кажется довольно конкурентным, учитывая, что в K отсутствуют регулярные выражения. Выберите между формой «XoX» и формой «X» в зависимости от того, был ли найден каждый символ в таблице поиска игнорируемых гласных, и присоединитесь к полученным спискам.

Вы можете попробовать это в своем браузере, используя ОК :

http://johnearnest.github.io/ok/index.html?run=%20%2C%2F%7B(x%2C%22o%22%2Cx%3Bx)9%3E%22%20aeiouåäö%22%3Fx%7D'%22Min%20svävare%20är%20full%20med%20ål%22

(К сожалению, я не могу предоставить кликабельную ссылку, потому что переполнение стека не позволяет использовать акцентированные символы в URL)

Golfscript, 35 байт

{."aeiouåäö\n "?-1={."o"\}{}if}%

Ожидается, что вход будет в стеке. С вводом (50 байтов):

"#{STDIN.gets}"{."aeiouåäö\n "?-1={."o"\}{}if}%

Работает со шведскими гласными å, ä и ö.

Sed (в командной строке), 28 байт

sed 's/\([^aeiou]\)/\1o\1/g'

Либо передайте текст, либо введите его напрямую. Сам по себе код sed составляет 22 байта.

R, 45 символов

gsub("([^aeiouäöå ])","\\1o\\1",readline(),i=T)

Простое регулярное выражение. Читает со стандартного ввода. i=Tозначает ignore.case=TRUE(благодаря частичному сопоставлению имен аргументов), что делает gsubрегистр нечувствительным.

Использование:

> gsub("([^aeiouäöå ])","\\1o\\1",readline(),i=T)
Min svävare är full med ål
[1] "MoMinon sosvovävovarore äror fofulollol momedod ålol"
> gsub("([^aeiouäöå ])","\\1o\\1",readline(),i=T)
hello
[1] "hohelollolo"
> gsub("([^aeiouäöå ])","\\1o\\1",readline(),i=T)
hElLo
[1] "hohElolLoLo"

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

>" oieauåäöOIEAUÅÄÖ"0i:1+?!;01.
 :&=?\     l?!v&
^[0o&<&o"o"o:&<

Это не самый короткий ответ, но мне нравится задача программирования в <> <

Попробуйте это здесь

golflua, 36 байт

B=I.r():g("[^aeiou%W ]","%1o%1")w(B)

Простое сопоставление с образцом: возьмите stdin, затем найдите не гласные ( %Wзаботится о не алфавитно-цифровых символах) и вставьте oмежду двумя заменами. К сожалению, выполнение всего этого в рамках записи (т. Е. w(I.r():g(....))) Также выводит количество вставок, хотя это сохранило 3 символа. Эквивалент Lua будет

line = io.read()
rovar = line:gsub("[^aeiou%W ]","%1o%1")
print(rovar)

REXX, 107 байт

parse arg s
v='aeiouåäö '
o=
do until s=''
  parse var s l 2 s
  if verify(l,v)>0 then l=l'o'l
  o=o||l
  end
say o

"MoMinon sosvovävovarore äror fofulollol momedod ålol"

JavaScript 43

Спасибо @Masterzagh за сохранение синтаксиса функций.

x=>x.replace(/[bcdfghj-np-tv-z]/gi,"$&o$&")

JavaScript 62

function E(x){return x.replace(/[bcdfghj-np-tv-z]/gi,"$&o$&")}