Có một trò chơi khởi động ngẫu nhiên nhỏ trong đó bạn sắp xếp mình thành một vòng tròn và gửi zips, zaps và zops xung quanh bằng cách chỉ vào một người và nói từ tiếp theo trong chuỗi, sau đó họ làm tương tự cho đến khi tất cả các bạn được làm nóng hoặc bất cứ điều gì.

Nhiệm vụ của bạn là tạo ra một chương trình đưa ra từ tiếp theo theo thứ tự cho một từ đầu vào. (Zip -> Zap -> Zop -> Zip) Vì có rất nhiều cách khác nhau để nói ba từ và cầu thang có thể được thêm vào chúng, chương trình của bạn nên bắt chước sao chép chữ và chữ và mang hậu tố.

Để giải thích, đầu vào của bạn sẽ là một hoặc nhiều Zs, sau đó một hoặc nhiều Is, As hoặc Os (tất cả cùng một chữ cái), sau đó một hoặc nhiều Ps, (tất cả các chữ cái cho đến thời điểm này có thể nằm trong trường hợp hỗn hợp) theo sau một số hậu tố tùy ý (có thể trống). Bạn nên để lại các bước chạy của Zs và Ps, cũng như hậu tố chính xác như đã nhận, nhưng sau đó thay đổi Is thành As, As thành Os hoặc Os thành Is, bảo quản trường hợp ở mỗi bước.

Ví dụ trường hợp kiểm tra

zip         ==> zap
zAp         ==> zOp
ZOP         ==> ZIP
ZiiP        ==> ZaaP
ZZaapp      ==> ZZoopp
zzzzOoOPppP ==> zzzzIiIPppP
Zipperoni   ==> Zapperoni
ZAPsky      ==> ZOPsky
ZoPtOn      ==> ZiPtOn
zipzip      ==> zapzip
zapzopzip   ==> zopzopzip
zoopzaap    ==> ziipzaap

Quy tắc và ghi chú

• Bạn có thể sử dụng bất kỳ mã hóa ký tự thuận tiện nào cho đầu vào và đầu ra, miễn là nó hỗ trợ tất cả các chữ cái ASCII và nó được tạo ra trước thử thách này.
• Bạn có thể giả sử từ đầu vào là một số biến thể của Zip, Zap hoặc Zop. Tất cả các đầu vào khác dẫn đến hành vi không xác định.
  • Các đầu vào hợp lệ sẽ khớp hoàn toàn với biểu thức chính quy Z+(I+|A+|O+)P+.*(trong trường hợp hỗn hợp)

Chúc bạn chơi golf vui vẻ!

JavaScript (Node.js) ,  69 63 57  54 byte

s=>Buffer(s).map(c=>s|c%4<1?s=c:c+c*90%320%34%24-8)+''

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

Làm sao?

Chúng tôi xử lý chuỗi đầu vào từng ký tự.$s$

Chúng tôi tái sử dụng như một lá cờ: càng sớm càng một giá trị số được lưu trữ trong đó, chúng ta biết rằng chúng ta không được cập nhật bất cứ điều gì khác.$s$

Để xác định "p"(112) và "P"(80), chúng tôi sử dụng thực tế là mã ASCII của họ là bội số của và các mã ASCII của các chữ cái khác vào đầu chuỗi ( , và nguyên âm) thì không.$4$"z""Z"

Để biến nguyên âm có mã ASCII thành đối tác của nó trong khi rời và không thay đổi, chúng tôi sử dụng chức năng sau:$c$$n$zZ

 letter | ASCII code |  * 90 | % 320 | % 34 | % 24 | - 8 | new letter
--------+------------+-------+-------+------+------+-----+-----------------------
   'i'  |     105    |  9450 |  170  |   0  |   0  |  -8 | 105 -  8 =  97 -> 'a'
   'a'  |      97    |  8730 |   90  |  22  |  22  |  14 |  97 + 14 = 111 -> 'o'
   'o'  |     111    |  9990 |   70  |   2  |   2  |  -6 | 111 -  6 = 105 -> 'i'
   'z'  |     122    | 10980 |  100  |  32  |   8  |   0 | 122 +  0 = 122 -> 'z'
   'I'  |      73    |  6570 |  170  |   0  |   0  |  -8 |  73 -  8 =  65 -> 'A'
   'A'  |      65    |  5850 |   90  |  22  |  22  |  14 |  65 + 14 =  79 -> 'O'
   'O'  |      79    |  7110 |   70  |   2  |   2  |  -6 |  79 -  6 =  73 -> 'I'
   'Z'  |      90    |  8100 |  100  |  32  |   8  |   0 |  90 +  0 =  90 -> 'Z'

Đã bình luận

s =>                  // s = input string
  Buffer(s)           // convert it to a Buffer of ASCII codes
  .map(c =>           // for each ASCII code c in s:
    s |               //   if s is numeric
    c % 4 < 1 ?       //   or c is either 'p' or 'P':
      s = c           //     turn s into a numeric value and yield c
    :                 //   else:
      c +             //     update c
        c * 90 % 320  //     by applying the transformation function
        % 34 % 24     //     (see above)
        - 8           //
  ) + ''              // end of map(); coerce the Buffer back to a string

C (gcc) ,  81 ... 61 48  46 byte

Đã lưu 2 byte nhờ @Grimy

Cổng câu trả lời JS của tôi . Đầu ra bằng cách sửa đổi chuỗi đầu vào.

f(char*s){for(;*++s%4;*s+=*s*90%320%34%24-8);}

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

Đã bình luận

f(char * s) {       // f = function taking the input string s
  for(;             //   for each character *s in s:
    *++s % 4;       //     advance the pointer; exit if *s is either 'p' or 'P' (it's safe 
                    //     to skip the 1st character, as it's guaranteed to be 'z' or 'Z')
    *s +=           //     update the current character:
      *s * 90 % 320 //       apply a transformation formula that turns
      % 34 % 24     //       a vowel into the next vowel in the sequence
      - 8           //       while leaving 'z' and 'Z' unchanged
  );                //   end of for()
}                   // end of function

Stax , 19 byte

Ç╛√êΣ%,╖FP╚`=Lh←⌡·ƒ

Chạy và gỡ lỗi nó

Võng mạc 0.8.2 , 21 byte

iT`Io`A\OIia\oi`^.+?p

Hãy thử trực tuyến! Chuyển ngữ các chữ cái lên đến và bao gồm cả chữ cái đầu tiên p, mặc dù zvà pkhông có trong phần phiên âm nên không bị ảnh hưởng. Cái đầu tiên Ođược trích dẫn bởi vì nó thường mở rộng ra 13567và cái thứ hai ođược trích dẫn bởi vì nó cũng là ma thuật; trong phần đầu tiên của phiên âm, nó mở rộng sang chuỗi khác. Do đó, phiên âm kết quả là từ IAOIiaoiđể AOIiaoisau đó loại bỏ trùng lặp chữ nguồn kết quả trong IAOiaođể AOIaoi.

C, 43 byte

f(char*s){for(;*++s%4;*s^=*s%16*36%98%22);}

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

Dựa trên câu trả lời của Arnauld . Tôi đã thực hiện một tìm kiếm brute-force để tìm công thức ngắn nhất biến a => o, o => i, i => a, z => z.

Japt , 22 20 byte

-2 byte nhờ Oliver

r"%v+"_d`i¬iao¯`pu}"

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

R , 110 76 byte

-36 byte nhờ Krill

Hàm này có một đầu vào của một chuỗi.

function(a)sub(s<-sub('z+(.+?)p.*','\\1',a,T),chartr('aioAIO','oaiOAI',s),a)

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

Perl 6 , 41 33 byte

{S:i{.+?p}=$/~~tr/iaoIAO/aoiAOI/}

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

Thay thế trường hợp không nhạy cảm đơn giản để thay đổi phần nguyên âm.

Python 3.8 (tiền phát hành) , 81 78 byte

lambda s,p='iaoIAO':''.join(('aoiAOI'+c)[(p:=p*(ord(c)%4)).find(c)]for c in s)

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

Python 2 , 98 byte

lambda s:''.join(('aoiAOI'+c)[(-~-('p'in s[:i].lower())*'iaoIAO').find(c)]for i,c in enumerate(s))

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

Java (JDK) , 52 byte

s->{for(int i=0;s[++i]%4>0;)s[i]^=s[i]%16*36%98%22;}

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

• Cảng C của Grimy trả lời. Hãy chắc chắn để nâng cao câu trả lời của mình!

Perl 5, 31 byte

s/.+?p/$&=~y,iaoIAO,aoiAOI,r/ei

TIO

SNOBOL4 (CSNOBOL4) , 183 byte

	INPUT (BREAK('Pp') SPAN('Pp')) . P REM . S
A	P 'a' ='o'	:S(A)
Z	P 'A' ='O'	:S(Z)F(P)
I	P 'i' ='a'	:S(I)
K	P 'I' ='A'	:S(K)F(P)
O	P 'o' ='i'	:S(O)
L	P 'O' ='I'	:S(L)
P	OUTPUT =P S
END

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

Python 2 , 84 byte

f=lambda s,r='':s[0]in'pP'and r+s or f(s[1:],r+('aoiAOI'+s[0])['iaoIAO'.find(s[0])])

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

C # (Trình biên dịch tương tác Visual C #) , 60 byte

n=>{for(int i=0;n[i]%4>0;)n[i]^=(char)(n[i++]%16*36%98%22);}

Dựa trên câu trả lời C của Grimy.

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

C / C ++ (trình biên dịch VC ++) 192byte

đây là một thử khá ngây thơ nhưng dù sao

void f(char*I){int c[]={-8,14,6},B=1,v[]={105,97,111},j=0;for(*I;*I>0&B;I++){if(*I==80|*I==112){B=0;break;}if(*I==90|*I==122){}else{for(j;j<3;j++){if(*I==v[j]|*I==v[j]-32){*I+=c[j];break;}}}}}

Một số phiên bản dễ đọc hơn một chút là đây

#include "stdafx.h"

void f(char * theString)
{
    signed int change[] = {'a'-'i','o'-'a','o'-'i'}; // add this to the vowel to get the next one
    char theVowels[] = {'i','a','o'};
    int breaker = 1;
    printf("Input %s\n",theString);
    for (int i = 0;(theString[i] != '\0') && breaker; i++)
    {
        switch (theString[i])
        {
            case 'Z': /*fall through*/
            case 'z': break;
            case 'P': /*fall through*/
            case 'p': breaker = 0;
                      break; 
            default: 
            {
                for (int j = 0; j < 3; j++)
                {
                    if ((theString[i] == theVowels[j]) || (theString[i]==(theVowels[j]-'a'+'A')))
                    {
                        theString[i] += change[j];
                        break;
                    }
                }
            }
            break;
        }

    }
    printf("Output %s\n",theString);
}
int main()
{
    char theString[]= "zzzzIIIIp0815-4711"; // a test string
    f(theString);
    return 0;
}

Ruby , 40 byte

$_[$&]=$&.tr"IAOiao","AOIaoi"if/z+.+?p/i

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

05AB1E (di sản) , 22 byte

l'pkIg‚£ć…iaoDÀ‚Du+`‡ì

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Chắc chắn có thể được chơi golf nhiều hơn một chút ..

Sử dụng phiên bản kế thừa của 05AB1E thay vì viết lại Elixir, vì +hợp nhất các trường trong danh sách có cùng độ dài, trong khi phiên bản mới sẽ cần ghép nối zip-‚øJ thay thế.

Giải trình:

l                       # Lowercase the (implicit) input-string
                        #  i.e. "ZipPeroni" → "zipperoni"
 'pk                   '# Get the index of the first "p"
                        #  i.e. "zipperoni" → 2
    Ig‚                 # Pair it with the length of the entire input-string
                        #  i.e. 2 and "zipperoni" → [2,9]
       £                # Split the (implicit) input-string into parts of that size
                        #  i.e. "ZipPeroni" and [2,9] → ["Zi","pPeroni"]
        ć               # Extract head: push the head and remainder separately to the stack
                        #  i.e. ["Zi","pPeroni"] → ["pPeroni"] and "Zi"
         …iao           # Push string "iao"
             DÀ         # Duplicate, and rotate it once towards the left: "aoi"
               ‚        # Pair them up: ["iao","aoi"]
                Du      # Duplicate and transform it to uppercase: ["IAO","AOI"]
                  +     # Python-style merge them together: ["iaoIAO","aoiAOI"]
                   `    # Push both strings to the stack
                    ‡   # Transliterate; replacing all characters at the same indices
                        #  i.e. "Zi", "iaoIAO" and "aoiAOI" → "Za"
                     ì  # Prepend it to the remainder (and output implicitly)
                        #  i.e. ["pPeroni"] and "Za" → ["ZapPeroni"]

PHP, 30 byte

quá đơn giản cho một TiO:

<?=strtr($argn,oiaOIA,iaoIAO);

Chạy như ống với -nF. Đối với PHP 7.2, hãy đặt chuỗi ký tự bằng dấu ngoặc kép.