Compte tenu d' une entrée de nombre entier non négatif, écrire un programme qui convertit le nombre en hexadécimal et retourne une valeur de truthy si la forme hexadécimale du nombre ne contient que des caractères Apar l' intermédiaire Fet une valeur de Falsey autrement.

Cas de test

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 octets si votre programme imprime Only letterspour le défi décrit ci-dessus, Only numberssi la version hexadécimale du nombre ne contient que les chiffres 0-9et Mixsi le nombre hexadécimal contient au moins un nombre et au moins une lettre.

C'est du code golf. Les règles standard s'appliquent. Le code le plus court en octets gagne. Les fonctions ou les programmes complets sont autorisés.

Pyth, 43 - 40 = 3 octets

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

Suite de tests

Cela réalise le bonus. Only numberset Only lettersheureusement, ne diffèrent que de 4 lettres. Le formatage de style printf est utilisé avec %.

Le système de sélection est fait en prenant l'intersection de l'hex avec Gl'alphabet et en soustrayant G. Si aucune des deux ne finit par être faussée, c'est un mélange, alors que si l'intersection est faussée, ce sont des nombres et si la soustraction est faussée, ce sont des lettres.

Pyth, 6 octets

!-.HQG

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

Testez-le ici

Gelée , 6 octets

b16>9P

Essayez-le en ligne!

Comment ça marche

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

xT(16)O(Sz)

Assez simple. Ceci utilise TeaScript 2.0. Vous pouvez obtenir cette version du Github

Explication

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

Essayez-le en ligne (version légèrement modifiée qui fonctionne sur le Web)

Python, 24 octets

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

Convertit l'entrée en chaîne hexadécimale (sans 0xpréfixe) avec '%x'%n. Voyons si tous ses caractères sont supérieurs à '9'(quelles lettres sont) en voyant si le minest au-dessus '9'.

MATL , 10

i16YA1Y2mA

Exemples

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

Explication

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

Bonus: 53−40 = 13

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

Exemples

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

Explication

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

Féliciter les intégrés!

C, 46 43 37 octets

Maintenant avec plus de récursivité! (Merci Dennis):

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

Bonus: encore plus court (33 octets), mais échoue pour 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()prend un intet retourne soit 0(faux) ou non nul (vrai).

Je n'ai même pas essayé d'obtenir le bonus, ne "MixOnly lettersnumbers"prend que 23 octets; suivre la nouvelle condition aurait nécessité 9 octets supplémentaires, printf()soit 8 octets, soit 40 octets, annulant ainsi l'effort.

Test principal:

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

1 octet supprimé grâce à sysreq et à Python 3.

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

Simple lambdaet tranchant.

Perl 6 , 18 octets

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

Mathematica, 32 octets

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

Explication:

                               &   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, pas d'expressions rationnelles, 28 octets

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

Il y a aussi cette version à 27 octets, mais elle retourne la valeur inverse.

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

Julia, 18 octets

n->isalpha(hex(n))

C'est une fonction anonyme qui accepte un entier et retourne un booléen. Pour l'appeler, donnez-lui un nom, par exemple f=n->....

L'entrée est convertie en chaîne hexadécimale en utilisant hex, puis nous vérifions si elle est entièrement composée de caractères alphabétiques en utilisant isalpha.

JavaScript ES6, 29

Pas de bonus

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

Avec la nouvelle valeur de -40, le bonus est plus proche maintenant ... mais pas assez. Bonus score 70 71 - 40 => 30 31

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

Extrait de test (tapez un nombre dans la zone de saisie)

#I { width:50%}

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

GS2 , 6 octets

V↔i/◙s

Le code source utilise le codage CP437. Essayez-le en ligne!

Comment ça marche

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

Octave, 22 octets

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

Java, 46 44 38 octets

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

Une ligne assez simple qui convertit le nombre entier en chaîne hexadécimale et utilise regex pour déterminer si tous les caractères sont des lettres.

-2 octets grâce à @ Eng.Fouad.

CJam ( 9 à 8 octets)

{GbA,&!}

Démo en ligne

Ruby, 19 octets

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

Avec bonus, 70 - 40 = 30 octets

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

Perl, 69 - 40 = 29 octets

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

Ceylan, 55 octets

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

Simplement ... nous formaterons nun nombre hexadécimal (ce qui produira une chaîne), appellerons le .digitnombre (qui retournera vrai s'il s'agit d'un chiffre), puis vérifions si l'un d'entre eux est vrai, puis le nier.

La version avec bonus a un score beaucoup plus élevé de 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"));

_{Je ne sais pas comment quiconque pourrait créer une version bonus suffisamment courte pour être meilleure que la version sans bonus, même ces chaînes ont à elles seules une longueur de 28. Peut-être une langue qui rend vraiment difficile de produire une valeur de vérité / falsey.}

Voici une version formatée:

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

Rouille, 70 octets

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

Parce que tu sais, Java Rust.

C'est en fait assez élégant, cependant:

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
  )

Mais il est dommage que la définition de la fonction passe-partout est si longue ....: P

CJam, 44 octets - 40 bonus = 4 octets

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

Essayez-le ici ~

Sérieusement, 12 octets

4ª,¡OkúOkd-Y

Décharge Hex:

34a62cad4f6b
a34f6b642d59

Essayez-le en ligne

C'est la même chose que les réponses de l'autre langue. Ce ne serait que 7 octets si Sérieusement supportait encore la soustraction de chaînes.

EDIT: Sérieusement prend maintenant en charge la soustraction de chaînes et la solution suivante de 7 octets fonctionne désormais:

ú4╙,¡-Y

Décharge Hex:

a334d32cad2d59

Essayez-le en ligne

05AB1E , 2 octets (non concurrents)

Code:

ha

Ha! C'est deux octets! Malheureusement non compétitif car cette langue postdate le challenge :(

Explication:

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

Essayez-le en ligne! ou Vérifiez tous les cas de test!

Python 3, 28 octets

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

Common Lisp, 40 octets

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

Essayez-le en ligne!

SmileBASIC 3.2.1, 78 octets

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

Japt, 12 octets

!UsG r"[a-f]

Essayez-le en ligne!

Comment ça marche

!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 caractères

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

Il n'y a pas de booléen dans Gema, donc il génère simplement «t» ou «f».

Échantillon échantillon:

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