डिकोड बेबी-टॉक!

26

जब बच्चे अपना मुंह खोलते हैं, तो वे सिर्फ छींटाकशी नहीं करते हैं। वे वास्तव में एक उच्च उन्नत, वयस्क प्रूफ सिफर में बात कर रहे हैं ...

द बेबी-टॉक सिपर

जब एक बच्चा बात करता है, तो यह कुछ ऐसा दिख सकता है जैसे gogooa gagooook aagaaoooy प्रत्येक एकल-अंतरिक्ष अलग-अलग अनुभाग एक चरित्र का प्रतिनिधित्व करता है (इसलिए ऊपर दिया गया उदाहरण 3 वर्णों का प्रतिनिधित्व करता है)।

किसी अनुभाग को समझने के लिए, हमें अस और ओएस की संख्या की गणना करनी चाहिए। हालांकि, हम केवल उन लोगों को गिनते हैं जो दूसरे स्वर से सटे हैं। उदाहरण के लिए, 'गैग' में ए की गिनती नहीं होगी, लेकिन 'गॉग' में ए और ओ दोनों होंगे।

ऊपर दिए गए उदाहरण की गिनती इस तरह होगी:

Section    | Num Os | Num As

gogooa     | 2      | 1
gagooook   | 4      | 0
aagaaoooy  | 3      | 4

हम इन मानों का उपयोग इनपुट को पॉलीबीस स्क्वायर पर प्लेनटेक्स्ट में बदलने के लिए करते हैं। यह अंग्रेजी वर्णमाला का 5x5 प्रतिनिधित्व है, जो 'J' को छोड़ता है (कृपया ध्यान दें कि, बच्चे की बात में, 0-गिनती के नियम टेबल पर लागू होते हैं):

  0 1 2 3 4
0 A B C D E
1 F G H I K
2 L M N O P
3 Q R S T U
4 V W X Y Z

स्तंभ के रूप में ओएस की संख्या और पंक्ति की तरह संख्या का उपयोग करके, हम पाते हैं कि प्रत्येक अनुभाग किस वर्ण का प्रतिनिधित्व करता है:

Section    | Num Os | Num As | Character

gogooa     | 2      | 1      | (2,1) -> H
gagooook   | 4      | 0      | (4,0) -> E
aagaaoooy  | 3      | 4      | (3,4) -> Y

जो हमें बताता है कि बच्चा "ही" कह रहा था।

नोट्स :
- यदि किसी वर्ण का प्रतिनिधित्व करने वाले खंड में 4 से अधिक या Os है, तो एक्स्ट्रा को अनदेखा करें, क्योंकि 4 टेबल पर अधिकतम मान है। - इस कार्य के लिए, वाई एक स्वर नहीं है - केवल ए, ई, आई, ओ और यू।

चुनौती

आपका कार्य एक पूर्ण कार्यक्रम बनाना है जो एक इनपुट लेता है, एक शब्द बेबी-स्पीक में, और उसे सादे में प्रिंट करता है।

  • आपका प्रोग्राम अपरकेस, लोअरकेस, और दोनों के मिश्रण में इनपुट लेने में सक्षम होना चाहिए।
  • इनपुट में केवल ASCII वर्णमाला अक्षर (AZ और az) होंगे, जिसमें शिशु शब्दों को अलग करने के लिए एकल स्थान होंगे।
  • आउटपुट टेक्स्ट किसी भी स्थिति में हो सकता है।
  • आपको इनपुट से लेना चाहिए STDINऔर प्लेनटेक्स्ट को प्रिंट करना चाहिए STDOUT। यदि आपकी भाषा में ये नहीं हैं, तो निकटतम समकक्ष का उपयोग करें।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है - लेकिन किसी भी समाधान का स्वागत है।

परीक्षण के मामलों

'GLOOG KAKAAOOO ARGOOO OOOOOGUGUU' -> CODE
'oaka pooopaa gaau augu' -> GOLF
'Aoao U oOOAoa oaoAoo aoAoAOa' -> NAPPY
'GUG gAGaA gOougOou' -> ALE
'OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI' -> HELLO
code-golf  string  cipher 
— FlipTack
स्रोत
3
'GUG gAGaA gOougOou' -> 'ALE'बच्चे पीते हैं एले? : डी
— क्रिति लिथोस
7
केवल सबसे अच्छा: D @KritiiLithos
— FlipTack
1
मामला आवश्यकता अनावश्यक लगता है, है ना? आप जो कुछ भी कर रहे हैं वह एक .toUpperCase()समान फ़ंक्शन कॉल को जोड़ रहा है , वास्तव में उत्तेजक चुनौती नहीं है
— मेयरमोनी
1
gogooa2 ओ का कैसे होता है? और gagooook0 के पास कैसे है ?
— मैजिक ऑक्टोपस Urn
1
दरअसल, @EriktheGolfer, वह है FAG: P
— FlipTack

जवाबों:

6

05AB1E , 46 बाइट्स

lð¡vyžNvyð:}ð¡D€g1›ÏJ©'a¢4‚W5*®'o¢4‚Ws\+A'j-è?

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

चरणों में व्याख्या

  1. शब्दों को बनाने के लिए रिक्त स्थान पर विभाजित करें
  2. अंतरिक्ष के साथ शब्दों में konsonants बदलें
  3. स्वरों के समूह बनाने के लिए रिक्त स्थान पर शब्दों को विभाजित करें
  4. 2 से कम लंबाई वाले स्वर समूहों को हटा दें
  5. गिनती का मिनट (ए) और 4 प्राप्त करें, 5 से गुणा करें
  6. गिनती (ओ) और 4 का मिनट प्राप्त करें
  7. गिनती जोड़ें
  8. वर्णमाला के उस सूचकांक पर पत्र प्राप्त करें ("j" को छोड़कर)
— Emigna
स्रोत
अच्छी नौकरी, जीतने पर बधाई
— FlipTack
मुझे व्यंजन द्वारा बंटवारे का दृष्टिकोण पसंद है, मैंने ऐसा नहीं सोचा था
— फ्लिपकैक
9

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

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

STDIN पर इनपुट दें:

perl -M5.010 baby.pl <<< "OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI"

baby.pl:

#!/usr/bin/perl -a
say map{$A=$O=$_=uc;y/AEIOU/@/c;s/(\B.|.\B)/$$1+=$$1<4/eg;(A..I,K..Z)[5*$A+$O]}@F

यह एक हाल ही में पर्याप्त पर्ल संस्करण मानता है जहां -aइसका अर्थ है -n। यदि आपका पर्ल बहुत पुराना है, तो आपको एक स्पष्ट -nविकल्प जोड़ना होगा ।

यह भी मानता है कि बच्चे एएससीआई स्ट्रिंग्स को सामान्य नहीं कह सकते हैं जो अंकों की तरह शुरू होते हैं 1 this will not work

— टन हास्पेल
स्रोत
यह एक सही धारणा है। मैं इस प्रश्न में निर्दिष्ट करना सुनिश्चित
— करूंगा
6

ब्रेनफक, 656 बाइट्स

+[[>>>,[>++++[<-------->-]]<]<<[>]<-[+[<+>>+<-]----[>>+<<----]>>+[<[-<]<[>]>>-]-<[[-]>+<]>[[-[->]<<+>]<->>>]<<<[>>>+<<<-]<<-]>>>>>[[<+>>+<-]----[>-<----]>--[----<]<[>]>[----<]<[>]>[------<]<[>]>[------<]<[>]><+>[[-]<->]>>]<<<[>->]<[<]>[>[<<<<<+>>>>>>+<-]<<<<]<[-]>>>>[<[>[>+<-]<-]>[-]->[<+>-]>>]<<<[-<----[>-<----]>[>+>+<<-]+>[<->[-]<]<[<]>[[<<<]<+>>>>[>>>]<<<-]>+>--------------[<->[-]]<[-<<<<[<<<]>+>>[>>>]>]<<<<]<[<+<+>>-]>++++[<<[->]>[<]>-]+<<[[-]++++<[-]>>]>[<]<<[>+<-]>>+>->[>+>+<<-]<++++[>>[-<]<[>]<-]>>[[-]++++>[-]]<<<[>]<->>>>[<+>-]<[<<<+>>>-]<<<<[>+++++<-]>[>+>+<<-]<++++++++[>>[-<]<[>]<-]>>[[-]>+<]----[>+<----]>++.[-]+>>>,[<++++[>--------<-]]>]

यह कुछ घंटों के लिए मारने का एक बहुत अच्छा तरीका था।

8-बिट रैपिंग सेल का उपयोग करने वाले एक ब्रेनफैक दुभाषिया की आवश्यकता होती है, जिससे आप सेल 0 से बाएं जा सकते हैं और ,स्टड खाली होने पर 0 का उपयोग करते हैं। मेरे अनुभव में, ये सबसे आम सेटिंग्स हैं।

यह कार्यक्रम वाई को एक स्वर नहीं मानता है, लेकिन अगर ओपी चाहता है कि यह एक आसान तय है।

ऐसा लगता है कि यह लिखना एक चुनौतीपूर्ण काम होगा लेकिन अगर आप भाषा के साथ कुछ परिचित हैं तो कोड में कुछ भी आश्चर्यजनक या नया नहीं है। मानक ब्रेनफैक रणनीति: इनपुट पढ़ें, लेकिन सुनिश्चित करें कि आप प्रत्येक बाइट के बीच खाली कोशिकाओं के एक जोड़े को छोड़ दें, इनपुट के बारे में डेटा संग्रहीत करने के लिए उन खाली कोशिकाओं का उपयोग करें, आपके द्वारा संग्रहीत डेटा का उपयोग यह तय करने के लिए करें कि इसे कैसे बदलना है और अंत में कुछ थूकना है। । इस मामले में यह इनपुट मिल था में, यह सब को अपरकेस में यह आंकड़ा बाहर जो कोशिकाओं स्वर हैं, कि जानकारी फेंक इसे का उपयोग निर्धारित करने के लिए जो कोशिकाओं रहे हैं के बाद सेट करने के लिए अगले स्वर, सब कुछ सेट है कि कुछ करने के लिए एक स्वर के बगल में नहीं है मूल्य जो कभी भी प्रासंगिक नहीं होंगे इसलिए वे बाद में इस तरह से नहीं हैं, और आप मूल रूप से काम कर रहे हैं। वहाँ से आपको बस अपना As और Os गिनना है , गुणा करना हैA5 से Os और J, आउटपुट से बचने के लिए 8 से ऊपर विशेष मामला है। मैंने एक बार में पूरे इनपुट को लेने के बजाय एक बार इस एक शब्द को चुनने का विकल्प चुना, इसलिए मुझे उस कोड का हिस्सा सेट करना पड़ा, जो स्टड को 0 या 32 पर तोड़ने के लिए पढ़ता है, लेकिन यह बहुत बड़ी समस्या नहीं है (बस एक शर्त में 32 से घटाव लपेटो तो ऐसा नहीं होता है यदि मान 0 पहले से ही है, तो आपके द्वारा याद किए गए किसी भी निर्देश <या >निर्देशों के लिए सही है )।

मुझे नहीं पता कि यह कितना उपयोगी होगा क्योंकि मैंने इसे अपने विचारों को वास्तविक स्पष्टीकरण के बजाय सीधे रखने के लिए लिखा था, लेकिन यहां मेरी टिप्पणियों और इसके मूल इंडेंटेशन के साथ कोड है:

+[[>>>,[>++++[<-------->-]]<]get an entire word of input
                            each character lowered by 32
                            two empty cells between characters
                            stops when reaching a space or null byte

any lowercase letters have become uppercase; anything with a value below 65 used
to be an uppercase character; fix it

<<[>]<-[+                for each character until hitting 1:
  [<+>>+<-]              make a backup
  subtract 64 from the character but stop if it hits 0
  ----[>>+<<----]>>+     generate the number 64
  [                      64 times:
    <[                     if the character is not 0:
      -                    subtract 1
      <                    go to a guaranteed 0 cell to break the loop
    ]

    we're either on the character or to the left of it; sync up
    <[>]

  >>-]
  -<[[-]>+<]>            logical NOT of character

  [                      if logical NOT returns true:
    [-[->]<<+>]<-          add 32 to backup of character
  >>>]

  <<<[>>>+<<<-]          move copy over to make room
<<-]
  >>>>>[                 for each character:
  [<+>>+<-]              make copies
  ----[>-<----]>--       check if it's A
  [----<]<[>]>           check if it's E
  [----<]<[>]>           check if it's I
  [------<]<[>]>         check if it's O
  [------<]<[>]>         check if it's U

  IF YOU NEED TO ADD Y; THIS IS THE PLACE

  <+>[[-]<->]            logical NOT to complete vowel check
>>]

<<<[                if the last char is a vowel; prevent a side effect
  >->
]

<[<]>[                 for each character:
  >[                     if it's a vowel:
    <<<<<+>>>>>>+<-          leave a flag to the left and right to show that a
  ]                          vowel is adjacent
<<<<]

<[-]>                  clean up a side effect left behind if first char is vowel

>>>[                   for each char:
  <[                     if it's adjacent to a vowel:
    >[>+<-]<-              move it to the side
  ]
  >[-]-                otherwise; destroy it
  >[<+>-]              move backup over if it exists (subtracting 1)
>>]

all characters without a vowel beside them have been set to 255
all characters with a vowel beside them are set to itself minus 1

notable charaters are: 'A' minus 1 = 64
                       'O' minus 1 = 78

<<<[                 for each character:
  -<----[>-<----]      subtract 64
  >[>+>+<<-]           make a copy
  +>[<->[-]<]<[<]>     logical NOT

  [[<<<]<+>>>>[>>>]<<<-] if NOT returns true; record an A

  >+>--------------  subtract 14 from backup

  [<->[-]]<          logical NOT
  [-<<<<[<<<]>+>>[>>>]>] if NOT returns true; record an O
<<<<]


<[<+<+>>-]           make a backup of A count
>++++[<<[->]>[<]>-]  subtract 4 but don't go below 0
+<<[                   if the char was greater than 3:
  [-]++++<[-]>>          put 4 there
]
>[<]                  resynchronise
<<[>+<-]              if there were fewer than 4 As put the number back

same thing but for the O count

>>+>->[>+>+<<-]       make a backup of O count
<++++[>>[-<]<[>]<-]   subtract 4 but don't go below 0
>>[                     if the char was greater than 3:
  [-]++++>[-]             put 4 there
]
<<<[>]                resynchronise
<->>>>[<+>-]          if there were fewer than 4 Os put the number back

<[<<<+>>>-]<<<<[>+++++<-] A*5 plus B = index of character to output

>[>+>+<<-]            make a backup
<++++++++[>>[-<]<[>]<-] subtract 8 but don't go below 0
>>[[-]>+<]            if the result is nonzero it is late enough in the alphabet
                      that it must be increased by 1 to exclude J as a possible
                      output
----[>+<----]>++      add 65 to make it a letter
.[-]+>>>,             output and get new input
[<++++[>--------<-]]> sub 32 if not 0
]
— undergroundmonorail
स्रोत
यह आश्चर्यजनक है ... और हां, स्वरों से मेरा मतलब है एक, ई, आई, ओ, यू :)
— फ्लिपकार्ट
6

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

alert(prompt().replace(/\S+ ?/g,x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)))

प्रत्येक शब्द (और निम्नलिखित स्थान) को उसके संबंधित अक्षर से बदल देता है।

s.split` `.map().join`` अब 3 बाइट्स है:

alert(prompt().split` `.map(x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)).join``)
— ETHproductions
स्रोत
वर्तमान में चुनौती यह बताती है कि आपको "एक पूरा कार्यक्रम लिखना चाहिए जो [STDIN] से इनपुट लेता है और इसे [STDIN] पर प्रिंट करता है।" इसका मतलब है कि वर्तमान में लिखित फ़ंक्शन के उत्तर की अनुमति नहीं है।
— 16:97 पर CAD97
अच्छा प्रस्तुत है, लेकिन जैसा कि सीएडी ने कहा, यह एक पूर्ण कार्यक्रम होना चाहिए। मैं जावास्क्रिप्ट से बहुत परिचित नहीं हूँ लेकिन मुझे लगता है कि संकेत और चेतावनी STDIN / OUT के लिए सबसे अच्छा समकक्ष है, है ना?
— FlipTack
@ Flp.Tkc हाँ, जब तक आप नोड या किसी अन्य वातावरण का उपयोग नहीं कर रहे हैं। मैं अपना कोड अपडेट कर दूंगा।
— ETHproductions
प्रश्न कहता है या निकटतम समतुल्य है। ब्राउज़र में js के लिए, एक संकेत और चेतावनी काफी करीब हैं
— फ्रेड स्टार्क
5

पर्ल, 159 +1 = 160 बाइट्स

+1 बाइट -n फ़्लैग के लिए। व्हॉट्सएप कोड का हिस्सा नहीं है और केवल पठनीयता के लिए प्रदान किया गया है।

for(split$",lc){
    $b=0;
    @a=sort/([ao](?=[aeiou])|(?<=[aeiou])[ao])/g;
    $b++until$b>$#a||$a[$b]eq o;
    $c=($d=$#a-$b+1)>4?4:$d;
    $b=$b>4?4:$b;
    print+(a..i,k..z)[5*$b+$c];
}

कोड रिक्त स्थान द्वारा इनपुट को विभाजित करता है और आगे बढ़ने से पहले प्रत्येक बच्चे के शब्द को निचले हिस्से में परिवर्तित करता है। रेगेक्स सभी या ओ स्वरों का पता लगाता है जो एक अन्य स्वर के बाद होते हैं, या एक स्वर से आगे बढ़ते हैं, और उन्हें सॉर्ट करते हैं, शुरुआत में एक, ओ के अंत में, फिर पहले 'ओ' के सूचकांक को ढूंढता है। यदि मैचों की शेष संख्या (उर्फ, 'ए' की संख्या 4 से अधिक है, तो हम 4 ए के बारे में परवाह करते हैं, और यदि 4 से अधिक ओ हैं, तो हम 4 ओ की परवाह करते हैं। फिर यह मैट्रिक्स से उपयुक्त अक्षर को खींचता है और प्रिंट करता है, फिर अगले बच्चे के शब्द पर चलता है।

— गेब्रियल बेनामी
स्रोत
4

ब्रेनफक, 283 बाइट्स

,[[<[>-[>>>-<<<----[----[>+<------[>-<------[<[-]>>>>[-]->>[-]<<<<<-]]]]]>[>>>>+
<<<<-]>>+<[>[>+<-]>>[>+<-]<<<-]<,<<[>>>+<<<-]>]>+[<+>[-<<]>[[-]+++++[<++++++>-]<
+<]>>>]<]>>[-]>+>>+[[-]>[<+>-[<+>-[<+>-[<+>[-]]]]]<<<]>->[>+<-[[>+<-]>>+>]>[+>--
--[->]]]+[-<+]>>+++++++++++++[>+++++<-]>.,]

प्रारूपित:

,
[
  [
    <
    [
      >-
      [
        not a
        >>>-<<<
        ----
        [
          not e
          ----
          [
            not i
            >+<
            ------
            [
              not o
              >-<
              ------
              [
                consonant
                <[-]>
                >>>[-]->>[-]<<<<<-
              ]
            ]
          ]
        ]
      ]
      >[>>>>+<<<<-]> >+<
      [
        prev was vowel
        >[>+<-]>>[>+<-]<<<-
      ]
      <,<<[>>>+<<<-]
      >
    ]
    >+
    [
      <+>[-<<]
      >[[-]+++++[<++++++>-]<+<]
      >>>
    ]
    <
  ]
  >>[-]>+>>+
  [
    [-]
    >[<+>-[<+>-[<+>-[<+>[-]]]]]<
    <<
  ]
  >->
  [
    >+<-
    [
      [>+<-]
      >>+>
    ]
    >
    [
      +>----[->]
    ]
  ]
  +[-<+]
  >>+++++++++++++[>+++++<-]
  >.,
]

यह इनपुट में अनुगामी न्यूलाइन के साथ या उसके बिना काम करता है।

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

प्रत्येक वर्ण को मॉड 32 संसाधित किया जाता है (नियंत्रण प्रवाह के साथ जैसे कि मॉड ऑपरेशन को लागू करने वाला कोड केवल प्रोग्राम में एक बार होता है)। यह केस असंवेदनशीलता को सक्षम करता है, साथ ही एक ही मामले में स्पेस कैरेक्टर और ईओएफ को समाप्‍त करता है। एक अनुगामी न्यूलाइन को उसी तरह से व्यवहार किया जाता है J, जो आउटपुट को प्रभावित नहीं करता है।

मेमोरी लेआउट का स्केच:

0 x C c y a A b B

जहां cइनपुट चरित्र है, Cचार मॉड 32 है, xयह है कि क्या यह एक स्वर है, yयह है कि क्या पिछला चार्ट एक स्वर था, Aऔर क्रमशः Bमान्य (स्वरों के आगे) aऔर oवर्णों की गिनती है , aऔर bक्या उनके बड़े बफ़र्स हैं एक आसन्न स्वर है या नहीं इसके आधार पर नकल या साफ हो जाना।

जब एक स्थान या ईओएफ पहुंच जाता है, तो कुछ करतब 4 से अधिक की संख्या को कम करने और पत्र को छोड़ने के लिए किया जाता है J, और फिर डिकोड किए गए वर्ण को मुद्रित किया जाता है।

— मिच श्वार्ट्ज
स्रोत
यह बाइट गिनती में जावा कार्यान्वयन के बहुत करीब है ... आप से
— नफरत करता है
यह एक अपराध है कि यह मेरे तुच्छ समाधान की तुलना में कम अंक है जो दो बार से अधिक है
— अंडरग्राउंडमोरल
@undergroundmonorail जो मुझे एक साथी बनाता है!
— मिच श्वार्ट्ज
3

PHP, 163 बाइट्स

<?php for(;$c=preg_replace('/(?<![AEIOU]).(?![AEIOU])/','',strtoupper($argv[++$i]));$j=min($d[79],4)+5*min($d[65],4),print range(A,Z)[$j+($j>8)])$d=count_chars($c);

अधिक पठनीय संस्करण:

<?php
for (
    ;
    $c = preg_replace(
        '/(?<![AEIOU]).(?![AEIOU])/',
        '',
        strtoupper($argv[++$i])
    );
    $j = min($d[79], 4) + 5 * min($d[65], 4),
    print range(A, Z)[$j + ($j > 8)]
)
    $d = count_chars($c);

टेस्ट:

$ php babytalk.php GLOOG KAKAAOOO ARGOOO OOOOOGUGUU
CODE
$ php babytalk.php oaka pooopaa gaau augu
GOLF
$ php babytalk.php Aoao U oOOAoa oaoAoo aoAoAOa
NAPPY
$ php babytalk.php GUG gAGaA gOougOou
ALE
$ php babytalk.php OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI
HELLO
— chocochaos
स्रोत
3

जावा 8, 272 266 251 249 बाइट्स

interface M{static void main(String[]i){String z="(?=[AEIOU])|(?<=[AEIOU])";for(String s:i[0].split(" ")){int a=s.split("(?i)A"+z+"A",-1).length-1,o=s.split("(?i)O"+z+"O",-1).length-1,t=(a>4?4:a)*5+(o>4?4:o);System.out.printf("%c",t>9?t+66:t+65);}}}

-6 बाइट्स @ जोबा को धन्यवाद ।
-1 बाइट जावा 7 से 8 में परिवर्तित हो रही है, और 14 16 अतिरिक्त बाइट्स प्रिंट-पार्ट को बदलकर सहेजे गए हैं।

स्पष्टीकरण:

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

interface M{                   // Class:
  static void main(String[]i){ //  Main method:
    String z="(?=[AEIOU])|(?<=[AEIOU])";
                               //   Regex-part for look-ahead or look-behind of vowels
    for(String s:i[0].split(" ")){  
                               //    Loop over the program-arguments
      int a=s.split("(?i)A"+z+"A",-1).length-1,
                               //     The amount of A's with adjacent vowels
          o=s.split("(?i)O"+z+"O",-1).length-1,
                               //     The amount of O's with adjacent vowels
          t=(a>4?4:a)          //     If `a` is larger than 4, just take 4, else take `a`
            *5                 //     Multiply it by 5
            +(o>4?4:o);        //     And add 4 if `o` is larger than 4, else take `o`
       System.out.printf("%c", //     Print a character:
        t>9?                   //      If `t` is larger than 9 (index of J)
         t+66                  //       Take character unicode (skipping J)
        :                      //      Else:
         t+65);                //       Take character unicode (prior to J)
    }                          //   End of loop
  }                            //  End of main-method
}                              // End of program
— केविन क्रूज़सेन
स्रोत
1
वर्तमान में चुनौती यह बताती है कि आपको "एक पूरा कार्यक्रम लिखना चाहिए जो [STDIN] से इनपुट लेता है और इसे [STDIN] पर प्रिंट करता है।" इसका मतलब है कि वर्तमान में लिखित फ़ंक्शन के उत्तर की अनुमति नहीं है।
— 16:97 पर CAD97
@ CAD97 धन्यवाद, अतीत को पढ़िए। मैंने उसी के अनुसार अपना उत्तर संपादित किया है।
— केविन क्रूज़सेन
1
ऊपरी केस स्ट्रिंग का उपयोग करने के बजाय, s.split
— Joba
2

पायथन 3, 163 162 157 146 बाइट्स

import re
for W in input().upper().split():S=''.join(re.findall("[AEIOU]{2,}",W)).count;I=min(S('A'),4)*5+min(S('O'),4);print(end=chr(65+I+(I>9)))

2 से बड़े स्वरों के सभी स्ट्रिंग को खोजने के लिए रेगेक्स का उपयोग करता है, 4 और अधिकतम के साथ As और Os को गिनता है, और फिर प्रिंट करता है।

— FlipTack
स्रोत
2

एपीएल, ६०

{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶

ध्यान दें कि ←IO and 0 और ⎕ML ← 3

उदाहरण:

fn←{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶
fn 'Aoao U oOOAoa oaoAoo aoAoAOa'
NAPPY

Dyalog 15.0 में काम करता है , क्योंकि यह एक संस्करण है जिसमें 819 introduced एक स्ट्रिंग को कम करने के लिए पेश किया गया था।

— मोरिस ज़ुक्का
स्रोत
क्या आप सुनिश्चित हैं कि आपने J को छोड़ दिया है और K को नहीं?
— FrownyFrog
1

आर, 261 बाइट्स

मुझे लगता है कि मैंने इस काम को करने के लिए बहुत अधिक समय बिताया है और मेरा मानना ​​है कि यह एक अनावश्यक रूप से जटिल समाधान है, हालांकि यह काम करता है। स्टड से इनपुट लेता है, यह महत्वपूर्ण है कि स्ट्रिंग उद्धरणों में संलग्न है।

x=el(strsplit(toupper(scan(,""))," "))
cat(apply(sapply(c("A","O"),function(y)sapply(sapply(regmatches(x,gregexpr("[AEIOU]{2,}",x,)),paste,collapse=""),function(s)min(sum(el(strsplit(s,""))%in%y),4)))+1,1,function(z)t(matrix(LETTERS[-10],5))[z[1],z[2]]),sep="")

चार नेस्टेड- applyऑफमिली का उपयोग सैद्धांतिक रूप से केवल दो का उपयोग करके कम किया जा सकता है mapply। लेकिन क्योंकि इनपुट्स mapplyएक ही लंबाई के नहीं होंगे, छोटे को पुनर्नवीनीकरण किया जाता है जो चीजों को जटिल करता है और मैं काम करने वाले समाधान का पता नहीं लगा सकता।

अगर किसी को दिलचस्पी है तो मैं बाद में एक असम्बद्ध व्याख्या जोड़ूंगा।

आर-फिडल पर सभी परीक्षण मामलों की कोशिश करें

कृपया ध्यान दें कि यह संस्करण स्टड के बजाय एक फ़ंक्शन तर्क के रूप में इनपुट लेता है क्योंकि scanआर-फिडल पर काम नहीं करता है। इसके अलावा, इसे पढ़ने में आसान बनाने के लिए एक नई पंक्ति जोड़ी।

— Billywob
स्रोत
0

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

import re;f,b,v,n,r,l,t,g,a,o=re.findall,input().lower(),'aeiou',list(range(26)),'[aeiou]','abcdefghiklmnopqrstuvwxyz','',len,'a','o';del n[9],
for w in b.split():
 O,A=g(f(o+r,w))+g(f(r+o,w)),g(f(a+r,w))+g(f(r+a,w))
 if O>4:O=4
 if A>4:A=4
 t+=l[A*5+O]
print(t)

कम गॉकेटेड (टिप्पणियाँ छोटे कोड में चर हैं):

import re
findAll = re.findall #f
babyTalk = input('Baby Talk: ').lower() #b
vowels = 'aeiou' #v
numbers = list(range(26)) #n
del numbers[9]
letters = 'abcdefghiklmnopqrstuvwxyz' #l
finalText = '' #t
length = len #g
regex = '[aeiou]' #r
o = 'o' #o
a = 'a' #a
for word in babyTalk.split(): #w in b
 Os = len(findAll('o[aeiou]', word)) + len(findAll('[aeiou]o', word)) #O
 As = len(findAll('a[aeiou]', word)) + len(findAll('[aeiou]a', word)) #A
 if Os > 4: Os = 4
 if As > 4: As = 4
 print(As, Os)
 finalText += letters[As*5+Os]
 print(finalText)

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

— nedla2004
स्रोत
यह एक शब्द के लिए काम नहीं करता है blaoaoaog: इंटरलेस्ड स्वर एक से अधिक बार गिने जाते हैं, zजब यह होना चाहिए t(हालांकि यह सिर्फ काम करता है aaaooo, हालांकि मैं यह पता नहीं लगा सकता कि क्यों ....)
— CAD97
@ CAD97 क्या आप कह रहे हैं कि aooa p होना चाहिए, n नहीं?
— nedla2004
उद्देश्य से नहीं; aooa== (2,2) == n, aoaoao== (3,3) ==t
— CAD97
बस यह परीक्षण किया और सीएडी सही है, gaoaoaogटी के बजाय जेड प्रिंट करता है। मुझे लगता है कि यह इसलिए है क्योंकि आपका रेगेक्स उठा रहा है [ao,oa,ao,oa,ao], जो मायने रखता है 5,5, फिर इसे 4,4ज़ेड को मुद्रित करता है , मुद्रण। जेड
— फ्लिपटैक
@ Flp.Tkc क्या आप जानते हैं कि इसे कैसे ठीक किया जाए? मैं regex के लिए बहुत नया हूँ।
— nedla2004
0

कोटलिन , 221 209 बाइट्स

अब और अधिक बदसूरत और धीमा, सभी 11 बाइट्स के नाम पर

readLine()!!.toLowerCase().split(" ").map{fun
c(c:Char)=Regex("([aeiou]{2,})").findAll(it).fold(0){a,b->a+b.value.count{it==c}}.let{if(it>4)4 else it}
(('A'..'I')+('K'..'Z'))[c('a')*5+c('o')]}.forEach(::print)

BabyTalk.ktsस्क्रिप्ट के रूप में चलाने के लिए इसे किसी फ़ाइल (उदा। ) में सहेजें । या, fun main(z:Array<String>)=26 से अधिक बाइट्स की लागत के लिए उपरोक्त कोड को सामान्य रूप से तैयार किया जा सकता है और संकलित किया जा सकता है ।

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

इंडेंट:

readLine()!!
    .toLowerCase()
    .split(" ")
    .map {
        fun c(c: Char) =
            Regex("([aeiou]{2,})")
                .findAll(it)
                .fold(0) {
                    a, b ->
                    a + b.value.count { it == c }
                }
                .let { if (it > 4) 4 else it }
        (('A'..'I') + ('K'..'Z'))[c('a') * 5 + c('o')]
    }
    .forEach(::print)
— CAD97
स्रोत
0

PHP, 124 129 121 120 125 बाइट्स

for(;$s=$argv[++$i];print chr((8<$O+=5*$A)+$O+65))for($k=$A=$O=0;$c=_&$s[$k++];$p=$c)$$c+=$$c<4&!trim($p.$s[$k]&__,AEIOU)[1];

कमांड लाइन तर्कों से इनपुट लेता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

टूट - फूट

for(;$s=$argv[++$i];            # loop $s through arguments
    print chr((8<$O+=5*$A)+$O+65)   # 3. map A and O counts to letter, print
)
    for($k=$A=$O=0;                 # 1. reset A and O counters
        $c=$s[$k++]&_;              # 2. loop $c through characters:
        $p=$c)                          # 2. remember current character as previous
        $$c+=                           # 1. increment counter for $c, if ...
            $$c<4&                          # it is < 4 and ...
            !trim($p.$s[$k]&__,AEIOU)[1];   # ... previous or next char is vowel
— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.