Khi em bé mở miệng, chúng không chỉ phun ra tiếng vô nghĩa. Họ thực sự đang nói chuyện trong một mật mã chứng minh người lớn rất tiên tiến ...

Mật mã Baby-talk

Khi bé nói chuyện, nó có thể trông giống như gogooa gagooook aagaaoooy Mỗi phần tách biệt một không gian đại diện cho một ký tự (vì vậy ví dụ trên đại diện cho 3 ký tự).

Để giải mã một phần, chúng ta phải đếm số lượng As và Os. Tuy nhiên, chúng tôi chỉ tính những người liền kề với một nguyên âm khác. Ví dụ: A trong 'gag' sẽ không được tính, nhưng cả A và O trong 'gaog' sẽ.

Đếm ví dụ trên sẽ như thế này:

Section    | Num Os | Num As

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

Sau đó, chúng tôi sử dụng các giá trị này để chuyển đổi đầu vào thành bản rõ trên hình vuông Polybius. Đây là một đại diện 5x5 của bảng chữ cái tiếng Anh, bỏ qua 'J' (xin lưu ý rằng, trong quy tắc đếm bé, nói 0 áp dụng cho bảng):

  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

Sử dụng số lượng Os làm cột và số lượng Như là hàng, chúng tôi tìm thấy mỗi ký tự đại diện cho mỗi phần:

Section    | Num Os | Num As | Character

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

Điều đó cho chúng tôi biết rằng đứa bé chỉ đang nói "HEY".

Lưu ý :
- Nếu một phần đại diện cho một ký tự có nhiều hơn 4 As hoặc Os, hãy bỏ qua các phần bổ sung, vì 4 là giá trị tối đa trên bảng. - Đối với nhiệm vụ này, Y không phải là nguyên âm - chỉ có A, E, I, O và U.

Các thách thức

Nhiệm vụ của bạn là tạo ra một chương trình đầy đủ , bao gồm một đầu vào, một từ trong tiếng trẻ con và in nó trong bản rõ.

• Chương trình của bạn phải có thể lấy đầu vào bằng chữ hoa, chữ thường và kết hợp cả hai.
• Đầu vào sẽ chỉ chứa các chữ cái bảng chữ cái ASCII (AZ và az), với các khoảng trống để phân cách các từ bé.
• Văn bản đầu ra có thể trong mọi trường hợp.
• Bạn nên lấy đầu vào từ STDINvà in bản rõ trên STDOUT. Nếu ngôn ngữ của bạn không có những thứ này, hãy sử dụng tương đương gần nhất.
• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng - nhưng mọi giải pháp đều được hoan nghênh.

Các trường hợp thử nghiệm

'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 byte

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

Hãy thử trực tuyến!

Giải thích theo các bước

1. phân chia trên khoảng trắng để tạo thành từ
2. thay thế từ trong từ bằng khoảng trắng
3. chia các từ trên khoảng trắng để tạo thành các nhóm nguyên âm
4. loại bỏ các nhóm nguyên âm có chiều dài ngắn hơn 2
5. lấy số đếm nhỏ (a) và 4, nhân với 5
6. lấy tối thiểu số đếm (o) và 4
7. thêm số lượng
8. nhận thư tại chỉ mục của bảng chữ cái (không bao gồm "j")

Perl, 82 byte

Bao gồm +1 cho -a

Cung cấp đầu vào trên 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

Điều này giả định một phiên bản perl đủ gần đây trong đó -angụ ý -n. Nếu perl của bạn quá cũ, bạn sẽ cần thêm một -ntùy chọn rõ ràng .

Nó cũng cho rằng các em bé không thể nói các chuỗi ASCII chung bắt đầu bằng các chữ số như 1 this will not work

Brainfuck, 656 byte

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

Đây là một cách khá hay để giết một vài giờ.

Yêu cầu trình thông dịch brainfuck sử dụng các ô gói 8 bit, cho phép bạn đi bên trái từ ô 0 và trả về 0 nếu ,được sử dụng khi stdin trống. Theo kinh nghiệm của tôi, đây là những cài đặt phổ biến nhất.

Chương trình này không coi Y là nguyên âm, nhưng nếu OP muốn nó là một sửa chữa dễ dàng.

Có vẻ như viết nó sẽ là một nhiệm vụ khó khăn nhưng nếu bạn có một chút quen thuộc với ngôn ngữ thì không có gì đáng ngạc nhiên hoặc mới trong mã. Chiến thuật Brainfuck tiêu chuẩn: Đọc đầu vào nhưng đảm bảo bạn để lại một vài ô trống giữa mỗi byte, sử dụng các ô trống đó để lưu trữ dữ liệu về đầu vào, sử dụng dữ liệu bạn đã lưu trữ để quyết định cách chuyển đổi và nhổ cái gì đó ở cuối . Trong trường hợp này, nó nhận được đầu vào, đặt tất cả thành chữ hoa, tìm ra các ô nào là nguyên âm, vứt bỏ thông tin đó sau khi sử dụng nó để xác định các ô nào bên cạnh nguyên âm, đặt mọi thứ không nằm cạnh nguyên âm thành một số giá trị sẽ không bao giờ có liên quan để chúng không bị cản trở và về cơ bản bạn đã hoàn thành. Từ đó bạn chỉ cần đếm As và Os của mình, nhân lênAs bằng 5 và thêm số Os, trường hợp đặc biệt bất cứ điều gì trên 8 để tránh J và đầu ra. Tôi đã chọn xử lý một từ này cùng một lúc, thay vì lấy toàn bộ đầu vào cùng một lúc, vì vậy tôi phải thiết lập phần mã đọc stdin để ngắt ở 0 hoặc 32, nhưng đó không phải là vấn đề quá lớn (chỉ cần trừ 32 trong một điều kiện để nó không xảy ra nếu giá trị đã là 0, sau đó sửa cho bất kỳ <hoặc >hướng dẫn nào bạn bỏ lỡ sau này).

Tôi không biết nó sẽ hữu ích như thế nào vì tôi đã viết nó chủ yếu để giữ cho suy nghĩ của tôi thẳng hơn là một lời giải thích thực sự, nhưng đây là đoạn mã với các bình luận của tôi và sự thụt ban đầu của nó:

+[[>>>,[>++++[<-------->-]]<]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 byte

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

Thay thế từng từ (và khoảng trắng sau) bằng chữ cái tương ứng.

s.split` `.map().join`` dài hơn 3 byte:

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 byte

+1 byte cho cờ -n. Khoảng trắng không phải là một phần của mã và chỉ được cung cấp để dễ đọc.

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

Mã phân tách đầu vào theo khoảng trắng và chuyển đổi từng từ bé thành chữ thường trước khi tiếp tục. Regex tìm thấy tất cả các nguyên âm a hoặc o được theo sau bởi một nguyên âm khác hoặc được đặt trước bởi một nguyên âm và sắp xếp chúng, ở đầu, o ở cuối, sau đó tìm chỉ số của 'o' đầu tiên. Nếu số lượng trận đấu còn lại (còn gọi là số 'a) lớn hơn 4, thì chúng tôi quan tâm đến 4 a và nếu có nhiều hơn 4 giờ, chúng tôi quan tâm đến 4 giờ. Sau đó, nó kéo chữ cái thích hợp ra khỏi ma trận và in nó, sau đó chuyển sang từ bé tiếp theo.

Brainfuck, 283 byte

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

Định dạng:

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

Điều này hoạt động có hoặc không có một dòng mới trong đầu vào.

Hãy thử trực tuyến.

Mỗi ký tự được xử lý mod 32 (với luồng điều khiển sao cho mã thực hiện thao tác mod chỉ xảy ra một lần trong chương trình). Điều này cho phép không nhạy cảm trường hợp, cũng như thu gọn ký tự khoảng trắng và EOF thành một trường hợp duy nhất. Một dòng mới được xử lý giống như J, không ảnh hưởng đến đầu ra.

Phác thảo bố cục bộ nhớ:

0 x C c y a A b B

nơi clà nhân vật đầu vào, Clà char mod 32, xlà cho dù đó là một nguyên âm, ylà liệu char trước là một nguyên âm, Avà Blà những tội danh hợp lệ (bên cạnh nguyên âm) avà oký tự tương ứng, và avà blà bộ đệm tương ứng của họ được sao chép hoặc xóa tùy thuộc vào việc có một nguyên âm liền kề.

Khi đạt đến một khoảng trắng hoặc EOF, một số trò tung hứng được thực hiện để giảm số lượng lớn hơn 4 và bỏ qua chữ cái J, sau đó ký tự được giải mã được in.

PHP, 163 byte

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

Phiên bản dễ đọc hơn:

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

Các xét nghiệm:

$ 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 byte

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 byte nhờ @Joba .
-1 byte chuyển đổi từ Java 7 thành 8 và 14 16 byte bổ sung được lưu bằng cách thay đổi phần in.

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Sử dụng regex để tìm tất cả các chuỗi nguyên âm lớn hơn 2, đếm As và Os với tối đa là 4, và sau đó in.

APL, 60

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

Lưu ý rằng ⎕IO ← 0 và ⎕ML ← 3

Thí dụ:

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

Hoạt động trong Dyalog 15.0 , vì đây là phiên bản trong đó 819⌶ được giới thiệu để viết thường một chuỗi.

Bình thường, 64 byte

Có lẽ có thể được chơi golf hơn nữa. Hãy thử nó ở đây!

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

R, 261 byte

Tôi nghĩ rằng tôi đã dành quá nhiều thời gian chỉ để làm việc này và tôi tin rằng đây là một giải pháp phức tạp không cần thiết, mặc dù nó hoạt động. Lấy đầu vào từ stdin, điều quan trọng là chuỗi được đặt trong dấu ngoặc kép.

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

Về applymặt lý thuyết, việc sử dụng bốn gia đình lồng nhau có thể giảm xuống chỉ còn hai bằng cách sử dụng mapplythay thế. Nhưng vì các yếu tố đầu vào mapplysẽ không có cùng độ dài, nên đầu vào ngắn hơn được tái chế làm phức tạp mọi thứ và tôi không thể tìm ra giải pháp hiệu quả.

Nếu bất cứ ai quan tâm tôi sẽ thêm một lời giải thích vô căn cứ sau này.

Hãy thử tất cả các trường hợp thử nghiệm trên R-fiddle

Xin lưu ý rằng phiên bản này lấy đầu vào làm đối số chức năng thay vì từ stdin vì scankhông hoạt động trên R-fiddle. Hơn nữa, thêm một dòng mới để dễ đọc hơn.

Python 3, 262 byte

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)

Ít đánh gôn (Các ý kiến ​​là các biến trong mã rút gọn):

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)

Hãy thử trực tuyến!

Kotlin , 221 209 byte

Bây giờ nhiều hơn xấu xí và chậm, tất cả trong tên của 11 byte

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)

Lưu nó vào một tệp (ví dụ BabyTalk.kts) để chạy dưới dạng tập lệnh. Hoặc, đoạn mã trên có thể được thêm vào fun main(z:Array<String>)=và được biên dịch bình thường với chi phí thêm 26 byte.

Hãy thử trực tuyến!

Thụt lề:

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 byte

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

Lấy đầu vào từ các đối số dòng lệnh. Chạy với -nrhoặc thử trực tuyến .

phá vỡ

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 byte

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

Hãy thử trực tuyến!