A Cifra Latina Melhor de César Porco

32

O problema com a cifra de César é que as palavras resultantes são muitas vezes impronunciáveis. O problema com o Pig Latin é que é fácil decodificar. Por que não combiná-los?

Entrada

Uma palavra que consiste nas 26 letras em inglês.

Saída

Primeiro, mude cada consoante na palavra para a próxima consoante no alfabeto. Então, b vai para c, d vai para f, e z vai para b. Em seguida, mude cada vogal para a próxima vogal do alfabeto (u vai para a). Por último, somente se a primeira letra da palavra for consoante, mova essa letra para o final da palavra e adicione "ay" ao final da palavra.

Exemplos:

cat -> evday  
dog -> uhfay   
eel -> iim
  • Isso é , então o código mais curto vence.
  • Caso não importa.
  • As vogais que serão usadas são A, E, I, O e U
qazwsx
fonte
2
Não, mas você pode, se quiser
qazwsx
6
Bem-vindo ao PPCG! Desafio muito bom, claramente apresentado.
Jonathan Allan
6
Caso de teste sugerido:z → bay
Arnauld 16/09
1
jot ot e wisz opvisitvoph dupdiqv cav o fu puv vjopl ov jimqt xovj vji ecomovz vu qsupuapdi vji xusftvay
Shadow
4
Caso de teste sugerido the → jivay:? (Isto é, se a palavra começa com várias consoantes, não só mover um deles?)
DLosc

Respostas:

3

Stax , 20 bytes

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

Execute e depure

Explicação

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)

Passei por algumas iterações e finalmente a reduzi para 20. Minha solução original era 53 bytes.

Multi
fonte
7

Ruby , 96 69 bytes

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

Experimente online!

Curiosidade do dia: tr () corresponde às seqüências da direita para a esquerda. Eu sempre assumi que era da esquerda para a direita.

GB
fonte
6

R , 86 85 bytes

Maneira simples. chartrpossui a propriedade útil e encantadora que pode especificar intervalos de letras , economizando alguns bytes.

-1 bytes roubando as strings de tradução da solução Ruby da GB - atualize-a!

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

Experimente online!

J.Doe
fonte
5

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

Experimente online!

Créditos

Olivier Grégoire
fonte
1
168 bytes
Kevin Cruijssen
4

05AB1E , 21 bytes

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

Experimente online!

Explicação

ž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"
Emigna
fonte
4

Node.js 10.9.0 , 121 116 bytes

Espera a sequência de entrada em 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'

Experimente online!

Identificando vogais

v

2130466 = 000001000001000001000100010
               ^     ^     ^   ^   ^
          zyxwvutsrqponmlkjihgfedcba-

E faz:

(2130466 >> n) & 1

n

Seja shiftCount o resultado de mascarar todos, exceto os 5 bits menos significativos de rnum , ou seja, computar rnum e 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
Arnauld
fonte
4

Python 2 , 153 121 110 99 91 bytes

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

Experimente online!

8 bytes cortados devido a uma sugestão de Matthew Jensen

Chas Brown
fonte
Você pode salvar 8 bytes usando a função string.translate ():lambda s:[s[1:]+s[0]+"ux",s][s[0]in'aeiou'].translate(8*".ecdfighjoklmnpuqrstvawxyzb.....")
Matthew Jensen
@MatthewJensen Clever! Normalmente eu evito translateem Python 2 ...
Chas Brown 14/11
Coincidentemente, agora também funciona para maiúsculas
Matthew Jensen
3

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

A entrada é feita através de uma tabela pré-existente, de acordo com nossos padrões de IO .

Executa a substituição de caracteres primeiro, usando a função ( new to SQL 2017 ) TRANSLATE, e depois verifica o primeiro caractere.

Irritante por muito tempo devido ao tamanho da palavra-chave SQL.

BradC
fonte
3

Script de shell, 70 bytes

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

Experimente online!

Anjo
fonte
3

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]

Experimente online!

Curtis Bechtel
fonte
2

Retina 0.8.2 , 50 bytes

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

Experimente online! O link inclui casos de teste. Abordagem semelhante à resposta R. Explicação:

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

orefere-se ao outro conjunto, ou seja aei\oub-df-hj-np-tv-zb, que se expande para aeioubcdfghjlkmnpqrstvwxyzb, então se uoexpande para uaeioubcdfghjlkmnpqrstvwxyzb. Isso resulta na seguinte transliteração:

uaeioubcdfghjlkmnpqrstvwxyzb
aeioubcdfghjlkmnpqrstvwxyzb

O segundo ue bsão ignorados, pois nunca podem ser correspondidos, portanto, isso fornece a cifra desejada. (Observe que na Retina 1 você pode, é claro, usar em vvez de aei\oueconomizar 5 bytes.)

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

Se a primeira letra não for uma vogal, gire-a até o final e coloque o sufixo ay.

Neil
fonte
2

Gelatina , 24 bytes

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

Experimente online!

Economizou 1 byte graças a Jonathan Allan (use a sintaxe de dois caracteres em vez de aspas).

Mr. Xcoder
fonte
Infelizmente, versão muito mais sadia e não furtiva ( equivalente furtivo 1 bit mais curto ). Eu não será capaz de atualizar esta dentro das próximas horas, mas não apontar se você encontrar melhorias.
Mr. Xcoder
Use ⁾aypara um byte. O ©poderia ir após o eque é isso que você está armazenando. Eu tenho ØẹØḄ,żṙ€¥1ẎyṙḢe©ØḄƊ®⁾ayẋ.
Jonathan Allan
2

> <> , 94 92 bytes

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

Experimente online!

Editar: salvou 2 bytes usando a entrada 97, em vez de 32, para que o dicionário iniciasse no início da linha. Versão anterior:

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

Vermelho , 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]

Experimente online!

Como (quase) sempre, a entrada mais longa

Galen Ivanov
fonte
1

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)

Experimente online!

Henrik Hansen
fonte
1

Perl 5 , 56 bytes

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

Experimente online!

hobbs
fonte
1
Você precisa de -s entre ce dou ge h?
Neil
@ Neil não, eu não. Eu escrevi um programa para comprimir os intervalos ... e entendi errado a lógica :) Obrigado.
Hbbs #
Normalmente, nesses casos, você escreve <s>58</s> 56 bytesno cabeçalho e muitas pessoas adicionam um "Editar: salvou 2 bytes graças ao @Neil". ou alguns quando são ajudados em um comentário.
Neil
1

Dyalog APL (SBCS), 57 bytes

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

Experimente online!

Recebe entrada apenas em maiúsculas! (Porque ⎕Aé o alfabeto maiúsculo)

  • ⎕A{(⍺~⍵)⍵}'AEIOU': Vetor de consoantes e vogais
  • (⊂⍵⍳⍨∊a)⌷∊1⌽¨a: Usa índices de cada letra da palavra no alfabeto normal ( ⊂⍵⍳⍨∊a) para indexar ( ) na cifra ∊1⌽¨a.
  • ('AY',⍨1⌽⊢)⍣(∊/⊃¨⍵a): Move a primeira letra para o final e acrescenta 'AY', se a primeira letra for uma consoante.

Obrigado pelo desafio legal!

akhmorn
fonte
0

JavaScript (SpiderMonkey) , 107 bytes

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

Experimente online!

Espera entrada em minúsculas.

Substitui cada caractere da sequência por um na sequência 'aeiouabcdfghjklmnpqrstvwxyzb'e, em seguida, piglatinifica qualquer coisa com uma consoante inicial.

Yair Rand
fonte
0

PHP, 112 bytes

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

ou

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

assumir entrada em minúsculas. Execute como pipe -nRou experimente-os online .


Você também pode usar em
strtr($s,uzbcadfgehjklminpqrsotvwxy,range(a,z))vez de
strtr($s,range(a,z),ecdfighjoklmnpuqrstvawxyzb).

Titus
fonte