Rövarspråket

Rövarspråket ist ein Wortspiel schwedischer Kinder aus den Büchern über Kalle Blomkvist von Astrid Lindgren.

Die Grundregeln lauten wie folgt (aus Wikipedia):

• Jeder Konsonant (Rechtschreibung, nicht Aussprache) wird verdoppelt und ein o dazwischen eingefügt.
• Vokale bleiben erhalten.

Einige Beispiele:

• "hallo" -> "hohelollolo"
• "Min svävare är full med ål" -> "MoMinon sosvovävovarore äror fofulollol momedod ålol"

Schwedische Konsonanten sind die gleichen wie die englischen, daher sollte das Programm sowohl mit schwedischen als auch mit englischen Einträgen funktionieren.

Der Buchstabe "y" wird in diesem Fall - wie meistens - als Konsonant genommen.

Deine Aufgabe:

Schreiben Sie ein Programm, um eine Folge von schwedischen Buchstaben, die durch eine Funktion oder durch stdin eingegeben wurden, in das entsprechende Rövarspråket zu konvertieren. Kürzeste Antwort in Bytes gewinnt!

Retina , 14 + 5 = 19 Bytes

Retina ist eine Sprache, die im Wesentlichen nur aus .NET-Regex besteht und so wenig Aufwand wie möglich verursacht. Der Code für dieses Programm besteht aus zwei Dateien:

i`[b-z-[eiou]]

$0o$0

Dadurch wird die Eingabe in STDIN gelesen und die Ausgabe in STDOUT gedruckt.

Wenn Sie die Dateien pattern.rgxund aufrufen replacement.rpl, können Sie das Programm einfach wie folgt ausführen

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

Erläuterung

Dies ist ziemlich einfach, aber lassen Sie mich trotzdem eine Erklärung hinzufügen (hauptsächlich darüber, wie Retina funktioniert). Wenn Retina mit 2 Dateien aufgerufen wird, wird automatisch angenommen, dass es im "Ersetzungsmodus" arbeitet, wobei die erste Datei die Regex und die zweite Datei das Muster ist.

Retina kann konfiguriert werden (einschließlich RegexOptionsund anderer Optionen), indem der Regex `und eine Konfigurationszeichenfolge vorangestellt werden . In diesem Fall gebe ich nur das, iwas der normale Regex-Modifikator für Groß- und Kleinschreibung ist.

Der reguläre Ausdruck selbst verwendet die .NET-Zeichenklassensubtraktion, um mit einem beliebigen Konsonanten im ASCII-Bereich übereinzustimmen. Die Ersetzung schreibt das Match dann einfach zweimal mit einem odazwischen liegenden zurück.

Verwenden von Unix KSH 27 28 32 27 Bytes (oder 21, wenn nur innerhalb des Befehls sed gezählt wird)

Vielen Dank an die Vorschläge anderer :) Geschätzt.

..Ich bin auf folgendes gekommen:

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

(erlaubt für Leerzeichen und schwedische Zeichen)

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 Bytes

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

Dies ist ein vollständiges Programm, das von STDIN gelesen und auf STDOUT gedruckt wird. Es funktioniert für beliebige Unicode-Eingaben und behandelt die folgenden 42 Zeichen als Konsonanten:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Teste es hier.

Erläuterung

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 Bytes

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

Vielen Dank an Masterzagh, der mich daran erinnert hat, dass eine Funktion auch akzeptabel ist, und an seinen Regex-Tipp in Bezug auf Rückverweise ohne Erfassung!

Längere Version mit Eingabe / Ausgabe:

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

Zeigt eine Eingabeaufforderung zur Eingabe der Zeichenfolge an und anschließend ein Dialogfeld mit der Rövarspråket-Ausgabe. Der Code verwendet einen regulären Ausdruck, um die Konsonanten zu verdoppeln und os einzufügen .

Mathematica, 84 73 72 Bytes

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

Erläuterung:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" ist ein regulärer Ausdruck, bei dem die Groß- und Kleinschreibung aller Konsonanten nicht berücksichtigt wird.
• a:*..*:>a<>"o"<>aerstellt eine verzögerte Regel, um diese Konsonanten an sich zu binden aund durch und zu ersetzen, die von sich selbst umgeben sind.
• Schließlich StringReplace[#,*..*]&schafft eine reine Funktion , diese Regel zu jedem passenden Brief in seiner Argumentation anwenden.

Julia, 46 44 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die eine einzelne Zeichenfolge eingibt und das Rövarspråket-Äquivalent ausgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=t->....

Abgesehen von Leerzeichen nach dem Komma wurde hier nicht wirklich viel gespielt replace().

Hier verwenden wir 3 Argumente in der replace()Funktion: die Eingabezeichenfolge, den regulären Ausdruck zum Identifizieren von Teilzeichenfolgen und eine Ersetzung. Julia bezeichnet reguläre Ausdrucksmuster mit r"...". Durch idas Hinzufügen zum Ende wird die Groß- und Kleinschreibung ignoriert. Dieser spezielle reguläre Ausdruck entspricht den Konsonanten. Wenn eine Funktion zum Ersetzen verwendet wird, ist die Ausgabe die Funktion, die auf jede übereinstimmende Teilzeichenfolge angewendet wird. Die Funktion, die wir hier verwenden, nimmt einen String sund gibt ihn zurück sos, da sie *in Julia eine String-Verkettung durchführt. Somit ist das Endergebnis die Eingabezeichenfolge, wobei jeder Konsonant mit einem "0" dazwischen verdoppelt wird.

Beispiele:

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"

Beachten Sie, dass dies 9 Byte länger ist, wenn das Ergebnis gedruckt und nicht zurückgegeben werden muss. Warten auf Bestätigung vom OP.

Edit: 2 Bytes gespart dank Martin Büttner!

Haskell, 81 Bytes

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

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

Ich kann die Liste der Konsonanten nicht ohne teure imports klug konstruieren . Selbst wenn Sie den Buchstaben auf Kleinbuchstaben drehen, werden mehr Bytes benötigt, als nur die Konsonanten in Groß- und Kleinbuchstaben aufzulisten.

Java 8, 45

Verwendung als Lambda-Funktion. Verwendet regulären Ausdruck.

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

Versuch es hier

Perl, 33 Bytes

Diese Antwort ist meistens nur für reguläre Ausdrücke bestimmt, mit einer kleinen Menge zusätzlichen Codes für die Ausführung von E / A.

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

Es ist schon eine Weile her, dass ich Perl-Regexes verwendet habe, daher kann dies wahrscheinlich verbessert werden.

$_=<>;                              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-Version) - 133

Ok, das ist riesig. Aber C hat keine regulären Ausdrücke. Bitte sag mir, wenn du etwas siehst, das es kürzer machen kann ...

#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 Batch, 235 Bytes

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

Verwendung:

script.bat hello

Ausgabe:

hohelollolo

Sie fragen sich vielleicht, warum ich d nicht auf "aoui" gesetzt habe. Wenn Sie nach Ungleichheiten suchen, müssen Sie aus einer Schleife ausbrechen. Nicht alles, was funktionieren sollte, funktioniert im Batch. Das Skript verarbeitet 1 Wort Zeichen [so wie sie auf Ihrer Tastatur erscheinen]. Alle Leerzeichen und Zeilenumbrüche, die noch vorhanden sind, sind für die Ausführung des Skripts erforderlich.

Windows XP oder höher erforderlich. Nicht in Windows 8 und höher getestet.

PowerShell - 35 Byte

Nur um zu zeigen, dass PowerShell auch hier mithalten kann, und mit dem Regex, der Martin Büttners Retina-Antwort schamlos gestohlen wurde:

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

akzeptiert Zeichenketteneingaben von stdin

Pyth - 28 Bytes

Dies funktioniert auf offensichtliche Weise, indem die Konsonantenliste im laufenden Betrieb unter Verwendung der eingestellten Differenz generiert wird.

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

Erklärung folgt in Kürze.

Probieren Sie es hier aus .

Clip 10 , 30

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

Grundlegende Regex-Substitution.

Pyth, 25 24 23

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

Führen Sie es hier aus.

Python, 61

Ich konnte keine Zeichenklassenvereinigung oder -subtraktion zum Laufen bringen, und deshalb glaube ich nicht, dass Python über diese Funktion verfügt. Ich musste stattdessen einen negativen Lookahead verwenden.

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

Führen Sie es hier aus: http://repl.it/fQ5

Link zur Umkehrung: /codegolf//a/48182/34718

K, 38 Zeichen

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 Bytes

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

Eine einfache Lösung scheint ziemlich wettbewerbsfähig zu sein, da K keine regulären Ausdrücke hat. Wählen Sie zwischen dem "XoX" -Formular und dem "X" -Formular basierend darauf, ob jedes Zeichen in einer Nachschlagetabelle ignorierter Vokale gefunden wurde, und fügen Sie die resultierenden Listen hinzu.

Sie können es in Ihrem Browser mit OK versuchen :

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

(Leider kann ich keinen anklickbaren Link bereitstellen, da der Stapelüberlauf keine Zeichen mit Akzent in URLs zulässt.)

Golfscript, 35 Bytes

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

Erwartet, dass sich die Eingabe auf dem Stapel befindet. Mit Eingabe (50 Bytes):

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

Arbeitet mit den schwedischen Vokalen å, ä und ö.

Sed (in der Befehlszeile), 28 Byte

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

Leiten Sie den Text entweder weiter oder geben Sie ihn direkt ein. Allein der sed-Code ist 22 Byte groß.

R 45 Zeichen

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

Einfacher Regex. Liest von stdin. i=Tsteht für ignore.case=TRUE(dank teilweiser Übereinstimmung der Argumentnamen), wodurch die gsubGroß- und Kleinschreibung unwichtig wird.

Verwendung:

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

<> <(Fisch), 64 Bytes

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

Es ist nicht die kürzeste Antwort, aber ich genieße die Herausforderung, in <> <zu programmieren

Probieren Sie es hier aus

Golflua, 36 Bytes

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

Einfache Mustererkennung: nimm stdin, finde dann die Nicht-Vokale ( %Wkümmert sich um nicht-alphanumerische Zeichen) und füge ein ozwischen die beiden Ersetzungen. Leider wird bei all diesen Schreibvorgängen w(I.r():g(....))auch die Anzahl der Einfügungen ausgegeben, obwohl 3 Zeichen gespart wurden. Ein Lua-Äquivalent wäre

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

REXX, 107 Bytes

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

Vielen Dank an @Masterzagh für die Einsparung von Funktionssyntax.

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

JavaScript 62

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