Rövarspråket

Rövarspråket to gra słowna, w którą bawią się szwedzkie dzieci, z książek o Kalle Blomkvist autorstwa Astrid Lindgren.

Podstawowe zasady są następujące (z Wikipedii):

• Każda spółgłoska (pisownia ma znaczenie, a nie wymowa) jest podwojona, a między nimi wstawia się o.
• Samogłoski pozostają nietknięte.

Kilka przykładów:

• „cześć” -> „hohelollolo”
• „Min svävare är full med ål” -> „MoMinon sosvovävovarore äror fofulollol momedod ålol”

Spółgłoski szwedzkie są takie same jak angielskie, więc program powinien działać zarówno ze szwedzkimi, jak i angielskimi wpisami.

Litera „y” jest w tym przypadku traktowana jako spółgłoska - jak zwykle.

Twoje zadanie:

Napisz program do konwersji ciągu szwedzkich liter wprowadzonych przez funkcję lub przez stdin na jego odpowiednik Rövarspråket. Najkrótsza odpowiedź w bajtach wygrywa!

Siatkówka oka , 14 + 5 = 19 bajtów

Retina to język, który jest po prostu wyrażeniem regularnym .NET z możliwie najmniejszym narzutem. Kod tego programu składa się z dwóch plików:

i`[b-z-[eiou]]

$0o$0

Odczytuje dane wejściowe STDIN i drukuje dane wyjściowe do STDOUT.

Jeśli wywołasz pliki pattern.rgxi replacement.rpl, możesz uruchomić program po prostu jak

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

Wyjaśnienie

Jest to dość proste, ale i tak dodam wyjaśnienie (głównie o tym, jak działa Retina). Jeśli Retina zostanie wywołana z 2 plikami, automatycznie zakłada się, że działa w „trybie zastępowania”, gdzie pierwszy plik jest wyrażeniem regularnym, a drugi plik jest wzorcem.

Siatkówkę można skonfigurować (w tym RegexOptionsi inne opcje), poprzedzając wyrażenie regularne za pomocą `i ciąg konfiguracji. W tym przypadku daję tylkoi który jest normalnym modyfikatorem wyrażenia regularnego w przypadku niewrażliwości na wielkość liter.

Jeśli chodzi o sam regex, używa odejmowania klasy znaków .NET, aby dopasować dowolną spółgłoskę w zakresie ASCII. Zastępca następnie po prostu zapisuje mecz dwa razy z opośrodkiem.

Korzystanie z Uniksa KSH 27 28 32 27 bajtów (lub 21, jeśli liczymy tylko w poleceniu sed)

Dzięki sugestiom innych :) Doceniamy.

.. doszedłem do tego:

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

(dozwolone dla spacji i szwedzkich znaków)

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 bajtów

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

Jest to pełny odczyt programu ze STDIN i drukowanie do STDOUT. Działa dla dowolnego wprowadzania Unicode i traktuje następujące 42 znaki jako spółgłosek:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Sprawdź to tutaj.

Wyjaśnienie

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 bajtów

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

Dzięki Masterzaghowi za przypomnienie mi, że funkcja będzie również akceptowalna, oraz za jego wskazówkę dotyczącą wyrażeń regularnych dotyczących odwołań zwrotnych bez przechwytywania!

Dłuższa wersja z wejściem / wyjściem:

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

Wyświetla okno zachęty do wprowadzenia ciągu, a następnie wyświetla okno dialogowe zawierające dane wyjściowe Rövarspråket. Kod używa wyrażenia regularnego, aby podwoić spółgłosek i wstawić os.

Mathematica, 84 73 72 bajty

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

Wyjaśnienie:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" jest wyrażeniem regularnym pasującym do wszystkich spółgłosek bez rozróżniania wielkości liter.
• a:*..*:>a<>"o"<>atworzy opóźnioną regułę, aby powiązać te spółgłoski ai zastąpić ją otoczeniem o lub o.
• Wreszcie StringReplace[#,*..*]&tworzy czystą funkcję, stosując tę ​​regułę do każdej pasującej litery w argumencie.

Julia, 46 44 bajtów

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

Tworzy to anonimową funkcję, która pobiera pojedynczy ciąg znaków i wypisuje odpowiednik Rövarspråket. Aby to nazwać, nadaj mu nazwę, np f=t->....

Naprawdę niewiele tu grało w golfa, oprócz miejsc po przecinkach replace().

W funkcji używamy 3 argumentów replace(): ciągu wejściowego, wyrażenia regularnego do identyfikowania podciągów i zamiany. Julia oznacza wzorce wyrażeń regularnych przez r"...". Dodanie ido końca powoduje, że wielkość liter nie jest uwzględniana. Ta konkretna regex pasuje do spółgłosek. Jeśli funkcja jest używana do zamiany, wynikiem jest funkcja zastosowana do każdego dopasowanego podłańcucha. Funkcja używamy tutaj pobiera ciąg si powraca sos, ponieważ* wykonuje Julian łączenie łańcucha. Tak więc wynikiem końcowym jest łańcuch wejściowy z każdą spółgłoską podwójną z „o” pomiędzy.

Przykłady:

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"

Zauważ, że będzie to o 9 bajtów dłużej, jeśli będziemy musieli wydrukować wynik, zamiast go zwrócić. Oczekuje na potwierdzenie z PO.

Edycja: Zapisano 2 bajty dzięki Martinowi Büttnerowi!

Haskell, 81 bajtów

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

Zastosowanie: f "Hello there!"-> "HoHelollolo tothoherore!".

Nie mogę sprytnie skonstruować listy spółgłosek bez drogich imports. Nawet odwrócenie litery w celu sprawdzenia małych liter wymaga więcej bajtów niż po prostu wypisanie zarówno wielkich, jak i małych spółgłosek.

Java 8, 45

Użyj jako funkcji lambda. Używa wyrażenia regularnego.

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

Wypróbuj tutaj

Perl, 33 bajtów

Ta odpowiedź jest głównie tylko do wyrażenia regularnego, z niewielką ilością dodatkowego kodu do wykonania operacji we / wy.

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

Minęło trochę czasu, odkąd użyłem wyrażeń regularnych Perla, więc prawdopodobnie można to poprawić.

$_=<>;                              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 (wersja ideone.com) - 133

Ok, to jest ogromne. Ale C nie ma wyrażeń regularnych. Powiedz mi, jeśli widzisz coś, co może go skrócić ...

#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);}

Pakiet Windows, 235 bajtów

@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%

Stosowanie:

script.bat hello

Wynik:

hohelollolo

Być może zastanawiasz się, dlaczego nie ustawiłem d na „aoui”, sprawdzanie, czy nie jest równe, wymaga wyjścia z pętli. Nie wszystko, co powinno działać, działa zbiorczo. Skrypt obsługuje 1 słowo znaków [pojawiających się na klawiaturze]. Wszystkie spacje i znaki nowej linii, które są jeszcze obecne, są wymagane do uruchomienia skryptu.

Wymagany system Windows XP lub nowszy. Nie testowano w systemie Windows 8 i nowszych.

PowerShell - 35 bajtów

Tylko po to, aby pokazać, że PowerShell może czasem w nich konkurować, a dzięki wyrażeniu regularnemu bezwstydnie skradzionemu z Retiny Martina Büttnera odpowiedź:

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

akceptuje ciąg znaków od standardowego wejścia

Pyth - 28 bajtów

Działa to w oczywisty sposób, generując listę spółgłosek w locie z wykorzystaniem ustawionej różnicy.

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

Wyjaśnienie już wkrótce.

Wypróbuj tutaj .

Klip 10 , 30

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

Podstawowe podstawienie wyrażenia regularnego.

Pyth, 25 24 23

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

Uruchom tutaj.

Python, 61

Nie mogłem zmusić do działania związku klasy lub odejmowania, więc nie sądzę, aby Python miał tę funkcję. Zamiast tego musiałem użyć negatywnego spojrzenia.

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

Uruchom tutaj: http://repl.it/fQ5

Link do odwrotnej strony: /codegolf//a/48182/34718

K, 38 znaków

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

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

K, 31 bajtów

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

Proste rozwiązanie wydaje się dość konkurencyjne, biorąc pod uwagę, że K nie ma wyrażeń regularnych. Wybierz pomiędzy formą „XoX” i „X” na podstawie tego, czy każdy znak został znaleziony w tabeli odnośników ignorowanych samogłosek i dołącz do powstałych list.

Możesz spróbować w przeglądarce za pomocą OK :

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

(Niestety nie mogę podać linku, który można kliknąć, ponieważ przepełnienie stosu nie wydaje się dopuszczać znaków akcentowanych w adresach URL)

Golfscript, 35 bajtów

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

Oczekuje, że dane wejściowe znajdą się na stosie. Z wejściem (50 bajtów):

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

Współpracuje ze szwedzkimi vovels å, ä i ö.

Sed (w wierszu poleceń), 28 bajtów

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

Wpisz tekst bezpośrednio lub wpisz go bezpośrednio. Sam kod sed sam w sobie ma 22 bajty.

R, 45 znaków

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

Proste wyrażenie regularne. Czyta ze standardowego. i=Toznacza ignore.case=TRUE(dzięki częściowemu dopasowaniu nazw argumentów), co czyni gsubrozróżnianie wielkości liter.

Stosowanie:

> 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"

<> <(Ryby), 64 bajty

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

To nie jest najkrótsza odpowiedź, ale podoba mi się wyzwanie programowania w <> <

Wypróbuj tutaj

golflua, 36 bajtów

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

Proste dopasowanie wzorców: weź standardowe wejście, a następnie znajdź nie-samogłoski ( %Wzajmie się znakami niealfanumerycznymi) i wstaw omiędzy dwoma zamiennikami. Niestety, robienie tego wszystkiego w trakcie zapisu (tj. w(I.r():g(....))) Również generuje liczbę wstawień, chociaż zapisano 3 znaki. Byłby to odpowiednik Lua

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

REXX, 107 bajtów

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

Dzięki @Masterzagh za oszczędność na składni funkcji.

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

JavaScript 62

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