Números que en realidad son letras


42

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.


2
Actualmente redactando una respuesta en Golfical.
SuperJedi224

Mi idea actual: encubierta a la cadena de base 16, luego ver si intenta analizar esa cadena como devuelve un número de base 10NaN
Cyoce

@Cyoce Eso puede funcionar, dependiendo de su elección de idioma
SuperJedi224 12/12/2015

3
Bono poco realista (una vez más): solo la cadena MixOnlynumbersletterstiene 21 caracteres
edc65

3
Dices "entrada entera positiva", pero 0 es un caso de prueba.
xnor

Respuestas:


22

Pyth, 43-40 = 3 bytes

?&K@J.HQG-JG"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.


1
Maldita sea, este Pyth es raro. Sin embargo, sería genial si pudieras obtener una puntuación negativa.
KaareZ

15

Pyth, 6 bytes

!-.HQG

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

Pruébalo aquí


12

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.

¿No hay un construido para 16 o no es una cosa?
CalculatorFeline

1
Hay ahora. Esta fue una de las primeras respuestas de Jelly ...
Dennis

11

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)


3
¿Es el voto negativo porque esto es largo? ¿Hay algo más mal con esta respuesta que yo no sepa? ¿O a alguien simplemente no le gusta personalmente esta respuesta?
Downgoat

2
¡No diría que 16 o 13 bytes es largo!
Luis Mendo

23
Tienes que admitir que rebajar tus publicaciones es bastante tentador.
Dennis

10

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


No sé cómo maneja Python los caracteres / números, pero el código ASCII de '9'es 54. Entonces, si puede escribir ...>54, puede guardar un byte.
CompuChip

@CompuChip Python no trata los caracteres o cadenas como números. De hecho, Python 2 los considera mayores que todos los números.
xnor

8

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          

2
hmmm que es eso? ¡Parece que Matlab tiene algo de energía nuclear ahora!
Abr001am

@ Agawa001 Jajaja. Más o menos
Luis Mendo el


8

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

¿Qué es ?:? Tuve que reemplazarlo ||para que se compilara. Además, ¿puede guardar un byte reemplazando el *con un &evitando así el ()s de la izquierda (aunque luego tiene que agregar un espacio)?
Neil

@Neil a?:bes una extensión de GNU que evalúa asi aes un valor verdadero, de lo contrario b. Es útil para manejar punteros nulos como send(message ?: "(no message)");. Sé que no es portátil, pero la portabilidad del código nunca es una preocupación en el golf de código :)
Stefano Sanfilippo

@StefanoSanfilippo puede reducir esto a 33bytes al hacer esto: F(x){x=(x%16>9)*(x<16?:F(x/16));}esto abusa de un error (GCC) donde si no hay una variable de retorno en una función y se estableció el argumento principal, en algunos casos devolverá automáticamente el argumento principal ( basado en qué lógica se hizo), ¡y este es uno de esos casos! Pruébelo en línea: bit.ly/2pR52UH
Albert Renshaw

8

Python 3, 30 29 bytes

1 byte eliminado gracias a sysreq y Python 3.

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

Simple lambday rebanador.


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&

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.

7

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)

¡Agradable! También puede reorganizarlo así para 23 bytes:F=n=>!n||n%16>9&F(n>>4)
user81655

@ user81655 - Desafortunadamente, esa versión devuelve verdadero para 0, por lo que es incorrecta.
zocky

Oh cierto, supongo que lo más corto sería F=n=>n%16>9&&n<16|F(n>>4)entonces.
user81655

@ user81655 Estoy bastante seguro de que necesita hacer un cortocircuito ||, pero creo que podría salirse con la suya en &lugar de hacerlo &&en ese caso.
Neil

@Neil ¿Por qué es eso? ¿Lo probaste?
user81655

7

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.


6

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>


-n-1= ~n, ¿verdad?
CalculatorFeline

@CatsAreFluffy si n no es numérico como 'A' (ese es el objetivo de este desafío), ~n == -1mientras que-n-1 == NaN
edc65

4

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.


4

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.


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

Falla para 516 ..
CalculatorFeline

@CatsAreFluffy No, no lo hace.
TNT

Bueno, ahora determina si la cadena contiene una letra hexadecimal, así que elimine el +–es un desperdicio de bytes.
CalculatorFeline

@CatsAreFluffy No. matches devuelve verdadero si toda la cadena puede coincidir con la expresión regular dada. [a-f]sin el signo más es incorrecto ya que no coincide con toda la cadena dado que contiene más de un carácter; Lo haría si y solo si un carácter válido está presente.
TNT


3

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

Tarde, pero '%x'%n!~/\d/es una verificación más corta para la solución uno, y la solución dos tiene un recuento de bytes sin procesar de 70, no 75.
Value Ink el

3

Perl, 69-40 = 29 bytes

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

2

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

2

Ó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


Tengo una idea. Más cierres!
CalculatorFeline


2

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


1
11: 4╙,¡#S;ú∩S=(o o , muchas formas de deletrear :16:en dos bytes: P)
Mego

No sabía SI pensar.
quintopia

2

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!


1
hdÔ©1åi•4?ŸâτΛ•}®0åi•4?ŸàpÕTà•}®g2Qi•²•} 36B` para la bonificación que resulta en ... ¡6 más! Wooooo bonos!
Urna de pulpo mágico



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"

No veo ningún carácter que no sea ASCII aquí (a menos que haya algunos); este contador es el decisivo definitivo y dice 81.
gato

1
No importa que la implementación use UTF-16 internamente; para el resto del mundo, también pueden ser caracteres UTF-8 en el rango 0-127, por lo tanto, su recuento de bytes es 81.
gato

Gracias por los comentarios, no estaba seguro si "bytes" significaba que debía contar 2 por char. 81 lo es.
caracol_

En realidad, el consenso actual de + 10 / -0 (que, por cierto, ahora no estoy de acuerdo) es que siempre debemos usar la codificación que usa un intérprete. Si no está de acuerdo, publique una opinión disidente sobre esa pregunta.
lirtosiast

@ThomasKwa pfft, está bien, oops, ahora lo sé mejor. No me di cuenta de que había un consenso al respecto, y dediqué bastante tiempo al meta.
gato

1

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.

Creo que !!UsG r"\\dpodría funcionar y ahorrar un byte
Downgoat

@Downgoat Buena observación, pero eso devuelve verdadero para cualquier número que contenga una letra.
ETHproductions

1

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.