Rövarspråket

Rövarspråket è un gioco di parole giocato da bambini svedesi, dai libri su Kalle Blomkvist di Astrid Lindgren.

Le regole di base sono le seguenti (da Wikipedia):

• Ogni consonante (l'ortografia conta, non la pronuncia) viene raddoppiata e una o viene inserita nel mezzo.
• Le vocali rimangono intatte.

Alcuni esempi:

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

Le consonanti svedesi sono le stesse di quelle inglesi, quindi il programma dovrebbe funzionare sia con voci svedesi che inglesi.

La lettera "y" è considerata consonante in questo caso, come nella maggior parte dei casi.

Il tuo compito:

Scrivi un programma per convertire una stringa di lettere svedesi, immessa attraverso una funzione o tramite stdin, nel suo equivalente Rövarspråket. Vince la risposta più breve in byte!

Retina , 14 + 5 = 19 byte

Retina è un linguaggio che è essenzialmente solo regex .NET con il minor sovraccarico possibile. Il codice per questo programma è costituito da due file:

i`[b-z-[eiou]]

$0o$0

Questo legge l'input su STDIN e stampa l'output su STDOUT.

Se chiami i file pattern.rgxe replacement.rpl, puoi eseguire il programma semplicemente come

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

Spiegazione

Questo è piuttosto semplice, ma vorrei comunque aggiungere qualche spiegazione (principalmente su come funziona Retina). Se Retina viene invocata con 2 file, si presume automaticamente che funzioni in "Sostituisci modalità", dove il primo file è la regex e il secondo file è il modello.

Retina può essere configurata (che include RegexOptionse altre opzioni) anteponendo regex con `e una stringa di configurazione. In questo caso lo sto solo dando, iche è il normale modificatore regex per l'insensibilità al caso.

Per quanto riguarda la regex stessa, utilizza la sottrazione della classe di caratteri .NET per far corrispondere qualsiasi consonante nell'intervallo ASCII. Il sostituto, quindi, riscrive la partita due volte con un ointervallo.

Uso di Unix KSH 27 28 32 27 byte (o 21 se contiamo solo all'interno del comando sed)

Grazie ai suggerimenti degli altri :) Apprezzato.

.. Sono arrivato a questo:

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

(consentito per spazi e personaggi svedesi)

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 byte

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

Questo è un programma completo che legge da STDIN e stampa su STDOUT. Funziona con input Unicode arbitrario e tratta i seguenti 42 caratteri come consonanti:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

Provalo qui.

Spiegazione

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 byte

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

Grazie a Masterzagh per avermi ricordato che anche una funzione sarebbe stata accettabile, e per il suo suggerimento regex riguardante i riferimenti indietro senza catturare!

Versione più lunga con input / output:

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

Visualizza una finestra di prompt per inserire la stringa, quindi mostra una finestra di dialogo contenente l'output di Rövarspråket. Il codice usa una regex per raddoppiare le consonanti e inserire os.

Mathematica, 84 73 72 byte

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

Spiegazione:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" è una regex che corrisponde a tutte le consonanti senza distinzione tra maiuscole e minuscole.
• a:*..*:>a<>"o"<>acrea una regola ritardata per legare quelle consonanti ae sostituirla con e o circondata da se stessa.
• Infine, StringReplace[#,*..*]&crea una funzione pura applicando quella regola a ogni lettera corrispondente nel suo argomento.

Julia, 46 44 byte

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

Ciò crea una funzione anonima che accetta un singolo input di stringa e stampa l'equivalente di Rövarspråket. Per chiamarlo, dagli un nome, ad es f=t->....

Qui non è stato praticato molto golf, a parte gli spazi dopo le virgole replace().

Qui stiamo usando 3 argomenti nella replace()funzione: la stringa di input, l'espressione regolare per identificare le sottostringhe e una sostituzione. Julia indica i modelli di espressione regolare di r"...". L'aggiunta ialla fine non fa distinzione tra maiuscole e minuscole. Questa regex particolare corrisponde alle consonanti. Se viene utilizzata una funzione per la sostituzione, l'output è quella funzione applicata a ciascuna sottostringa abbinata. La funzione che stiamo usando qui prende una stringa se ritorna sos, poiché *esegue la concatenazione di stringhe in Julia. Quindi il risultato finale è la stringa di input con ogni consonante raddoppiata con una "o" tra.

Esempi:

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"

Si noti che questo sarà più lungo di 9 byte se si deve stampare il risultato anziché restituirlo. In attesa di conferma dall'OP.

Modifica: salvato 2 byte grazie a Martin Büttner!

Haskell, 81 byte

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

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

Non posso costruire abilmente l'elenco delle consonanti senza costose import. Anche trasformare la lettera in lettere minuscole richiede più byte rispetto al semplice elenco delle consonanti maiuscole e minuscole.

Java 8, 45

Utilizzare come funzione lambda. Usa un'espressione regolare.

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

Prova qui

Perl, 33 byte

Questa risposta è principalmente solo regex, con una piccola quantità di codice aggiuntivo per eseguire l'I / O.

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

È da un po 'che non uso le regex del Perl, quindi probabilmente questo può essere migliorato.

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

Ok, questo è enorme. Ma C non ha espressioni regolari. Per favore dimmi se vedi qualcosa che può renderlo più breve ...

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

Batch di Windows, 235 byte

@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

Produzione:

hohelollolo

Forse ti starai chiedendo perché non ho impostato d su "aoui", per verificare se non è uguale è necessario uscire da un ciclo. Non tutto ciò che dovrebbe funzionare, funziona, in batch. Lo script gestisce 1 parola di caratteri [come appaiono sulla tastiera]. Tutti gli spazi e le nuove righe ancora presenti sono necessari per l'esecuzione dello script.

È richiesto Windows XP o versioni successive. Non testato in Windows 8 e versioni successive.

PowerShell - 35 byte

Solo per dimostrare che PowerShell può competere anche in questi a volte, e con la regex sottratta spudoratamente dalla risposta Retina di Martin Büttner:

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

accetta l'input di stringa da stdin

Pyth - 28 byte

Questo funziona in modo ovvio generando all'istante l'elenco delle consonanti usando la differenza saggia.

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

Spiegazione in arrivo.

Provalo qui .

Clip 10 , 30

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

Sostituzione regex di base.

Pyth, 25 24 23

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

Eseguilo qui.

Python, 61

Non riuscivo a far funzionare l'unione o la sottrazione di una classe di personaggi, quindi non penso che Python abbia quella caratteristica. Ho dovuto usare un lookahead negativo invece.

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

Eseguilo qui: http://repl.it/fQ5

Link all'inverso: /codegolf//a/48182/34718

K, 38 caratteri

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 byte

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

Una soluzione semplice sembra abbastanza competitiva dato che K manca di regex. Seleziona tra il modulo "XoX" e il modulo "X" in base al fatto che ogni carattere sia stato trovato in una tabella di ricerca di vocali ignorate e unisciti agli elenchi risultanti.

Puoi provarlo nel tuo browser 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

(Sfortunatamente non posso fornire un link cliccabile perché lo stack overflow non sembra consentire caratteri accentati negli URL)

Golfscript, 35 byte

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

Si aspetta che l'input sia nello stack. Con input (50 byte):

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

Funziona con le vovels svedesi å, ä e ö.

Sed (sulla riga di comando), 28 byte

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

Puoi inserire il testo o inserirlo direttamente. Solo il codice sed da solo è di 22 byte.

R, 45 caratteri

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

Regex semplice. Legge da stdin. i=Tsta per ignore.case=TRUE(grazie alla corrispondenza parziale dei nomi degli argomenti), che rendegsub maiuscole e minuscole.

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"

<> <(Pesce), 64 byte

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

Non è la risposta più breve ma mi piace la sfida della programmazione in <> <

Provalo qui

golflua, 36 byte

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

Semplice pattern-matching: prendi lo stdin, quindi trova le non vocali ( %Wsi occupa dei caratteri non alfanumerici) e inserisci una otra le due sostituzioni. Purtroppo, fare tutto questo all'interno della scrittura (cioè, w(I.r():g(....))) genera anche il conteggio degli inserimenti, sebbene abbia salvato 3 caratteri. Un equivalente di Lua sarebbe

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

REXX, 107 byte

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

Grazie a @Masterzagh per il salvataggio sulla sintassi della funzione.

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

JavaScript 62

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