З урахуванням невід'ємного цілого введення, напишіть програму, яка перетворює число в шістнадцятковий і повертає триєдине значення, якщо шістнадцяткова форма числа містить лише символи 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якщо шістнадцятковий варіант числа містить лише цифри 0-9і Mixякщо шістнадцятковий номер містить хоча б одне число і хоча б одну букву.

Це код гольфу. Діють стандартні правила. Виграє найкоротший код у байтах. Дозволені або функції, або повні програми.

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?

Спробуйте в Інтернеті (трохи змінена версія, яка працює в Інтернеті)

Пітон, 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(хибний), або ненульовий (справжній).

Я навіть не намагався досягти бонусу, "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 байт

Позбавлений 1 байт завдяки sysreq та Python 3.

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

Математика, 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,&!}

Демонстрація в Інтернеті

Рубін, 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число (яке повертає істину, якщо воно є цифрою), потім перевіряємо, чи будь-який з них правдивий, а потім заперечуємо це.

Версія з бонусом має набагато вищу оцінку 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 разом. Можливо, мова, яка робить насправді складно створити значення truthy / falsey.}

Ось відформатована версія:

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 байт, якщо серйозно підтримується віднімання рядків.

EDIT: Серйозно тепер підтримується віднімання рядків, і наступне 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:])>'@'

Лист звичайний, 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.

Гема, 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