เมื่อเด็กเปิดปากพวกเขาไม่เพียง แต่พูดพล่อยๆ จริงๆแล้วพวกเขากำลังพูดในรหัสขั้นสูงที่พิสูจน์ได้สำหรับผู้ใหญ่ ...

Baby-talk Cipher

เมื่อเด็กพูดถึงมันอาจมีลักษณะคล้ายกับgogooa gagooook aagaaoooy แต่ละส่วนที่คั่นด้วยช่องว่างเดี่ยวแทนอักขระ (ตัวอย่างด้านบนแสดงถึง 3 ตัวอักษร)

ในการถอดรหัสส่วนเราจะต้องนับจำนวน As และ Os ที่มี อย่างไรก็ตามเราจะนับเฉพาะสิ่งที่อยู่ติดกับสระอื่นเท่านั้น ตัวอย่างเช่น A ใน 'ปิดปาก' จะไม่นับ แต่ทั้ง A และ O ใน 'gaog' จะเป็นเช่นนั้น

การนับตัวอย่างด้านบนจะมีลักษณะเช่นนี้:

Section    | Num Os | Num As

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

จากนั้นเราใช้ค่าเหล่านี้เพื่อแปลงอินพุตให้เป็นข้อความธรรมดาบนสแควร์ Polybius นี่คือการแสดงตัวอักษรภาษาอังกฤษ 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

การใช้จำนวน Os เป็นคอลัมน์และจำนวน As เป็นแถวเราจะพบว่าอักขระแต่ละตัวแสดงถึง:

Section    | Num Os | Num As | Character

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

ซึ่งบอกเราว่าเด็กแค่พูดว่า "HEY"

หมายเหตุ :
- หากส่วนที่เป็นตัวแทนของตัวละครมีมากกว่า 4 As หรือ Os ให้ละเว้นค่าพิเศษเนื่องจาก 4 เป็นค่าสูงสุดของตาราง - สำหรับภารกิจนี้ Y ไม่ใช่สระ - เฉพาะ A, E, I, O และ U.

ความท้าทาย

งานของคุณคือการสร้างโปรแกรมเต็มรูปแบบซึ่งรับหนึ่งอินพุตคำพูดสำหรับเด็กแล้วพิมพ์ออกมาเป็นข้อความธรรมดา

• โปรแกรมของคุณจะต้องสามารถป้อนข้อมูลเป็นตัวพิมพ์ใหญ่ตัวพิมพ์เล็กและทั้งสองอย่าง
• ข้อมูลที่ป้อนจะมีเพียงตัวอักษรตัวอักษร ASCII (AZ และ az) โดยมีช่องว่างเดียวเพื่อแยกคำพูดของเด็ก
• ข้อความเอาต์พุตสามารถเป็นได้ทุกกรณี
• คุณควรใช้ข้อมูลจากและพิมพ์ธรรมดาบนSTDIN STDOUTหากภาษาของคุณไม่มีสิ่งเหล่านี้ให้ใช้เทียบเท่าที่ใกล้ที่สุด
• นี่คือcode-golfดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์จะเป็นผู้ชนะ - แต่ก็ยินดีต้อนรับทางออกใด ๆ

กรณีทดสอบ

'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

05AB1E , 46 ไบต์

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

ลองออนไลน์!

คำอธิบายในขั้นตอน

1. แบ่งช่องว่างเพื่อสร้างคำ
2. แทนที่ konsonants เป็นคำด้วยช่องว่าง
3. แบ่งคำในช่องว่างเพื่อจัดกลุ่มของสระ
4. ลบกลุ่มเสียงสระที่มีความยาวน้อยกว่า 2
5. รับจำนวนนับขั้นต่ำ (a) และ 4 คูณด้วย 5
6. รับค่า min (o) และ 4
7. เพิ่มจำนวน
8. รับตัวอักษรที่ดัชนีของตัวอักษรนั้น (ยกเว้น "j")

Perl, 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

นี้จะถือว่าล่าสุดรุ่น Perl พอที่หมายถึง-a -nถ้า Perl ของคุณเก่าเกินไปคุณจะต้องเพิ่ม-nตัวเลือกที่ชัดเจน

นอกจากนี้ยังถือว่าเด็กไม่สามารถพูดสตริง ASCII ทั่วไปที่เริ่มต้นด้วยตัวเลขเช่น 1 this will not work

brainfuck, 656 ไบต์

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

นี่เป็นวิธีที่ดีในการฆ่าสองสามชั่วโมง

ต้องใช้ล่าม brainfuck ที่ใช้เซลล์ห่อแบบ 8 บิตช่วยให้คุณออกจากเซลล์ 0 และส่งคืน 0 ถ้า,ใช้เมื่อ stdin ว่างเปล่า จากประสบการณ์ของฉันนี่เป็นการตั้งค่าที่พบได้บ่อยที่สุด

โปรแกรมนี้ไม่ได้พิจารณาเสียงสระของ Y แต่ถ้า OP ต้องการให้มันเป็นการแก้ไขที่ง่าย

ดูเหมือนว่าการเขียนนี้จะเป็นงานที่น่ากลัว แต่ถ้าคุณมีความคุ้นเคยกับภาษาที่ไม่มีอะไรแปลกใหม่หรือแปลกใหม่ในรหัส กลยุทธ์ brainfuck มาตรฐาน: อ่านอินพุต แต่ให้แน่ใจว่าคุณปล่อยให้เซลล์ว่างสองสามตัวระหว่างแต่ละไบต์ใช้เซลล์ว่างเหล่านั้นเพื่อเก็บข้อมูลเกี่ยวกับอินพุตใช้ข้อมูลที่คุณเก็บไว้เพื่อตัดสินใจว่าจะแปลงมันและคายบางอย่างออกมาในตอนท้าย . ในกรณีนี้มันได้รับอินพุตให้ตั้งค่าเป็นตัวพิมพ์ใหญ่คิดว่าเซลล์ใดเป็นสระทิ้งข้อมูลนั้นหลังจากใช้เพื่อกำหนดว่าเซลล์ใดติดกับสระตั้งค่าทุกอย่างที่ไม่ได้อยู่ใกล้กับสระ คุณค่าที่ไม่เคยมีความเกี่ยวข้องดังนั้นพวกเขาจึงไม่ได้อยู่ในภายหลังและโดยทั่วไปคุณจะทำเสร็จแล้ว จากนั้นคุณก็ต้องนับของคุณAและOs คูณAs 5 และเพิ่มจำนวนOs, กรณีพิเศษอะไรก็ตามที่สูงกว่า 8 เพื่อหลีกเลี่ยง J และเอาท์พุท ฉันเลือกที่จะจัดการคำนี้ทีละคำแทนที่จะป้อนข้อมูลทั้งหมดในครั้งเดียวดังนั้นฉันต้องตั้งค่าส่วนของรหัสที่อ่าน stdin ให้หยุดที่ 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
]

JavaScript (ES6), 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``)

Perl, 159 +1 = 160 bytes

+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];
}

รหัสจะแยกอินพุตด้วยช่องว่างและแปลงคำแต่ละคำให้เป็นตัวพิมพ์เล็กก่อนที่จะดำเนินการต่อ Regex ค้นหาสระทั้งหมดหรือสระที่ตามมาด้วยสระอื่นหรือถูกนำหน้าด้วยสระและเรียงลำดับให้เป็นสระในตอนเริ่มต้นและท้ายที่สุดจะพบดัชนีของ 'o' ตัวแรก หากจำนวนการจับคู่ที่เหลืออยู่ (aka จำนวนของ 'a's) มากกว่า 4 เราก็สนใจ 4 a และถ้ามีมากกว่า 4 o เราจะสนใจ 4 o จากนั้นมันจะดึงตัวอักษรที่เหมาะสมออกมาจากเมทริกซ์แล้วพิมพ์ออกมา

Brainfuck, 283 ไบต์

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

จัดรูปแบบ:

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

สิ่งนี้ทำงานได้โดยมีหรือไม่มีบรรทัดใหม่ต่อท้ายในอินพุต

ลองออนไลน์

อักขระแต่ละตัวถูกประมวลผล mod 32 (ด้วยโฟลว์ควบคุมเช่นว่าโค้ดที่ใช้การดำเนินการ mod จะเกิดขึ้นเพียงครั้งเดียวในโปรแกรม) สิ่งนี้เปิดใช้งานการคำนึงถึงขนาดตัวพิมพ์และการย่ออักขระช่องว่างและ EOF ลงในเคสเดียว บรรทัดใหม่ต่อท้ายจะได้รับการปฏิบัติเช่นเดียวกับJที่ไม่ส่งผลกระทบต่อการส่งออก

ร่างของเค้าโครงหน่วยความจำ:

0 x C c y a A b B

โดยที่cอักขระอินพุตCคือ char mod 32 xคือว่าเป็นเสียงสระyหรือไม่คืออักขระก่อนหน้านี้เป็นสระAและBเป็นจำนวนที่ถูกต้อง (ถัดจากสระ) aและoตัวอักษรตามลำดับaและbเป็นบัฟเฟอร์ตามลำดับที่ ได้รับการคัดลอกหรือล้างขึ้นอยู่กับว่ามีเสียงสระ

เมื่อถึงช่องว่างหรือ EOF การเล่นกลบางอย่างจะทำเพื่อลดจำนวนมากกว่า 4 และข้ามตัวอักษรJจากนั้นอักขระถอดรหัสจะถูกพิมพ์

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

Java 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 ไบต์ขอบคุณที่@Joba
-1 ไบต์แปลงจาก Java 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

Python 3, 163 162 157 146 bytes

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

ใช้ regex เพื่อค้นหาสตริงของสระที่ใหญ่กว่า 2 ทั้งหมดนับเป็นและ Os ด้วยสูงสุด 4 แล้วพิมพ์

APL, 60

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

โปรดทราบว่า⎕IO← 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 8 ได้รับการแนะนำให้ใช้ตัวพิมพ์เล็กสตริง

Pyth, 64 ไบต์

อาจจะสามารถเล่นกอล์ฟต่อไปได้ ลองที่นี่!

L?<b5b4DebK+ds:rbZ"[aeiou]{2,}"1J+*/K\a5y/K\oR@G?<J9JhJu+GeHcQd"

R, 261 ไบต์

ฉันคิดว่าฉันใช้เวลามากเกินไปในการทำงานและฉันเชื่อว่านี่เป็นวิธีการแก้ปัญหาที่ไม่จำเป็นแม้ว่าจะใช้งานได้ก็ตาม รับอินพุตจาก stdin เป็นสิ่งสำคัญที่สตริงจะอยู่ในเครื่องหมายคำพูด

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จะไม่ยาวเท่ากันจึงทำให้ชิ้นที่สั้นกว่านั้นถูกรีไซเคิลซึ่งทำให้สิ่งต่าง ๆ ยุ่งยากและฉันไม่สามารถหาวิธีแก้ปัญหาที่ทำงานได้

หากใครมีความสนใจฉันจะเพิ่มคำอธิบายที่ไม่ดี

ลองเคสทดสอบทั้งหมดบนซอ

โปรดทราบว่ารุ่นนี้ใช้การป้อนข้อมูลเป็นอาร์กิวเมนต์ฟังก์ชั่นแทนจาก stdin เพราะscanไม่ทำงานบนซอ นอกจากนี้ยังเพิ่มบรรทัดใหม่เพื่อให้อ่านง่ายขึ้น

Python 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)

หัก Golfed (ความคิดเห็นเป็นตัวแปรในรหัสย่อ):

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)

ลองออนไลน์!

Kotlin , 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)

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

J , 109 ไบต์

echo{&(u:97+i.26)(+8<[)5#.4<.'AO'+/@e."1 0/~(;@#~1<#@>)@(</.~0+/\@,}.~:&(e.&'AEOUI')}:);._1' ',toupper 1!:1]3

ลองออนไลน์!