थोड़ा सुधार करने वाला गेम है जहाँ आप अपने आप को एक मंडली में व्यवस्थित करते हैं और एक व्यक्ति की ओर इशारा करते हुए चारों ओर ज़िप, ज़ैप, और ज़ॉप भेजते हैं और अगले शब्द को अनुक्रम में कहते हैं, फिर वे ऐसा तब तक करते हैं जब तक कि आप सभी गर्म नहीं हो जाते या जो कुछ।

आपका कार्य एक ऐसा प्रोग्राम बनाना है जो अनुक्रम में दिए गए अगले शब्द को एक इनपुट शब्द देता है। (ज़िप -> जैप -> ज़ोप -> ज़िप) चूंकि इन तीन शब्दों और सीढ़ियों को कहने के लिए बहुत सारे अलग-अलग तरीके हैं जो आपके लिए जोड़े जा सकते हैं, आपके प्रोग्राम को केस और लेटर दोहराव और प्रत्ययों को ले जाना चाहिए।

विस्तृत करने के लिए, आपका इनपुट एक या अधिक Zs होगा, फिर एक या एक से अधिक Is, As, या Os (सभी समान अक्षर), फिर एक या अधिक Ps, (इस बिंदु तक सभी अक्षर मिश्रित मामले में हो सकते हैं) कुछ मनमाने प्रत्यय (जो खाली हो सकते हैं)। आपको Zएस और Pएस के रनों को छोड़ देना चाहिए , साथ ही प्रत्यय को बिल्कुल प्राप्त करना चाहिए, लेकिन फिर Iएस को Aएस, Aएस से Oएस, या Oएस से Iएस में बदल दें, प्रत्येक चरण पर मामले को संरक्षित करना।

उदाहरण परीक्षण मामले

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

नियम और नोट्स

आप इनपुट और आउटपुट के लिए किसी भी सुविधाजनक वर्ण एन्कोडिंग का उपयोग कर सकते हैं, बशर्ते कि यह सभी ASCII पत्रों का समर्थन करता है और यह इस चुनौती से पहले बनाया गया था।
आप मान सकते हैं कि इनपुट शब्द ज़िप, जैप या ज़ोप के कुछ प्रकार है। अन्य सभी सूचनाओं का अपरिभाषित व्यवहार होता है।
- मान्य इनपुट रेगेक्स Z+(I+|A+|O+)P+.*(मिश्रित मामले में) का पूर्ण मिलान करेगा

हैप्पी गोल्फिंग!

code-golf string

— Beefster
स्रोत

2

ziop -> यह क्या करता है?

— जोशुआ

2

@ जोशुआ यह विवरण के अनुसार अमान्य है ( "सभी समान पत्र देखें" )।

— अरनुलद

1

@ अरनल्ड: और ज़ूपज़ाप के लिए परीक्षण मामला विवरण से असहमत है।

— जोशुआ

4

@ जोशुआ क्यों? यह केवल प्रमुख zऔर पहले के बीच के स्वरों पर लागू होता है p। प्रत्यय में कुछ भी हो सकता है।

— अरनुलद

9

जावास्क्रिप्ट (Node.js) , 69 63 57 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

हम वर्ण द्वारा इनपुट स्ट्रिंग $s$ वर्ण को संसाधित करते हैं ।

हम पुन: उपयोग $s$ एक ध्वज के रूप में: जैसे ही एक अंकीय मान उस में संग्रहीत किया जाता है, हम जानते हैं कि हम कुछ और अद्यतन नहीं करना चाहिए।

पहचान करने के लिए "p"(112) और "P"(80), हम तथ्य यह है कि उनके ASCII कोड के गुणज हैं का उपयोग $4$ और स्ट्रिंग की शुरुआत में अन्य पत्र के ASCII कोड ( "z", "Z"और स्वर) नहीं हैं।

छोड़ने और अपरिवर्तित रहने के दौरान अपने समकक्ष में ASCII कोड $c$ साथ एक स्वर चालू करने के लिए , हम निम्नलिखित फ़ंक्शन का उपयोग करते हैं: $n$ zZ

n = c + ((((90 \times c) mod 320) mod 34) mod 24) - 8

$n=c+((((90\times c) \bmod 320)\bmod 34)\bmod 24)-8$

 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'

टिप्पणी की गई

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

— Arnauld
स्रोत

आप उस फंक्शन में कैसे आए?

— थॉमस हिर्श

2

@ThomasHirsch यह एक क्रूर-बल खोज फ़ंक्शन के साथ पाया गया था। पहला चरण (गुणन + 1 मोडुलो) सुनिश्चित करता है कि पैरामीटर लोअरकेस और अपरकेस दोनों के लिए समान परिणाम देते हैं। दूसरा चरण (अगले 2 मॉड्यूल और घटाव) यह जांचता है कि क्या सही डेल्टा मान वहां से प्राप्त किया जा सकता है।

— अरनौद

6

सी (जीसीसी) , 81 ... 61 48 46 बाइट्स

2 बाइट्स @Grimy की बदौलत सहेजे गए

मेरे जेएस जवाब का पोर्ट । इनपुट स्ट्रिंग को संशोधित करके आउटपुट।

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

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

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

— Arnauld
स्रोत

-2 बाइट्स

— ग्रिमी

@Grimy अच्छा पकड़, धन्यवाद! (मैंने *++s%4कुछ बिंदु पर कोशिश की , लेकिन परिणामी अनुकूलन की अनदेखी की ...)

— अरनौल

1

आगे -3 बाइट्स । यह आपके जेएस उत्तर पर भी लागू होना चाहिए।

— ग्रिमी

@ मेरी यह मेरी से काफी अलग है, इसलिए आप इसे एक अलग उत्तर के रूप में पोस्ट करना चाह सकते हैं।

— अरनौल

5

स्टैक्स , 19 बाइट्स

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

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

5

रेटिना 0.8.2 , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं! पहले और बाद के अक्षरों को ट्रांसलेट pकरता है, हालांकि लिप्यंतरण अनुभाग में नहीं हैं zऔर pइसलिए प्रभावित नहीं होते हैं। पहला Oउद्धृत किया जाता है क्योंकि यह सामान्य रूप से फैलता है 13567और दूसरा oउद्धृत किया जाता है क्योंकि यह भी जादू है; लिप्यंतरण के पहले भाग में यह दूसरे स्ट्रिंग में फैलता है। परिणामी लिप्यंतरण इसलिए है IAOIiaoiताकि AOIiaoiडुप्लिकेट स्रोत पत्रों को हटाने से परिणाम IAOiaoप्राप्त हों AOIaoi।

— नील
स्रोत

4

सी, 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अर्नुलद के जवाब के आधार पर । मैंने सबसे छोटा सूत्र खोजने के लिए एक जानवर-बल खोज की, जो a => o, o => i, i => a, z => z है।

— ग्रिमी
स्रोत

3

जाप , 22 20 बाइट्स

ओलिवर को -2 बाइट्स धन्यवाद

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

इसे ऑनलाइन आज़माएं!

— ASCII-केवल
स्रोत

3

आर , 110 76 बाइट्स

-36 बाइट्स क्रिल के लिए धन्यवाद

यह फ़ंक्शन एक स्ट्रिंग का इनपुट लेता है।

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

इसे ऑनलाइन आज़माएं!

— सीटी हॉल
स्रोत

1

आर में टुकड़ों से स्ट्रिंग को इकट्ठा करना बहुत लंबा हो जाता है ... लेकिन आप पहले एक विकल्प को sनिकालकर बहुत सारे बाइट्स बचाते हैं, जिसका हम अनुवाद कर रहे हैं, और फिर इसका अनुवाद अनुवादित प्रति के साथ करेंगे: 76 बाइट्स

— किरिल एल।

@KirillL।, आह वह चतुर चाल है जिसे मैं खोजने की कोशिश कर रहा था।

— सीटी हॉल

2

पर्ल 6 , 41 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्वर अनुभाग को स्थानांतरित करने के लिए सरल केस-असंवेदनशील प्रतिस्थापन।

— मजाक कर रहा है
स्रोत

2

पायथन 3.8 (पूर्व-रिलीज़) , 81 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पायथन 2 , 98 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

2

जावा (JDK) , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पोर्ट ऑफ ग्रिम सी का उत्तर। उसके उत्तर को सुनिश्चित करें!

— ओलिवियर ग्रेजायर
स्रोत

ग्रिम सी जवाब के एक बंदरगाह का उपयोग करके -3 बाइट्स : s->{for(int i=0;s[++i]%4>0;)s[i]^=s[i]%16*36%98%22;} 52 बाइट्स ।

— केविन क्रूज़सेन

1

पर्ल 5, 31 बाइट्स

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

TIO

— नहुएल फौलीउल
स्रोत

1

SNOBOL4 (CSNOBOL4) , 183 बाइट्स

	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

इसे ऑनलाइन आज़माएं!

— गिउसेप्पे
स्रोत

1

पायथन 2 , 84 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— चास ब्राउन
स्रोत

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 60 बाइट्स

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

ग्रिम के सी उत्तर के आधार पर।

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत

1

यह दुर्भाग्य से काम नहीं करता है क्योंकि यह प्रत्यय के स्वरों को भी बदल देता है।

— एमीना

@Emigna ऊपर कहा गया है के रूप में, यह सब बदल देता aoi-vowels, इससे पहले कि पहले सिर्फ लोगों के बजाय p/ P। गोल्फ लेकिन एक बात: ("iao".IndexOf((char)(c|32))+1)%4हो सकता है-~"iao".IndexOf((char)(c|32))%4

— केविन Cruijssen

1

C / C ++ (VC ++ कंपाइलर) 192bytes

यह एक भोली कोशिश है, लेकिन वैसे भी

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

कुछ और अधिक पठनीय संस्करण यह है

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

— डेर बेंडर
स्रोत

tio: tio.run/…

— der bender

tio गोल्फ: tio.run/…

— der bender

0

रूबी , 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— किरिल एल।
स्रोत

0

05AB1E (विरासत) , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

निश्चित रूप से थोड़ा और गोल्फ हो सकता है ..

अमृत के बजाय 05AB1E के विरासत संस्करण का उपयोग करता है, क्योंकि +एक ही-लंबाई सूची में फ़ील्ड्स को मर्ज करता है, जबकि नए संस्करण को एक जोड़ी-ज़िप-जुड़ने की आवश्यकता होती है‚øJ इसके बजाय ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

0

PHP, 30 बाइट्स

एक TiO के लिए बहुत आसान है:

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

साथ पाइप के रूप में चलाएँ -nF। PHP 7.2 के लिए, स्ट्रिंग शाब्दिक को उद्धरणों में रखें।

— तैसा
स्रोत

यह oiaपहले के बजाय केवल p/ के बजाय सभी स्वरों का अनुवाद Pकरता है, है ना?

— केविन क्रूज़सेन

जिप, जैप, ज़ॉप खेलें

उदाहरण परीक्षण मामले

नियम और नोट्स

जावास्क्रिप्ट (Node.js) , 69 63 57 54 बाइट्स

कैसे?

टिप्पणी की गई

सी (जीसीसी) , 81 ... 61 48 46 बाइट्स

टिप्पणी की गई

स्टैक्स , 19 बाइट्स

रेटिना 0.8.2 , 21 बाइट्स

सी, 43 बाइट्स

जाप , 22 20 बाइट्स

आर , 110 76 बाइट्स

पर्ल 6 , 41 33 बाइट्स

पायथन 3.8 (पूर्व-रिलीज़) , 81 78 बाइट्स

पायथन 2 , 98 बाइट्स

जावा (JDK) , 52 बाइट्स

पर्ल 5, 31 बाइट्स

SNOBOL4 (CSNOBOL4) , 183 बाइट्स

पायथन 2 , 84 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 60 बाइट्स

C / C ++ (VC ++ कंपाइलर) 192bytes

रूबी , 40 बाइट्स

05AB1E (विरासत) , 22 बाइट्स

PHP, 30 बाइट्स