Numbers that are actually letters

Question

Given a non-negative integer input, write a program that converts the number to hexadecimal and returns a truthy value if the hexadecimal form of the number contains only the characters A through F and a falsey value otherwise.

---

Test cases

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)

---

Bonus: -40 bytes if your program prints Only letters for the challenge described above, Only numbers if the hexadecimal version of the number only contains the digits 0-9 and Mix if the hexadecimal number contains at least one number and at least one letter.

---

This is code golf. Standard rules apply. Shortest code in bytes wins. Either functions or full programs are allowed.

Answer 1

Pyth, 43 - 40 = 3 bytes

?&[e-mail]-JG"Mix"%"Only %sers"?K"lett""numb

Test suite

This achieves the bonus. Only numbers and Only letters fortunately only differ by 4 letters. printf-style formatting is used with %.

The selection system is done by both taking the intersection of the hex with G, the alphabet, and subtracting out G. If neither ends up falsy, it's a mix, while if the intersection is falsy, it's numbers, and if the subtraction is falsy, it's letters.

Answer 2

Pyth, 6 bytes

!-.HQG

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

Test it here

Answer 3

Jelly, 6 bytes

b16>9P

Try it online!

How it works

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.

Answer 4

TeaScript, 11 bytes 13 15 16

xT(16)O(Sz)

Pretty simple. This uses TeaScript 2.0. You can get this version from the Github

Explanation

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

Try it online (slightly modified version that works on web)

Answer 5

Python, 24 bytes

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

Converts the input a hex string (without 0x prefix) with '%x'%n. Sees if all its chars are greater than '9' (which letters are) by seeing if the min is above '9'.

Answer 6

MATL, 10

i16YA1Y2mA

Examples

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

Explanation

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

---

Bonus challenge: 53−40 = 13

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

Examples

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

Explanation

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          

Answer 7

Python 3, 30 29 bytes

1 byte stripped thanks to sysreq and Python 3.

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

Simple lambda and slicing.

Answer 8

LabVIEW, 52-40 = 12 LabVIEW Primitives

Praise the built-ins!

Answer 9

C, 46 43 37 bytes

Now with more recursion! (Thanks Dennis):

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

Bonus: even shorter (33 bytes), but fails for 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() takes an int and returns either 0 (false) or non-zero (true).

I didn't even try to achieve the bonus, "MixOnly lettersnumbers" takes 23 bytes alone, tracking the new condition would have required 9 additional bytes, printf() is 8 bytes, which adds up to 40, nullifying the effort.

Test main:

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

Answer 10

Mathematica, 32 bytes

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

Explanation:

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

Answer 11

Julia, 18 bytes

n->isalpha(hex(n))

This is an anonymous function that accepts an integer and returns a boolean. To call it, give it a name, e.g. f=n->....

The input is converted to a hexadecimal string using hex, then we check whether its entirely comprised of alphabetic characters using isalpha.

Answer 12

Perl 6, 18 bytes

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

usage:

# 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

Answer 13

Javascript, ES6, no regexp, 28 bytes

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

There's also this 27-byte version but it returns the inverse value.

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

Answer 14

JavaScript ES6, 29

No bonus

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

With the new value of -40 the bonus is nearer now ... but not enough. Bonus score 70 71 - 40 => 30 31

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

Test snippet (type a number inside the input box)

#I { width:50%}

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

Answer 15

GS2, 6 bytes

V↔i/◙s

The source code uses the CP437 encoding. Try it online!

How it works

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

Answer 16

Java, 46 44 38 bytes

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

Pretty simple one-liner that converts the integer to a hexadecimal string and uses regex to determine if all characters are letters.

-2 bytes thanks to @Eng.Fouad.

Answer 17

Octave, 22 bytes

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

Answer 18

CJam (9 8 bytes)

{GbA,&!}

Online demo

Answer 19

Perl, 69 - 40 = 29 bytes

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

Answer 20

Ruby, 19 bytes

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

Ungolfed:

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

Usage:

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

With bonus, 70 - 40 = 30 bytes

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

Usage:

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

Answer 21

Python 3, 28 bytes

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

Answer 22

Common Lisp, 40 bytes

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

Try it online!

Answer 23

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"

Answer 24

Ceylon, 55 bytes

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

Straightforward ... we format n as a hexadecimal number (which produces a string), call on each character of that string the .digit number (which returns true if it is a digit), then check whether any of them are true, then negate this.

The version with bonus has a lot higher score of 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"));

_{I'm not sure how anyone could make a bonus version short enough to be better than the no-bonus version, even those strings alone have length 28 together. Maybe a language which makes it really hard to produce a truthy/falsey value.}

Here is a formatted version:

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

Answer 25

Seriously, 12 bytes

4ª,¡OkúOkd-Y

Hex Dump:

34a62cad4f6b
a34f6b642d59

Try It Online

It's the same as the other stack language answers. It would be only 7 bytes if Seriously supported string subtraction yet.

EDIT: Seriously now supports string subtraction and the following 7 byte solution now works:

ú4╙,¡-Y

Hex Dump:

a334d32cad2d59

Try It Online

Answer 26

Rust, 70 bytes

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

Because, ya know, Java Rust.

It's actually quite elegant, though:

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
  )

But it's a shame the function definition boilerplate is so long.... :P

Answer 27

CJam, 44 bytes - 40 bonus = 4 bytes

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

Try it here~

Answer 28

05AB1E, 2 bytes (non-competing)

Code:

ha

Ha! That is two bytes! Sadly non-competing because this language postdates the challenge :(

Explanation:

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

Try it online! or Verify all test cases!

Answer 29

Ruby, 16 bytes

->n{/\d/!~'%x'%n}

Ruby, 70 bytes - 40 bonus = 30

f=->n{s="Only #{n%16<10?:Numbers:'Letters'}";n<16||s==f[n/16]?s:'Mix'}

Answer 30

PHP, 32 bytes

_{since rink.attendant.6 won´t react; I post my own.}

echo+ctype_alpha(dechex($argn));

takes input from STDIN; prints 1 or 0; run with -R.

bonus attempt, 93 87-40=47
_{5 bytes saved by Jörg, 1 by me}

echo(ctype_alpha($s=dechex($argn))+$d=ctype_digit($s))?"Only ".[lett,numb][$d].ers:Mix;

takes input from STDIN; run with -nR.

btw. ctype_xdigit would be an option for Mix and help serialize (though pi is the shortest alternative); but I guess it can´t get any shorter than Jörgs idea with my golfing.
The more you serialize, the longer it gets.

a partly serialized version for 101 100-40=60:
_{2 bytes saved and 1 byte fixed by Jörg}

echo strtr([ctype_alpha($s=dechex($argn))=>_letters,ctype_digit($s)=>_numbers,Mix][1],[_=>"Only "]);

and fully serialized for 114 112-40=72:
_{-2 bytes inspired by Jörg}

foreach([pi=>Mix,ctype_alpha=>lett,is_numeric=>numb]as$f=>$t)$f(dechex($argn))&&$s=$t<a?$t:"Only $t".ers;echo$s;

Answer 31

PHP, 56 44 bytes

This isn't going to win, but might as well. Takes one command-line argument.

Thank you @Blackhole for reducing this by 12 bytes.

<?=ctype_lower(base_convert($argv[1],10,16))

// Previous attempt, 56 bytes
<?=preg_match('#^[a-f]+$#',base_convert($argv[1],10,16))

Answer 32

Japt, 12 bytes

!UsG r"[a-f]

Try it online!

How it works

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

Answer 33

Haskell, 39 bytes

p n|mod n 16<10=0|n<16=1|1<2=p$div n 16

Returns 0 or 1. Usage example:

*Main> map p [10,100,161,11259375,0]
[1,0,0,1,0]

Haskell has neither built-in base conversion nor check for letters. Both functions are in modules where the imports alone would cost 36 bytes, so that's not an option. Instead I check the input number n for:

1. if mod n 16 is less than 10 -> False
2. if n is less than 16 -> True
3. otherwise re-check with n/16.

Answer 34

C, 132 bytes

int main(){int a=0,p=1;char b[256];scanf("%d",&a);sprintf(b,"%x",a);for(char*c=b;*c!='\0';c++)if(isdigit(*c)){printf("False");p=0;}if(p)printf("True");return 0;}

Detailed

int main()
{
    int a=0, p=1;
    char b [256];

    scanf("%d",&a); // read input as an integer
    sprintf(b,"%x",a); // read in Hex into string

    for(char * c=b; *c!='\0'; c++)
    {
        if(isdigit(*c)) // if it's a digit
        {
            printf("%x No",a);
            p=0;
        }
    }

    if(p) // if no digit was found
    {
        printf("%x Yes",a);
    }

    return 0;
}

Bonus, 232 - 40 = 192 bytes

int main(){int a=0, p=0,q=0;char b [256];scanf("%d",&a);sprintf(b,"%x",a);for(char * c=b; *c!='\0'; c++) if(isdigit(*c)) p=1; else q=1;if(p&&q) printf("Mixed");else if(p) printf("Only numbers");else printf("Only letters");return 0;}

Detailed

int main()
{
    int a=0, p=0,q=0;
    char b [256];

    scanf("%d",&a);
    sprintf(b,"%x",a);

    for(char * c=b; *c!='\0'; c++) if(isdigit(*c)) p=1; else q=1;

    if(p&&q) printf("Mixed");
    else if(p) printf("Only numbers");
    else printf("Only letters");

    return 0;
}

Answer 35

Gema, 41 characters

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

There is no boolean in Gema, so it simply outputs “t” or “f”.

Sample run:

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

Answer 36

Perl, 24 bytes

$_=sprintf"%x",$_;$_=/\D/&/\d/?Mix:Only.$".(/\d/?numb:lett).ers

Code is 63 bytes, add 1 for the -p flag, and then subtract 40 for the bonus.

Answer 37

Binary-Encoded Golfical, 50+1 (-x flag)=51 bytes

Noncompeting; the modulo instruction used here, although it was added to the specs, according the repo's revision history, on the same day this question was posted, was for some reason never implemented until earlier today.

Hexdump:

00 C0 03 15 14 14 1B 1A 14 08 01 14 17 00 10 14
00 01 0A 01 21 1E 2C 3D 14 53 2D 14 08 01 0A 01
1C 00 0A 00 10 17 0A 01 08 01 00 00 26 14 1E 1C
1D 14

This encoding can be converted back to the original graphical form using the included Encoder utility, or run directly by adding the -x flag.

Original image:

Magnified 50x:

Rough translation:

prompt *p
label A
push *p
*p%=16
if *p<10
 print 0
 exit
endif
*p=pop
*p/=16
if *p==0
 print 1
 exit
endif
goto A

Answer 38

SmileBASIC, 52 50 bytes

INPUT V
H$=HEX$(V)WHILE""<H$P=@A<POP(H$)||P
WEND?P

Determines if each digit is a number or letter by comparing it with @A (the A doesn't matter since it would only look at it if the first characters were the same). @ is between the number and the letters in ASCII.

Answer 39

MATL, 7 bytes

1YAtk=~

Explanation:

1       % number literal
YA      % convert integer to string representation in given base (16)
t       % duplicate elements
k       % convert (the second) string to lowercase
=       % is equal?
~       % logical 'not' (element-wise)
        % (implicit) convert to string and display

For only letters to be in the base-16 representation, when the string is made lowercase every character must have changed, so the arrays should never be equal to each other, and only arrays of ones are truthy in MATL.

Bonus challenge, 47-40 = 7 bytes:

1YAtk=XK?'Only numbers'}Ka?'Mix'}'Only letters'

Essentially the same as the other MATL answer given, the same ending was used just without trailing ]] and with reordering the outputs.

Answer 40

Befunge (quirkster flavor), 34 bytes

&:44*%9`!#@ #. #0_44*/:!#@ #. #1_#

Befunge control flow loops around to the beginning when it hits the end, so a recursive solution is pretty natural. If the input is less than 9 modulo 16, print 0 (the only falsey value in Befunge) and exit. If not, divide the number by 16, rounding down. If it's now 0, print 1 and exit, otherwise recurse. In effect, this checks each hex digit from right to left.

Answer 41

Clojure, 35 bytes

#(every?(set"abcdef")(format"%x"%))

Answer 42

tcl, 35

puts [string is alp [format %x $n]]

demo

Answer 43

Pushy, 16 bytes

$&16%v16/;OKT)P#

Try it online!

Essentially calculates all digits as numbers 0-16, and then checks they are all over 10.

                    \ Implicit: Input on first stack
$        ;          \ While input != 0:
 &16%v              \   Push input % 16 to second stack
      16/           \   Floordiv input by 16
          O         \ Go to second stack
           KT)      \ Map all numbers to boolean: bigger than 10?
              P     \ Get the product (only 1 if all values are 1)
               #    \ Print result.

Answer 44

Excel, 121 bytes

=LEN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(DEC2HEX(A2),"A",),"B",),"C",),"D",),"E",),"F",))=0

Nothing graceful about this one.

Answer 45

CoffeeScript, 42 36 bytes

f=(x)->/^[a-f]+$/.test x.toString 16

// Previous attempt (42)
f=(x)->!x.toString(16).replace /[a-f]/g,''

---

JavaScript (ES6), 41 36 bytes

f=x=>/^[a-f]+$/.test(x.toString(16))

// Previous attempt (41)
f=x=>!x.toString(16).replace(/[a-f]/g,``)

Answer 46

R, 34 bytes

!grepl("\\d",sprintf("%x",scan()))

scan() takes an integer from stdin, sprintf("%x",...) returns the hexadecimal representation of that integer (R's sprintf is equivalent to C's sprintf), then the regex checks if the string contains digits.

Usage:

> !grepl("\\d",sprintf("%x",scan()))
1: 100
2: 
Read 1 item
[1] FALSE
> !grepl("\\d",sprintf("%x",scan()))
1: 10
2: 
Read 1 item
[1] TRUE
> !grepl("\\d",sprintf("%x",scan()))
1: 161
2: 
Read 1 item
[1] FALSE
> !grepl("\\d",sprintf("%x",scan()))
1: 11259375
2: 
Read 1 item
[1] TRUE
> !grepl("\\d",sprintf("%x",scan()))
1: 0
2: 
Read 1 item
[1] FALSE

Answer 47

, 9 chars / 16 bytes

!ïⓧċ/[α]⌿

Try it here (Firefox only).

Regex aliases ftw!

Explanation

        // Implicit: ï = input
!       // logical-negate the result of the following code:
 ïⓧ    // convert ï to hex...
 ċ/[α]⌿ // and see if it has any letters
        // implicit output

Answer 48

Pyke, 6 bytes

b16G-!

Try it here!

Or 10 bytes with the bonus

b16\9L>]0}DlRs*"Only numbers,Only letters,Mix"\,c@

Explanation:

b16                                                -      base_16(input())
   \9L<                                            -     map("9">char for char in ^)
       ]0                                          -    list(^)
         }                                         -   set(^)
          DlRs*                                    -  len(^)*sum(^)
                                                 @ - V[^]
               "Only numbers,Only letters,Mix"\,c  -  str.split(",")

Try it here!