El problema con el cifrado César es que las palabras resultantes a menudo son impronunciables. El problema con Pig Latin es que es fácil de decodificar. ¿Por qué no combinarlos?

Entrada

Una palabra que consta de las 26 letras en inglés.

Salida

Primero, cambie cada consonante de la palabra a la siguiente consonante del alfabeto. Entonces, b va a c, d va a f, y z va a b. Luego, cambie cada vocal a la siguiente vocal del alfabeto (u va a a). Por último, solo si la primera letra de la palabra es una consonante, mueva esa letra al final de la palabra y agregue "ay" al final de la palabra.

Ejemplos:

cat -> evday  
dog -> uhfay   
eel -> iim

• Este es el código de golf , por lo que gana el código más corto.
• El caso no importa.
• Las vocales que se utilizarán son A, E, I, O y U

Stax , 20 bytes

ù≥±╘├*Lâ■8O±âΓ║Θæ%º•

Ejecutar y depurarlo

Explicación

Vc:tVv:tBcVc#{sL"ay"+}ML             #Full program, unpacked, implicit input
Vc:t                                 #Push consonants and ring translate input
    Vv:t                             #Push vowels and ring translate input
        BCvc#                        #Push first letter and tail of word, find number 
                                     #of occurrences to consonants
             {sL"ay"+}M              #If truthy (word starts with consonant)
                                     #swap stack, listify, add "ay"
                       L             #Listify stack (combines words that start with vowel)

Pasé por algunas iteraciones y finalmente lo bajé a 20. Mi solución original fue de 53 bytes.

Ruby , 96 69 bytes

->s{/^[^aeiou]/=~(r=s.tr'zb-yadehinotu','b-zefijopuva')?$'+$&+'ay':r}

Pruébalo en línea!

Dato curioso del día: tr () hace coincidir las cadenas de derecha a izquierda. Siempre supuse que era de izquierda a derecha.

R , 86 85 bytes

Manera simple. chartrtiene la propiedad encantadora y útil de que puede especificar rangos de letras , que ahorran unos pocos bytes.

-1 bytes robando las cadenas de traducción de la solución Ruby de @ GB - ¡vota!

function(s)sub("^([^aeiou])(.*)","\\2\\1ay",chartr('zb-yadehinotu','b-zefijopuva',s))

Pruébalo en línea!

Java (JDK) , 167 bytes

s->{String r="",a="aeiouabcdfghjklmnpqrstvwxyzb",c=s.split("")[0];s=a.indexOf(c)>5?s.substring(1)+c+"ux":s;for(var d:s.split(""))r+=a.charAt(a.indexOf(d)+1);return r;}

Pruébalo en línea!

Créditos

• -7 bytes gracias a Kevin Cruijssen , que usa mejores tipos.
• -1 byte gracias a ceilingcat .

05AB1E , 21 bytes

žMDÀ‡žNDÀ‡¬žNsåiÀ…ÿay

Pruébalo en línea!

Explicación

žMDÀ‡                   # replace each vowel with the next vowel in the alphabet
     žNDÀ‡              # replace each consonant with the next consonant in the alphabet
          ¬žNsåi        # if the first letter is a consonant
                À…ÿay   # rotate the word left and add "ay"

Node.js 10.9.0 , 121 116 bytes

Espera la cadena de entrada en minúsculas.

s=>(v=n=>2130466>>n&1)((a=Buffer(s).map(n=>(g=i=>v(n=n%61?n+1:97)^i?g(i):n)(v(n))))[0],a+='')?a:a.slice(1)+a[0]+'ay'

Pruébalo en línea!

Identificando vocales

$v$

2130466 = 000001000001000001000100010
               ^     ^     ^   ^   ^
          zyxwvutsrqponmlkjihgfedcba-

Y lo hace:

(2130466 >> n) & 1

$n$

Deje que shiftCount sea ​​el resultado de enmascarar todos menos los 5 bits menos significativos de rnum , es decir, calcular rnum y 0x1F.

Comentado

s =>                      // s = input string
  ( v = n =>              // v = helper function taking n = ASCII code in [97..122]
    2130466 >> n & 1      //     and returning 1 if the corresponding character is a vowel
  )                       //     or 0 otherwise (see the previous paragraph)
  (                       // this statement will ultimately invoke v on a[0]
    ( a = Buffer(s)       //   convert s to a Buffer, holding ASCII codes
      .map(n =>           //   for each ASCII code n in there:
        ( g = i =>        //     g = recursive function taking i = vowel flag
          v(              //       update n and invoke v on the new value:
            n = n % 61 ?  //         if n is less than 122 (meaning less than 'z'):
              n + 1       //           increment n
            :             //         else:
              97          //           wrap around by setting n to 97 (meaning 'a')
          ) ^ i ?         //       if v(n) is not equal to i:
            g(i)          //         do recursive calls until it is
          :               //       else:
            n             //         stop recursion and return the new n
        )(v(n))           //     initial call to g with i = v(n)
      )                   //   end of map()
    )[0],                 //   invoke v on a[0]
    a += ''               //   coerce the updated Buffer back to a string
  ) ?                     // if a[0] is a vowel:
    a                     //   return the string as-is
  :                       // else:
    a.slice(1) + a[0]     //   move the leading consonant to the end
    + 'ay'                //   and append the 'ay' suffix

Python 2 , 153 121 110 99 91 bytes

lambda s:[s[1:]+s[0]+"ux",s][s[0]in'aeiou'].translate(8*".ecdfighjoklmnpuqrstvawxyzb.....")

Pruébalo en línea!

8 bytes eliminados debido a una sugerencia de Matthew Jensen

T-SQL, 169 bytes

SELECT IIF(CHARINDEX(LEFT(a,1),'aeiou')=0,SUBSTRING(a,2,99)+LEFT(a,1)+'ay',a)FROM
(SELECT TRANSLATE(v,'aeioubcdfghjklmnpqrstvwxyz','eiouacdfghjklmnpqrstvwxyzb')a FROM t)s

La entrada es a través de una tabla preexistente, según nuestros estándares de IO .

Realiza la sustitución de caracteres primero, usando el ( nuevo en SQL 2017 )TRANSLATE , luego verifica el primer carácter.

Molesto largo debido principalmente a la longitud de la palabra clave SQL.

Script de shell, 70 bytes

tr a-z b-{|tr eiou{bfjpv fjpvbeioua|sed -E 's/^([^aeiou])(.*)/\2\1ay/'

Pruébalo en línea!

Haskell , 102 97 bytes

h(c:r)|elem c"aeiou"=c:r|True=r++c:"ay"
f s=h["ecdfighjoklmnpuqrstvawxyzb"!!(fromEnum y-97)|y<-s]

Pruébalo en línea!

Retina 0.8.2 , 50 bytes

T`uo`aei\oub-df-hj-np-tv-zb
^([^aeiou])(.*)
$2$1ay

Pruébalo en línea! El enlace incluye casos de prueba. Enfoque similar a la respuesta R. Explicación:

T`uo`aei\oub-df-hj-np-tv-zb

ose refiere al otro conjunto, es decir aei\oub-df-hj-np-tv-zb, que se expande a aeioubcdfghjlkmnpqrstvwxyzb, por lo que se uoexpande a uaeioubcdfghjlkmnpqrstvwxyzb. Esto da como resultado la siguiente transliteración:

uaeioubcdfghjlkmnpqrstvwxyzb
aeioubcdfghjlkmnpqrstvwxyzb

Los segundos uy bse ignoran, ya que nunca pueden coincidir, por lo que esto proporciona el cifrado deseado. (Tenga en cuenta que en Retina 1, por supuesto, puede usarlo en vlugar de aei\ouahorrar 5 bytes).

^([^aeiou])(.*)
$2$1ay

Si la primera letra no es una vocal, gírala hasta el final y sufijo ay.

Jalea , 24 bytes

,ṙ¥1y
ØẹçØḄçṙḢe©ØḄƊ®⁾ayx

Pruébalo en línea!

Guardado 1 byte gracias a Jonathan Allan (use la sintaxis de dos caracteres en lugar de comillas).

> <> , 94 92 bytes

i:0(?v"a"%
2%?!v\~r:5g
a2r}<vr+ad*
ol?!;>4g
ecdfighjoklmnpuqrstvawxyzb
1   1   1     1     1

Pruébalo en línea!

Editar: ahorró 2 bytes al tomar el mod de entrada 97 en lugar de 32, por lo que el diccionario podría comenzar al comienzo de la línea. Versión previa:

i:0(?v84*%
2%?!v\~r:5g
37r}<vr*46*
ol?!;>4g
 ecdfighjoklmnpuqrstvawxyzb
 1   1   1     1     1

Rojo , 149 bytes

func[s][c:"aeioua.bcdfghjklmnpqrstvwxyzb"t: copy""foreach p s[append t c/(1
+ index? find c p)]if 7 < index? find c t/1[move t tail t append t"ay"]t]

Pruébalo en línea!

Como (casi) siempre, la entrada más larga

F # (Mono) , 197 bytes

let f(s:string)=
 let a="aeiouabcdfghjklmnpqrstvwxyzb"
 new string(s|>Seq.map(fun c->a.[a.IndexOf(c)+1])|>Seq.toArray)|>(fun x->if a.IndexOf(x.[0])>5 then x.Substring(1)+(string x.[0])+"ay"else x)

Pruébalo en línea!

Perl 5 , 56 bytes

y/a-z/ecdfighjok-npuq-tvaw-zb/;s/^([^aeiou])(.*)/$2$1ay/

Pruébalo en línea!

Dyalog APL (SBCS), 57 bytes

{a←⎕A{(⍺~⍵)⍵}'AEIOU'⋄('AY',⍨1⌽⊢)⍣(∊/⊃¨⍵a)⊢(⊂⍵⍳⍨∊a)⌷∊1⌽¨a}

Pruébalo en línea!

¡Toma entradas solo en mayúsculas! (Porque ⎕Aes alfabeto en mayúsculas)

• ⎕A{(⍺~⍵)⍵}'AEIOU': Vector de consonantes y vocales
• (⊂⍵⍳⍨∊a)⌷∊1⌽¨a: Utiliza índices de cada letra de la palabra en el alfabeto normal ( ⊂⍵⍳⍨∊a) para indexar ( ⌷) en el cifrado ∊1⌽¨a.
• ('AY',⍨1⌽⊢)⍣(∊/⊃¨⍵a): Mueve la primera letra al final y agrega 'AY', si la primera letra es una consonante.

¡Gracias por el genial desafío!

JavaScript (SpiderMonkey) , 107 bytes

x=>x.replace(/./g,y=>(z='aeiouabcdfghjklmnpqrstvwxyzb')[z.search(y)+1]).replace(/^([^aeiou])(.+)/,'$2$1ay')

Pruébalo en línea!

Espera entrada en minúsculas.

Reemplaza cada carácter de la cadena con el que está detrás de ella en la cadena 'aeiouabcdfghjklmnpqrstvwxyzb'y luego piglatinifica cualquier cosa con una consonante inicial.

PHP, 112 bytes

<?=strtr(($s=strstr(aeiou,($s=$argn)[0])?$s:substr($s,1).$s[0].ux),join(range(a,z)),ecdfighjoklmnpuqrstvawxyzb);

o

<?=strtr(($s=strstr(aeiou,($argn)[0])?$argn:substr($s,1).$s[0].ux),join(range(a,z)),ecdfighjoklmnpuqrstvawxyzb);

Asumir entrada en minúsculas. Ejecutar como tubería -nRo probarlos en línea .

También podría usar en
strtr($s,uzbcadfgehjklminpqrsotvwxy,range(a,z))lugar de
strtr($s,range(a,z),ecdfighjoklmnpuqrstvawxyzb).