Hay un pequeño juego de calentamiento de improvisación en el que se organizan en un círculo y envían cremalleras, zap y zops alrededor señalando a una persona y diciendo la siguiente palabra en la secuencia, luego hacen lo mismo hasta que todos se calientan o lo que sea.

Su tarea es crear un programa que dé la siguiente palabra en secuencia dada una palabra de entrada. (Zip -> Zap -> Zop -> Zip) Dado que hay muchas formas diferentes de decir estas tres palabras y palabras que se pueden agregar a ellas, su programa debe imitar la duplicación de mayúsculas y minúsculas y llevar sufijos.

Para elaborar, su entrada será una o más Zs, luego una o más Is, As o Os (todas la misma letra), luego una o más Ps, (todas las letras hasta este punto pueden estar en mayúsculas y minúsculas) seguido de algún sufijo arbitrario (que puede estar vacío). Debe dejar las ejecuciones de Zsy Ps, así como el sufijo exactamente como se recibió, pero luego cambie Is a As, As a Os o Os a Is, conservando mayúsculas y minúsculas en cada paso.

Ejemplos de casos de prueba

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

Reglas y notas

Puede usar cualquier codificación de caracteres conveniente para entrada y salida, siempre que admita todas las letras ASCII y que se haya creado antes de este desafío.
Puede suponer que la palabra de entrada es una variante de Zip, Zap o Zop. Todas las demás entradas dan como resultado un comportamiento indefinido.
- Las entradas válidas coincidirán por completo con la expresión regular Z+(I+|A+|O+)P+.*(en mayúsculas y minúsculas)

¡Feliz golf!

code-golf string

— Carne de res
fuente

2

ziop -> ¿qué hace esto?

— Joshua

2

@Joshua Esto no es válido según la descripción (ver "toda la misma letra" ).

— Arnauld

1

@Arnauld: Y el caso de prueba para zoopzaap no está de acuerdo con la descripción.

— Joshua

44

@Joshua ¿Por qué? Esto solo se aplica a las vocales entre las principales zy las primeras p. El sufijo puede contener cualquier cosa.

— Arnauld

9

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

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

Pruébalo en línea!

¿Cómo?

Procesamos la cadena de entrada $s$ carácter por carácter.

Reutilizamos $s$ como un indicador: tan pronto como se almacena un valor numérico en él, sabemos que no debemos actualizar nada más.

Para identificar "p"(112) y "P"(80), se utiliza el hecho de que sus códigos ASCII son múltiplos de $4$ y los códigos ASCII de las otras letras al principio de la cadena ( "z", "Z"y vocales) no lo son.

Para convertir una vocal con el código ASCII $c$ en su contraparte $n$ al salir zy Zsin cambios, utilizamos la siguiente función:

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'

Comentado

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
fuente

¿Cómo se te ocurrió esa función?

— Thomas Hirsch

2

@ThomasHirsch Se encontró con una función de búsqueda de fuerza bruta. El primer paso (multiplicación + 1er módulo) asegura que los parámetros den un resultado idéntico tanto en minúsculas como en mayúsculas. El segundo paso (los siguientes 2 módulos y la resta) verifica si se pueden obtener los valores delta correctos a partir de ahí.

— Arnauld

6

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

Guardado 2 bytes gracias a @Grimy

Puerto de mi respuesta JS . Salidas modificando la cadena de entrada.

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

Pruébalo en línea!

Comentado

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
fuente

-2 bytes

— Grimmy

@ Grimy Buena captura, gracias! (Intenté *++s%4en algún momento pero pasé por alto la optimización resultante ...)

— Arnauld

1

Más -3 bytes . Este también debería ser aplicable a su respuesta JS.

— Grimmy

@Grimy Es lo suficientemente diferente al mío, por lo que es posible que desee publicar esto como una respuesta por separado.

— Arnauld

5

Stax , 19 bytes

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

Ejecutar y depurarlo

— recursivo
fuente

5

Retina 0.8.2 , 21 bytes

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

Pruébalo en línea! Translitera las letras hasta el primero p, incluido el primero , aunque el zy pno están en la sección de transliteración, por lo que no se ven afectados. El primero Ose cita porque normalmente se expande 13567y el segundo ose cita porque también es mágico; en la primera parte de la transliteración se expande a la otra cadena. Por consiguiente, la transcripción resultante es de IAOIiaoia AOIiaoicontinuación, la eliminación de las letras de código duplicados resultados en IAOiaoa AOIaoi.

— Neil
fuente

4

C, 43 bytes

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

Pruébalo en línea!

Basado en la respuesta de Arnauld . Hice una búsqueda de fuerza bruta para encontrar la fórmula más corta que convierte a => o, o => i, i => a, z => z.

— Mugriento
fuente

3

Japt , 22 20 bytes

-2 bytes gracias a Oliver

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

Pruébalo en línea!

— Solo ASCII
fuente

3

R , 110 76 bytes

-36 bytes gracias a Krill

Esta función toma una entrada de una cadena.

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

Pruébalo en línea!

— CT Hall
fuente

1

Recopilar la cadena de piezas en R tiende a ser muy larga ... Pero ahorra muchos bytes extrayendo primero una subcadena sque traduciremos y luego reemplazándola con una copia traducida: 76 bytes

— Kirill L.

@ KirillL., Ah, ese es el truco inteligente que estaba tratando de encontrar.

— CT Hall

2

Perl 6 , 41 33 bytes

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

Pruébalo en línea!

Sustitución simple sin distinción entre mayúsculas y minúsculas para desplazar la sección vocal.

— Jo King
fuente

2

Python 3.8 (prelanzamiento) , 81 78 bytes

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

Pruébalo en línea!

Python 2 , 98 bytes

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

Pruébalo en línea!

— TFeld
fuente

2

Java (JDK) , 52 bytes

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

Pruébalo en línea!

La respuesta C del puerto de Grimy. ¡Asegúrate de votar su respuesta!

— Olivier Grégoire
fuente

-3 bytes usando un puerto de respuesta C de Grimy en su lugar: s->{for(int i=0;s[++i]%4>0;)s[i]^=s[i]%16*36%98%22;} 52 bytes .

— Kevin Cruijssen

1

Perl 5, 31 bytes

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

TIO

— Nahuel Fouilleul
fuente

1

SNOBOL4 (CSNOBOL4) , 183 bytes

	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

Pruébalo en línea!

— Giuseppe
fuente

1

Python 2 , 84 bytes

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

Pruébalo en línea!

— Chas Brown
fuente

1

C # (compilador interactivo de Visual C #) , 60 bytes

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

Basado en la respuesta C de Grimy.

Pruébalo en línea!

— Encarnación de la ignorancia
fuente

1

Esto desafortunadamente no funciona ya que reemplaza las vocales en el sufijo también.

— Emigna

Como @Emigna afirma anteriormente, esto reemplaza todos los aoivocales, en lugar de solo los anteriores al primer p/ P. Sin embargo, una cosa para el golf: ("iao".IndexOf((char)(c|32))+1)%4puede ser-~"iao".IndexOf((char)(c|32))%4

— Kevin Cruijssen

1

C / C ++ (compilador VC ++) 192bytes

este es un intento bastante ingenuo pero de todos modos

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

alguna versión un poco más legible es esta

#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
fuente

tio: tio.run/…

— der bender

tio golfed: tio.run/…

— der bender

0

Rubí , 40 bytes.

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

Pruébalo en línea!

— Kirill L.
fuente

0

05AB1E (heredado) , 22 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Definitivamente se puede jugar al golf un poco más ...

Utiliza la versión heredada de 05AB1E en lugar de la reescritura de Elixir, porque +combina campos en listas de la misma longitud, mientras que la nueva versión necesitaría un par-zip-join‚øJ .

Explicación:

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
fuente

0

PHP, 30 bytes

demasiado simple para un TiO:

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

Ejecutar como tubería con -nF. Para PHP 7.2, ponga los literales de cadena entre comillas.

— Tito
fuente

Esto translitera todas las oiavocales en lugar de solo las anteriores a la primera p/ P, ¿no?

— Kevin Cruijssen

Juega Zip, Zap, Zop

Ejemplos de casos de prueba

Reglas y notas

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

¿Cómo?

Comentado

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

Comentado

Stax , 19 bytes

Retina 0.8.2 , 21 bytes

C, 43 bytes

Japt , 22 20 bytes

R , 110 76 bytes

Perl 6 , 41 33 bytes

Python 3.8 (prelanzamiento) , 81 78 bytes

Python 2 , 98 bytes

Java (JDK) , 52 bytes

Perl 5, 31 bytes

SNOBOL4 (CSNOBOL4) , 183 bytes

Python 2 , 84 bytes

C # (compilador interactivo de Visual C #) , 60 bytes

C / C ++ (compilador VC ++) 192bytes

Rubí , 40 bytes.

05AB1E (heredado) , 22 bytes

PHP, 30 bytes