Tôi không thích các chuỗi có nhiều hơn ba nguyên âm liên tiếp. Bạn có thể viết một chương trình loại bỏ tất cả các nguyên âm mà tôi không muốn từ không?

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đầu vào là một chuỗi chỉ chứa ký tự ASCII có thể in (bao gồm 0x20 đến 0x7E).

Đầu ra là một chuỗi chỉ chứa tối đa 3 nguyên âm liên tiếp. Nếu có hơn 3 nguyên âm liên tiếp trong chuỗi đầu vào, chương trình của bạn sẽ tạo ra một chuỗi đầu ra bao gồm ba nguyên âm đầu tiên gặp phải trong lần chạy đó, loại bỏ mọi nguyên âm liên tiếp tiếp theo.

Y không phải là một nguyên âm cho các mục đích của thử thách này.

Đây là mã golf, vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng.

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

"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."

Bình thường, 21 byte

sfg3=Z&}rT0"aeiou"hZz

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

Tôi lặp đi lặp lại qua tất cả các ký tự và theo dõi xem tôi đã chuyển bao nhiêu nguyên âm bằng cách sử dụng bộ đếm. Mỗi khi tôi vượt qua một char, không phải là nguyên âm, tôi đặt lại bộ đếm thành 0. Tôi viết lại ký tự, bất cứ khi nào bộ đếm> 4.

sfg3=Z&}rT0"aeiou"hZz   implicit: z = input string
                                  Z = 0
 f                  z   test every char T in z; keep chars, that return true:
        rT0                convert T to lower
       }   "aeiou"         test if T is a vowel
      &           hZ       logical and with Z+1, 
                           gives 0 if ^ is false, otherwise Z+1
    =Z                     update Z with this value
  g3                       test if 3 >= Z
s                       sum up all remaining chars and print

Không thể đọc được , 1647 byte

"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "

Giải trình

Chương trình này tương đương với mã giả như thế này:

while (cp = (ch = read)) + 1 {
    (
        (cp -= 65) ?    // A
            (cp -= 4) ?     // E
                (cp -= 4) ?     // I
                    (cp -= 6) ?     // O
                        (cp -= 6) ?     // U
                            (cp -= 12) ?    // a
                                (cp -= 4) ?     // e
                                    (cp -= 4) ?     // i
                                        (cp -= 6) ?     // o
                                            (cp - 6) ?      // u
                                                0
                                            : 1
                                        : 1
                                    : 1
                                : 1
                            : 1
                        : 1
                    : 1
                : 1
            : 1
        : 1
    ) ? ((--vs)+4) ? print(ch) : (++vs) : {
        print(ch)
        vs = 0
    }
}

với các bài tập biến sau:

0   (unused)   (13 bytes)
1   cp         ( 4 bytes; occurs 20× in the code)
2   vs         ( 7 bytes; occurs  5× in the code)
3   ch         (10 bytes; occurs  3× in the code)

Như bạn thấy, tôi đã tránh biến số 0 vì 0 nó là một hằng số dài để viết.

Vì vậy, chúng tôi đọc từng ký tự và lưu trữ giá trị trong cả hai cpvà ch. Chúng tôi sẽ sửa đổi cpnhưng giữ chxung quanh để chúng tôi có thể in nó nếu cần thiết. Chúng tôi liên tiếp trừ các số 65, 4, 4, 6, v.v. cpđể kiểm tra xem đó có phải là một trong số 10 ký tự nguyên âm có thể có trong ASCII không (lưu ý rằng cuối cùng không cần phải là một bài tập).

vsluôn chứa 3 ít hơn số nguyên âm vẫn được phép in. Nó bắt đầu lúc 0, vì vậy 3 nguyên âm có thể được in. Khi nó đạt đến-3 , chúng tôi ngừng in nguyên âm.

Nếu chúng tôi gặp phải một nguyên âm (bao gồm cả khoảng trắng), chúng tôi sẽ thực hiện print(ch)theo sauvs = 0 . Như bạn có thể đoán, điều này đặt lại bộ đếm nguyên âm.

Nếu chúng ta gặp một nguyên âm , chúng ta thực thi ((--vs)+4) ? print(ch) : (++vs). Hãy phá vỡ điều này:

• giảm giá vs;
• nếu giá trị là bây giờ -4, chúng ta đã đi quá xa, vì vậy đừng in bất cứ thứ gì, nhưng tăng dần vstrở lại để -3chúng ta sẽ tiếp tục từ chối in nguyên âm;
• nếu không, in ký tự.

Võng mạc , 25 byte

i`([aeiou]{3})[aeiou]+
$1

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

Khá đơn giản thay thế regex. Điều này cũng hoạt động cho cùng một số byte:

Ri`(?<=[aeiou]{3})[aeiou]

JavaScript (ES6), 42

Là một chức năng ẩn danh

s=>s.replace(/[aeiou]+/gi,v=>v.slice(0,3))

Perl, 27 ký tự

(Mã 26 ký tự + 1 ký tự tùy chọn dòng lệnh)

s/[aeiou]{3}\K[aeiou]+//gi

Không phải là một vấn đề lớn, chỉ là một dịp hiếm hoi tôi nhớ \Ktồn tại.

Chạy mẫu:

bash-4.3$ perl -pe 's/[aeiou]{3}\K[aeiou]+//gi' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

Nghiêm túc, 34 byte

,;ù0╗`Ok"aeiou"Okd-Y;╜+*;╗4>`M@░εj

Bãi rác Hex:

2c3b9730bb604f6b226165696f75224f6b
642d593bbd2b2a3bbb343e604d40b0ee6a

Dùng thử trực tuyến

Nó sử dụng thuật toán tương tự như câu trả lời Pyth, ánh xạ chuỗi, trong khi theo dõi độ dài của nguyên âm hiện tại trong một thanh ghi, tăng nó bất cứ khi nào ký tự hiện tại là nguyên âm và kiểm tra xem nó có vượt quá độ dài cho phép không, trả về 0 nếu có, và sau đó lọc chuỗi gốc bằng bộ lọc được tạo này. Nó sẽ ngắn hơn rất nhiều một khi chúng ta có thể sử dụng phép trừ đặt trên chuỗi. (Có Okthể xóa và Okdcó thể được thay thế bằng chỉ @). Tôi nghe thấy tính năng này sẽ đến trong bản cập nhật tiếp theo ....

C, 166 byte

Tôi nghĩ không phải là câu trả lời ngắn nhất nhưng chơi golf độc đáo ..

#define V v[1][i]!=
#define P printf("%c",v[1][i]),j
j;main(i,v)char**v;{for(i=0;V 0;i++)(V 97&V 'e'&V 'i'&V 'o'&V 'u'&V 65&V 69&V 73&V 79&V 85)?P=0:j>3?j++:P++;}

trường hợp thử nghiệm:

$ a.exe "We're queueing up for the Hawaiian movie."

We're queung up for the Hawaiin movie.

$ wc -c vowels.c 

166 vowels.c

Toán học, 68 byte

a=Characters@"aeiouAEIOU";StringReplace[#,b:a~Repeated~{3}~~a..:>b]&

Câu trả lời regex sẽ có cùng độ dài, nhưng ai sử dụng regex?

Java, 115 byte

class a{public static void main(String[] a){System.out.println(a[0].replaceAll("(?i)([aeiou]{3})[aeiou]*","$1"));}}

Dự kiến ​​đầu vào là tham số chương trình.

Đầu ra thử nghiệm đơn vị:

Aei
screeen
We're queung up for the Hawaiin movie.

APL, 40 ký tự

{⍵/⍨1↓4≠⊃+/(1-⍳4)⌽¨⊂'aeiouAEIOU'∊⍨' ',⍵}

Bằng tiếng Anh:

• 'aeiouAEIOU'∊⍨' ',⍵: tìm các nguyên âm (và đặt trước một khoảng trắng để ngắt khi xoay);
• (1-⍳4)⌽¨⊂: xoay 0, 1, 2, 3 lần (có quấn quanh) đẩy sang phải vectơ boolean;
• ⊃+/ sum: các phép quay và unbox
• 1↓4≠: tìm khác 4 và xóa cái đầu tiên (để thu thập khoảng trống chúng tôi đã đặt trước)
• ⍵/⍨: trong đối số, chỉ giữ lại phần tử có tổng khác 4.

Perl 6 ,  36  35 byte

{S:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/} # 36 bytes

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' # 34 + 1 = 35 bytes

sử dụng:

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.

C (205 byte)

#include <stdio.h>
#define T(x)for(i=0;i<10;++i){if(v[i]==x){b=x;m=1;break;}}putchar(c);
main(b,c,i,m){char v[]="aeiouAEIOU";
while((c=getchar())!=EOF){if(!m){T(c);}else{if(b==c)continue;else{m=0;T(c);}}}}

(Thêm một dòng ngắt cho rõ ràng)

Scala, 107 byte

readLine.foldLeft("",0)((a,n)=>if(!"aeiou".contains(n|32))a._1+n->0 else if(a._2>2)a else(a._1+n,a._2+1))_1

Javascript ES6, 43 ký tự

s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")

Kiểm tra:

f=s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")
;`"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."`
.replace(/"/g,"").split("\n").every(s=>f((s=s.split(" => "))[0])==s[1])

x86 tệp MS-DOS .COM , 44 byte 36 byte

Các tệp .COM được hỗ trợ rộng rãi từ MS-DOS 1 cho đến hiện tại --- Tôi đang chạy trong dosemu, chỉ sử dụng các lệnh 8086.

Giảm từ 44 xuống 36 byte bằng cách sử dụng REPNE SCASB để kiểm tra nguyên âm thay vì sử dụng một lệnh riêng để kiểm tra từng nguyên âm.

Hex dump, reversible using `xxd -r -seek -256`:
0100: b3 03 43 b4 08 cd 21 88 c2 24 df b1 05 bf 1f 01   ..C...!..$......
0110: f2 ae 74 02 b3 05 4b 74 e9 b4 02 cd 21 eb e4 41   ..t...Kt....!..A
0120: 45 49 4f 55                                       EIOU

Unassembled using debug:
0100 B303    MOV BL,03     ; initialize counter to 3 (will increment by 1 to be 4)
0102 43      INC BX        ; increment counter--runs each time it hits 0 so it never goes <0
0103 B408    MOV AH,08     ; 
0105 CD21    INT 21        ; with AH=8, read 1 char without echo
0107 88C2    MOV DL,AL     ; copy input for potential output
0109 24DF    AND AL,DF     ; make input uppercase for testing
010B B105    MOV CL,05     ; count of 5 vowels to test against
010D BF1F01  MOV DI,011F   ; location of first vowel to test against
0110 F2AE    REPNE SCASB   ; test input against each vowel
0112 7402    JZ 0116       ; if input was not a vowel:
0114 B305    MOV BL,05     ;    reset counter to 5 (will decrement by 1 to be 4)
0116 4B      DEC BX        ; decrement counter regardless
0117 74E9    JZ 0102       ; if hit 0 (fourth or later vowel): goto 102
0119 B402    MOV AH,02     ; 
011B CD21    INT 21        ; with AH=2, print char
011D EBE4    JMP 0103      ; go to 103 for next character

bytes 011f-0123 contain the uppercase vowels AEIOU

Matlab / Octave, 54 byte

@(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

Thí dụ:

>> @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')
ans = 
    @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

>> ans('We''re queueing up for the Hawaiian movie.')
ans =
We're queung up for the Hawaiin movie.

Hãy thử nó tại ideone .

V , 21 byte (không biên dịch)

ñ[aeiou]ñÍãqû3}úsq*

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

Giải trình:

ñ[aeiou]ñ                     "Assign the string `[aeiou]` to register 'q'
         Íã                   "Search and replace on multiple lines (case insensitive):
           <C-r>q             "Register 'q'
                 û3}          "Repeated 3 times
                    ús        "Mark the following to be removed:
                      <C-r>q* "Register 'q' repeated any number of times

Đây chỉ là ngắn hơn so với giải pháp đơn giản hơn:

Íã[aeiou]û3}ús[aeiou]*

(22 byte)

Ruby, 44 byte

><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')

Thí dụ:

% ruby -e "$><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')" <<< "
Aeiou
screeeen
We're queueing up for the Hawaiian movie.
Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.