Nguyên âm vần: Táo và Chuối

Có một bài hát thiếu nhi truyền thống lặp đi lặp lại cùng một văn bản, chỉ mỗi lần mỗi nguyên âm được thay thế bằng một nguyên âm ngẫu nhiên, nhưng không đổi trong khổ thơ hiện tại.

Thử thách

Mục tiêu là đề xuất mã ngắn nhất thực hiện chuyển đổi như vậy trên văn bản đầu vào.

Quy tắc

1. Bạn phải in vần nhiều lần vì có nguyên âm riêng biệt trong đó.
2. Mỗi bản in phải được phân tách bằng dấu ngắt dòng (kết hợp nền tảng cụ thể của \nvà\r được chấp nhận).
3. Đối với phép lặp i, thay thế mỗi nguyên âm bằngi nguyên âm riêng biệt thứ trong văn bản gốc.
4. Văn bản đầu vào là một chuỗi các ký tự ASCII có thể in được (phạm vi [32, 126] .
5. Đầu vào sẽ không chứa ngắt dòng nhúng.
6. Chỉ các ký tự nguyên âm phải bị ảnh hưởng, khác phải được xuất chính xác như đầu vào.
7. Chỉ các ký tự nguyên âm mới được tính: nguyên âm mũi, mặc dù nghe giống như nguyên âm (như trong tiếng Pháp "Tintin" ), không được xử lý như một nguyên âm đơn.
8. Trường hợp quan trọng đối với đầu ra, nhưng là vị trí (thay thế nguyên âm chữ hoa được thực hiện bằng nguyên âm thay thế chữ hoa)
9. Nguyên âm chữ hoa không khác biệt so với bản sao chữ thường của chúng (tức là a<=>A )
10. Nguyên âm liên tiếp luôn được xem xét riêng biệt (nghĩa là Boatmang lại cả hai BootvàBaat )
11. Vì chữ cái yđại diện cho một nguyên âm hoặc danh từ phụ âm (như chúng ta đang nói tiếng Anh), nên việc xử lý nó như một nguyên âm hoặc một phụ âm được cho phép, tuy nhiên câu trả lời phải nói rõ rằng họ có xử lý ynhư một nguyên âm hay không.

Ví dụ:

Chào thế giới

Hello world!

cho:

Helle werld!
Hollo world!

Trích từ văn bản gốc tiếng Pháp (dịch), yđược xử lý như một nguyên âm:

An elephant that was rambling all gently in the woods...

cho:

An alaphant that was ramblang all gantla an tha waads...
En elephent thet wes rembleng ell gentle en the weeds...
In iliphint thit wis rimbling ill gintli in thi wiids...
Yn ylyphynt thyt wys rymblyng yll gyntly yn thy wyyds...
On olophont thot wos romblong oll gontlo on tho woods...

Lưu ý hành vi trên nguyên âm chữ hoa hàng đầu: trường hợp được giữ ở chỉ mục của nó (quy tắc 8 và 9).

Ví dụ vô nghĩa

Đầu vào không chứa bất kỳ nguyên âm nào, như:

lgn@hst:~$ rm -rf ./* ~ /

phải tạo ra không có đầu ra, hoặc ngắt dòng đơn.

Nguyên âm đơn đầu vào

Đầu vào chứa một nguyên âm đơn là đầu ra.

Dad sat at a car and saw a fat bat.

cho:

Dad sat at a car and saw a fat bat.

Đây là môn đánh gôn , vì vậy, mã số ít nhất sẽ thắng (không có gì ngoài vinh quang PPCG vĩnh cửu)!

Võng mạc , 45 byte

~(K`A\EI\OU
L$`\\?(.)
./$1/i&$*\T`Vv`5*$&$L$&

Hãy thử trực tuyến! Không được tính ylà một nguyên âm. Giải trình:

K`A\EI\OU

Thay thế văn bản bằng chuỗi ký tự A\EI\OU.

L$`\\?(.)

Khớp từng chữ cái tùy ý trước dấu gạch chéo ngược.

./$1/i&$*\T`Vv`5*$&$L$&

Xuất ra một dòng mã Retina cho mỗi chữ cái.

~(

Đánh giá mã được tạo (hiển thị bên dưới) bằng cách sử dụng đầu vào ban đầu. Các .nguyên nhân mã không xuất ra bộ đệm (cuối cùng). Các /<vowel>/i&nguyên nhân phần còn lại của dòng để chạy chỉ khi đầu vào có chứa các nguyên âm nhất định (case-insensitively). Các *nguyên nhân khiến kết quả của dòng bị bỏ qua, do đó nguyên âm tiếp theo có thể được kiểm tra. Các \nguyên nhân khiến kết quả được in trên dòng riêng của nó trước khi nó bị bỏ qua. Các T`Vv`AAAAAatransliterates hoa Vowels để AAAAAs và tất cả chữ thường vowels tới a. \Alà một lối thoát đề cập đến ASCII 07 (BEL), nhưng E, không phải là một lớp nhân vật, nhưng may mắn thay, nó cũng không phải là một lối thoát.)O và olà các lớp ký tự tích hợp cần được thoát để đưa ra các giá trị theo nghĩa đen của chúng (e

./A/i&*\T`Vv`AAAAAa
./E/i&*\T`Vv`\E\E\E\E\E\e
./I/i&*\T`Vv`IIIIIi
./O/i&*\T`Vv`\O\O\O\O\O\o
./U/i&*\T`Vv`UUUUUu

Ruby , 78 byte

->s{s.downcase.scan(/[aeiou]/).uniq.map{|v|s.tr"AEIOUaeiou",v.upcase*5+v}*?\n}

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

Một cách tiếp cận nhanh chóng và ngây thơ. Y không được coi là một nguyên âm.

bash, 96 byte

Hai giải pháp có độ dài bằng nhau:

v=aeiouAEIOU;for x in `grep -o [$v]<<<$1|sed 's/./\L&&&&&\U&/'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}
v=aeiouAEIOU;for x in `tr -cd $v<<<$1|sed 's/./\L&&&&&\U&\n/g'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}

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

Đưa đầu vào làm đối số dòng lệnh và xuất ra STDOUT.

05AB1E (di sản) , 19 byte

(Một cách gián tiếp) đã lưu một byte nhờ Kevin (in trực tiếp bên trong vòng lặp thay vì tham gia, chỉ hoạt động trong phiên bản cũ).

lžMÃÙεžMDu«s5×Du«‡=

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

Sử dụng Elixir viết lại, 20 byte

lžMÃÙεžMDu«s5×Du«‡}»

Hãy thử trực tuyến! (không cóy) | Hãy thử trực tuyến! (vớiy,žMđược thay thế bằngžO- áp dụng tương tự cho phiên bản cũ)

Làm thế nào nó hoạt động

lžMÃÙεžMDu«s5×Du«‡}»     Full program. Example: "Hello"
l                        Convert the input to lowercase. "Hello" –> "hello"
 žMÃ                     Keep only lowercase vowels. "hello" –> "eo"
    Ù                    Remove duplicates. "eo" –> "eo"
     ε            }      For each of the characters (example with "e"):
      žMDu«              Yield "aeiouAEIOU"
           s5×           Swap, and repeat the current char 5 times. "e" –> "eeeee"
              Du«        Duplicate, uppercase and merge. "eeeee" –> "eeeeeEEEE"
                 ‡       Transliteration. For each item in B, replace it in A with
                         the corresponding item in C.
                   »     Join on newlines.

Japt v2.0a0 -R, 24 22 byte

Xử lý ynhư một nguyên âm. Thay đổi cả lần xuất hiện của \yđể \vđối xử với nó như một phụ âm.

v f\y â £r\y_Xc^H*ZøZu

Thử nó

Giải trình

v                          :Lowercase
   \y                      :RegEx /[aeiouy]/gi (\v is /[aeiou]/gi)
  f                        :Get all matches as an array
      â                    :Deduplicate
        £                  :Map each X
         r\y               :  Replace all matches of the RegEx above in the input
             _             :  Pass matches through a function as Z
              Xc^          :    XOR the character code of X with
                 H*        :     32 multiplied by
                   Zø      :     Does Z contain
                     Zu    :      Uppercase Z
                           :Implicitly join with newlines and output

Thạch ,  23 20 18  17 byte

-2 Cảm ơn Erik the Outgolfer

ØcŒHZx5fƇðØc,yð€Y

Để điều trị y như một nguyên âm thay thế cả hai cbằngy s.

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

Làm sao?

ØcŒHZx5fƇðØc,yð€Y - Link: list of characters, S
Øc                - vowels -> "AEIOUaeiou"
  ŒH              - split in half -> ["AEIOU", "aeiou"]
    Z             - transpose -> ["Aa", "Ee", "Ii", "Oo", "Uu"]
     x5           - times 5 -> ["AAAAAaaaaa", "EEEEEeeeee", "IIIIIiiiii", "OOOOOooooo", "UUUUUuuuuu"]
        Ƈ         - filter keep if:
       f          -   filter keep only -> those of X which have required vowels
                  -                       ...i.e. if S = "blah" then ["AAAAAaaaaa"]
         ð    ð€  - dyadic chain for €ach:
          Øc      -   vowels -> "AEIOUaeiou"
            ,     -   pair       e.g. ["AEIOUaeiou","AAAAAaaaaa"]
             y    -   translate  e.g. swap A for A, E for A, ...
                Y - join with newlines

Màu đỏ , 229 byte

Lấy ymột nguyên âm không

func[s][v: charset"aoeiu"w: charset"AOEIU"p: copy""parse s[any[[copy c[v | w](if not find p c[append p c lowercase c
parse s[any[[copy n to[v | w | end]](prin n)opt[v(prin c)|[w(prin uppercase copy c)]| skip]]]print""])]| skip]]]

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

Hơi dễ đọc hơn:

f: func [ s ] [
    v: charset "aoeiu"
    w: charset "AOEIU"
    p: copy ""
    parse s[ 
        any [
            [ copy c [ v | w ]
                ( if not find p c [ 
                    append p c
                    lowercase c
                    parse s [
                        any [
                            [ copy n to [ v | w | end ] ]
                                 ( prin n )
                            opt [ v ( prin c )
                                | [ w ( prin uppercase copy c ) ]
                                | skip
                                ]
                            ] 
                        ]
                    print ""
                ] )
            ]
            | skip
        ]
    ]
]

R , 138 , 129 byte

function(x,U=utf8ToInt,a=U(V<-'aeiouAEIOU'))for(i in (which(a%in%U(x))-1)%%5)cat(chartr(V,intToUtf8(rep(a[i+c(1,6)],e=5)),x),'
')

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

• y không được coi là một nguyên âm

Python, 129 119 112 byte

import re
f=lambda s:'\n'.join(r('[AEIOU]',v.upper(),r('[aeiou]',v,s))for v in'aeiou'if v in s.lower());r=re.sub

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

Không điều trị $y$ như nguyên âm.

-7 byte nhờ @ Mr.Xcoder

JavaScript (Node.js) , 99 byte

Xử lý $y$ như một phụ âm.

s=>(g=F=>Buffer(s).map(c=>2130466>>c&c>64?F(c):c)+`
`)(v=>g[v&=31]||(g[v]=S+=g(c=>c&96|v)),S='')&&S

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

Đã bình luận

s => (                   // s = input string
  g = F =>               // g = helper function taking a callback function F
    Buffer(s)            // turn s into a Buffer
    .map(c =>            // for each ASCII code c in s:
      2130466            //   2130466 is a vowel bitmask: 1000001000001000100010
                         //                               u     o     i   e   a
      >> c               //   the ECMAScript specification enforces that the shiftCount is
                         //   the result of masking out all but the least significant 5 bits
      & c > 64           //   also make sure to ignore non-letter characters
      ?                  //   if a vowel is identified:
        F(c)             //     invoke F with c
      :                  //   else:
        c                //     just yield c
    ) + `\n`             // end of map(); coerce back to a string and append a newline
  )(v =>                 // invoke g with a callback that takes v:
    g[v &= 31] || (      //   unless this vowel has already been encountered:
      g[v] =             //     mark it as encountered
      S +=               //     and append to the output string S
      g(                 //     the result of another call to g:
        c => c & 96 | v  //       where vowels are replaced with v, using the original case
      )                  //     end of inner call to g
    ),                   //
    S = ''               //   start with S = ''
  ) && S                 // end of outer call to g; return S

Java 10, 196 188 byte

s->{var d=new int[99];for(var c:s.toUpperCase().replaceAll("[^AEIOU]","").toCharArray())if(d[c]++<1)System.out.println(s.replaceAll("[AEIOU]",c+"").replaceAll("[aeiou]",(char)(c+32)+""));}

-8 byte nhờ @ joH1 .

Không có ynguyên âm để lưu byte.

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

Giải trình:

s->{                       // Method with String parameter and no return-type
  var d=new int[99];       //  Integer-array indicating which vowels we've already output
  for(var c:s.toUpperCase()//  Convert the input to uppercase
            .replaceAll("[^AEIOU]","")
                           //  Remove all non-vowels
            .toCharArray())//  Convert it to a character array)
                           //  And loop over those vowel-characters
    if(d[c]++              //   Increase the vowel-count by 1
             <1)           //   And if it was 0 this iteration:
      System.out.println(  //    Print with trailing newline:
        s                  //     The input,
         .replaceAll("[AEIOU]",c+"")
                           //     with every uppercase vowel replace with the current vowel
         .replaceAll("[aeiou]",(char)(c+32)+""));}
                           //     and every lowercase vowel replaced as well

Python 2 , 112 byte

s=input()
V='aeiouAEIOU'
for v in V:
 if v in s.lower():print''.join([c,[v.upper(),v][c>'Z']][c in V]for c in s)

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

Đối xử ynhư một phụ âm.

Perl 6 , 64 byte

{m:g:i/<[aeiou]>/».lc.unique».&{$^v;say S:g:ii[<[aeiou]>]=$v}}

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

Java (OpenJDK 8) , 184 byte

y là một nguyên âm

s->s.chars().mapToObj(c->""+(char)(c>96?c:c+32)).filter("aeiouy"::contains).distinct().forEach(c->System.out.println(s.replaceAll("[aeiouy]",c).replaceAll("[AEIOUY]",c.toUpperCase())))

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