वार्ता

एलियंस पृथ्वी पर बस गए हैं और अजीब तरह से, उनकी वर्णमाला हमारे जैसी ही है। उनकी भाषा भी कुछ भिन्न और आसानी से अंतर की गणना के साथ हमारे समान है।

चुनौती

एक स्ट्रिंग लें और एलियन की भाषा के समकक्ष आउटपुट करें। अनुवाद इस प्रकार काम करता है:

संबंधित शब्द में सभी स्वरों को स्वैप करें:

  Vowel |   With
--------+--------
   a    |   obo
   e    |   unu
   i    |   ini
   o    |   api
   u    |   iki

_{आप विदेशी-> अंग्रेजी का अनुवाद करने के लिए एक और अनुवादक भी लिख सकते हैं, हालांकि यह वैकल्पिक है।}

उदाहरण

Input: Shaun
Output: Shoboikin

Input: Java
Output: Jobovobo

Input: Hello, World!
Output: Hunullapi, Wapirld!

यदि स्वर कैपिटल में है तो आप पहले अक्षर को कैपिटल करें।

Input: Alan
Output: Obolobon

Input: Australia
Output: Oboikistroboliniobo

नियम

मानक खामियां लागू होती हैं
नई पंक्तियों वाले पाठ के लिए काम करना चाहिए
आप या तो एक फंक्शन, लैम्ब्डा, या फुल प्रोग्राम लिख सकते हैं

Capingrobotikilobotiniapins apin wrinitining थूनू रनवुणरसुनु ट्रोबोनस्लोब्बीर!

code-golf string

— शॉन वाइल्ड
स्रोत

मुझे यकीन नहीं है कि आप एलियन का अनुवाद करने के लिए एक और अनुवादक भी लिख सकते हैं-> अंग्रेजी का मतलब माना जाता है। क्या हम नियमित के बजाय रिवर्स ट्रांसलेटर लिख सकते हैं?

— डेनिस

4

हो सकता है कि यह सिर्फ मुझे है, लेकिन यह है कि मेरे पास स्पष्ट नहीं है भी यहां इस अर्थ में किया जाता है। वैसे भी, मुझे यकीन नहीं है कि यह एक नियम है अगर यह वास्तविक कार्य का हिस्सा नहीं है।

— डेनिस

@ डेनिस आप थोड़े दंडात्मक हो रहे हैं, लेकिन मैंने इसे स्पष्ट करने के लिए इसे संपादित किया है।

— शॉन वाइल्ड

2

न्यूलाइन्स की आवश्यकता क्यों? मेरी राय में, यह अनावश्यक है और चुनौती के मुख्य बिंदु पर कुछ भी नहीं जोड़ता है।

— अदनान

1

क्या इनपुट में कोई ASCII वर्ण या केवल एक सबसेट हो सकता है। जैसे, क्या इनपुट में कभी नंबर होंगे?

— रिले

14

हास्केल, 100 91 बाइट्स

(>>= \x->last$[x]:[y|(z:y)<-words"aobo eunu iini oapi uiki AObo EUnu IIni OApi UIki",z==x])

— डेमियन
स्रोत

5

होबोस्कुनुल निश्चित रूप से

— जे.के.

12

टीआई-बेसिक, 173 + 59 + 148 = 380 बाइट्स

उम्मीद है कि एलियंस TI-83/84 कैलकुलेटर का उपयोग करते हैं;)

मुख्य कार्यक्रम, 173 बाइट्स

बोनस: सामान्य या रिवर्स अनुवादक चाहते हैं या नहीं, इसके आधार पर दूसरी या तीसरी पंक्ति रखें।

"("+Ans+")→Str1
"@a~obo@A~Obo@e~unu@E~Unu@i~ini@I~Ini@o~api@O~Api@u~iki@U~Iki@→Str2    <-- English to Alien
"@obo~a@Obo~A@unu~e@Unu~E@ini~i@Ini~I@api~o@Api~O@iki~u@Iki~U@→Str2    <-- Alien to English
For(I,2,length(Ans
If "@"=sub(Str2,I-1,1
Then
Str1+"~"+sub(Str2,I,inString(Str2,"@",I)-I
prgmQ
Ans→Str1
End
End

उपप्रोग्राम ( prgmQ), 59 बाइट्स:

Ans→Str9
inString(Ans,"~
sub(Str9,Ans,length(Str9)-Ans+1→Str8
Str9
prgmR
Repeat Str9=Ans+Str8
Ans+Str8→Str9
prgmR
End

उपप्रोग्राम ( prgmR), 148 बाइट्स:

Ans→Str0
inString(Ans,"~→Z
inString(Str0,"~",Ans+1→Y
inString(sub(Str0,1,Z-1),sub(Str0,Z+1,Ans-Z-1→X
sub(Str0,1,-1+inString(Str0,"~
If X
sub(Str0,1,X-1)+sub(Str0,Y+1,length(Str0)-Y)+sub(Str0,X+length(sub(Str0,Z+1,Y-Z-1)),Z-X-length(sub(Str0,Z+1,Y-Z-1

PS ~टोकन 0x81का @प्रतिनिधित्व करता है और टोकन का प्रतिनिधित्व करता है 0x7F, यहां और जानें ।

क्यों इन कार्यक्रमों के लिए एक उच्च बाइट गिनती है पी पी एस भाग है, क्योंकि sub(, inString(, length(, और सभी छोटे अक्षरों दोनों एक बाइट रहे हैं ...

— Timtech
स्रोत

मैं तुम्हें मिश्रित लगता है prgmRऔर prgmQएक बार अपने कोड सुर्खियों में?

— बाइट कमांडर

हां, उस @ByteCommander को पकड़ने के लिए धन्यवाद :)

— टाइमटेक

8

पर्ल, 56 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट दें

alien.pl:

#!/usr/bin/perl -p
s%\w%"`"&$&|("A\x0fboE\x15nuI\x09niO\x01piU\x09ki"=~/\u$&\K.../,$&)%eg

दिखाए गए अनुसार काम करता है, लेकिन \xXXदावा किए गए स्कोर को प्राप्त करने के लिए वास्तविक चरित्र से पलायन को प्रतिस्थापित करता है

— टन हास्पेल
स्रोत

1

+1 केवल विदेशी अवतार के लिए प्रस्तुत किया गया। बस मजाक कर रहे हैं, समाधान भी अच्छा है।

— चौकी

1

यीशु मसीह .. अपने सबसे अच्छे, देवियों और मर्द।

— प्रिदु नीमरे

6

सीड 89

s,a,&b\n,gi
s,i,&n\r,gi
s,o,&p\r,gi
s,u,&k\r,gi
s,e,&n\f,gi
y,aeouAEOU\n\r\f,ouaiOUAIoiu,

— रिले
स्रोत

क्या यह उस इनपुट के लिए काम करता है जिसमें newlines शामिल हैं?

— जॉर्डन

@ जोर्डन यह करता है। sed "एक समय में एक पंक्ति" पढ़ता है। तो यह पहली न्यूलाइन तक सब कुछ प्रोसेस करेगा, प्रिंट करेगा, न्यूलाइन प्रिंट करेगा, फिर ज्यादा टेक्स्ट होने पर शुरू करेगा।

— रिले

आह, बिल्कुल। 👍🏻

— जॉर्डन

@ जोर्डन यह एक नियम नहीं था जब मैंने इसे लिखा था, लेकिन इसने वैसे भी काम करना समाप्त कर दिया।

— रिले

6

पायथन, 99 95 93 बाइट्स

lambda s:"".join(("ouiaiOUIAI bnnpkbnnpk ouiiiouiii"+c)["aeiouAEIOU".find(c)::11] for c in s)

Ideone.com पर ...

बहुत साधारण। बस सूचकांक को हम प्रत्येक वर्ण को स्वर सूची में पाते हैं और इसका उपयोग हमें उन तीन वर्णों को खींचने के लिए करते हैं जिनकी हमें आवश्यकता होती है। यदि यह नहीं मिला है, तो .find()रिटर्न -1केवल स्ट्रिंग के अंत में वर्तमान चरित्र को चिपका दें। रिक्त स्थान आवश्यक हैं इसलिए किसी भी पत्र "a"में जोड़ा नहीं जाता है c। अनूदित स्वरों को अक्षर क्रम (हर अनुवाद का पहला अक्षर, फिर दूसरा, फिर तीसरा) द्वारा समूहीकृत किया जाता है।

— एससीबी
स्रोत

वाह, अच्छा रचनात्मक दृष्टिकोण। मैं प्रभावित हूँ :)

— बाइट कमांडर

1

आप अंतरिक्ष में["aeiouAEIOU".find(c)::11] for

— acrolith

6

05AB1E , 28 27 20 बाइट्स

žÀ.•₅%~≠#ùÛãú•3ôD™«‡

इसे ऑनलाइन आज़माएं!

Unuxplobonobotiniapin

žÀ                    # the string "aeiouAEIOU"
  .•₅%~≠#ùÛãú•        # the string "obounuiniapiiki"
              3ô      # split in pieces of 3
                D™«   # concatenate with a title-case copy
                   ‡  # transliterate

— Emigna
स्रोत

2

इनि लपिवुनु अंतर्यामी!

— शॉन वाइल्ड

@BasicallyAlanTuring: मुझे मेरे सिर में अनुवाद करने के लिए बहुत लंबा रास्ता तय किया। मुझे लगता है कि मुझे एक रिवर्स ट्रांसलेटर की जरूरत है: पी

— एमिग्ना

2

इसके लिए जाओ, बहुत मुश्किल नहीं होना चाहिए: पी

— शॉन वाइल्ड

डरावना, मुझे लगता है कि यह कहता है कि मुझे गोल्फ से प्यार है।

— डेटागोड

मैंने अपना प्रश्न बदल दिया है जो आपको उत्तर को अमान्य बनाता है। यह नई लाइनों के साथ काम करना चाहिए

— शॉन वाइल्ड

5

PHP, 91 बाइट्स

<?=strtr($argv[1],[A=>Obo,E=>Unu,I=>Ini,O=>Api,U=>Iki,a=>obo,e=>unu,i=>ini,o=>api,u=>iki]);

— जार्ग हुल्सरमन
स्रोत

5

अजगर, 129 बाइट्स

lambda s:"".join([str,str.capitalize][ord(l)<91]({"a":"obo","e":"unu","i":"ini","o":"api","u":"iki"}.get(l.lower(),l))for l in s)

इसे ideone.com पर देखें

यहाँ एक अधिक अच्छी तरह से स्वरूपित संस्करण है:

lambda s: \
    "".join(
        [str, str.capitalize][ord(l) < 91](
            {"a":"obo", "e":"unu", "i":"ini", "o":"api", "u":"iki"}
            .get(l.lower(), l)
        )
    for l in s)

सबसे दिलचस्प हिस्से हैं { ... }.get(l.lower(), l)जो lडिक्शनरी में लोअर केस में कन्वर्ट किए गए लेटर को देखने की कोशिश करते हैं और या तो ट्रांसलेट किया हुआ वर्जन (अगर मिला), या फिर ओरिजिनल लेटर,
और [str, str.capitalize][ord(l) < 91]( ... )जो चेक करते हैं कि ओरिजिनल लेटर एक कैपिटल लेटर है () ASCII कोड 91 से कम होता है) और फिर या तो str()फ़ंक्शन को पत्र के साथ तर्क के रूप में बुलाता है (यदि यह एक कैपिटल लेटर नहीं था, कुछ भी नहीं करता है) या str.capitalize()फ़ंक्शन (ऊपरी मामले में तर्क स्ट्रिंग के पहले अक्षर को कनवर्ट करता है)।

— बाइट कमांडर
स्रोत

5

सी (जीसीसी) , 150 141 136 134 बाइट्स

a;i;e(char*n){for(char*v=" AEIOUIAI",*t;i=*n++;printf(&a))t=index(v,i-i/96*32),a=t?t-v:0,a=a?v[a+3]|L" 潢畮楮楰楫"[a]<<8|i&32:i;}

इसे ऑनलाइन आज़माएं!

@ ASCII- केवल के लिए @algmyr और -8 धन्यवाद के जवाब के आधार पर

कम गोल्फ वाला संस्करण

a;i;
e(char*n){
  for(char*v=" AEIOUIAI",*t;i=*n++;printf(&a))
    t=index(v,i-i/96*32),
    a=t?t-v:0,
    a=a?v[a+3]|L" 潢畮楮楰楫"[a]<<8|i&32:i;
}

— ceilingcat
स्रोत

149?

a;l;i;e(char*n){for(char*v=" AEIOU",*t;i=*n++;printf("%c%c%c"+4*!a,(a?" OUIAI"[a]:i)|i&32," bnnpk"[a]," ouiii"[t=index(v,i-32*l),a=t?t-v:0]))l=i>96;}

— एएससीआईआई-केवल

शायद यह भी 149:

a;l;i;e(char*n){for(char*v="AEIOU",*t;i=*n++;printf("%c%c%c"+4*!a,(a?" OUIAI"[a]:i)|i&32," bnnpk"[a]," ouiii"[t=index(v,i&95),a=t&&t-v<5?t-v+1:0]));}

— केवल

144:

a;l;i;e(char*n){for(char*v=" AEIOU",*t;i=*n++;)printf("%c%c%c"+4*!a,a?" OUIAI"[a]|i&32:i," bnnpk"[a]," ouiii"[t=index(v,i-i/96*32),a=t?t-v:0]);}

— केवल

4

बैच, 215 बाइट्स

@echo off
set/pt=
set s=
:l
if "%t%"=="" echo(%s%&exit/b
set c=%t:~0,1%
for %%a in (obo.a unu.e ini.i api.o iki.u Obo.A Unu.E Ini.I Api.O Iki.U)do if .%c%==%%~xa set c=%%~na
set s=%s%%c%
set t=%t:~1%
goto l

STDIN पर इनपुट लेता है। प्रोसेसिंग-बाय-कैरेक्टर में केस-सेंसिटिव होने की सुविधा है।

— नील
स्रोत

बैच सब कुछ के लिए सबसे खराब उपकरण है, है ना? (ठीक है, कम से कम आप टीआई-बेसिक को हरा दें) अच्छा बैच में एक कोडगॉल्फ को देखकर, वैसे!

— YoYoYonnY

4

पायथ, 42 बाइट्स

#sXw"aeiouAEIOU"+Jc"obounuiniapiiki"3mrd3J

एक प्रोग्राम जो STDIN पर इनपुट लेता है और आउटपुट प्रिंट करता है।

इसे ऑनलाइन आज़माएं

यह काम किस प्रकार करता है

#sXw"aeiouAEIOU"+Jc"obounuiniapiiki"3mrd3J  Program.
#                                           Loop until error statement:
   w                                         Get w, the next line of the input
                   "obounuiniapiiki"         Yield string literal "obounuiniapiiki"
                  c                 3        Split that into groups of three characters
                 J                           Assign that to J and yield J
                                     mrd3J   Map title case over J
                +                            Merge the lower and title groups
    "aeiouAEIOU"                             Yield string literal "aeiouAEIOU"
  X                                          Translate w from that to the three-character
                                             groups
 s                                           Concatenate that
                                             Implicitly print

— TheBikingViking
स्रोत

4

सी, 167 बाइट्स

मैं वास्तव में सी कोडिंग करते समय हमेशा मुख्य कार्यों को करने की अपनी आदत को तोड़ना नहीं चाहता था, लेकिन यह मुख्य रूप से संस्करण की तुलना में काफी कम है और इस तरह मुझे एक और पत्र मिला जो मुझे चाहिए था!

golfed

a;l;i;e(char*n){for(;i=*n++;l=i>90,i-=32*l,a=!(i-65)+2*!(i-69)+3*!(i-73)+4*!(i-79)+5*!(i-85),printf(a?"%c%c%c":"%c",(a?"HOUIAI"[a]:i)+l*32,"ibnnpk"[a],"!ouiii"[a]));}

टिप्पणी की गई

a;l;i;
e(char*n)
{
    for(;
        i = *n++;  /* Get char and advance */
        l = i>90,  /* Is lowercase? */
        i -= 32*l, /* Make uppercase */

        /* Is 1,2,3,4,5 depeding on the vowel and 0 for no vowel */
        a = !(i-65) + 2*!(i-69) + 3*!(i-73) + 4*!(i-79) + 5*!(i-85),

        printf(a?"%c%c%c":"%c",        /* Print 1 or 3 chars? */
               (a?"HOUIAI"[a]:i)+l*32, /* Print appropriate char+case */
                  "ibnnpk"[a],            /* Print appropriate char */
                  "!ouiii"[a]));          /* Print appropriate char */
}

C के बारे में कुछ विशेष है और आप कितने भयानक हो सकते हैं।

— algmyr
स्रोत

151 बाइट्स

— छत

@ceilingcat मैं कहूंगा कि अपना जवाब खुद ही दें। यह अपने स्वयं के उत्तर देने के लिए पर्याप्त है। :)

— अल्जाइमर

3

रेटिना , 60 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

[A-Z]
»$&
T`L`l
i
ini
u
iki
e
unu
a
·b·
o
api
·
o
T`»l`_L`».

इसे ऑनलाइन आज़माएं!

— मार्टिन एंडर
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 94 93 92 बाइट्स

s=>s.replace(/[aeiou]/gi,c=>"OUIAIouiai"[n="AEIOUaeiou".search(c)]+"bnnpk"[n%=5]+"ouiii"[n])

बचाया 1 बाइट edc65 करने के लिए धन्यवाद
सहेजा 1 बाइट नील को धन्यवाद

डेमो

let f =
s=>s.replace(/[aeiou]/gi,c=>"OUIAIouiai"[n="AEIOUaeiou".search(c)]+"bnnpk"[n%=5]+"ouiii"[n])

function translate() {
  document.getElementById("o").value = f(document.getElementById("i").value);
}
translate();

<input id="i" size=80 oninput="translate()" value="Hello, World!"><br><input id="o" size=80 disabled>

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

.indexOf.search~<0

— edc65

1

मैंने देखा कि क्या होगा यदि आप केवल स्वरों को प्रतिस्थापित करते हैं, और मुझे मूल रूप से s=>s.replace(/[aeiou]/gi,c=>"ouiaiOUIAI"[n="aeiouAEIOU".indexOf(c)]+"bnnpk"[n%=5]+"ouiii"[n])93 बाइट्स मिले हैं। लेकिन चूंकि cअब एक स्वर के रूप में जाना जाता है आप अब बाइट बचाने searchके indexOfलिए उपयोग कर सकते हैं !

— नील

@ नील - अच्छा! मैंने वास्तव में दोनों की कोशिश की, लेकिन उनके संयोजन के बारे में नहीं सोचा।

— अरनुलद

2

जावा 8, 172 बाइट्स

String f(String s){String v="AEIOUaeiou",r="OboUnuIniApiIkiobounuiniapiiki",o="";for(char c:s.toCharArray()){int n=v.indexOf(c);o+=n>-1?r.substring(n*3,n*3+3):c;}return o;}

ungolfed:

String f(String s){
    String v="AEIOUaeiou",r="OboUnuIniApiIkiobounuiniapiiki",o="";
    for(char c:s.toCharArray()){
        int n=v.indexOf(c);
        o+=n>-1?r.substring(n*3,n*3+3):c;
    }
    return o;
}

और एलियन वापस अंग्रेजी में (171 बाइट्स):

String g(String s){String[] v="AEIOUaeiou".split(""),r="Obo Unu Ini Api Iki obo unu ini api iki".split(" ");for(int i=0;i<v.length;i++)s=s.replaceAll(r[i],v[i]);return s;}

Ungolfed:

String g(String s){
    String[] v="AEIOUaeiou".split(""),r="Obo Unu Ini Api Iki obo unu ini api iki".split(" ");
    for(int i=0;i<v.length;i++)s=s.replaceAll(r[i],v[i]);
    return s;
}

— अल आर
स्रोत

2

Tcl, 75 बाइट्स

अनुवाद करने के लिए स्ट्रिंग चर में है s।

string map {A Obo a obo E Unu e unu I Ini i ini O Api o api U Iki u iki} $s

— पीटर लेवरिन
स्रोत

2

गणितज्ञ, 128 बाइट्स

#~StringReplace~{"a"->"obo","A"->"Obo","e"->"unu","E"->"Unu","i"->"ini","I"->"Ini","o"->"api","O"->"Api","u"->"iki","U"->"Iki"}&

निश्चित नहीं है कि IgnoreCase->Trueकेस चेक के साथ एक छोटे प्रोग्राम का उपयोग करके प्राप्त किया जा सकता है या नहीं ।

— u54112
स्रोत

2

C 178 बाइट्स

char*p[256],*a="obo\0unu\0ini\0api\0iki\0Obo\0Unu\0Ini\0Api\0Iki",*b="aeiouAEIOU";main(c){for(c=0;b[c];++c)p[b[c]]=a+4*c;for(;(c=getchar())>0;)p[c]?printf("%s",p[c]):putchar(c);}

— RosLuP
स्रोत

1

153 बाइट्स

— सीलिंगकैट

@ceilingcat & c ठीक हो सकता है यदि यह संख्या को बाइट 1 बाइट 2 बाइट 3 के रूप में सहेजता है ... उदाहरण के लिए स्मृति में ff 00 00 00 के रूप में 255, लेकिन यदि 255 के लिए अन्य एंडियन है तो हमारे पास 00 00 00 एफएफ है और शून्य स्ट्रिंग प्रिंट करें ...

— रोजलूपी

2

सी, 163 162 159 बाइट्स

char*t="aeiou";n,k;q(char*x){for(;*x;n<0||(*x=t[n>1?n%2?0:2:n+3])&&k>90||(*x-=32),printf("%c%.2s",*x++,n<0?"":&"bonunipiki"[2*n]))n=strchr(t,tolower(k=*x))-t;}

— o79y
स्रोत

char*t="aeiou";लूप में डालने से 1 बाइट बचती है

— मुकुल कुमार

144 बाइट्स

— सीलिंगकैट

2

सी #, 133 121 बाइट्स

s=>{int i;return string.Concat(s.Select(c=>(i ="AIUEOaiueo".IndexOf(c))>-1?"OboIniIkiUnuApioboiniikiunuapi".Substring(i*3,3):c+""));}

संपादित करें (धन्यवाद `milk`)

धन्यवाद :) मैं वास्तव में इस अधिभार को जानता हूं लेकिन किसी तरह यह लिखते समय इसे पूरी तरह से भूल गया ..

s=>string.Concat(s.Select((c,i)=>(i="AIUEOaiueo".IndexOf(c))>-1?"OboIniIkiUnuApioboiniikiunuapi".Substring(i*3,3):c+""));

— स्टीफन
स्रोत

आप Select(char, int)ओवरलोड का उपयोग कर सकते हैं, इसलिए आपको घोषणा करने की आवश्यकता नहीं है iऔर यह सब एक पंक्ति में रख सकते हैं।

s=>string.Concat(s.Select((c,i)=>(i="AIUEOaiueo".IndexOf(c))>-1?"OboIniIkiUnuApioboiniikiunuapi".Substring(i*3,3):c+""));

— दूध

2

सी, ~~207~~ 202 बाइट्स (सायोस के लिए धन्यवाद)

#include <stdio.h>
#define r(c,t) case c:printf(t);continue;
int main(){int c;while(~(c=getchar())){switch(c){r('a',"obo")r('e',"unu")r('i',"ini")r('o',"api")r('u',"iki")default:putchar(c);}}return 0;}

1) मैं किसी भी तरह की घोषणाओं से पहले टाइप करने से नफरत करता हूं

2) मैं वास्तव में अनुपयोगी कोड (मुख्य () फ़ंक्शन के बिना) डालना पसंद नहीं करता

उपयोग:

c89 cg.c -o cg; echo "Testing" | ./cg

— Xdevelnet
स्रोत

PPCG में आपका स्वागत है!

— मार्टिन एंडर

@MartinEnder, यह अप्रत्याशित है ... लेकिन धन्यवाद :)

— Xdevelnet

(c=getchar())!= EOFबन सकता है~(c=getchar())

— साइओस

143 बाइट्स

— सीलिंगकैट

1

स्विफ्ट 2.2 196 बाइट्स

¯ \ _ (ツ) _ / ¯

golfed

var r = ["a":"obo","e":"unu","i":"ini","o":"api","u":"iki"];var q={(s:String) in var o = "";for var i in s.lowercaseString.characters{o += r[String(i)] != nil ? r[String(i)]!:String(i)};print(o);}

unGolfed

var r = ["a":"obo","e":"unu","i":"ini","o":"api","u":"iki"]
var q={(s:String) in
    var o = ""
    for var i in s.lowercaseString.characters {
        o += r[String(i)] != nil ? r[String(i)]!:String(i)
    }
    print(o)
}

— Danwakeem
स्रोत

क्या रिक्त स्थान var r = [आवश्यक हैं?

— साइओस

यदि आप एक काम के बीच में एक जगह नहीं रखते हैं तो यह खेल के मैदान के ऐप में हाँ है, यह आपको एक त्रुटि देता है और आपको रिक्त स्थान जोड़ने के लिए कहता है। स्विफ्ट शायद गोल्फ के साथ सबसे खराब भाषाओं में से एक है, लेकिन मुझे लगा कि यह कोशिश करना मजेदार होगा।

— Danwakeem

और यह दिलचस्प था कि यह मुझे वह त्रुटि नहीं देता था जब मैं एक चर को बंद करने के लिए असाइन कर रहा था। इसलिए

— सिकुड़ते

हां, मैने भी ध्यान दिया। इसलिए मैं उलझन में था।

— साइओस 20'16

0

पर्ल 6 , 84 82 बाइट्स

{my%o=<a obo e unu i ini o api u iki>;S:i:g[<{%o.keys}>]=%o{$/.lc}.samecase($/~'a')}

{my%o=<a obo e unu i ini o api u iki>;S:i:g[<[aeiou]>]=%o{$/.lc}.samecase($/~'a')}

विस्तारित:

# bare block lambda with implicit parameter ｢$_｣
{
  # create the mapping
  my %v = <a obo e unu i ini o api u iki>;

  # replace vowels in ｢$_｣
  S
    :ignorecase
    :global
  [
    <[aeiou]>
  ]

  = # replace them with:

  %v{ $/.lc }
  # change it to be the same case as what was matched, and a lowercase letter
  .samecase( $/ ~ 'a' )
}

उपयोग:

my &english-to-alien = {my%o=<a obo e unu i ini o api u iki>;S:i:g[<[aeiou]>]=%o{$/.lc}.samecase($/~'a')}

say english-to-alien 'Australia'; # Oboikistroboliniobo

— ब्रैड गिल्बर्ट b2gills
स्रोत

0

सी - 192 बाइट्स

(newlines स्पष्टता के लिए जोड़ा गया)

int c,j,b;main(){
char*f[]={"bo","nu","ni","pi","ki",""},
s[]={14,16,0,-14,-12};
while(c=getchar()){for(b=j=0;j<10;++j)
{if(c=="aeiouAEIOU"[j]){c+=s[j%=5];b=1;break;}}
printf("%c%s",c,f[b?j:5]);}}

बस देखने की मेज और एक बूलियन स्विच।

स्वरों की तालिका (स्ट्रिंग) में प्रत्येक अक्षर को देखें; यदि पाया जाता है, तो तालिका में नियम के अनुसार इसे संशोधित करें s। एक स्ट्रिंग द्वारा पीछा किए गए प्रत्येक वर्ण को प्रिंट करें: यदि एक स्वर मिला था, तो sतालिका में संग्रहित शेष शब्दांश के बाद मूल्य द्वारा संशोधित चरित्र को प्रिंट करें f; यदि एक स्वर नहीं मिला, तो मूल वर्ण और एक रिक्त स्ट्रिंग मुद्रित करें।

— musarithmia
स्रोत

149 बाइट्स

— सीलिंगकैट

0

रूबी, 102 93 91 88 78 बाइट्स

gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}

स्पष्टीकरण:

ruby -pe "gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}"उदाहरण के लिए, अगले प्रकार की पंक्ति को निष्पादित करें , उदाहरण के लिए, Australiaयह आउटपुट होना चाहिए:Oboikistroboliniobo :।

यह बहुत सीधा है, सभी स्वरों को बदले जाने वाले स्वर के सूचकांक (b), अनुक्रमणिका के आधार पर प्रतिस्थापित स्ट्रिंग में 3 और अगले 3 वर्णों के साथ प्रतिस्थापित करें।

— Biketire
स्रोत

1

मुझे संदेह है कि आउटपुट में अग्रणी और अनुगामी उद्धरण चिह्न (और आंतरिक पलायन यदि इनपुट के उद्धरण चिह्न हैं) तो यह अयोग्य हो सकता है। वैसे भी, आप bRegexp ( /[#{b=...}/) में असाइनमेंट ले जाकर दो बाइट्स बचा सकते हैं ।

— जॉर्डन

1

मुझे लगता है कि अंतरिक्ष p $*अनावश्यक है

— Cyoce

1

-pअतिरिक्त बाइट को बचाने के लिए ध्वज का उपयोग करें । ruby -pe 'gsub(/[#{b="aeiouAEIOU"}]/){"obounuiniapiikiOboUnuIniApiIki"[b.index($&)*3,3]}'

— मूल्य इंक

मेरी गिनती 78 + 2 ( -pe) है। आपको 71 कैसे मिले?

— नहीं कि चार्ल्स

@NothatCharles क्या इस मामले में निष्पादन के लिए आवश्यक वर्ण वास्तव में मायने रखते हैं? मैंने अभी उन्हें नहीं गिना।

— बीकाटेयर

0

टीआई-बेसिक, 201 197 195 बाइट्स

Ans+" →Str1:"AEIOUaeiou→Str2:"OUIAIouiai→Str3:"bonunipiki→Str4:1→X:While X<length(Str1:inString(Str2,sub(Str1,X,1→A:5fPart(.2A→B:If A:sub(Str1,1,X-1)+sub(Str3,A,1)+sub(Str4,2B-1,2)+sub(Str1,X+1,length(Str1)-X→Str1:X+1+2(A>0→X:End:sub(Str1,1,length(Str1)-1

यह सोचने के लिए कि मुझे यहाँ एक और TI-BASIC जवाब मिलेगा!

वैसे भी, इनपुट एक अंग्रेजी स्ट्रिंग है Ans।
आउटपुट अनुवादित स्ट्रिंग है।

उदाहरण:

"HE
HE
prgmCDGF1A
HUnu
"Hello
Hello
prgmCDGF1A
Hunullapi

स्पष्टीकरण:
(पठनीयता के लिए जोड़े गए नए अंक। एक ही पंक्ति से एकाधिक पंक्तियों :को निम्नलिखित कोड ब्लॉक में दर्शाया जाएगा ।)

Ans+" →Str1                     ;append a space to the input string and store the result
                                ; in "Str1"
"AEIOUaeiou→Str2                ;store the upper- and lowercase vowels in "Str2"
"OUIAIouiai→Str3                ;store the beginning letter of each corresponding translated
                                ; vowel in "Str3"
"bonunipiki→Str4                ;store the remaining letters of each translated vowel
                                ; in "Str4"
1→X                             ;store 1 in "X"
While X<length(Str1             ;loop until all English letters have been checked
inString(Str2,sub(Str1,X,1→A    ;get the current letter and store its index in "Str2"
                                ; into "A"
5fPart(.2A→B                    ;get which translated vowel end should be used
                                ; B ranges from 1 to 5
If A                            ;if the current letter is a vowel
sub(Str1,1,X-1)                 ;extract the substring of the input before the
                                ; current letter
: +sub(Str3,A,1)                ;append the translated vowel start
: +sub(Str4,2B-1,2)             ;append the translated vowel end
: +sub(Str1,X+1,length(Str1)-X  ;append the remaining substring of the input
: →Str1                         ;store the result of these concatenations into "Str1"
X+1+2(A>0→X                     ;check if A>0 (if the current letter was a vowel)
                                ; if true, increment "X" by three
                                ; if false, increment "X" by one
End
sub(Str1,1,length(Str1)-1       ;remove the trailing space and store the result in "Ans"
                                ;implicit print of "Ans"

टिप्पणियाँ:

TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।
TI-BASIC में लोअरकेस अक्षर दो बाइट्स हैं।

— ताउ
स्रोत

अंग्रेजी से विदेशी अनुवादक

वार्ता

चुनौती

उदाहरण

नियम

हास्केल, 100 91 बाइट्स

टीआई-बेसिक, 173 + 59 + 148 = 380 बाइट्स

पर्ल, 56 बाइट्स

सीड 89

पायथन, 99 95 93 बाइट्स

05AB1E , 28 27 20 बाइट्स

PHP, 91 बाइट्स

अजगर, 129 बाइट्स

सी (जीसीसी) , 150 141 136 134 बाइट्स

बैच, 215 बाइट्स

पायथ, 42 बाइट्स

सी, 167 बाइट्स

golfed

टिप्पणी की गई

रेटिना , 60 बाइट्स

जावास्क्रिप्ट (ईएस 6), 94 93 92 बाइट्स

डेमो

जावा 8, 172 बाइट्स

Tcl, 75 बाइट्स

गणितज्ञ, 128 बाइट्स

सी, 163 162 159 बाइट्स

सी #, 133 121 बाइट्स

संपादित करें (धन्यवाद milk)

स्विफ्ट 2.2 196 बाइट्स

golfed

unGolfed

पर्ल 6 , 84 82 बाइट्स

विस्तारित:

उपयोग:

सी - 192 बाइट्स

रूबी, 102 93 91 88 78 बाइट्स

टीआई-बेसिक, 201 197 195 बाइट्स

संपादित करें (धन्यवाद `milk`)