Dada una entrada de número entero no negativo, escribir un programa que convierte el número en hexadecimal y devuelve un valor Truthy si la forma hexadecimal del número contiene sólo los caracteres Aa través Fy un valor Falsey lo contrario.

Casos de prueba

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)

Bonificación: -40 bytes si su programa imprime Only letterspara el desafío descrito anteriormente, Only numberssi la versión hexadecimal del número solo contiene los dígitos 0-9y Mixsi el número hexadecimal contiene al menos un número y al menos una letra.

Este es el código de golf. Aplican reglas estándar. El código más corto en bytes gana. Se permiten funciones o programas completos.

Pyth, 43-40 = 3 bytes

?&[email protected]"Mix"%"Only %sers"?K"lett""numb

Banco de pruebas

Esto logra la bonificación. Only numbersy Only lettersafortunadamente solo difieren en 4 letras. Se utiliza el formato de estilo printf con %.

El sistema de selección se realiza tomando la intersección del hex con Gel alfabeto y restando G. Si ninguno de los dos termina siendo falso, es una mezcla, mientras que si la intersección es falsa, son números, y si la resta es falsa, son letras.

Pyth, 6 bytes

!-.HQG

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

Pruébalo aquí

Jalea , 6 bytes

b16>9P

Pruébalo en línea!

Cómo 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.

TeaScript , 11 bytes 13 15 16

xT(16)O(Sz)

Bastante simple. Esto usa TeaScript 2.0. Puedes obtener esta versión de Github

Explicación

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

Pruébelo en línea (versión ligeramente modificada que funciona en la web)

Python, 24 bytes

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

Convierte la entrada en una cadena hexadecimal (sin 0xprefijo) con '%x'%n. Ve si todos sus caracteres son mayores que '9'(qué letras son) al ver si minestá arriba '9'.

MATL , 10

i16YA1Y2mA

Ejemplos

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

Explicación

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

Reto de bonificación: 53−40 = 13

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

Ejemplos

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

Explicación

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          

LabVIEW, 52-40 = 12 primitivas de LabVIEW

Alabado sea el incorporado!

C, 46 43 37 bytes

¡Ahora con más recursividad! (Gracias Dennis):

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

Bono: incluso más corto (33 bytes), pero falla por 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()toma un inty devuelve 0(falso) o no cero (verdadero).

Ni siquiera intenté alcanzar la bonificación, solo "MixOnly lettersnumbers"toma 23 bytes, el seguimiento de la nueva condición habría requerido 9 bytes adicionales, printf()es de 8 bytes, lo que suma 40, anulando el esfuerzo.

Prueba 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");
  }
}

Python 3, 30 29 bytes

1 byte eliminado gracias a sysreq y Python 3.

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

Simple lambday rebanador.

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

Mathematica, 32 bytes

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

Explicación:

                               &   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.

Javascript, ES6, no regexp, 28 bytes

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

También existe esta versión de 27 bytes, pero devuelve el valor inverso.

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

Julia, 18 bytes

n->isalpha(hex(n))

Esta es una función anónima que acepta un entero y devuelve un booleano. Para llamarlo, dale un nombre, por ejemplo f=n->....

La entrada se convierte en una cadena hexadecimal usando hex, luego verificamos si está completamente compuesta de caracteres alfabéticos usando isalpha.

JavaScript ES6, 29

Sin bonificación

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

Con el nuevo valor de -40, el bono está más cerca ahora ... pero no lo suficiente. Puntuación de bonificación 70 71 - 40 => 30 31

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

Fragmento de prueba (escriba un número dentro del cuadro de entrada)

#I { width:50%}

<input id=I oninput="test()"/><br>
Hex <span id=H></span><br>
Result <span id=R></span>

GS2 , 6 bytes

V↔i/◙s

El código fuente usa la codificación CP437. Pruébalo en línea!

Cómo funciona

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

Octava, 22 bytes

@(n)all(dec2hex(n)>64)

Java, 46 44 38 bytes

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

Bastante simple que convierte el número entero en una cadena hexadecimal y usa expresiones regulares para determinar si todos los caracteres son letras.

-2 bytes gracias a @ Eng.Fouad.

CJam ( 9 8 bytes)

{GbA,&!}

Demostración en línea

Ruby, 19 bytes

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

Sin golf:

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

Con bonificación, 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

Perl, 69-40 = 29 bytes

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

Ceilán, 55 bytes

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

Directo ... formateamos ncomo un número hexadecimal (que produce una cadena), llamamos a cada carácter de esa cadena el .digitnúmero (que devuelve verdadero si es un dígito), luego verificamos si alguno de ellos es verdadero, y luego lo negamos.

La versión con bonificación tiene una puntuación mucho más alta 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"));

_{No estoy seguro de cómo alguien podría hacer una versión de bonificación lo suficientemente corta como para ser mejor que la versión sin bonificación, incluso esas cadenas solo tienen una longitud 28 juntas. Quizás un lenguaje que hace que sea realmente difícil producir un valor verdadero / falso.}

Aquí hay una versión formateada:

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

Óxido, 70 bytes

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

Porque, ya sabes, Java Rust.

Sin embargo, en realidad es 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
  )

Pero es una pena que la definición de la función repetitiva sea tan larga ...: P

CJam, 44 bytes - 40 bonus = 4 bytes

2,riGbAf/&:-"Only numbersOnly lettersMix"C/=

Pruébalo aquí ~

En serio, 12 bytes

4ª,¡OkúOkd-Y

Hex Dump:

34a62cad4f6b
a34f6b642d59

Pruébalo en línea

Es lo mismo que las otras respuestas de lenguaje de pila. Sería de solo 7 bytes si Seriamente soportara la sustracción de cadenas todavía.

EDITAR: en serio ahora admite la resta de cadenas y la siguiente solución de 7 bytes ahora funciona:

ú4╙,¡-Y

Hex Dump:

a334d32cad2d59

Pruébalo en línea

05AB1E , 2 bytes (no competitivos)

Código:

ha

¡Decir ah! ¡Eso es dos bytes! Lamentablemente no compite porque este lenguaje es posterior al desafío :(

Explicación:

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

Pruébalo en línea! o Verifique todos los casos de prueba!

Python 3, 28 bytes

lambda x:min(hex(x)[1:])>'@'

Lisp común, 40 bytes

(every'alpha-char-p(format()"~x"(read)))

Pruébalo en línea!

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"

Japt, 12 bytes

!UsG r"[a-f]

Pruébalo en línea!

Cómo 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.

Gema, 41 personajes

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

No hay booleanos en Gema, por lo que simplemente genera "t" o "f".

Ejecución de muestra:

bash-4.3$ echo -n '11259375' | gema '*=@c{@radix{10;16;*}};c:<D>=f@end;?=;\Z=t'
t