Rövarspråket

Rövarspråket es un juego de palabras jugado por niños suecos, de los libros sobre Kalle Blomkvist de Astrid Lindgren.

Las reglas básicas son las siguientes (de Wikipedia):

• Cada consonante (la ortografía importa, no la pronunciación) se duplica y se inserta una o en el medio.
• Las vocales se dejan intactas.

Algunos ejemplos:

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

Las consonantes suecas son las mismas que las inglesas, por lo que el programa debería funcionar con entradas suecas e inglesas.

La letra "y" se toma como una consonante en este caso, como lo es la mayoría de las veces.

Tu tarea:

Escriba un programa para convertir una cadena de letras suecas, ingresadas a través de una función o a través de stdin, en su equivalente de Rövarspråket. ¡La respuesta más corta en bytes gana!

Retina , 14 + 5 = 19 bytes

Retina es un lenguaje que es esencialmente una expresión regular .NET con la menor sobrecarga posible. El código para este programa consta de dos archivos:

i`[b-z-[eiou]]

$0o$0

Esto lee la entrada en STDIN e imprime la salida en STDOUT.

Si llama a los archivos pattern.rgxy replacement.rpl, puede ejecutar el programa simplemente como

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

Explicación

Esto es bastante sencillo, pero permítanme agregar alguna explicación de todos modos (principalmente sobre cómo funciona Retina). Si se invoca Retina con 2 archivos, se supone automáticamente que funciona en "Modo de reemplazo", donde el primer archivo es la expresión regular y el segundo archivo es el patrón.

La retina se puede configurar (que incluye RegexOptionsy otras opciones) anteponiendo la expresión regular con `una cadena de configuración. En este caso, solo le doy icuál es el modificador de expresiones regulares para la insensibilidad de mayúsculas y minúsculas.

En cuanto a la expresión regular en sí, utiliza la resta de la clase de caracteres de .NET para hacer coincidir cualquier consonante en el rango ASCII. El reemplazo luego solo escribe el partido dos veces con un ointermedio.

Usando Unix KSH 27 28 32 27 bytes (o 21 si solo contamos dentro del comando sed)

Gracias a las sugerencias de otros :) Apreciado.

.. Me puse a esto:

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

(permitido para espacios y caracteres suecos)

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$}*}/

Este es un programa completo que lee desde STDIN e imprime en STDOUT. Funciona para la entrada arbitraria de Unicode y trata los siguientes 42 caracteres como consonantes:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Pruébalo aquí.

Explicación

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$&")

¡Gracias a Masterzagh por recordarme que una función también sería aceptable, y por su consejo de expresiones regulares con respecto a las referencias posteriores sin capturar!

Versión más larga con entrada / salida:

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

Muestra un cuadro de aviso para ingresar la cadena, luego muestra un cuadro de diálogo que contiene la salida de Rövarspråket. El código usa una expresión regular para duplicar las consonantes e insertar os.

Mathematica, 84 73 72 bytes

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

Explicación:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" es una expresión regular que coincide con todas las consonantes sin distinción entre mayúsculas y minúsculas.
• a:*..*:>a<>"o"<>acrea una regla retrasada para unir esas consonantes ay reemplazarla con o rodeada por sí misma.
• Finalmente, StringReplace[#,*..*]&crea una función pura aplicando esa regla a cada letra coincidente en su argumento.

Julia, 46 44 bytes

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

Esto crea una función anónima que toma una sola entrada de cadena e imprime el equivalente de Rövarspråket. Para llamarlo, asígnele un nombre, por ejemplo f=t->....

No se ha jugado mucho golf aquí, aparte de los espacios después de las comas replace().

Aquí estamos usando 3 argumentos en la replace()función: la cadena de entrada, la expresión regular para identificar subcadenas y un reemplazo. Julia denota patrones de expresión regular por r"...". Agregar ial final lo hace insensible a mayúsculas y minúsculas. Esta expresión regular particular coincide con las consonantes. Si se usa una función para el reemplazo, la salida es esa función aplicada a cada subcadena coincidente. La función que estamos usando aquí toma una cadena sy regresa sos, ya que *realiza la concatenación de cadenas en Julia. Por lo tanto, el resultado final es la cadena de entrada con cada consonante duplicada con una "o" entre ellas.

Ejemplos:

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"

Tenga en cuenta que esto será 9 bytes más largo si tenemos que imprimir el resultado en lugar de devolverlo. En espera de confirmación por parte del OP.

Editar: ¡ Guardado 2 bytes gracias a Martin Büttner!

Haskell, 81 bytes

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

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

No puedo construir inteligentemente la lista de consonantes sin imports costosas . Incluso convertir la letra para verificar en minúsculas necesita más bytes que simplemente enumerar las consonantes en mayúsculas y minúsculas.

Java 8, 45

Úselo como una función lambda. Utiliza expresiones regulares.

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

Intenta aquí

Perl, 33 bytes

Esta respuesta es principalmente de expresiones regulares, con una pequeña cantidad de código adicional para realizar E / S.

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

Ha pasado un tiempo desde que usé expresiones regulares de Perl, por lo que esto probablemente pueda mejorarse.

$_=<>;                              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 (versión de ideone.com) - 133

Ok, esto es enorme. Pero C no tiene expresiones regulares. Por favor, dime si ves algo que pueda acortarlo ...

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

Lote de Windows, 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%

Uso:

script.bat hello

Salida:

hohelollolo

Tal vez se pregunte por qué no configuré d en "aoui", la comprobación de no iguales requiere salir de un bucle. No todo lo que debería funcionar, funciona, por lotes. El script maneja 1 palabra de caracteres [como aparecen en su teclado]. Todos los espacios y líneas nuevas que todavía están presentes son necesarios para que se ejecute el script.

Se requiere Windows XP o superior. No probado en Windows 8 y superior.

PowerShell - 35 bytes

Solo para mostrar que PowerShell también puede competir en estos a veces, y con la expresión regular robada descaradamente de la respuesta de Martin Büttner Retina:

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

acepta entrada de cadena desde stdin

Pyth - 28 bytes

Esto funciona de la manera obvia al generar la lista de consonantes sobre la marcha utilizando la diferencia establecida.

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

Explicación próximamente.

Pruébalo aquí .

Clip 10 , 30

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

Sustitución básica de expresiones regulares.

Pyth, 25 24 23

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

Ejecútalo aquí.

Python, 61

No pude lograr que una unión o resta de clase de caracteres funcione, por lo que no creo que Python tenga esa característica. Tuve que usar un lookahead negativo en su lugar.

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

Ejecútelo aquí: http://repl.it/fQ5

Enlace a la inversa: /codegolf//a/48182/34718

K, 38 caracteres

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}'

Una solución sencilla parece bastante competitiva dado que K carece de expresiones regulares. Seleccione entre la forma "XoX" y la forma "X" en función de si cada carácter se encontró en una tabla de búsqueda de vocales ignoradas y únase a las listas resultantes.

Puedes probarlo en tu navegador usando 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

(Lamentablemente, no puedo proporcionar un enlace en el que se pueda hacer clic porque el desbordamiento de la pila no parece permitir caracteres acentuados en las URL)

Golfscript, 35 bytes

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

Espera que la entrada esté en la pila. Con entrada (50 bytes):

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

Trabaja con las vocales suecas å, ä y ö.

Sed (en línea de comando), 28 bytes

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

Puede canalizar el texto o escribirlo directamente. Solo el código sed por sí solo es de 22 bytes.

R, 45 caracteres

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

Regex simple. Lecturas de stdin. i=Tsignifica ignore.case=TRUE(gracias a la coincidencia parcial de los nombres de los argumentos), lo que hace que no se gsubdistinga entre mayúsculas y minúsculas.

Uso:

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

<> <(Pez), 64 bytes

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

No es la respuesta más corta, pero disfruto el desafío de programar en <> <

Pruébalo aquí

golflua, 36 bytes

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

Coincidencia de patrones simple: tome stdin, luego encuentre las no vocales ( %Wse ocupa de los caracteres no alfanuméricos) e inserte una oentre los dos reemplazos. Lamentablemente, hacer todo esto dentro de la escritura (es decir, w(I.r():g(....))) también genera el recuento de inserciones, aunque salvó 3 caracteres. Un equivalente de Lua sería

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

Gracias a @Masterzagh por ahorrar en la sintaxis de la función.

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

JavaScript 62

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