음수가 아닌 정수 입력이 주어지면 숫자를 16 진수로 변환하고 16 진수 형식의 숫자 만 문자 A를 포함 F하고 그렇지 않으면 거짓 값을 반환하는 프로그램을 작성하십시오.

테스트 사례

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 letters도전에 대한 전술, Only numbers숫자의 16 진수 버전은 숫자를 포함하는 경우 0-9와 Mix16 진수는 적어도 하나 개의 번호와 적어도 하나의 문자가 포함 된 경우.

이것은 코드 골프입니다. 표준 규칙이 적용됩니다. 바이트 단위의 최단 코드가 이깁니다. 기능 또는 전체 프로그램이 허용됩니다.

Pyth, 43-40 = 3 바이트

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

테스트 스위트

이것은 보너스를 달성합니다. Only numbers그리고 Only letters다행히 단 4 글자가 다르다. printf 스타일 형식은와 함께 사용됩니다 %.

선택 시스템은 16 진수와 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.

티 스크립트 , 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?

온라인으로 사용해보십시오 (웹에서 작동하는 약간 수정 된 버전)

파이썬, 24 바이트

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

입력을 16 진수 문자열 ( 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()를 가져 와서 (false) 또는 0이 아닌 (true)를 int반환합니다 0.

나는 보너스를 달성하려고하지 않았지만 "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");
  }
}

파이썬 3, 30 29 바이트

sysreq 및 Python 3 덕분에 1 바이트가 제거되었습니다 .

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

간단 lambda하고 슬라이싱.

펄 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

수학, 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.

자바 스크립트, 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->....

입력은을 사용하여 16 진수 문자열로 변환 된 hex다음을 사용하여 전체가 알파벳 문자로 구성되어 있는지 확인합니다 isalpha.

자바 스크립트 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)

자바, 46 44 38 바이트

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

정수를 16 진수 문자열로 변환하고 정규식을 사용하여 모든 문자가 문자인지 여부를 결정하는 매우 간단한 한 줄짜리.

@ Eng.Fouad 덕분에 -2 바이트

CJam ( 9 8 바이트)

{GbA,&!}

온라인 데모

루비, 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는 16 진수 (문자열을 생성)로 포맷 하고 해당 문자열의 각 문자를 .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"));

녹, 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
  )

그러나 함수 정의 상용구가 너무 길다는 것은 부끄러운 일입니다 .... : P

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

하아! 그것은 2 바이트입니다! 슬프게도 경쟁이되지 않기 때문에이 언어는 도전 과제를 게시합니다.

설명:

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

파이썬 3, 28 바이트

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

공통 리스프, 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"

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