给定一个非负整数输入，写一个程序转换的数量为十六进制并返回，如果数字的十六进制形式仅包含字符的truthy值A通过F否则一个falsey值。

测试用例

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)

奖励：如果您的程序为上述挑战而打印，数字的十六进制版本仅包含数字并且十六进制数字包含至少一个数字和至少一个字母，则为-40字节。Only lettersOnly numbers0-9Mix

这是代码高尔夫。适用标准规则。以字节为单位的最短代码获胜。允许使用功能或完整程序。

Pyth，43-40 = 3个字节

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

测试套件

这实现了奖金。Only numbers而Only letters幸运的是只有4个字母不同。printf样式的格式与一起使用%。

选择系统是通过将十六进制与的交集取G字母并减去来完成的G。如果两个都不都是假的，那是一个混合，如果相交是假的，那是数字，如果相减是假的，那就是字母。

Pyth，6个字节

!-.HQG

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

在这里测试

果冻，6个字节

b16>9P

在线尝试！

这个怎么运作

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个字节13 15 16

xT(16)O(Sz)

很简单 这使用TeaScript 2.0。您可以从Github获取此版本

说明

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

在线尝试（可在网络上稍作修改的版本）

Python，24个字节

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

用转换输入的十六进制字符串（不带0x前缀）'%x'%n。'9'通过查看是否在min上方，查看其所有字符是否大于（哪些字母为）'9'。

MATL，10

i16YA1Y2mA

例子

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

说明

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

额外挑战：53-40 = 13

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

例子

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

说明

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个LabVIEW原语

赞美内置！

C，46 43 37字节

现在有了更多的递归！（感谢丹尼斯）：

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

奖励：甚至更短（33字节），但失败了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()接受int并返回0（false）或非零（true）。

我什至没有尝试获得奖金，"MixOnly lettersnumbers"仅占用23个字节，跟踪新条件将需要9个额外的字节，printf()即8个字节，这总计40个字节，使工作量无效。

测试主体：

#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个字节

由于sysreq和Python 3，去除了 1个字节。

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

简单lambda切片。

Perl 6、18个字节

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

用法：

# 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个字节

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

说明：

                               &   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，无正则表达式，28个字节

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

也有这个27字节的版本，但是它返回相反的值。

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

朱莉娅，18个字节

n->isalpha(hex(n))

这是一个接受整数并返回布尔值的匿名函数。要给它起个名字，例如f=n->...。

使用将输入转换为十六进制字符串hex，然后使用来检查其是否完全由字母字符组成isalpha。

JavaScript ES6、29

没有奖金

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

随着新值-40的增加，奖金现在越来越近了……但是还不够。奖金分数70 71-40 => 30 31

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

测试代码段（在输入框中输入数字）

#I { width:50%}

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

GS2，6个字节

V↔i/◙s

源代码使用CP437编码。在线尝试！

这个怎么运作

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

八度，22字节

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

Java，46 44 38字节

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

非常简单的单行代码，它将整数转换为十六进制字符串，并使用正则表达式确定所有字符是否都是字母。

-2个字节，感谢@ Eng.Fouad。

CJam（9 8字节）

{GbA,&!}

在线演示

Ruby，19个字节

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

取消高尔夫：

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

用法：

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

有奖金，70-40 = 30字节

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

用法：

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个字节

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

锡兰，55字节

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

直截了当...我们将其格式设置n为十六进制数字（产生一个字符串），调用该字符串的每个字符的.digit数字（如果是数字，则返回true），然后检查其中是否为真，然后取反。

带奖金的版本得分更高-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"));

_{我不确定有人怎么能使奖金版本短得比无奖金版本更好，即使那些字符串本身的长度都为28。也许是一种很难产生真假价值的语言。}

这是格式化的版本：

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

Rust，70个字节

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

因为，您知道，Java Rust。

不过，它实际上非常优雅：

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
  )

但是很遗憾，功能定义样板太长了。

CJam，44个字节-40个奖励= 4个字节

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

在这里试试〜

认真地，12个字节

4ª,¡OkúOkd-Y

十六进制转储：

34a62cad4f6b
a34f6b642d59

在线试用

与其他堆栈语言答案相同。如果严重支持字符串减法，则只有7个字节。

编辑：严重现在支持字符串减法，下面的7字节解决方案现在可以工作：

ú4╙,¡-Y

十六进制转储：

a334d32cad2d59

在线试用

05AB1E，2个字节（非竞争）

码：

ha

哈！那是两个字节！可悲的是没有竞争，因为这种语言推迟了挑战：(

说明：

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

在线尝试！或验证所有测试用例！

Python 3，28个字节

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

Common Lisp，40个字节

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

在线尝试！

SmileBASIC 3.2.1，78字节

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

Japt，12个字节

!UsG r"[a-f]

在线尝试！

这个怎么运作

!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个字符

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

Gema中没有布尔值，因此只输出“ t”或“ f”。

样品运行：

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