Rövarspråket

Rövarspråket é um jogo de palavras jogado por crianças suecas, dos livros sobre Kalle Blomkvist de Astrid Lindgren.

As regras básicas são as seguintes (da Wikipedia):

• Cada consoante (a ortografia importa, não a pronúncia) é dobrada e um o é inserido no meio.
• As vogais são deixadas intactas.

Alguns exemplos:

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

As consoantes suecas são iguais às inglesas; portanto, o programa deve funcionar com entradas suecas e inglesas.

A letra "y" é considerada consoante neste caso - como na maioria das vezes.

Sua tarefa:

Escreva um programa para converter uma sequência de letras suecas, inserida através de uma função ou através de stdin, no seu equivalente a Rövarspråket. Menor resposta em bytes ganha!

Retina , 14 + 5 = 19 bytes

Retina é uma linguagem que é essencialmente apenas regex .NET com o mínimo de sobrecarga possível. O código para este programa consiste em dois arquivos:

i`[b-z-[eiou]]

$0o$0

Isso lê a entrada em STDIN e imprime a saída em STDOUT.

Se você chamar os arquivos pattern.rgxe replacement.rpl, poderá executar o programa simplesmente como

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

Explicação

Isso é bem direto, mas deixe-me acrescentar algumas explicações de qualquer maneira (principalmente sobre como o Retina funciona). Se o Retina for chamado com 2 arquivos, presume-se que ele funcione automaticamente no "Modo Substituir", onde o primeiro arquivo é a regex e o segundo arquivo é o padrão.

A retina pode ser configurada (que inclui RegexOptionse outras opções), acrescentando o regex com `uma string de configuração. Nesse caso, estou fornecendo apenas io modificador regex normal para insensibilidade a maiúsculas e minúsculas.

Quanto ao próprio regex, ele usa a subtração de classe de caracteres do .NET para corresponder a qualquer consoante no intervalo ASCII. A substituição apenas grava a partida de volta duas vezes com um ointervalo.

Usando Unix KSH 27 28 32 27 bytes (ou 21, se contarmos apenas dentro do comando sed)

Obrigado às sugestões de outros :) Apreciado.

.. Eu comecei a isso:

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

(permitido para espaços e 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 é um programa completo que lê de STDIN e imprime em STDOUT. Ele funciona para entrada Unicode arbitrária e trata os seguintes 42 caracteres como consoantes:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Teste aqui.

Explicação

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

Agradeço a Masterzagh por me lembrar que uma função também seria aceitável, e por sua dica de regex sobre referências anteriores sem capturar!

Versão mais longa com entrada / saída:

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

Exibe uma caixa de prompt para inserir a sequência e mostra uma caixa de diálogo contendo a saída Rövarspråket. O código usa uma regex para duplicar as consoantes e inserir os.

Mathematica, 84 73 72 bytes

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

Explicação:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" é uma regex que corresponde a todas as consoantes sem distinção entre maiúsculas e minúsculas.
• a:*..*:>a<>"o"<>acria uma regra atrasada para vincular essas consoantes ae substitui-a por e o cercada por ela mesma.
• Por fim, StringReplace[#,*..*]&cria uma função pura que aplica essa regra a todas as letras correspondentes em seu argumento.

Julia, 46 44 bytes

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

Isso cria uma função anônima que recebe uma única entrada de sequência e imprime o equivalente ao Rövarspråket. Para chamá-lo, dê um nome, por exemplo f=t->....

Não se jogou muita coisa aqui, além de espaços após as vírgulas replace().

Aqui, estamos usando três argumentos na replace()função: a sequência de entrada, a expressão regular para identificar substrings e uma substituição. Julia denota padrões de expressão regular por r"...". A adição iao final faz com que não seja sensível a maiúsculas. Essa regex específica corresponde às consoantes. Se uma função é usada para a substituição, a saída é essa função aplicada a cada substring correspondente. A função que estamos usando aqui pega uma string se retorna sos, pois *realiza concatenação de string em Julia. Assim, o resultado final é a sequência de entrada com cada consoante dobrada com um "o" entre.

Exemplos:

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"

Observe que isso terá 9 bytes a mais se precisarmos imprimir o resultado em vez de devolvê-lo. Aguardando confirmação do OP.

Editar: salvou 2 bytes graças 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!".

Não posso inteligentemente construir a lista de consoantes sem imports caros . Mesmo girar a letra para marcar em minúscula precisa de mais bytes do que simplesmente listar consoantes maiúsculas e minúsculas.

Java 8, 45

Use como uma função lambda. Usa expressão regular.

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

Tente aqui

Perl, 33 bytes

Essa resposta é principalmente somente regex, com uma pequena quantidade de código extra para executar E / S.

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

Já faz um tempo desde que eu usei expressões regulares Perl, então isso provavelmente pode ser melhorado.

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

Ok, isso é enorme. Mas C não tem expressões regulares. Diga-me se você vê algo que pode torná-lo mais curto ...

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

Resultado:

hohelollolo

Você pode estar se perguntando por que eu não defini d como "aoui", para verificar se não é igual, é necessário interromper um loop. Nem tudo o que deve funcionar, funciona, em lote. O script lida com 1 palavra de caracteres [como eles aparecem no teclado]. Todos os espaços e novas linhas que ainda estão presentes são necessários para a execução do script.

Windows XP ou superior, necessário. Não testado no Windows 8 e acima.

PowerShell - 35 bytes

Apenas para mostrar que o PowerShell também pode competir nelas, e com o regex roubado descaradamente da resposta Retina de Martin Büttner:

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

aceita entrada de string de stdin

Pitão - 28 bytes

Isso funciona da maneira óbvia, gerando a lista de consoantes em tempo real usando a diferença entre conjuntos.

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

Explicação em breve.

Experimente aqui .

Clip 10 , 30

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

Substituição básica de regex.

Pitão, 25 24 23

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

Execute-o aqui.

Python, 61

Eu não conseguia fazer com que uma união ou subtração de classe de personagem funcionasse, então não acho que o Python tenha esse recurso. Eu tive que usar um lookahead negativo em seu lugar.

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

Execute-o aqui: http://repl.it/fQ5

Link para o inverso: /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}'

Uma solução direta parece bastante competitiva, dado que K carece de regexes. Selecione entre o formulário "XoX" e o formulário "X" com base na localização de cada caractere em uma tabela de pesquisa de vogais ignoradas e entre nas listas resultantes.

Você pode experimentá-lo no seu 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

(Infelizmente, não posso fornecer um link clicável porque o excesso de pilha não parece permitir caracteres acentuados nos URLs)

Golfscript, 35 bytes

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

Espera que a entrada esteja na pilha. Com entrada (50 bytes):

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

Trabalha com os vovéis suecos å, ä e ö.

Sed (na linha de comando), 28 bytes

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

Canalize o texto ou digite-o diretamente. Apenas o código sed, por si só, tem 22 bytes.

R, 45 caracteres

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

Regex simples. Lê de stdin. i=Tsignifica ignore.case=TRUE(graças à correspondência parcial dos nomes dos argumentos), o que torna as gsubmaiúsculas e 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"

<> <(Peixe), 64 bytes

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

Não é a resposta mais curta, mas eu gosto do desafio de programar em <> <

Experimente aqui

golflua, 36 bytes

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

Correspondência simples de padrões: pegue stdin e encontre as não vogais ( %Wcuida de caracteres não alfanuméricos) e insira um oentre as duas substituições. Infelizmente, fazer tudo isso dentro da gravação (ou seja w(I.r():g(....))) também gera a contagem de inserções, embora tenha economizado 3 caracteres. Um equivalente Lua seria

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

Agradecemos ao @Masterzagh por economizar na sintaxe da função.

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

JavaScript 62

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