Schreiben Sie bei einer nicht negativen Ganzzahleingabe ein Programm, das die Zahl in Hexadezimal umwandelt und einen Wahrheitswert zurückgibt, wenn die Hexadezimalform der Zahl nur die Adurchgehenden Zeichen Fund ansonsten einen False-Wert enthält.

Testfälle

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 Byte, wenn Ihr Programm Only lettersfür die oben beschriebene Herausforderung druckt , Only numberswenn die hexadezimale Version der Nummer nur die Ziffern enthält 0-9und Mixwenn die hexadezimale Nummer mindestens eine Ziffer und mindestens einen Buchstaben enthält.

Das ist Code Golf. Es gelten Standardregeln. Kürzester Code in Bytes gewinnt. Es sind entweder Funktionen oder vollständige Programme zulässig.

Pyth, 43 - 40 = 3 Bytes

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

Testsuite

Damit ist der Bonus erreicht. Only numbersund unterscheiden sich Only lettersglücklicherweise nur um 4 buchstaben. printf-Formatierung wird mit verwendet %.

Das Auswahlsystem wird durchgeführt, indem sowohl der Schnittpunkt des Hex mit Gdem Alphabet genommen als auch subtrahiert wird G. Wenn beides nicht falsch ist, handelt es sich um eine Mischung. Wenn die Schnittmenge falsch ist, sind es Zahlen und wenn die Subtraktion falsch ist, sind es Buchstaben.

Pyth, 6 Bytes

!-.HQG

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

Teste es hier

Gelee , 6 Bytes

b16>9P

Probieren Sie es online!

Wie es funktioniert

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 Bytes 13 15 16

xT(16)O(Sz)

Ziemlich einfach. Dies verwendet TeaScript 2.0. Sie können diese Version vom Github erhalten

Erläuterung

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

Probieren Sie es online aus (leicht modifizierte Version, die im Web funktioniert)

Python, 24 Bytes

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

Konvertiert die Eingabe in einen Hex-String (ohne 0xPräfix) mit '%x'%n. Überprüft, ob alle Zeichen größer sind als '9'(welche Buchstaben sind), indem überprüft wird, ob das minoben steht '9'.

MATL , 10

i16YA1Y2mA

Beispiele

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

Erläuterung

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

Bonus Herausforderung: 53 - 40 = 13

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

Beispiele

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

Erläuterung

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

Loben Sie die Einbauten!

C 46 43 37 Bytes

Jetzt mit mehr Rekursion! (Danke Dennis):

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

Bonus: Noch kürzer (33 Bytes), scheitert aber an 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()Nimmt ein intund gibt entweder 0(false) oder einen Wert ungleich Null (true) zurück.

Ich habe nicht einmal versucht, den Bonus zu erreichen, "MixOnly lettersnumbers"nimmt 23 Bytes allein, die Verfolgung der neuen Bedingung hätte 9 zusätzliche Bytes erforderlich gemacht, printf()ist 8 Bytes, was sich auf 40 summiert, was den Aufwand zunichte macht.

Testleitung:

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

1 Byte entfernt dank sysreq und Python 3.

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

Einfach lambdaund in Scheiben schneiden.

Perl 6 , 18 Bytes

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

Verwendungszweck:

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

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

Erläuterung:

                               &   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, kein regulärer Ausdruck, 28 Bytes

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

Es gibt auch diese 27-Byte-Version, die jedoch den inversen Wert zurückgibt.

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

Julia, 18 Bytes

n->isalpha(hex(n))

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und einen Booleschen Wert zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=n->....

Die Eingabe wird mithilfe von in eine hexadezimale Zeichenfolge konvertiert. hexAnschließend wird mithilfe von überprüft, ob die Eingabe vollständig aus alphabetischen Zeichen besteht isalpha.

JavaScript ES6, 29

Kein Bonus

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

Mit dem neuen Wert von -40 ist der Bonus jetzt näher ... aber nicht genug. Bonuspunktzahl 70 71 - 40 => 30 31

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

Test-Snippet (geben Sie eine Zahl in das Eingabefeld ein)

#I { width:50%}

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

GS2 , 6 Bytes

V↔i/◙s

Der Quellcode verwendet die CP437-Codierung. Probieren Sie es online!

Wie es funktioniert

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

Oktave, 22 Bytes

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

Java, 46 44 38 Bytes

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

Ziemlich einfacher Einzeiler, der die Ganzzahl in eine hexadezimale Zeichenfolge umwandelt und mithilfe von Regex feststellt, ob alle Zeichen Buchstaben sind.

-2 Bytes dank @ Eng.Fouad.

CJam ( 9 8 Bytes)

{GbA,&!}

Online-Demo

Ruby, 19 Bytes

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

Ungolfed:

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

Verwendungszweck:

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

Mit Bonus 70 - 40 = 30 Bytes

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

Verwendungszweck:

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 Bytes

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

Ceylon, 55 Bytes

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

Ganz einfach ... Wir formatieren nals Hexadezimalzahl (die eine Zeichenfolge erzeugt), rufen für jedes Zeichen dieser Zeichenfolge die .digitZahl auf (die true zurückgibt, wenn es sich um eine Ziffer handelt), prüfen dann, ob eine davon true ist, und negieren diese.

Die Version mit Bonus hat eine viel höhere Punktzahl von 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"));

_{Ich bin mir nicht sicher, wie jemand eine Bonusversion so kurz machen könnte, dass sie besser ist als die ohne Bonus, auch wenn diese Saiten alleine eine Länge von 28 haben. Vielleicht eine Sprache, die es wirklich schwer macht, einen Wahrheitswert zu produzieren.}

Hier ist eine formatierte Version:

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 Bytes

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

Weil, weißt du, Java Rust.

Eigentlich ist es aber ziemlich elegant:

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
  )

Aber es ist eine Schande, dass die Funktionsdefinition Boilerplate so lang ist ...: P

CJam, 44 Bytes - 40 Bonus = 4 Bytes

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

Probieren Sie es hier ~

Im Ernst, 12 Bytes

4ª,¡OkúOkd-Y

Hex Dump:

34a62cad4f6b
a34f6b642d59

Probieren Sie es online

Es ist das gleiche wie bei den anderen Antworten in der Stapelsprache. Es wären nur 7 Bytes, wenn die Zeichenfolgensubtraktion noch ernsthaft unterstützt würde.

BEARBEITEN: Unterstützt nun ernsthaft die Zeichenfolgensubtraktion und die folgende 7-Byte-Lösung funktioniert jetzt:

ú4╙,¡-Y

Hex Dump:

a334d32cad2d59

Probieren Sie es online

05AB1E , 2 Bytes (nicht konkurrierend)

Code:

ha

Ha! Das sind zwei Bytes! Leider nicht konkurrierend, da diese Sprache die Herausforderung datiert :(

Erläuterung:

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

Probieren Sie es online! oder Überprüfen Sie alle Testfälle!

Python 3, 28 Bytes

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

Common Lisp, 40 Bytes

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

Probieren Sie es online!

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"

Japt, 12 Bytes

!UsG r"[a-f]

Probieren Sie es online!

Wie es funktioniert

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

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

In Gema gibt es keinen Booleschen Wert, daher wird einfach "t" oder "f" ausgegeben.

Probelauf:

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