Gioca a Zip, Zap, Zop

22

C'è un piccolo gioco di riscaldamento improvvisato in cui ti organizzi in un cerchio e mandi zip, zaps e zops in giro indicando una persona e dicendo la parola successiva nella sequenza, quindi fanno lo stesso fino a quando tutti ti riscaldano o qualunque cosa.

Il tuo compito è quello di creare un programma che dia la parola successiva in sequenza data una parola di input. (Zip -> Zap -> Zop -> Zip) Dato che ci sono molti modi diversi per dire queste tre parole e flairs che possono essere aggiunti a loro, il tuo programma dovrebbe imitare la duplicazione di maiuscole e lettere e portare suffissi.

Per elaborare, il tuo input sarà una o più Zs, quindi una o più Is, As o Os (tutta la stessa lettera), quindi una o più Ps (tutte le lettere fino a questo punto possono essere in maiuscolo) seguite da qualche suffisso arbitrario (che può essere vuoto). Dovresti lasciare le serie di Zs e Ps, così come il suffisso esattamente come ricevuto, ma poi cambiare la Is in As, As in Os, o in Os in Is, preservando il caso ad ogni passaggio.

Esempi di casi di 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

Regole e note

  • È possibile utilizzare qualsiasi comoda codifica dei caratteri per input e output, a condizione che supporti tutte le lettere ASCII e che sia stata creata prima di questa sfida.
  • Si può presumere che la parola di input sia una variante di Zip, Zap o Zop. Tutti gli altri input comportano un comportamento indefinito.
    • Gli input validi corrisponderanno completamente al regex Z+(I+|A+|O+)P+.*(in caso misto)

Buon golf!

code-golf  string 
— Beefster
fonte
2
ziop -> cosa fa questo?
— Joshua,
2
@Joshua Questo non è valido secondo la descrizione (vedi "tutta la stessa lettera" ).
— Arnauld,
1
@Arnauld: e il test case per zoopzaap non è d'accordo con la descrizione.
— Giosuè,
4
@Joshua Why? Questo vale solo per le vocali tra il primo ze il primo p. Il suffisso può contenere qualsiasi cosa.
— Arnauld,

Risposte:

9

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)+''

Provalo online!

Come?

Noi processo la stringa di input s carattere per carattere.

Riutilizziamo s come flag: non appena viene memorizzato un valore numerico, sappiamo che non dobbiamo aggiornare nient'altro.

Identificare "p"(112) e "P"(80), si usa il fatto che i loro codici ASCII sono multipli di 4 e codici ASCII delle altre lettere all'inizio della stringa ( "z", "Z"e vocali) non sono.

Per trasformare una vocale con codice ASCII c nella sua controparte n mentre rimane ze Zinvariata, utilizziamo la seguente funzione:

n=c+((((90×c)mod320)mod34)mod24)−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'

Commentate

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
fonte
Come ti è venuta in mente quella funzione?
— Thomas Hirsch,
2
@ThomasHirsch È stato trovato con una funzione di ricerca della forza bruta. Il primo passo (moltiplicazione + 1 ° modulo) assicura che i parametri forniscano risultati identici sia in minuscolo che maiuscolo. Il secondo passo (i successivi 2 moduli e la sottrazione) controlla se da lì è possibile ottenere i valori delta corretti.
— Arnauld
6

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

Salvato 2 byte grazie a @Grimy

Porta della mia risposta JS . Emette modificando la stringa di input.

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

Provalo online!

Commentate

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
fonte
— Grimmy
@Grimy Bella cattura, grazie! (Ho provato *++s%4ad un certo punto, ma ho trascurato l'ottimizzazione risultante ...)
— Arnauld
1
Ulteriori -3 byte . Questo dovrebbe essere applicabile anche alla tua risposta JS.
— Grimmy,
@Grimy È abbastanza diverso dal mio, quindi potresti voler pubblicare questo come una risposta separata.
— Arnauld,
5

Retina 0.8.2 , 21 byte

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

Provalo online! Traslittera le lettere fino alla prima inclusa p, anche se la ze pnon sono nella sezione traslitterazione, quindi non sono interessate. Il primo Oè citato perché normalmente si espande 13567e il secondo oè citato perché anche lui è magico; nella prima parte della traslitterazione si espande nell'altra stringa. La traslitterazione risultante è quindi da IAOIiaoia AOIiaoipoi rimuovere i duplicati lettere sorgente risultati in IAOiaoa AOIaoi.

— Neil
fonte
4

C, 43 byte

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

Provalo online!

Basato sulla risposta di Arnauld . Ho fatto una ricerca di forza bruta per trovare la formula più breve che gira a => o, o => i, i => a, z => z.

— Grimmy
fonte
3

R , 110 76 byte

-36 byte grazie a Krill

Questa funzione accetta un input di una stringa.

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

Provalo online!

— CT Hall
fonte
1
Raccogliere la stringa dai pezzi in R tende ad essere molto lungo ... Ma risparmi molti byte estraendo prima una sottostringa sche stiamo traducendo, e poi sostituendola con una copia tradotta: 76 byte
— Kirill L.
@KirillL., Ah, questo è il trucco intelligente che stavo cercando di trovare.
— CT Hall
2

Perl 6 , 41 33 byte

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

Provalo online!

Sostituzione semplice senza distinzione tra maiuscole e minuscole per spostare la sezione vocale.

— Jo King
fonte
1

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

Provalo online!

— Giuseppe
fonte
1

C # (compilatore interattivo Visual C #) , 60 byte

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

Basato sulla risposta C di Grimy.

Provalo online!

— Incarnazione dell'ignoranza
fonte
1
Questo purtroppo non funziona in quanto sostituisce anche le vocali nel suffisso.
— Emigna,
Come sopra indicato da @Emigna, questo sostituisce tutte le aoivocali, anziché solo quelle prima del primo p/ P. Una cosa al golf però: ("iao".IndexOf((char)(c|32))+1)%4può essere-~"iao".IndexOf((char)(c|32))%4
— Kevin Cruijssen il
1

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

questo è un tentativo piuttosto ingenuo ma comunque

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

qualche versione leggermente più leggibile è questa

#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
fonte
— der bender
tio golfed: tio.run/…
— der bender
0

05AB1E (legacy) , 22 byte

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

Provalo online o verifica tutti i casi di test .

Può sicuramente giocare a golf un po 'di più ..

Utilizza la versione legacy di 05AB1E invece della riscrittura elisir, perché +unisce i campi in elenchi della stessa lunghezza, mentre la nuova versione avrebbe bisogno di un accoppiamento zip-join‚øJ .

Spiegazione:

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
fonte
0

PHP, 30 byte

troppo semplice per un TiO:

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

Esegui come pipe con -nF. Per PHP 7.2, inserisci i valori letterali delle stringhe tra virgolette.

— Titus
fonte
Questo trascrive tutte le oiavocali anziché solo quelle precedenti alla prima p/ P, no?
— Kevin Cruijssen,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.