Des nombres qui sont en réalité des lettres

42

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.

Arcturus
la source
2
En train de rédiger une réponse dans Golfical.
SuperJedi224
Mon idée actuelle: convertir en chaîne de base 16, puis voir si essayer d’analyser cette chaîne comme un chiffre de base 10 revientNaN
Cyoce
@Cyoce Cela peut fonctionner, selon votre langue
SuperJedi224 12/12
3
Bonus irréaliste (encore une fois): seulement la chaîne a MixOnlynumbersletters21 caractères
edc65
3
Vous dites "entrée entière positive", mais 0 est un cas de test.
xnor

Réponses:

22

Pyth, 43 - 40 = 3 octets

?&[email protected]"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.

isaacg
la source
1
Zut ce Pyth est bizarre. Ce serait très cool si vous pouviez obtenir un score négatif cependant.
KaareZ
15

Pyth, 6 octets

!-.HQG

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

Testez-le ici

Adnan
la source
12

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.
Dennis
la source
N'y a-t-il pas un construit pour 16 ou est-ce pas une chose?
CalculatriceFeline
1
Il y a maintenant. C'était l'une des premières réponses de Jelly ...
Dennis
11

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)

Downgoat
la source
3
Le vote négatif est-il parce que c'est long? Y a-t-il autre chose qui ne va pas dans cette réponse dont je ne suis pas au courant? Ou est-ce que quelqu'un n'aime pas personnellement cette réponse?
Downgoat
2
Je ne dirais pas que 16 ou 13 octets, c'est long!
Luis Mendo
23
Vous devez admettre que rétrograder vos messages est plutôt tentant.
Dennis
10

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

Xnor
la source
Je ne sais pas comment Python gère les caractères / nombres, mais le code ASCII '9'est 54. Donc si vous pouvez écrire, ...>54vous pouvez sauvegarder un octet.
CompuChip
@ CompuChip Python ne traite pas les caractères ou les chaînes comme des nombres. En fait, Python 2 les considère plus grands que tous les nombres.
xnor
8

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          
Luis Mendo
la source
2
hmmm qu'est-ce que c'est? On dirait que Matlab a un peu de pouvoir maintenant!
Abr001am
@ Agawa001 Hahaha. En
quelque sorte
8

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");
  }
}
Stefano Sanfilippo
la source
C'est quoi ?:? Je devais le remplacer par ||pour le compiler. Aussi, pouvez-vous sauvegarder un octet en remplaçant le *par un &évitant ainsi le ()s à gauche (bien que vous deviez ensuite ajouter un espace)?
Neil
@Neil a?:best une extension GNU qui évalue asi if aest une valeur de vérité, sinon à b. Est pratique pour gérer les pointeurs nuls comme send(message ?: "(no message)");. Je sais que ce n'est pas portable, mais la portabilité du code n'est jamais une préoccupation dans le code golf :)
Stefano Sanfilippo
@StefanoSanfilippo vous pouvez obtenir ceci en 33octets: F(x){x=(x%16>9)*(x<16?:F(x/16));}ceci abuse d'un bogue (GCC) dans lequel s'il n'y a pas de variable de retour dans une fonction et que l'argument principal a été défini, il retournera automatiquement l'argument principal dans certains cas ( sur la base de quelle logique a été faite), et cela se trouve être un de ces cas! Essayez-le en ligne: bit.ly/2pR52UH
Albert Renshaw
8

Python 3, 30 29 octets

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

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

Simple lambdaet tranchant.

LeeNeverGup
la source
7

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
Brad Gilbert b2gills
la source
7

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.
LegionMammal978
la source
7

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)
zocky
la source
Agréable! Vous pouvez également le réorganiser comme F=n=>!n||n%16>9&F(n>>4)
suit
@ user81655 - Malheureusement, cette version renvoie true pour 0, elle est donc incorrecte.
Zocky
Oh oui, je suppose que le plus court serait F=n=>n%16>9&&n<16|F(n>>4)alors.
user81655
@ user81655 Je suis presque sûr que vous devez court-circuiter le ||, mais je pense que vous pourriez vous en tirer en utilisant &plutôt &&que dans ce cas.
Neil
@ Neil Pourquoi ça? L'avez-vous testé?
user81655
7

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.

Alex A.
la source
6

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>

edc65
la source
-n-1= ~n, non?
CalculatriceFeline
@CatsAreFluffy si n n'est pas numérique comme 'A' (c'est le but de ce défi), ~n == -1tandis que-n-1 == NaN
edc65
4

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.
Dennis
la source
4

Octave, 22 octets

@(n)all(dec2hex(n)>64)
Alephalpha
la source
4

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.

TNT
la source
"[a-f]+"économiserait 2 octets.
Eng.Fouad
Échoue pour 516 ..
CalculatorFeline
@CatsAreFluffy Non, ce n'est pas le cas.
TNT
Eh bien maintenant, il détermine si la chaîne contient une lettre hexadécimale, alors supprimez-le +, c’est un gaspillage d’octets.
CalculatriceFeline
@CatsAreFluffy No. matches renvoie true si la chaîne entière peut être mise en correspondance avec l'expression régulière donnée. [a-f]sans le signe plus, il est incorrect car il ne correspond pas à la chaîne entière, car il contient plus d'un caractère. ce serait le cas si et seulement si un caractère valide est présent.
TNT
3

CJam ( 9 à 8 octets)

{GbA,&!}

Démo en ligne

Peter Taylor
la source
2
Tout aussi court:{Gb$N<!}
Dennis
3

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
Vasu Adari
la source
En retard, mais la '%x'%n!~/\d/vérification est plus courte pour la solution un, et la solution deux a un nombre d'octets brut de 70, et non de 75.
Value Ink
3

Perl, 69 - 40 = 29 octets

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

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"));
Paŭlo Ebermann
la source
2

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

Poignée de porte
la source
J'ai une idée. Plus de fermetures!
CalculatorFeline
2

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

quintopie
la source
1
11: 4╙,¡#S;ú∩S=(ou ou , beaucoup d'orthographes :16:sur deux octets: P)
Mego
Je ne savais pas si je pense.
Quintopia
2

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!

Adnan
la source
1
hdÔ©1åi•4?ŸâτΛ•}®0åi•4?ŸàpÕTà•}®g2Qi•²•} 36B` pour le bonus résultant en ... 6 autres! Wooooo bonus!
Urne magique Octopus le
2

Python 3, 28 octets

lambda x:min(hex(x)[1:])>'@'
0WJYxW9FMN
la source
2

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"
escargot_
la source
Je ne vois pas de caractères non-ASCII ici (sauf s’il en existe); ce compteur est le décideur définitif et il dit 81.
Chat
1
Peu importe que la mise en œuvre utilise UTF-16 en interne; pour le reste du monde, ils peuvent aussi bien être des caractères UTF-8 dans la plage 0-127, ainsi votre nombre d'octets est 81.
Chat
Merci pour les commentaires, n'était pas sûr si "octets" signifiait que je devrais compter 2 par caractère. 81 c'est.
snail_
En fait, le consensus actuel de + 10 / -0 (avec lequel, d’ailleurs, je ne suis pas d’accord maintenant) est qu’il faut toujours utiliser le codage utilisé par un interprète. Si vous êtes en désaccord, veuillez publier une opinion divergente sur cette question.
lirtosiast
@ThomasKwa pfft, d'accord, oups, maintenant je sais mieux. Je n'avais pas réalisé qu'il y avait un consensus à ce sujet et j'ai passé pas mal de temps en méta.
Chat
1

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.
ETHproductions
la source
Je pense que cela !!UsG r"\\dpourrait fonctionner et économiser un octet
Downgoat
@Downgoat Bonne observation, mais cela retourne vrai pour tout nombre contenant une lettre.
ETHproductions
1

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
homme au travail
la source