Rövarspråket

Rövarspråketเป็นเกมคำศัพท์ที่เล่นโดยเด็ก ๆ ชาวสวีเดนจากหนังสือเกี่ยวกับ Kalle Blomkvist โดย Astrid Lindgren

กฎพื้นฐานมีดังนี้ (จาก Wikipedia):

• พยัญชนะทุกตัว (เรื่องการสะกดคำไม่ใช่การออกเสียง) เป็นสองเท่าและมีการแทรก o ในระหว่าง
• เสียงสระจะยังคงอยู่

ตัวอย่างบางส่วน:

• "สวัสดี" -> "hohelollolo"
• "Min svävareär full med ål" -> "MoMinon sosvovävovaroreäror fofulollol momedod ålol"

ตัวอักษรสวีเดนเหมือนกันกับภาษาอังกฤษดังนั้นโปรแกรมควรทำงานกับทั้งภาษาสวีเดนและภาษาอังกฤษ

ตัวอักษร "y" ถูกนำมาเป็นพยัญชนะในกรณีนี้ - เป็นส่วนใหญ่

งานของคุณ:

เขียนโปรแกรมเพื่อแปลงสตริงของตัวอักษรสวีเดนป้อนข้อมูลผ่านฟังก์ชั่นหรือผ่าน stdin ให้เทียบเท่าRövarspråket คำตอบที่สั้นที่สุดในการชนะไบต์!

เรติน่า , 14 + 5 = 19 ไบต์

เรติน่าเป็นภาษาที่เป็นหลักเพียง. NET regex ด้วยค่าใช้จ่ายน้อยที่สุด รหัสสำหรับโปรแกรมนี้ประกอบด้วยสองไฟล์:

i`[b-z-[eiou]]

$0o$0

นี่อ่านอินพุตบน STDIN และพิมพ์เอาต์พุตไปที่ STDOUT

หากคุณเรียกใช้ไฟล์pattern.rgxและreplacement.rplคุณสามารถเรียกใช้โปรแกรมเช่นเดียวกับ

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

คำอธิบาย

นี่เป็นเรื่องตรงไปตรงมา แต่ให้ฉันเพิ่มคำอธิบายต่อไป (ส่วนใหญ่เกี่ยวกับการทำงานของจอประสาทตา) หากมีการเรียกใช้ Retina 2 ไฟล์มันจะถูกสมมติให้ทำงานโดยอัตโนมัติใน "โหมดแทนที่" โดยที่ไฟล์แรกคือ regex และไฟล์ที่สองเป็นรูปแบบ

Retina สามารถกำหนดค่า (ซึ่งรวมถึงRegexOptionsและตัวเลือกอื่น ๆ ) โดยเตรียม regex ด้วย`และสตริงการกำหนดค่า ในกรณีนี้ฉันแค่ให้มันiซึ่งเป็นตัวแก้ไข regex ปกติสำหรับกรณีที่ไม่รู้สึก

สำหรับ regex นั้นมันใช้การลบคลาสอักขระ. NET เพื่อจับคู่พยัญชนะใด ๆ ในช่วง ASCII การแทนที่จากนั้นเพียงแค่เขียนการแข่งขันกลับมาสองครั้งด้วยoในระหว่าง

การใช้ Unix KSH 27 28 32 27 ไบต์ (หรือ 21 ถ้าเรานับเฉพาะในคำสั่ง sed)

ขอบคุณคำแนะนำของผู้อื่น :) ชื่นชม

.. ฉันลงมาที่นี่:

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

(อนุญาตสำหรับช่องว่างและตัวอักษรสวีเดน)

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 ไบต์

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

นี่คือการอ่านแบบเต็มโปรแกรมจาก STDIN และการพิมพ์ไปยัง STDOUT มันใช้งานได้กับอินพุต Unicode ที่กำหนดเองและใช้อักขระ 42 ตัวต่อไปนี้เป็นพยัญชนะ:

BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz

ทดสอบที่นี่

คำอธิบาย

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ไบต์

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

ขอบคุณ Masterzagh ที่เตือนฉันว่าฟังก์ชั่นจะเป็นที่ยอมรับเช่นกันและสำหรับเคล็ดลับ regex ของเขาเกี่ยวกับการตอบกลับโดยไม่ต้องจับ!

รุ่นที่ยาวกว่าพร้อมอินพุต / เอาต์พุต:

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

แสดงกล่องข้อความแจ้งเพื่อป้อนสตริงจากนั้นแสดงไดอะล็อกที่มีเอาต์พุตRövarspråket รหัสใช้ regex เพื่อเพิ่มพยัญชนะเป็นสองเท่าและใส่os

Mathematica, 84 73 72 ไบต์

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

คำอธิบาย:

• RegularExpression@"(?i)[BCDFGHJ-NP-TV-Z]" เป็น regex ที่ตรงกับพยัญชนะทุกตัว
• a:*..*:>a<>"o"<>aสร้างกฎล่าช้าในการผูกพยัญชนะเหล่านั้นaและแทนที่ด้วยและ o ล้อมรอบด้วยตัวเอง
• สุดท้ายStringReplace[#,*..*]&สร้างฟังก์ชั่นที่บริสุทธิ์โดยใช้กฎนั้นกับตัวอักษรที่ตรงกันทุกตัวในอาร์กิวเมนต์

จูเลีย46 46ไบต์

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

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่ระบุชื่อซึ่งรับอินพุตสตริงเดียวและพิมพ์Rövarspråketที่เทียบเท่า f=t->...เรียกว่าให้มันชื่อเช่น

ไม่ค่อยมีการเล่นกอล์ฟที่นี่จริง ๆ นอกเหนือจากช่องว่างหลังจากเครื่องหมายจุลภาคใน replace()ไม่มากได้รับจริงๆแข็งแรงเล่นกอล์ฟที่นี่นอกเหนือจากช่องว่างหลังเครื่องหมายจุลภาคใน

ที่นี่เราใช้อาร์กิวเมนต์ 3 ข้อในreplace()ฟังก์ชั่น: สตริงป้อนเข้า, นิพจน์ปกติสำหรับระบุสตริงย่อยและการแทนที่ r"..."จูเลียหมายถึงรูปแบบการแสดงออกโดยปกติ การเพิ่มiไปยังจุดสิ้นสุดทำให้ไม่คำนึงถึงขนาดตัวพิมพ์ regex นี้ตรงกับพยัญชนะ หากมีการใช้ฟังก์ชั่นสำหรับการเปลี่ยนผลลัพธ์คือฟังก์ชันนั้นใช้กับสตริงย่อยที่ตรงกันแต่ละอัน ฟังก์ชั่นที่เราใช้ที่นี่ต้องใช้สตริงsและส่งคืนsosเนื่องจาก*ทำการเชื่อมต่อสตริงในจูเลีย ดังนั้นผลลัพธ์สุดท้ายคือสตริงอินพุตที่มีตัวอักษรแต่ละตัวเป็นสองเท่าด้วย "o" ระหว่าง

ตัวอย่าง:

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"

โปรดทราบว่านี่จะเป็น 9 ไบต์อีกต่อไปหากเราต้องพิมพ์ผลลัพธ์แทนที่จะส่งคืน รอการยืนยันจาก OP

แก้ไข:บันทึก 2 ไบต์ขอบคุณ Martin Büttner!

Haskell, 81 ไบต์

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

การใช้งาน: f "Hello there!" ->"HoHelollolo tothoherore!" ->

ฉันไม่สามารถชาญฉลาดสร้างรายชื่อของพยัญชนะโดยไม่ต้องมีราคาแพงimports แม้แต่การหมุนตัวอักษรเพื่อตรวจสอบตัวพิมพ์เล็กก็ต้องใช้ไบท์มากกว่าเพียงแค่แสดงพยัญชนะทั้งบนและล่าง

Java 8, 45

ใช้เป็นฟังก์ชั่นแลมบ์ดา ใช้การแสดงออกปกติ

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

ลองที่นี่

Perl, 33 ไบต์

คำตอบนี้ส่วนใหญ่เป็นแบบ regex เท่านั้นโดยมีโค้ดพิเศษจำนวนเล็กน้อยเพื่อดำเนินการ I / O

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

เป็นเวลานานแล้วที่ฉันใช้ Perl regexes ดังนั้นนี่อาจปรับปรุงได้

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

โอเคนี่มันใหญ่มาก แต่ C ไม่มีนิพจน์ทั่วไป โปรดบอกฉันว่าคุณเห็นอะไรที่ทำให้สั้นกว่านี้ ...

#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, 235 ไบต์

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

การใช้งาน:

script.bat hello

เอาท์พุท:

hohelollolo

คุณอาจสงสัยว่าทำไมฉันไม่ตั้ง d เป็น "aoui" การตรวจสอบว่าไม่เท่ากันต้องแยกจากลูป ไม่ใช่ทุกอย่างที่ควรทำงานทำงานได้เป็นชุด สคริปต์จัดการอักขระ 1 คำ [ตามที่ปรากฏบนแป้นพิมพ์ของคุณ] ช่องว่างและการขึ้นบรรทัดใหม่ทั้งหมดที่ยังคงมีอยู่จำเป็นต้องมีเพื่อให้สคริปต์ทำงาน

ต้องการ Windows XP หรือสูงกว่า ไม่ได้ทดสอบใน Windows 8 ขึ้นไป

PowerShell - 35 ไบต์

เพียงเพื่อแสดงให้เห็นว่า PowerShell สามารถแข่งขันในบางครั้งเช่นกันและด้วย regex ที่ถูกขโมยอย่างไร้จุดหมายจากคำตอบของ Retina Büttnerของ Martin:

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

ยอมรับอินพุตสตริงจาก stdin

Pyth - 28 ไบต์

วิธีนี้ใช้งานได้อย่างชัดเจนโดยสร้างรายการพยัญชนะได้ทันทีโดยใช้ความแตกต่างที่ตั้งไว้อย่างชาญฉลาด

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

คำอธิบายจะมาเร็ว ๆ นี้

ลองได้ที่นี่

คลิป 10 , 30

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

การทดแทน regex พื้นฐาน

Pyth, 25 24 23

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

เรียกใช้ที่นี่

Python 61

ฉันไม่สามารถรับสหภาพแรงงานระดับตัวละครหรือการลบได้ดังนั้นฉันจึงไม่คิดว่า Python มีคุณสมบัติดังกล่าว ฉันต้องใช้ lookahead เชิงลบแทน

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

เรียกใช้ที่นี่: http://repl.it/fQ5

เชื่อมโยงไปยังสิ่งที่ตรงกันข้าม: /codegolf//a/48182/34718

K, 38 ตัวอักษร

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 ไบต์

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

การแก้ปัญหาที่ตรงไปตรงมาดูเหมือนว่าจะแข่งขันได้ค่อนข้างดีเนื่องจาก K ขาด regexes เลือกระหว่างฟอร์ม "XoX" และ "X" ตามว่าพบอักขระแต่ละตัวในตารางการค้นหาของสระที่ถูกละเว้นและเข้าร่วมรายการผลลัพธ์

คุณสามารถลองใช้เบราว์เซอร์ของคุณโดยใช้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

(น่าเสียดายที่ฉันไม่สามารถให้ลิงค์ที่คลิกได้เพราะกองล้นไม่ปรากฏเพื่ออนุญาตให้ใช้อักขระเน้นเสียงใน URL)

Golfscript, 35 ไบต์

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

คาดว่าอินพุตจะอยู่ในสแต็ก ด้วยอินพุต (50 ไบต์):

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

ทำงานร่วมกับ vovels สวีเดนå, äและö

Sed (บนบรรทัดคำสั่ง), 28 ไบต์

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

ไพพ์ข้อความหรือพิมพ์โดยตรง รหัสเซดเท่านั้นเองคือ 22 ไบต์

R, 45 ตัวอักษร

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

regex ง่าย อ่านจาก stdin i=Tย่อมาจากignore.case=TRUE(ด้วยการจับคู่บางส่วนของชื่ออาร์กิวเมนต์) ซึ่งทำให้gsubกรณีตาย

การใช้งาน:

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

<> <(ปลา) 64 ไบต์

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

มันไม่ใช่คำตอบที่สั้นที่สุด แต่ฉันก็สนุกกับการเขียนโปรแกรมใน <> <

ลองที่นี่

golflua, 36 ไบต์

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

การจับคู่รูปแบบง่าย ๆ : ใช้ stdin จากนั้นหาสระที่%Wไม่ใช่ตัวอักษร( ดูแลตัวอักษรที่ไม่ใช่ตัวอักษรและตัวเลข) และใส่oระหว่างสองตัวแทนที่ น่าเศร้าที่การทำทั้งหมดนี้ในการเขียน (เช่นw(I.r():g(....))) ก็เอาท์พุทจำนวนการแทรกแม้ว่ามันจะบันทึกไว้ 3 ตัวอักษร Lua จะเทียบเท่า

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

REXX, 107 ไบต์

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

Thanks to @Masterzagh for saving on function syntax.

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

JavaScript 62

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