Pronunciando Hex

Para aqueles que não são iniciantes no programa Vale do Silício, esse desafio é inspirado em uma troca assim ( YouTube ):

Kid -
  Here it is: Bit… soup. It’s like alphabet soup, BUT… it’s ones and zeros 
  instead of letters.
Erlich Bachman -
  {silence}
Kid -
  ‘Cause it’s binary? You know, binary’s just ones and zeroes.
Erlich Bachman -
  Yeah, I know what binary is. Jesus Christ, I memorized the hexadecimal 
  times tables when I was fourteen writing machine code. Okay? Ask me 
  what nine times F is. It’s fleventy-five. I don’t need you to tell me what binary is.

Deve-se notar que, tecnicamente, 0x9 * 0xF = 0x87não 'fleventy-five', mas isso traz uma questão importante - como você realmente pronunciava azar na conversa? Não é como oh ex eff efffluir da língua facilmente, então o que devemos fazer? Aqui está um gráfico de pronúncia útil que seguiremos.

A = ay       A0 = atta-       
B = bee      B0 = bibbity-    
C = cee      C0 = city-       
D = dee      D0 = dickety-    
E = ee       E0 = ebbity-     
F = eff      F0 = fleventy-   

Podemos dividir um número hexadecimal de quatro comprimentos em dois grupos de dois e determinar a pronúncia da tabela acima, bem como a pronúncia comum em inglês para números. Então, por exemplo 0xFFAB, teríamos Fleventy-eff bitey atta-bee.

Se um número estiver incluído, como 0xF5AB, você imprimiria Fleventy-five bitey atta-bee. Além disso, se um número inicia um dos grupos, você deve usar a pronúncia "dezenas". Por exemplo, 0x5FAAse tornaria Fifty-eff bitey atta-ay. No caso em que você tem algo parecido 0x1FAC, isso seria Effteen bitey atta-cee. Porém, se essa regra fosse usada 0x1AF4, a-teenpoderia ser confundida com eighteen, portanto, você deve adicionar um Y. Portanto, a saída correta seriaYayteen bitey fleventy-four

No caso de 0xD0F4, em vez de fazer Dickety-zero bitey fleventy-four, ignoraríamos o zero e imprimiríamos Dickety-bitey fleventy-four.

Os hífens devem aparecer apenas dentro dos grupos de dois, ou seja, o bitey não deve ser conectado a nenhum dos grupos com um hífen, a menos que o primeiro grupo seja apenas uma palavra! Assim 0x04F4seria four-bitey fleventy-four, mas 0x44F4seria forty-four bitey fleventy-four. Como o tricoplax disse, a mordida só deve ser hifenizada ao seguir um número redondo.

Para uma visão abrangente de como isso funcionará, confira o exemplo de E / S abaixo.

Objetivo

Crie um programa ou função que use uma string hexadecimal como argumento de entrada ou função e produza sua pronúncia. A saída deve ter capitalização adequada. Você pode supor que o tamanho desse número sempre será 4.

Exemplo de E / S

"0xFFFF" -> "Fleventy-eff bitey fleventy-eff"
"0x0000" -> "Zero"
"0x0010" -> "Ten"
"0x0100" -> "One-bitey zero"
"0x1110" -> "Eleven-bitey ten"
"0xBEEF" -> "Bibbity-ee bitey ebbity-eff"
"0x9999" -> "Ninety-nine bitey ninety-nine"
"0xA1B2" -> "Atta-one bitey bibbity-two"
"0x3C4F" -> "Thirty-cee bitey forty-eff"
"0x17AB" -> "Seventeen-bitey atta-bee"
"0x1AFB" -> "Yayteen-bitey fleventy-bee"
"0xAAAA" -> "Atta-ay bitey atta-ay"

Isso é código-golfe , portanto, o menor número de bytes vence.

Pyth - 312 293 286 251 bytes

Hora de começar a reduzir os dados, chegando mais.

Santo maior programa Pyth que eu já escrevi! Ainda há uma enorme compactação possível com os dados, tanto algortiimicamente quanto com base de conversão, mas apenas queria colocar isso em prática.

Kcs@LGjC"qNjÆÉý(7läQ«I?sfçÂØ^Ðûü»   u$ÐÃoó}QÛã´Hf®?Nâ²-YÜZÔ7ÂþæX#\"åØ"26\q=+K>K11J.e?+?bnb\|@K+16k"ty"-kTbc"  twen | for | | | | | atta bibbi ci dicke ebbi fleven"d.srj"bitey "m?++@Kd?k<d18"teen"\-<d32+j\-@V,JKfT.Dd16\ ?Gh=G.DQ256tG4\-

Eu interpreto a entrada como hexadecimal através de Q, que ele detecta automaticamente com o 0x. Em seguida, divmodo-o para 256 bytes, removo o primeiro byte se for zero e mapeio-o através de duas matrizes, uma para 0-1Fe depois 20-F0. O segundo também recebe um divmod através do primeiro array. A primeira opção obtém um hifen no final e a segunda obtém um hífen no meio e um espaço no final. Junte-se "bitey ", capitalize com o alcance e retire hífens .se nós somos bons.

A parte da compactação básica também é interessante porque eu comecei com a conversão básica de 128 -> 256. Mas agora, o que estou fazendo é usar "q"como separador em vez de espaço. Portanto, agora posso considerar a string como uma base 26 xLG, melhorando tremendamente a compactação.

Experimente aqui online .

Conjunto de teste .

Java - 856 bytes

Não é curto, mas pelo menos a segunda resposta;)

É um método chamado String p(String n)que fará o trabalho:

String p(String n){String[]b={"","ten","twen","thir","for","fif","six","seven","eigh","nine",
"atta","bibbi","ci","dicke","ebbi","fleven"};String[]s={"zero","one","two","three","four",
"five","six","seven","eight","nine","ay","bee","cee","dee","ee","eff"};String[]t={"ten",
"eleven","twelve","thir","four","fif","six","seven","eigh","nine","yay","bee","cee","dee",
"ee","eff"};int w=Byte.valueOf(n.substring(2,3),16);int x=Byte.valueOf(n.substring(3,4),16);
int y=Byte.valueOf(n.substring(4,5),16);int z=Byte.valueOf(n.substring(5,6),16);String r=(w==
1?t[x]+(x>2?"teen":""):((w==0?"":b[w]+(w>1&&w!=10?"ty":"")+"-")+(w==0&&x==0?"":s[x])))+((w==0
&&x>0||w==1&&x<3||w>0&&x==0)?"-":w==0&&x==0?"":" ")+(w>0||x>0?"bitey ":"")+(y==1?t[z]+(z>2?
"teen":""):((y==0?"":b[y]+(y>1&&y!=10?"ty":"")+"-")+(y>1&&z!=0||y==0?s[z]:"")));return (char)
(r.charAt(0)-32)+r.substring(1);}

Javascript - 577 719 bytes

function h(e){for(e=e.match(/.{1,2}/g),r="",i=1;i<e.length;i++)j=parseInt("0x"+e[i]),0!=j?r+=c(parseInt("0x"+e[i]))+"bitey ":i>1?r+="zero-bitey":0;return r=""==r?"Zero":r[0].toUpperCase()+r.substr(1,r.length-7),null!==r[r.length-1].match(/[-\s]$/g)?r=r.substr(0,r.length-1):0,r}function c(e){return d=["zero","one","two","three","four","five","six","seven","eight","nine","ay","bee","cee","dee","ee","eff","ten","eleven","twelve","thir","four","fif","six","seven","eigh","nine","yay","bee","cee","dee","ee","eff"],p=["twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety","atta","bibbity","city","dickety","ebbity","fleventy"],1>e?"":e>31?p[Math.floor(e/16)-2]+"-"+d[e%16]+" ":17>e?d[e]+"-":d[e]+"teen-"}

Tenho certeza de que há melhorias a serem feitas. Adicionado bônus, ele analisa seqüências hexagonais de comprimento arbitrário.

EDIT: Opa, ele não funciona direito quando há zeros à esquerda. Hum.

EDIT 2: Corrigido, eu acho. JSFiddle