Il y a un petit jeu d'échauffement d'improvisation où vous vous arrangez en cercle et envoyez des zips, zaps et zops autour en pointant une personne et en disant le mot suivant dans la séquence, puis ils font de même jusqu'à ce que vous soyez tous réchauffés ou peu importe.

Votre tâche consiste à créer un programme qui donne au mot suivant dans l'ordre donné un mot d'entrée. (Zip -> Zap -> Zop -> Zip) Comme il y a beaucoup de façons différentes de dire ces trois mots et flairs qui peuvent y être ajoutés, votre programme devrait imiter la duplication de casse et de lettre et porter des suffixes.

Pour élaborer, votre entrée sera un ou plusieurs Zs, puis un ou plusieurs Is, As ou Os (tous la même lettre), puis un ou plusieurs Ps, (toutes les lettres jusqu'à ce point peuvent être en casse mixte) suivies de un suffixe arbitraire (qui peut être vide). Vous devez laisser les séries de Zs et Ps, ainsi que le suffixe exactement tels qu'ils ont été reçus, puis changer le Is en As, As en Os ou Os en Is, en préservant la casse à chaque étape.

Exemples de cas de test

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

Règles et notes

Vous pouvez utiliser n'importe quel encodage de caractères pratique pour l'entrée et la sortie, à condition qu'il prenne en charge toutes les lettres ASCII et qu'il ait été créé avant ce défi.
Vous pouvez supposer que le mot d'entrée est une variante de Zip, Zap ou Zop. Toutes les autres entrées entraînent un comportement non défini.
- Les entrées valides correspondront parfaitement à l'expression régulière Z+(I+|A+|O+)P+.*(dans le cas mixte)

Bon golf!

code-golf string

— Beefster
source

2

ziop -> qu'est-ce que cela fait?

— Joshua

2

@Joshua Ceci n'est pas valide selon la description (voir "tous la même lettre" ).

— Arnauld

1

@Arnauld: Et le cas de test pour zoopzaap n'est pas d'accord avec la description.

— Joshua

4

@Joshua Pourquoi? Cela ne s'applique qu'aux voyelles entre les majuscules zet les premières p. Le suffixe peut contenir n'importe quoi.

— Arnauld

9

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

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

Essayez-le en ligne!

Comment?

Nous traitons la chaîne d'entrée caractère par caractère. $s$

Nous réutilisons comme indicateur: dès qu'une valeur numérique y est stockée, nous savons que nous ne devons rien mettre à jour d'autre. $s$

Pour identifier "p"(112) et "P"(80), nous utilisons le fait que leurs codes ASCII sont des multiples de et que les codes ASCII des autres lettres au début de la chaîne ( , et les voyelles) ne le sont pas. $4$ "z""Z"

Pour activer une voyelle avec le code ASCII dans son homologue tout en laissant et sans changement, nous utilisons la fonction suivante: $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'

Commenté

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
source

Comment avez-vous créé cette fonction?

— Thomas Hirsch

2

@ThomasHirsch Il a été trouvé avec une fonction de recherche par force brute. La première étape (multiplication + 1er module) s'assure que les paramètres donnent un résultat identique pour les minuscules et les majuscules. La 2ème étape (les 2 modules suivants et la soustraction) vérifie si les valeurs delta correctes peuvent être obtenues à partir de là.

— Arnauld

6

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

Sauvegardé 2 octets grâce à @Grimy

Port de ma réponse JS . Sorties en modifiant la chaîne d'entrée.

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

Essayez-le en ligne!

Commenté

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
source

-2 octets

— Grimmy

@Grimy Belle prise, merci! (J'ai essayé *++s%4à un moment donné mais j'ai négligé l'optimisation qui en résulte ...)

— Arnauld

1

-3 octets supplémentaires . Celui-ci devrait également être applicable à votre réponse JS.

— Grimmy

@Grimy Il est assez différent du mien, donc vous voudrez peut-être publier ceci comme une réponse distincte.

— Arnauld

5

Stax , 19 octets

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

Exécuter et déboguer

— récursif
source

5

Retina 0.8.2 , 21 octets

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

Essayez-le en ligne! Translittère les lettres jusqu'au premier inclus p, bien que le zet pne soit pas dans la section de translittération ne soit donc pas affecté. Le premier Oest cité parce qu'il se développe normalement 13567et le second oest cité parce qu'il est lui aussi magique; dans la première partie de la translittération, elle se développe dans l'autre chaîne. La translittération qui en résulte est donc de IAOIiaoià AOIiaoipuis la suppression des doublons des lettres sources se traduit par IAOiaoà AOIaoi.

— Neil
source

4

C, 43 octets

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

Essayez-le en ligne!

Basé sur la réponse d'Arnauld . J'ai fait une recherche par force brute pour trouver la formule la plus courte qui transforme a => o, o => i, i => a, z => z.

— Grimmy
source

3

Japt , 22 20 octets

-2 octets grâce à Oliver

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

Essayez-le en ligne!

— ASCII uniquement
source

3

R , 110 76 octets

-36 octets grâce à Krill

Cette fonction prend une entrée d'une chaîne.

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

Essayez-le en ligne!

— CT Hall
source

1

La collecte de la chaîne de morceaux dans R a tendance à être très longue ... Mais vous économisez beaucoup d'octets en extrayant d'abord une sous s- chaîne que nous allons traduire, puis en la remplaçant par une copie traduite: 76 octets

— Kirill L.

@KirillL., Ah c'est l'astuce astucieuse que j'essayais de trouver.

— CT Hall le

2

Perl 6 , 41 33 octets

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

Essayez-le en ligne!

Substitution simple insensible à la casse pour déplacer la section des voyelles.

— Jo King
source

2

Python 3.8 (pré-version) , 81 78 octets

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

Essayez-le en ligne!

Python 2 , 98 octets

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

Essayez-le en ligne!

— TFeld
source

2

Java (JDK) , 52 octets

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

Essayez-le en ligne!

Réponse de Port of Grimy's C. Assurez-vous de voter pour sa réponse!

— Olivier Grégoire
source

-3 octets en utilisant un port de la réponse C de Grimy à la place: s->{for(int i=0;s[++i]%4>0;)s[i]^=s[i]%16*36%98%22;} 52 octets .

— Kevin Cruijssen

1

Perl 5, 31 octets

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

TIO

— Nahuel Fouilleul
source

1

SNOBOL4 (CSNOBOL4) , 183 octets

	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

Essayez-le en ligne!

— Giuseppe
source

1

Python 2 , 84 octets

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

Essayez-le en ligne!

— Chas Brown
source

1

C # (Visual C # Interactive Compiler) , 60 octets

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

Basé sur la réponse de Grimy's C.

Essayez-le en ligne!

— Incarnation de l'ignorance
source

1

Malheureusement, cela ne fonctionne pas car il remplace également les voyelles dans le suffixe.

— Emigna

Comme @Emigna l'indique ci-dessus, cela remplace toutes les aoivoyelles, au lieu de seulement celles avant le premier p/ P. Une chose au golf cependant: ("iao".IndexOf((char)(c|32))+1)%4peut être-~"iao".IndexOf((char)(c|32))%4

— Kevin Cruijssen

1

C / C ++ (compilateur VC ++) 192 octets

c'est un essai plutôt naïf mais de toute façon

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

une version légèrement plus lisible est la suivante

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

— der bender
source

tio: tio.run/…

— der bender

tio a joué au golf

— der bender

0

Rubis , 40 octets

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

Essayez-le en ligne!

— Kirill L.
source

0

05AB1E (hérité) , 22 octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Peut certainement être joué un peu plus.

Utilise la version héritée de 05AB1E au lieu de la réécriture Elixir, car +fusionne les champs dans des listes de même longueur, tandis que la nouvelle version aurait plutôt besoin d'une paire-zip-join‚øJ .

Explication:

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

— Kevin Cruijssen
source

0

PHP, 30 octets

trop simple pour un TiO:

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

Exécuter en tant que tuyau avec -nF. Pour PHP 7.2, mettez les littéraux de chaîne entre guillemets.

— Titus
source

Cela translitère toutes les oiavoyelles au lieu de seulement celles avant le premier p/ P, n'est-ce pas?

— Kevin Cruijssen

Jouer à Zip, Zap, Zop

Exemples de cas de test

Règles et notes

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

Comment?

Commenté

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

Commenté

Stax , 19 octets

Retina 0.8.2 , 21 octets

C, 43 octets

Japt , 22 20 octets

R , 110 76 octets

Perl 6 , 41 33 octets

Python 3.8 (pré-version) , 81 78 octets

Python 2 , 98 octets

Java (JDK) , 52 octets

Perl 5, 31 octets

SNOBOL4 (CSNOBOL4) , 183 octets

Python 2 , 84 octets

C # (Visual C # Interactive Compiler) , 60 octets

C / C ++ (compilateur VC ++) 192 octets

Rubis , 40 octets

05AB1E (hérité) , 22 octets

PHP, 30 octets