संकल्पना

नंबर याद रखना मुश्किल हो सकता है। एक शब्द याद रखना आसान हो सकता है। बड़ी संख्या में याद करने के लिए, मैंने उन्हें लेट्सपेक की तरह उच्चारण करने का एक तरीका बनाया।

नियम

प्रत्येक अंक को पहले उसके संबंधित अक्षर से बदल दिया जाता है:

0 => O
1 => I
2 => R
3 => E
4 => A
5 => S
6 => G
7 => T
8 => B
9 => P

प्रतिस्थापन के बाद, दो अतिरिक्त चीजें उच्चारण में सुधार के लिए की जाती हैं:

दो व्यंजन के बीच, एक Uजोड़ा जाता है।
दो स्वरों के बीच, एक Nजोड़ा जाता है।

उदाहरण / परीक्षण के मामले

512431 => SIRANENI
834677081 => BENAGUTUTOBI
3141592 => ENINANISUPUR
1234567890 => IRENASUGUTUBUPO
6164817 => GIGABIT

क्या असंभव है

एक ही शब्द में मिश्रित अक्षर और संख्या
दो क्रमिक व्यंजन या दो क्रमिक स्वर
जो पत्र ऊपर की सूची में नहीं हैं
अन्य कैरेक्टर

नियम

इस कोड-गोल्फ का लक्ष्य इस अवधारणा के लिए 2-तरफा अनुवादक बनाना है।

यदि यह अक्षर-से-संख्या या संख्या-से-पत्र अनुवाद है, तो आपके कार्यक्रम को पहले स्वयं समझना होगा।
इसे ठीक से बनने के लिए प्रविष्टि की जांच करनी चाहिए।
यदि सब कुछ सही है, तो अनुवाद प्रदर्शित करें।
एल्स, एक त्रुटि संदेश प्रदर्शित करें, कुछ भी नहीं, एक गलत मान लौटाएं या प्रोग्राम को क्रैश करें।

विवरण

इनपुट नंबर / स्ट्रिंग जो भी प्रारूप में आप चाहते हैं दर्ज किया जा सकता है (स्टड, तर्क, ...)
यह कोड-गोल्फ है , इसलिए सबसे कम उत्तर जीतता है।
मानक खामियों को मना किया जाता है।

code-golf number

— SteeveDroz
स्रोत

11

नहीं GIGATESTERहोना चाहिए GIGATESUTER?

— kamoroso94

5

आमतौर पर, हम प्रविष्टि को 'ठीक से बनने' के लिए नहीं कहते हैं, क्योंकि यह बिना किसी अच्छे कारण के अतिरिक्त कोड है (अच्छी चुनौती की सिफारिशों के लिए मेटा प्रश्न देखें)। इसके अतिरिक्त, 'ठीक से गठित' का क्या अर्थ है?

— ओकेक्स

9

यदि इनपुट सत्यापन आवश्यक है, तो आपको अमान्य इनपुट के परीक्षण मामलों का एक सभ्य बैच (विशेष रूप से पत्र-केवल इनपुट जो लगभग मान्य हैं) शामिल होना चाहिए । मुझे उम्मीद है कि यह वास्तव में कई भाषाओं में चुनौती का मुख्य हिस्सा होगा।

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

2

मैं @MartinEnder से सहमत हूं कि आपको अमान्य मामलों के लिए कुछ परीक्षण मामलों को जोड़ना चाहिए, जैसे AB23; AEI; BB; Z; ACE; giga; !@#$; -123; आदि।, सत्यापन नियमों के आधार पर, हम परिवर्तित कर सकते हैं 6164735732 => GIGATESTER, लेकिन GIGATESTERएक ST(दो क्रमिक रूल नियम) के कारण, एक गलत मूल्य होगा । वर्तमान में आपकी चुनौती जिस तरह से सेट की गई है, चुनौती का मुख्य हिस्सा रूपांतरण के बजाय सत्यापन है। मैं इसके साथ ठीक हूं, लेकिन सत्यापन को उस मामले में थोड़ा बेहतर परिभाषित किया जाना चाहिए।

— केविन क्रूज़सेन

2

यदि यह अक्षर-से-संख्या या संख्या-से-पत्र अनुवाद है, तो आपके कार्यक्रम को पहले स्वयं को समझना चाहिए। तो अनुवाद को दो-तरफा होना चाहिए? पूर्ववर्ती पाठ और परीक्षण के मामले केवल पत्र को संख्या का सुझाव देते हैं

— लुइस मेंडो

5

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

दोनों अनुवाद तरीकों में एक स्ट्रिंग के रूप में इनपुट लेता है। या तो अनुवाद को स्ट्रिंग के रूप falseमें या अमान्य इनपुट के मामले में लौटाता है ।

f=(n,k)=>(t=n.replace(/./g,(c,i)=>1/n?(!i|p^(p=27>>c&1)?'':'UN'[p])+s[c]:~(x=s.search(c))?x:'',p=s='OIREASGTBP'),k)?t==k&&n:f(t,n)

डेमो

कोड स्निपेट दिखाएं

f=(n,k)=>(t=n.replace(/./g,(c,i)=>1/n?(!i|p^(p=27>>c&1)?'':'UN'[p])+s[c]:~(x=s.search(c))?x:'',p=s='OIREASGTBP'),k)?t==k&&n:f(t,n)

console.log(f("512431"))          // SIRANENI
console.log(f("834677081"))       // BENAGUTUTOBI
console.log(f("3141592"))         // ENINANISUPUR
console.log(f("1234567890"))      // IRENASUGUTUBUPO
console.log(f("6164735732"))      // GIGATESUTER

console.log(f("SIRANENI"))        // 512431 
console.log(f("BENAGUTUTOBI"))    // 834677081
console.log(f("ENINANISUPUR"))    // 3141592
console.log(f("IRENASUGUTUBUPO")) // 1234567890
console.log(f("GIGATESUTER"))     // 6164735732

console.log(f("AB23"))            // false
console.log(f("AEI"))             // false
console.log(f("ZZ"))              // false

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

— Arnauld
स्रोत

यदि यह पूरी तरह से काम नहीं करता है, तो इसे पोस्ट न करें।

— ओकेक्स

उम्मीद है कि अब उम्मीद के मुताबिक काम कर रहे हैं।

— अरनुलद

... या इनपुट में आरक्षित regexp वर्ण होने पर क्रैश। हालांकि अभी भी मान्य है

— edc65

2

जाप , 61 59 92 85 84 बाइट्स

मैं अधिकांश (लंबे) सप्ताहांत के लिए ऑफ़लाइन हूं, यदि इसके साथ कोई और समस्याएँ खोजी जाती हैं, तो कृपया मेरे लिए इसे हटाने के लिए एक मॉड पूछें जब तक कि मैं इसे ठीक नहीं कर सकता।

दोनों के संचालन के लिए एक स्ट्रिंग के रूप इनपुट लेता है और साथ ही या दोनों के लिए एक स्ट्रिंग रिटर्न falseअमान्य input.Assumes संख्या आदानों हमेशा कई अंक होने के लिए, 1 बाइट की जगह को जोड़ने UÉके साथ Un<space>करता है, तो जो मान्य नहीं है। falseपरीक्षण के मामले के लिए रिटर्न GIGATESTER, लेकिन, नियमों के अनुसार, अमान्य इनपुट होना चाहिए ।

V="OIREASGTBP"UÉ?¡VgXÃe"%v"²_i1'NÃe"%V"²_i1'UÃ:!Uè"%v%v|%V%V|[^{V}NU]" ©Ur"N|U" £VaX

इसे आज़माएँ: नंबर -> पत्र या पत्र -> संख्या

2 4 बाइट्स ने ओबारकोन को धन्यवाद दिया , जिन्होंने मुझे पहले इसे त्यागने के बाद फिर से इसे लेने के लिए मना लिया। काश वह नहीं होता!
33 26 25 (!) बाइट इनपुट वैधता की जांच करने के लिए एक त्वरित फिक्स (यानी, अभी तक पूरी तरह से गोल्फ होने के लिए) को लागू करने का त्याग किया।

व्याख्या

(अभी तक नवीनतम संस्करण के लिए अद्यतन किया जा सकता है)

                          :Implicit input of string U.
V="..."                   :Assign the string of letters to variable V, in order.
UÉ                        :Subtract 1 from U, which will give a number (truthy) if the input is a number or NaN (falsey) if the input is a string.
?                         :If it's a number then
¡                         :    Map over the input string, replacing each character (digit) with ...
VgX                       :      the character in string V at index X, the current digit.
Ã                         :    End mapping.
e                         :    Recursively replace ...
"%v"²                     :      every occurrence of 2 vowels (RegEx) ...
_i1'N                     :      with the current match with an "N" inserted at index 1.
Ã                         :    End replacement.
e                         :    Another recursive replacement of ...
"%V"²                     :      every occurrence of 2 non-vowel characters (i.e., consonants) ...
_i1'U                     :      with the current match with a "U" inserted at index 1.
Ã                         :    End replacement.
:                         :Else, if it's a string then
Uè"%v%v|%V%V|[^{V}NU]"    :    Count the number of matches of 2 successive vowels OR 2 successive non-vowels OR any character not in contained in string V plus N & U.
                          :    (The longest part of this code is the fecking input validation!)
?                         :    If that count is greater than 0 then
T                         :       Return 0.
:                              Else
Ur"N|U"                   :        Replace every occurrence of "N" OR "U" in string U with nothing.
£                         :        Map over the string, replacing each character (letter) with ...
VaX                       :         the index of the current character X in string V.
                          :Implicit output of resulting string

— झबरा
स्रोत

अमान्य इनपुट को संभालना प्रतीत नहीं होता है जैसेAEI

— Emigna

@ ईमग्ना: आह, गोड्डमनीत! आप पहले "नियम" से जलने के बाद कल्पना करेंगे, हमने बाकी नियमों को पढ़ने के लिए सोचा होगा! : \ "मैंने असंभव क्या किया" खंड लिया, इसका मतलब है कि हमें उन बिंदुओं में से किसी को भी संभालना नहीं होगा। शीघ्र ही आ रहा है।

— झबरा

2

पायथन 3 , 147 बाइट्स

lambda c:c in"0134"
def f(n):
 o="";a=b=1-x(n[0])
 for i in n:
  a=x(i)
  if a==b:o+="UN"[a]
  o+="OIREASGTBP"["0123456789".index(i)];b=a
 print(o)

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

— irapsaged
स्रोत

1

जावा (ओपनजेडके 8) , 416 410 399 382 376 370 बाइट्स

-2 बाइट्स @Cyoce को धन्यवाद

@Cyoce द्वारा एक विचार के लिए -17 अधिक बाइट्स धन्यवाद

-6 बाइट्स @KevinCruijssen को धन्यवाद

s->{String c="[RSGTBP]",v="[OIEA]",o="([256789])",e="([0134])";boolean b=s.matches("(c$|v$|(c|vN)(?=v)|(cU|v)(?=c))+".replace("c",c).replace("v",v));int i=-1;for(s=b?s.replaceAll("[UN]",""):s.matches("[0-9]+")?s.replaceAll(e+"(?="+e+")","$1N").replaceAll(o+"(?="+o+")","$1U"):i/0+"";i<9;s=b?s.replace(v,c):s.replace(c,v)){c=++i+"";v="OIREASGTBP".charAt(i)+"";}return s;}

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

उह, जावा प्रतिस्थापन तो क्रिया है।

फंक्शन जो एक स्ट्रिंग लेता है और संख्या -> अक्षर या इसके विपरीत से अनुवादित स्ट्रिंग लौटाता है। अमान्य इनपुट पर क्रैश (आप इसे tio उदाहरण में देख सकते हैं जहां यह पहले 10 परीक्षण मामलों के लिए सही मानों को आउटपुट करता है और फिर शून्य त्रुटि से विभाजित होता है जो डीबग दृश्य में दिखाता है)

Ungolfed (लूप के लिए पहला और अंतिम शब्द पठनीयता के लिए निकाला जाता है)

s-> {
    String c="[RSGTBP]", v="[OIEA]", o="([256789])", e="([0134])"; 
    boolean b=s.matches("(c$|v$|(c|vN)(?=v)|(cU|v)(?=c))+".replace("c",c).replace("v",v)); // lovely regex, explained below
    int i=-1;
    s= b? 
        s.replaceAll("[UN]",""); // remove N's and U's
        :s.matches("[0-9]+")?
        s.replaceAll(e+"(?="+e+")","$1N").replaceAll(o+"(?="+o+")","$1U"); // add N's and U's for separating vowels and consonants
        :i/0+""; // throw an error, looks like a sting for the ternary
    for(;i<9;) { 
        c=++i+"";
        v="OIREASGTBP".charAt(i)+"";
        s=b?s.replace(v,c):s.replace(c,v); // if it started with numbers, go to letters, or vice versa
    }
    return s;
}

संख्याओं के मिलान के लिए रेगेक्स सरल है, लेकिन यहां अक्षरों से संख्याओं के मिलान के लिए रेगेक्स है

(c$|v$|(c|vN)(?=v)|(cU|v)(?=c))+
(                             )+   every part of the word is
 c$                                a consonant at the end of the word
   |v$                             or a vowel at the end of the word
      |(c|vN)(?=v)                 or a consonant or a vowel + N followed by a vowel
                  |(cU|v)(?=c)     or a consonant + U or a vowel followed by a consonant


with c = [RSGTBP] and v = [OIEA]

— PunPun1000
स्रोत

ऐसा नहीं है कि यह आपके बड़े पैमाने पर बाइट की संख्या में सुधार करता है, लेकिन आप कोष्ठक को दूर कर सकते हैं(s)->

— Cyoce

@ हर बाइट मदद करता है

— Pun381000

के बाद से सभी को अपनी शाखाओं ifबयान कार्य (जो कोई मान) कर रहे हैं, जगह की कोशिश if... else if... elseसशर्त ऑपरेटर के साथ ?:, के साथ यह prefacing Object _=यह एक वैध बयान बनाने के लिए। यकीन नहीं है कि यह वास्तव में बाइट गिनती में मदद करेगा, लेकिन मुझे लगता है कि यह होगा।

— साइओस

दो छोटी चीजें जो आप गोल्फ कर सकते हैं। आप स्ट्रिंग को हटा सकते हैं t, क्योंकि आप केवल एक बार इसका उपयोग करते हैं। तो ( -4 बाइट्स ) t.charAt(i)+""बन जाता है । और आप for-loop घोषणा के अंदर के बाद for-loop के अंदर अंतिम पंक्ति रख सकते हैं । तो यह ( -1 बाइट ) बन जाता है । ओह, और आप उस लूप को फॉर-लूप के अंदर भी डाल सकते हैं : ( -1 बाइट )। "OIREASGTBP".charAt(i)+""i<9;for(;i<9;s=b?s.replace(v,c):s.replace(c,v)){s=b?...int i=-1;for(s=b?...;i<9;...

— केविन क्रूज़सेन

1

पीएचपी; 129 127 267 259 228 बाइट्स

$l=IOREASGTBP;$n=1023456789;ctype_digit($s=$argn)?:$s=preg_replace("#U|N#","",strtr($o=$s,$l,$n));for($r=$c=($t=strtr($s,$n,$l))[$i++];$d=$t[$i++];)$r.=((trim($c,AEIO)xor$x=trim($d,AEIO))?X:UN[!$x]).$c=$d;echo$o?$o==$r?$s:"":$r;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

टूट - फूट

$l=IOREASGTBP;$n=1023456789;
# if not digits, translate letters to digits and remember original
ctype_digit($s=$argn)?:$s=preg_replace("#U|N#","",strtr($o=$s,$l,$n));
# translate digits to letters:
for($r=$c=($t=strtr($s,$n,$l))                      # result = first letter
    [$i++];$d=$t[$i++];)                            # loop through letters
    $r.=((trim($c,AEIO)xor$x=trim($d,AEIO))?"":UN[!$x]) # append delimiter if needed
        .$c=$d;                                         # append next letter
# 
echo
    $o              # if original was remembered,
        ?$o==$r         # compare original to final result
            ?$s         # if equal, print digits
            :X          # else print X (as error message)
        :$r;        # else print letters

— टाइटस
स्रोत

1

जावा 8, 312 308 304 301 294 290 बाइट्स

s->{String r="",x="([AEIOU])",y="([BGNPRST])",z="0O1I2R3E4A5S6G7T8B9P";for(int c:s.getBytes())r+=c!=78&c!=85?z.charAt((c=z.indexOf(c)+(c<58?1:-1))<0?0:c):"";return s.matches("(("+x+y+")*"+x+"?)|(("+y+x+")*"+y+"?)|\\d*")?r.replaceAll(x+"(?="+x+")","$1N").replaceAll(y+"(?="+y+")","$1U"):"";}

बग-फिक्स के लिए -4 बाइट्स (308 → 304) (अक्सर ऐसा नहीं होता कि मेरे कोड में बग को ठीक करने पर बाइट-काउंट कम हो जाए ..: D)

EDIT: वर्णों के लिए लूप में रिटर्न-स्ट्रिंग को पहले बनाकर @ PunPun1000 के जावा उत्तर की तुलना में एक अलग दृष्टिकोण का उपयोग करता है , और फिर रिटर्न-टर्नरी (इसे इनपुट या तो सभी अंकों में मान्य करने के लिए एक अधिक अमूर्त रीगेक्स का उपयोग करता है) या दिए गए स्वर और व्यंजन बारी-बारी से हैं (इसलिए बिना किसी आसन्न स्वर के और न ही व्यंजन)।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                                   // Method with String parameter and String return-type
  String r="",                         //  Result-String
    x="([AEIOU])",y="([BGNPRST])",     //  Two temp Strings for the validation-regex
    z="0O1I2R3E4A5S6G7T8B9P";          //  And a temp-String for the mapping
  for(int c:s.getBytes())              //  Loop over the characters of the input-String
    r+=                                //   Append to the result-String:
       c!=78&c!=85?                    //    If the character is not 'N' nor 'U':
        z.charAt(                      //     Get the character from the temp-String `z`
         (c=z.indexOf(c)+              //      by getting the character before or after the current character
            +(c<58?1:-1))              //      based on whether it's a digit or not
             <0?0:c)                   //      and a 0-check to prevent errors on incorrect input like '!@#'
       :                               //    Else:
        "";                            //     Append nothing
                                       //  End of loop (implicit / single-line body)
  return s.matches("(("+x+y+")*"+x+"?)|(("+y+x+")*"+y+"?)|\\d*")?
                                       //  If the input is valid
                                       //  (Only containing the vowels and consonants of `x` and `y`, without any adjacent ones. Or only containing digits)
    r                                  //   Return the result
     .replaceAll(x+"(?="+x+")","$1N")  //    after we've added 'N's if necessary
     .replaceAll(y+"(?="+y+")","$1U")  //    and 'U's if necessary
   :"";                                //  Or return an Empty String if invalid
}                                      // End of method

सत्यापन regex:

(([AEIOU][BGNPRST])*[AEIOU]?)|(([BGNPRST][AEIOU])*[BGNPRST]?)|\\d*

— केविन क्रूज़सेन
स्रोत

0

05AB1E , 76 बाइट्स

.•.Ÿ^91Ý•Ul„nuSKDXSKg0QVvXyk}JYP©0Êi®}¤«SXuèŒ2ùv…U NSy0èìžMuyåOè})Já¨¹d_iQ®P

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

0अमान्य इनपुट के लिए मिथ्या मान लौटाता है ।

— Emigna
स्रोत

0

बैश ,241 238 235 बाइट्स

q=OIREASGTBP;[[ $1 == +([0-9]) ]]&&(x=`tr 0-9 $q<<<$1`;m={B,G,P,R,S,T};n={A,E,I,O};for i in `eval echo $m$m$n$n`;{ a=${i::1};b=${i:1:1};x=${x//$a$b/$a'U'$b};a=${i:2:1};b=${i:3:1};x=${x//$a$b/$a'N'$b};};echo $x)||tr $q 0-9<<<$1|tr -d UN

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

कम गोल्फ वाला:

q=OIREASGTBP;                          save string in q
[[ $1 == +([0-9]) ]]&&(                if argument 1 is only digits
x=`tr 0-9 $q<<<$1`;                    save in x each digit translated to corresponding letter
m={B,G,P,R,S,T};
n={A,E,I,O};
for i in `eval echo $m$m$n$n`;{        generates all combinations of vowels and consonants
                                       BBAA BBAE ... TTOI TTOO
   a=${i::1};                          saves first consonant in a
   b=${i:1:1};                         saves second consonant in b
   x=${x//$a$b/$a'U'$b};               insets U between consonants
   a=${i:2:1};                         saves first vowel in a
   b=${i:3:1};                         saves second vowel in b
   x=${x//$a$b/$a'N'$b};               inserts N between vowels
};
echo $x                               echoes result
)||                                   if argument contains letters
  tr $q 0-9<<<$1|tr -d UN             translates letter to corresponding number and deletes U and N

— marcosm
स्रोत

0

PHP, 268 बाइट्स

$v=OIEA;$l=RSGTBP;$d="0134256789";$c=ctype_digit;$p=preg_replace;echo!$c($a=$argn)?$c($e=strtr($p(["#\d|[$v]{2,}|[$l]{2,}#","#[$v]\KN(?=[$v])#","#[$l]\KU(?=[$l])#"],[_,"",""],$a),$v.$l,$d))?$e:_:$p(["#[$v](?=[$v])#","#[$l](?=[$l])#"],["$0N","$0U"],strtr($a,$d,$v.$l));

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

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

0

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

126 बाइट्स + 1 बाइट कमांड लाइन

$i="AEIOU]";$;=OIREASGTBP;1/!/[^$;NU\d]|[$i{2}|[^\d$i{2}/;eval"y/0-9$;NU/$;0-9/d";s/[$i\K(?=[$i)/N/g;s/[^N\d$i\K(?=[^\d$i)/U/g

उपयोग:

 echo -n "512431" | perl -p entry.pl

सभी चुनौती नियमों का पालन करना चाहिए - यदि सत्यापन विफल रहता है तो पत्र या संख्या को स्वीकार कर सकते हैं और त्रुटि (शून्य से विभाजन) करेंगे

— Jarmex
स्रोत

सत्यापन में इनपुट पर झूठी सकारात्मकता है NOऔर US।

— वैल्यू इंक

0

रूबी , 205 + 1 = 206 बाइट्स

-p+1 बाइट के लिए ध्वज का उपयोग करता है । अब एक संपूर्ण इनपुट सत्यापन प्रणाली के साथ।

d,w=%w"0-9 OIREASGTBP"
~/^\d+$/?($_.tr!d,w
gsub /([#{a='AEIO])(?=\g<1>)'}/,'\0N'
gsub /([^#{a}/,'\0U'):(+~/^(([AEIO])(N(?=[AEIO])|(?=\g<4>)|$)|([RSGTBP])(U(?=\g<4>)|(?=\g<2>|$)))+$/;$_.tr!("NU","").tr!w,d)

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

— मान स्याही
स्रोत

यह अक्षरों को संख्याओं में परिवर्तित नहीं करता है और न ही यह कोई मान्यता देता है!

— जरमेक्स

@ Jarmex उफ़, जोड़ा सत्यापन! यह एक बहुत बड़ा सत्यापन है, लेकिन मेरे पास इस मामले में ज्यादा विकल्प नहीं हैं

— वैल्यू इंक

0

पायथन 3, 741 बाइट्स

from functools import reduce;c=0;e="";n="NU";v="AEIOU";l="OIREASGTBPNU";x=('0','O'),('1','I'),('2','R'),('3','E'),('4','A'),('5','S'),('6','G'),('7','T'),('8','B'),('9','P');s=input()
try:
    int(s);y=reduce(lambda a,kv:a.replace(*kv),x,s)
    for i in y:
        e+=i
        if i in v:
            z=True
            try:
                if y[c+1] in v:e+="N"
            except:
                pass
        else:
            z=False
            try: 
                if not y[c+1] in v:e+="U"
            except:
                pass
        c+=1
except:
    for i in s:
        if not i in l:
            p
    y=reduce(lambda a,kv:a.replace(*kv[::-1]),x,s)
    for i in y: 
        if not i in n:e+=i
print(e)

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

सुधार के लिए बहुत जगह है, मुझे पता है।

— LyricLy
स्रोत

0

sed, 123 बाइट्स

s/[0134]/_&_/g
s/[25-9]/=&=/g
ta
y/OIREASGTBPU/0123456789N/
s/N//g
q
:a
s/__/N/g
s/==/U/g
y/0123456789_/OIREASGTBP=/
s/=//g

व्याख्या

सबसे पहले, हम अंकों को चारों ओर से घेरते हैं _ (स्वर के लिए) या =(व्यंजन के लिए ) ।

यदि हमने कोई प्रतिस्थापन नहीं किया है, तो हम अक्षरों को अंकों में परिवर्तित कर रहे हैं, इसलिए यह एक सरल प्रतिस्थापन है, और हटाएं U और N। फिर छोड़ दिया।

अन्यथा, हम लेबल करने के लिए शाखा देते हैं a, जहां हम लगातार स्वरों और फिर लगातार व्यंजन से निपटते हैं। फिर अंकों को अक्षरों में बदलना, और पहले चरण में हमारे द्वारा पेश किए गए मार्कर वर्णों को हटाना।

— टोबी स्पाईट
स्रोत

0

पायथन 3, 246 बाइट्स

v=lambda x:x in"AEIO"
V="OIREASGTBP"
i=input()
r=__import__("functools").reduce
print(r(lambda x,y:x+(("U",""),("","N"))[v(x[-1])][v(y)]+y,map(lambda x:V[x],map(int,i)))if i.isdigit()else r(lambda x,y:x*10+V.index(y),filter(lambda x:x in V,i),0))

स्पष्टीकरण:

int की सूची में नक्शा इनपुट
वर्णमाला में उनकी स्थिति के लिए मानचित्र की सूची
संचायक जोड़कर सूची को कम करें, साथ ही एक ~~ताना~~ का एक तत्व टपल , और वर्तमान तत्व
- ~~dict~~ टपल दो तत्वों, स्वर जा रहा है या नहीं के आधार पर एक सच तालिका है

— Setop
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 120

एक स्ट्रिंग के रूप में इनपुट लेने वाला फ़ंक्शन। यदि इनपुट मान्य है, तो गलत या फ़ंक्शन क्रैश होने पर यह ठीक से अनुवादित स्ट्रिंग लौटाता है।

n=>(t=n=>n.replace(/./g,d=>1/d?(v-(v=d<5&d!=2)?'':'UN'[v])+z[d]:~(a=z.search(d))?a:'',v=2,z='OIREASGTBP'))(q=t(n))==n&&q

कम गोल्फ वाला

n => 
{
  var t = n => { // function to translate, no check for invalid input
    var v = 2; // 1 = digit map to vowel, 0 = digit map to consonant, start with 2
    var z = 'OIREASGTBP'; // digits mapping
    return n.replace(/./g,
      d => 1/d // digit / alpha check
        ? ( // if digit
            w = v, // save previous value of v
            v = d < 5 & d != 2, // check if current digit will map to wovel or consonant
            (w != v 
             ? '' // if different - wovel+consonant or consonant+wovel or start of input
             : 'UN'[v] // if equal, insert required separator
            ) + z[d] // add digit translation
          )
        : ( // if alpha
             a = z.search(d), // look for original digit. Could crash if d is a reserved regexp char (not valid input)
             a != -1 ? a : '' // if digit found add to output, else do nothing
          )
    )
  }

  var q = t(n); // translate input an put in q
  if (t(q) == n) // translate again, result must be == to original input
    return q; // if ok return result
  else
    return false; // else return false
}

परीक्षा

var F=
n=>(t=n=>n.replace(/./g,d=>1/d?(v-(v=d<5&d!=2)?'':'UN'[v])+z[d]:~(a=z.search(d))?a:'',v=2,z='OIREASGTBP'))(q=t(n))==n&&q

;`512431 => SIRANENI
834677081 => BENAGUTUTOBI
3141592 => ENINANISUPUR
1234567890 => IRENASUGUTUBUPO
6164817 => GIGABIT`
.split('\n')
.forEach(x => {
  var [a,b] = x.match(/\w+/g)
  var ta = F(a)
  var tb = F(b)
  console.log(a==tb ? 'OK':'KO', a + ' => '+ ta)
  console.log(b==ta ? 'OK':'KO', b + ' => '+ tb)
})

function go() {
  O.textContent = F(I.value)
}

go()

<input id=I value='NUNS' oninput='go()'>
<pre id=O></pre>

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

— edc65
स्रोत

उच्चारण संख्या

संकल्पना

नियम

उदाहरण / परीक्षण के मामले

क्या असंभव है

नियम

विवरण

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

डेमो

जाप , 61 59 92 85 84 बाइट्स

व्याख्या

पायथन 3 , 147 बाइट्स

जावा (ओपनजेडके 8) , 416 410 399 382 376 370 बाइट्स

पीएचपी; 129 127 267 259 228 बाइट्स

जावा 8, 312 308 304 301 294 290 बाइट्स

05AB1E , 76 बाइट्स

बैश ,241 238 235 बाइट्स

PHP, 268 बाइट्स

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

रूबी , 205 + 1 = 206 बाइट्स

पायथन 3, 741 बाइट्स

sed, 123 बाइट्स

व्याख्या

पायथन 3, 246 बाइट्स

जावास्क्रिप्ट (ईएस 6), 120