Rövarspråket

Rövarspråket est un jeu de mots joué par des enfants suédois, tiré des livres sur Kalle Blomkvist d'Astrid Lindgren.

Les règles de base sont les suivantes (de Wikipedia):

• Chaque consonne (l'orthographe est importante, pas la prononciation) est doublée et un o est inséré entre les deux.
• Les voyelles sont laissées intactes.

Quelques exemples:

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

Les consonnes suédoises sont les mêmes que les consonnes anglaises, donc le programme devrait fonctionner avec les entrées suédoises et anglaises.

La lettre "y" est considérée comme une consonne dans ce cas - comme la plupart du temps.

Ta tâche:

Écrivez un programme pour convertir une chaîne de lettres suédoises, entrée via une fonction ou via stdin, en son équivalent Rövarspråket. La réponse la plus courte en octets gagne!

Rétine , 14 + 5 = 19 octets

La rétine est un langage qui est essentiellement une expression régulière .NET avec le moins de frais généraux possible. Le code de ce programme se compose de deux fichiers:

i`[b-z-[eiou]]

$0o$0

Cela lit l'entrée sur STDIN et imprime la sortie sur STDOUT.

Si vous appelez les fichiers pattern.rgxet replacement.rpl, vous pouvez exécuter le programme simplement comme

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

Explication

C'est assez simple, mais permettez-moi d'ajouter quand même quelques explications (principalement sur le fonctionnement de Retina). Si Retina est invoqué avec 2 fichiers, il est automatiquement supposé fonctionner en "mode de remplacement", où le premier fichier est l'expression régulière et le second fichier est le modèle.

La rétine peut être configurée (qui inclut RegexOptionset d'autres options) en ajoutant le regex avec `et une chaîne de configuration. Dans ce cas, je ne lui donne ique le modificateur d'expression régulière normal pour l'insensibilité à la casse.

Quant à l'expression régulière elle-même, elle utilise la soustraction de classe de caractères de .NET pour faire correspondre n'importe quelle consonne dans la plage ASCII. Le remplaçant réécrit ensuite le match deux fois avec un ointermédiaire.

Utiliser Unix KSH 27 28 32 27 octets (ou 21 si on ne compte que dans la commande sed)

Merci aux suggestions des autres :) Apprécié.

.. Je suis arrivé à ceci:

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

(autorisé pour les espaces et les caractères suédois)

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 octets

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

Il s'agit d'une lecture complète du programme depuis STDIN et d'une impression vers STDOUT. Il fonctionne pour une entrée Unicode arbitraire et traite les 42 caractères suivants comme des consonnes:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Testez-le ici.

Explication

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 octets

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

Merci à Masterzagh de m'avoir rappelé qu'une fonction serait également acceptable, et pour son conseil regex concernant les références arrières sans capture!

Version plus longue avec entrée / sortie:

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

Affiche une boîte de dialogue pour entrer la chaîne, puis affiche une boîte de dialogue contenant la sortie Rövarspråket. Le code utilise une expression régulière pour doubler les consonnes et insérer os.

Mathematica, 84 73 72 octets

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

Explication:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" est une expression régulière correspondant à toutes les consonnes sans tenir compte de la casse.
• a:*..*:>a<>"o"<>acrée une règle retardée pour lier ces consonnes à a, et la remplacer par et o entouré de lui-même.
• Enfin, StringReplace[#,*..*]&crée une fonction pure appliquant cette règle à chaque lettre correspondante dans son argument.

Julia, 46 44 octets

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

Cela crée une fonction anonyme qui prend une seule entrée de chaîne et imprime l'équivalent Rövarspråket. Pour l'appeler, donnez-lui un nom, par exemple f=t->....

Il n'y a pas beaucoup de golf ici, à part les espaces après les virgules replace().

Ici, nous utilisons 3 arguments dans la replace()fonction: la chaîne d'entrée, l'expression régulière pour identifier les sous-chaînes et un remplacement. Julia désigne les modèles d'expression régulière parr"..." . L'ajout ià la fin le rend insensible à la casse. Ce regex particulier correspond aux consonnes. Si une fonction est utilisée pour le remplacement, la sortie est cette fonction appliquée à chaque sous-chaîne correspondante. La fonction que nous utilisons ici prend une chaîne set retourne sos, car *effectue la concaténation de chaîne dans Julia. Ainsi, le résultat final est la chaîne d'entrée avec chaque consonne doublée d'un "o" entre.

Exemples:

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"

Notez que ce sera 9 octets de plus si nous devons imprimer le résultat plutôt que de le renvoyer. En attente de confirmation du PO.

Edit: sauvé 2 octets grâce à Martin Büttner!

Haskell, 81 octets

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

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

Je ne peux pas habilement construire la liste des consonnes sans imports coûteux . Même tourner la lettre pour vérifier en minuscules nécessite plus d'octets que de simplement lister les consonnes majuscules et minuscules.

Java 8, 45

À utiliser comme fonction lambda. Utilise une expression régulière.

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

Essayez ici

Perl, 33 octets

Cette réponse est principalement regex uniquement, avec une petite quantité de code supplémentaire pour effectuer les E / S.

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

Cela fait un moment que je n'ai pas utilisé d'expressions rationnelles en Perl, donc cela peut probablement être amélioré.

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

Ok, c'est énorme. Mais C n'a pas d'expressions régulières. S'il vous plaît dites-moi si vous voyez quelque chose qui peut le raccourcir ...

#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 octets

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

Usage:

script.bat hello

Production:

hohelollolo

Vous vous demandez peut-être pourquoi je n'ai pas défini d sur "aoui", la recherche de valeurs non égales nécessite une rupture de boucle. Tout ce qui devrait fonctionner ne fonctionne pas en lot. Le script gère 1 mot de caractères [tels qu'ils apparaissent sur votre clavier]. Tous les espaces et les nouvelles lignes qui sont toujours présents sont nécessaires pour que le script s'exécute.

Windows XP ou supérieur, requis. Non testé dans Windows 8 et supérieur.

PowerShell - 35 octets

Juste pour montrer que PowerShell peut parfois rivaliser dans ces derniers, et avec le regex volé sans vergogne à Retina de Martin Büttner:

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

accepte l'entrée de chaîne de stdin

Pyth - 28 octets

Cela fonctionne de manière évidente en générant la liste des consonnes à la volée en utilisant une différence d'ensemble.

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

Explication à venir.

Essayez-le ici .

Extrait 10 , 30

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

Substitution de regex de base.

Pyth, 25 24 23

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

Exécutez-le ici.

Python, 61

Je ne pouvais pas faire fonctionner une union ou une soustraction de classe de caractères, et donc je ne pense pas que Python ait cette fonctionnalité. J'ai dû utiliser un lookahead négatif à la place.

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

Exécutez-le ici: http://repl.it/fQ5

Lien vers l'inverse: /codegolf//a/48182/34718

K, 38 caractères

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 octets

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

Une solution simple semble assez compétitive étant donné que K manque de regex. Choisissez entre le formulaire "XoX" et le formulaire "X" selon que chaque caractère a été trouvé dans une table de recherche de voyelles ignorées et rejoignez les listes résultantes.

Vous pouvez l'essayer dans votre navigateur en utilisant 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

(Malheureusement, je ne peux pas fournir de lien cliquable car le débordement de pile ne semble pas autoriser les caractères accentués dans les URL)

Golfscript, 35 octets

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

S'attend à ce que l'entrée soit sur la pile. Avec entrée (50 octets):

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

Fonctionne avec les vovels suédois å, ä et ö.

Sed (en ligne de commande), 28 octets

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

Vous pouvez canaliser le texte ou le saisir directement. Seul le code sed est à lui seul de 22 octets.

R, 45 caractères

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

Regex simple. Lit à partir de stdin. i=Tsignifie ignore.case=TRUE(grâce à la correspondance partielle des noms d'arguments), ce qui rend la gsubcasse insensible.

Usage:

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

<> <(Poisson), 64 octets

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

Ce n'est pas la réponse la plus courte mais j'apprécie le défi de la programmation en <> <

Essayez-le ici

golflua, 36 octets

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

Correspondance de motif simple: prenez stdin, puis trouvez les non-voyelles ( %Ws'occupe des caractères non alphanumériques) et insérez un oentre les deux remplacements. Malheureusement, tout cela en écriture (c'est-à-dire w(I.r():g(....))) génère également le nombre d'insertions, bien qu'il ait enregistré 3 caractères. Un équivalent Lua serait

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

REXX, 107 octets

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

Merci à @Masterzagh d'avoir économisé sur la syntaxe des fonctions.

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

JavaScript 62

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