Números que são realmente letras


42

Dada uma entrada de número inteiro não negativo, escrever um programa que converte o número de hexadecimal e retorna um valor truthy se a forma hexadecimal do número contém apenas os caracteres Aatravés Fe um valor Falsey contrário.


Casos de teste

10
==> True (A in hexadecimal)

100
==> False (64 in hexadecimal)

161
==> False (A1 in hexadecimal)

11259375
==> True (ABCDEF in hexadecimal)

0
==> False (0 in hexadecimal)

Bônus: -40 bytes se o seu programa imprimir Only letterspara o desafio descrito acima, Only numbersse a versão hexadecimal do número contiver apenas os dígitos 0-9e Mixse o número hexadecimal contiver pelo menos um número e pelo menos uma letra.


Isso é código de golfe. Aplicam-se regras padrão. O menor código em bytes vence. São permitidas funções ou programas completos.


2
Atualmente elaborando uma resposta em Golfical.
SuperJedi224

Minha idéia atual: dissimular a base da string 16 e, em seguida, ver se a tentativa de analisar essa string como um número base 10 retornaNaN
Cyoce

@Cyoce Isso pode funcionar, dependendo da sua escolha de idioma
SuperJedi224

3
Bônus irrealista (mais uma vez): apenas a corda MixOnlynumberslettersé de 21 caracteres
edc65

3
Você diz "entrada inteira positiva", mas 0 é um caso de teste.
xnor

Respostas:


22

Pitão, 43 - 40 = 3 bytes

?&K@J.HQG-JG"Mix"%"Only %sers"?K"lett""numb

Suíte de teste

Isso alcança o bônus. Only numberse Only lettersfelizmente diferem apenas por 4 letras. A formatação no estilo printf é usada com %.

O sistema de seleção é realizado através da interseção do hexágono com Go alfabeto e da subtração G. Se nenhum deles acaba sendo falso, é uma mistura, enquanto se o cruzamento é falso, são números, e se a subtração é falso, são letras.


1
Droga, este Pyth é estranho. Seria muito legal se você pudesse obter uma pontuação negativa.
KaareZ

15

Pitão, 6 bytes

!-.HQG

  .HQ   # Converts the input to hexadecimal
 -   G  # Deletes all letters
!       # If empty, output True, else False

Teste aqui


12

Gelatina , 6 bytes

b16>9P

Experimente online!

Como funciona

b16>9P  Input: z

b16     Convert the input to base 16.
   >9   Compare each resulting digit with 9; return 1 iff greater.
     P  Take the product of the resulting Booleans.

Não existe um para 16 ou isso não é uma coisa?
CalculatorFeline

1
Existe agora. Esta foi uma das primeiras respostas geléia ...
Dennis

11

TeaScript , 11 bytes 13 15 16

xT(16)O(Sz)

Bem simples. Isso usa o TeaScript 2.0. Você pode obter esta versão no Github

Explicação

        // Implicit: x = input, Sz = alphabet
xT(16)  // input -> hex
O(Sz)   // Only letters?

Experimente online (versão ligeiramente modificada que funciona na web)


3
É o voto negativo porque isso é longo? Há algo mais errado com esta resposta que eu não conheço? Ou alguém simplesmente não gosta dessa resposta pessoalmente?
Downgoat 12/12/15

2
Eu não diria 16 ou 13 bytes é longo!
Luis Mendo

23
Você deve admitir que fazer down-down de suas postagens é bastante tentador.
Dennis

10

Python, 24 bytes

lambda n:min('%x'%n)>'9'

Converte a entrada em uma sequência hexadecimal (sem 0xprefixo) '%x'%n. Vê se todos os caracteres são maiores que '9'(quais letras são), verificando se o valor minestá acima '9'.


Não sei como o Python lida com caracteres / números, mas o código ASCII '9'é 54. Portanto, se você pode escrever, ...>54pode salvar um byte.
CompuChip

O @CompuChip Python não trata caracteres ou seqüências de caracteres como números. De fato, o Python 2 os considera maiores que todos os números.
Xnor

8

MATL , 10

i16YA1Y2mA

Exemplos

>> matl i16YA1Y2mA
> 240
0
>> matl i16YA1Y2mA
> 255
1

Explicação

i       % input                         
16YA    % convert to string representation in base 16
1Y2     % predefined literal: 'A':'Z'
m       % true for set member             
A       % all

Desafio de bônus: 53−40 = 13

i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]

Exemplos

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 255
Only letters

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 100
Only numbers

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 240
Mix

Explicação

i                       % input                                                 
16YA                    % convert integer to string representation in base 16
1Y2                     % predefined literal: 'A':'Z'
m                       % true for set member       
XK                      % copy to clipboard K                 
A                       % all                                   
?                       % if (top of the stack)                 
  'Only letters'        % string literal                                        
}                       % else                 
  K                     % paste from clipboard K      
  a                     % any                
  ?                     % if (top of the stack)      
    'Mix'               % string literal    
  }                     % else                                                  
    'Only numbers'      % string literal           
  ]                     % end             
]                       % end          

2
hmmm o que é isso? parece que o matlab tem um pouco de poder nuc agora!
Abr001am 12/12

@ Agawa001 Hahaha. Sort of
Luis Mendo


8

C, 46 43 37 bytes

Agora com mais recursão! (Obrigado Dennis):

F(x){return(x%16>9)*(x<16?:F(x/16));}

Bônus: ainda mais curto (33 bytes), mas falha em x = 0:

F(x){return!x?:(x%16>9)*F(x/16);}

b;F(x){for(b=x;x;x/=16)b*=x%16>9;return b;}

F()recebe um inte retorna 0(falso) ou diferente de zero (verdadeiro).

Eu nem tentei obter o bônus, "MixOnly lettersnumbers"ocupa 23 bytes sozinho, rastrear a nova condição exigiria 9 bytes adicionais, printf()é 8 bytes, o que totaliza 40, anulando o esforço.

Teste principal:

#include <stdio.h>

int main() {
  int testdata[] = {10, 100, 161, 11259375, 0};
  for (int i = 0; i < 5; ++i) {
    int d = testdata[i];
    printf("%d (0x%x) -> %s\n", d, d, F(d)?"yep":"nope");
  }
}

O que é ?:? Eu tive que substituí- ||lo por para compilar. Além disso, você pode salvar um byte substituindo o *com &por evitando os ()s à esquerda (embora você precise adicionar um espaço)?
Neil

@ Neil a?:bé uma extensão GNU que avalia ase aé um valor verdadeiro, caso contrário, para b. É útil para lidar com ponteiros nulos como send(message ?: "(no message)");. Eu sei que não é portátil, mas a portabilidade de código nunca é uma preocupação no golfe código :)
Stefano Sanfilippo

@StefanoSanfilippo, você pode reduzir isso para 33bytes fazendo isso: F(x){x=(x%16>9)*(x<16?:F(x/16));}isso abusa de um bug (GCC) em que se não houver variável de retorno em uma função e o argumento principal foi definido, ele retornará automaticamente o argumento principal em alguns casos ( com base em que lógica foi feita), e esse é um desses casos! Experimente on-line: bit.ly/2pR52UH
Albert Renshaw

8

Python 3, 30 29 bytes

1 byte removido graças ao sysreq e Python 3.

lambda n:hex(n)[2:].isalpha()

Simples lambdae fatiado.


7

Perl 6 , 18 bytes

{.base(16)!~~/\d/} # 18 bytes

uso:

# give it a name
my &code = {.base(16)!~~/\d/}

for 10, 100, 161, 11259375, 0 {
  printf "%8s %6s %s\n", $_, .base(16), .&code
}

      10      A True
     100     64 False
     161     A1 False
11259375 ABCDEF True
       0      0 False

7

Mathematica, 32 bytes

Tr@DigitCount[#,16,0~Range~9]<1&

Explicação:

                               &   A function returning whether
Tr@                                 the sum of elements of
   DigitCount[ ,  ,         ]        the numbers of
                   0~Range~9          zeros, ones, ..., nines in
                16                    the hexadecimal expansion of
              #                       the first argument
                             <1     is less than one.

7

Javascript, ES6, sem regexp, 28 bytes

F=n=>n%16>9&&(n<16||F(n>>4))

Há também essa versão de 27 bytes, mas ela retorna o valor inverso.

F=n=>n%16<10||n>15&&F(n>>4)

Agradável! Você também pode reorganizá-lo assim por 23 bytes:F=n=>!n||n%16>9&F(n>>4)
user81655

@ user81655 - Infelizmente, essa versão retorna true para 0, então está incorreta.
Zocky

Ah, certo, acho que o menor seria F=n=>n%16>9&&n<16|F(n>>4)então.
user81655

@ user81655 Tenho certeza de que você precisa dar um curto-circuito no ||, mas acho que você pode se safar de usar em &vez de &&nesse caso.
Neil

@ Neil Por que isso? Você testou?
user81655

7

Julia, 18 bytes

n->isalpha(hex(n))

Esta é uma função anônima que aceita um número inteiro e retorna um booleano. Para chamá-lo, dê um nome, por exemplo f=n->....

A entrada é convertida em uma cadeia hexadecimal usando hex, então verificamos se é totalmente composto por caracteres alfabéticos usando isalpha.


6

JavaScript ES6, 29

Nenhum bônus

n=>!/\d/.test(n.toString(16))

Com o novo valor de -40, o bônus está mais próximo agora ... mas não o suficiente. Escore de bônus 70 71 - 40 => 30 31

n=>/\d/.test(n=n.toString(16))?1/n?'Only numbers':'Mix':'Only letters'

Snippet de teste (digite um número dentro da caixa de entrada)

#I { width:50%}
<input id=I oninput="test()"/><br>
Hex <span id=H></span><br>
Result <span id=R></span>


-n-1= ~ncerto?
CalculatorFeline

@CatsAreFluffy se n não é numérico, tal como 'A' (que é o ponto inteiro neste desafio), ~n == -1enquanto-n-1 == NaN
edc65

4

GS2 , 6 bytes

V↔i/◙s

O código fonte usa a codificação CP437. Experimente online!

Como funciona

V       Evaluate the input.
 ↔      Push 16.
  i     Perform base conversion.
   /    Sort.
    ◙   Push [10].
     s  Perform greater-or-equal comparison.


4

Java, 46 44 38 bytes

i->i.toHexString(i).matches("[a-f]+");

Linha simples bastante simples que converte o número inteiro em uma sequência hexadecimal e usa regex para determinar se todos os caracteres são letras.

-2 bytes graças a @ Eng.Fouad.


"[a-f]+"economizaria 2 bytes.
Eng.Fouad

Falha na 516 ..
CalculatorFeline

@CatsAreFluffy Não, não.
TNT

Bem, agora ela determina se a string contém uma letra hexadecimal, então remova o +–é um desperdício de bytes.
CalculatorFeline

@CatsAreFluffy No. matches retorna true se a string inteira puder ser correspondida pelo regex especificado. [a-f]sem o sinal de adição está incorreto, pois não corresponde à cadeia inteira, pois contém mais de um caractere; seria se e somente se um caractere válido estiver presente.
TNT


3

Ruby, 19 bytes

->n{!('%x'%n)[/\d/]}

Ungolfed:

-> n {
  !('%x'%n)[/\d/]
}

Uso:

f=->n{!('%x'%n)[/\d/]} # Assigning it to a variable
f[0]
=> false
f[10]
=> true
f[100]
=> false
f[161]
=> false
f[11259375]
=> true

Com bônus, 70 - 40 = 30 bytes

->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}

Uso:

f=->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}
f[10]
=> Only letters
f[100]
=> Only numbers
f[161]
=> Mix

Tarde, mas '%x'%n!~/\d/é uma verificação mais curto para solução de um e dois solução tem uma contagem de matéria-byte de 70, não 75.
Valor Ink

3

Perl, 69 - 40 = 29 bytes

$_=sprintf"%X",<>;print s/\d//?$_?"Mix":"Only numbers":"Only letters"

2

Ceilão, 55 bytes

Boolean l(Integer n)=>!any(formatInteger(n,16)*.digit);

Direto ... formamos ncomo um número hexadecimal (que produz uma string), chamamos para cada caractere dessa string o .digitnúmero (que retorna verdadeiro se for um dígito), depois verificamos se algum deles é verdadeiro, e negamos isso.

A versão com bônus tem uma pontuação muito maior de 119 - 25 = 94 :

String c(Integer n)=>let(s=formatInteger(n),d=s*.digit)(every(d)then"Only numbers"else(any(d)then"Mix"else"Only letters"));

Não tenho certeza de como alguém poderia fazer uma versão bônus curta o suficiente para ser melhor que a versão sem bônus, mesmo aquelas cordas sozinhas têm comprimento 28 juntas. Talvez uma linguagem que dificulte a produção de um valor de verdade / falsey.

Aqui está uma versão formatada:

String c(Integer n) =>
        let (d = formatInteger(n,16)*.digit)
    (every(d) then "Only numbers"
                else (any(d) then "Mix"
                    else "Only letters"));

2

Ferrugem, 70 bytes

fn f(n:i32)->bool{format!("{:x}",n).chars().all(|c|c.is_alphabetic())}

Porque, você sabe, Java Rust.

Na verdade, é bastante elegante:

format!("{:x}", n)         // format n as hex (:x)
  .chars()                 // get an Iter over the characters
  .all(                    // do all Iter elements satisfy the closure?
    |c| c.is_alphabetic()  // self-explanatory
  )

Mas é uma pena que o clichê de definição de função seja tão longo ....: P


Eu tenho uma ideia. Mais fechamentos!
CalculatorFeline


2

Sério, 12 bytes

4ª,¡OkúOkd-Y

Hex Dump:

34a62cad4f6b
a34f6b642d59

Experimente Online

É o mesmo que as outras respostas no idioma da pilha. Seria apenas 7 bytes se a subtração de seqüência seriamente suportada.

Edição: agora seriamente suporta subtração de seqüência de caracteres e a seguinte solução de 7 bytes agora funciona:

ú4╙,¡-Y

Hex Dump:

a334d32cad2d59

Experimente Online


1
11: 4╙,¡#S;ú∩S=(ou ou , muitas maneiras de soletrar :16:em dois bytes: P)
Mego

Eu não sabia que SI pensava.
quintopia 14/12/2015

2

05AB1E , 2 bytes (não concorrente)

Código:

ha

Ha! Isso são dois bytes! Infelizmente, não concorre porque esse idioma adia o desafio :(

Explicação:

h   # Convert input to hexadecimal
 a  # is_alpha, checks if the value only contains letters

Experimente online! ou Verifique todos os casos de teste!


1
hdÔ©1åi•4?ŸâτΛ•}®0åi•4?ŸàpÕTà•}®g2Qi•²•} 36B` pelo bônus que resulta em ... mais 6! Wooooo bônus!
Magic Octopus Urn



2

SmileBASIC 3.2.1, 78 bytes

INPUT V FOR I=0 TO 9
IF INSTR(HEX$(V),STR$(I))>-1 THEN ?"FALSE"END
NEXT?"TRUE"

Não vejo caracteres não ASCII aqui (a menos que haja alguns); esse contador é o decisivo definitivo e diz 81.
cat

1
Não importa que a implementação use UTF-16 internamente; para o resto do mundo, eles também podem ser caracteres UTF-8 no intervalo 0-127, portanto, sua contagem de bytes é 81.
gato

Obrigado pelo feedback, não tinha certeza se "bytes" significava que eu deveria contar 2 por caractere. 81 é isso.
snail_

Na verdade, o consenso atual de +10 / -0 (que, a propósito, agora discordo) é que devemos sempre usar a codificação usada por um intérprete. Se você não concordar, envie uma opinião divergente sobre essa questão.
lirtosiast

@ThomasKwa pfft, ok, oops, agora eu sei melhor. Eu não percebi que havia um consenso sobre isso, e passo bastante tempo na meta.
gato

1

Japonês, 12 bytes

!UsG r"[a-f]

Experimente online!

Como funciona

!UsG r"[a-f] // Implicit: U = input integer, G = 16
 UsG         // Convert U to a base-16 string.
     r"[a-f] // Replace all lowercase letters with an empty string.
!            // Take the logical NOT of the result.
             // This returns true for an empty string; false for anything else.

Eu acho que !!UsG r"\\dpode funcionar e salvar um byte
Downgoat

@Downgoat Boa observação, mas isso retorna verdadeiro para qualquer número que contenha uma letra.
ETHproductions

1

Gema, 41 caracteres

*=@c{@radix{10;16;*}}
c:<D>=f@end;?=;\Z=t

Como não existe booleano no Gema, ele simplesmente gera "t" ou "f".

Exemplo de execução:

bash-4.3$ echo -n '11259375' | gema '*=@c{@radix{10;16;*}};c:<D>=f@end;?=;\Z=t'
t
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.