0xUsernames

Il y a tellement de gens qui utilisent un service de messagerie qu'ils manquent d'espace pour stocker tous les noms d'utilisateur! Pour résoudre ce problème, ils vont commencer à stocker les noms d'utilisateur sous forme hexadécimale, si possible.

Si un nom d'utilisateur se compose uniquement des caractères 0123456789ABCDEF(insensible à la casse), il peut être converti en hexadécimal et stocké sous forme d'entier. Par exemple, le nom d'utilisateur ba5eba11peut être interprété comme 0xBA5EBA11un entier hexadécimal.

Mais qu'en est-il 05AB1E? Cela a un zéro de tête, qui serait perdu. Ainsi, chaque fois que nous convertissons un nom d'utilisateur, nous nous assurons de faire précéder un 1avant de le lire comme un entier.

Le défi

Votre tâche consiste à écrire un programme ou une fonction qui, étant donné un nom d'utilisateur non vide sous forme de chaîne, «hexa-compresse» le nom d'utilisateur:

• S'il peut être interprété comme un entier hexadécimal, ajoutez un 1, interprétez-le comme hexadécimal, puis imprimez le résultat en base 10.
• Sinon, renvoyez simplement la chaîne non modifiée.

Il s'agit de code-golf , donc la solution la plus courte (en octets) l'emporte! Les fonctions de conversion de base intégrées sont autorisées.

Cas de test

Vous pouvez supposer que tous les entiers résultants se trouvent dans la plage d'entiers standard de votre langue.

Comme pour les noms d'utilisateur sur la plupart des systèmes de messagerie, les chaînes d'entrée ne contiendront que des caractères alphanumériques et des traits de soulignement.

N'oubliez pas, vous devez toujours ajouter un interligne 1avant la conversion!

"ba5eba11" -> 7421737489
"05AB1E"   -> 17148702
"dec0de"   -> 31375582
"Beef"     -> 114415    
"da7aba5e" -> 7960443486
"500"      -> 5376

"DENNIS" -> "DENNIS"
"Garth"  -> "Garth"
"A_B_C"  -> "A_B_C"
"0x000"  -> "0x000"

Pour référence, voici une implémentation de Python 3 que j'ai utilisée pour les cas de test (non golfée):

import re

def convert_name(name):
    if re.fullmatch('^[0-9A-Fa-f]+$', name):
        return int('1' + name.upper(), base = 16)
    else:
        return name

05AB1E , 4 octets

D1ìH

Explication

D    Duplicate input
 1ì  Prepend 1
   H Interpret as hexadecimal and implicitly display the value in base 10

Si l'entrée contient des caractères hexadécimaux invalides, Helle ne poussera rien, donc la dernière valeur de la pile sera l'entrée dupliquée, c'est pourquoi le programme imprime son entrée en cas d'entrée invalide.

Essayez-le en ligne!

JavaScript (ES6), 15 octets

s=>'0x1'+s-0||s

Comment ça marche

'0x1'+sconvertit l'entrée en une chaîne hexadécimale littérale avec un préfixe 1, par exemple 0x105ab1e. -0Convertit ensuite le résultat en un nombre. JavaScript voit le 0xau début et essaie implicitement de convertir de l'hexadécimal; si scontient des caractères non hexadécimaux, cela renvoie NaN. Puisque c'est faux (et que la sortie 0ne peut jamais être donnée à cause du préfixé 1), nous pouvons utiliser ||spour retourner ssi la conversion hexadécimale a échoué.

Extrait de test

f = s=>'0x1'+s-0||s

for(i of [
  "ba5eba11", "05AB1E", "dec0de", "Beef", "da7aba5e", "500",
  "DENNIS", "Garth", "A_B_C", "0x000"
]) console.log(i + ":", f(i));

Python 2 , 44 octets

Prend l'entrée comme une chaîne entre guillemets. -2 octets grâce à Rod!

a=input()
try:exec'a=0x1'+a
except:1
print a

Comme nous sommes garantis que l'entrée ne contiendra que des caractères alphanumériques et des traits de soulignement, il n'y a aucun moyen de créer un Python valide après 0x1avoir une chaîne hexadécimale. Si l'entrée est autre chose, l'erreur est ignorée et s'imprime telle qu'elle était à l'origine.

Je n'arrivais pas à faire une correspondance regex plus courte que try/except. En fait, l'expression régulière s'est avérée terriblement verbeuse:

import re
lambda n:re.match('^[0-9A-F]+$',n,2)and int('1'+n,16)or n

Perl 6 , 19 octets

{:16(1~S/_/Z/)//$_}

Essaye-le

Étendu:

{   # bare block lambda with implicit parameter ｢$_｣

    :16(     # convert from base 16
      1
      ~      # Str concatenated
      S/_/Z/ # replace an underscore with an invalid base 16 character
    )

  //         # defined or

    $_       # the input unchanged

}

Perl, 27 octets

-1 octet grâce à @ardnew .

26 octets de code + -p indicateur.

$_=hex"1$_"if!/[^0-9a-f]/i

Fournissez l'entrée sans nouvelle ligne finale. Avececho -n par exemple:

echo -n 05AB1E | perl -pe '$_=hex"1$_"if!/[^0-9a-f]/i'

Explication
C'est assez simple: /[^0-9a-f]/ic'est vrai si l'entrée contient un caractère autre que ceux autorisés à l'intérieur des nombres hexadécimaux. S'il est faux, $_(qui contient l'entrée), il est défini sur la valeur convertie (la conversion est effectuée par la fonction intégrée hex).
Et $_est implicitement imprimé grâce au -pdrapeau.

Pyth - 9 octets

.xi+1z16z

Même idée que la réponse de fliptack . Essayez une conversion hexadécimale-décimale, sinon sortez l'entrée.

Essayez-le ici!

Lot, 33 octets

@(cmd/cset/a0x1%1 2>nul)||echo %1

Comment ça marche

Une chaîne est passée en argument, 1 y est ajoutée et la chaîne est implicitement convertie en décimal et imprimée. Si la chaîne n'est pas hexadécimale valide, elle est simplement affichée.

Il convient de noter que, puisque les calculs par lots utilisent des entiers 32 bits signés, le plus grand nom d'utilisateur autorisé est FFFFFFF.

cmd /c prend la commande suivante, l'exécute dans un nouveau terminal et quitte.

set /a effectue des calculs et affiche implicitement le résultat en décimal lorsqu'il n'est pas stocké dans une variable.

0x1%1 indique à set de ajouter un 1 au premier argument (c'est facile car toutes les variables batch sont des chaînes) et indique que la chaîne doit être traitée comme hexadécimale.

2>nul supprime toutes les erreurs résultant d'un nombre hexadécimal non valide

||est un OU logique et exécute la commande à droite si la commande à gauche échoue. Les parenthèses font tout jusqu'à ce point une commande.

echo %1 affiche simplement le premier argument.

Lisp commun, 71

(lambda(n)(or(ignore-errors(parse-integer(format()"1~A"n):radix 16))n))

Les tests

Définir la fonction

CL-USER> (lambda(n)(or(ignore-errors(parse-integer(format()"1~A"n):radix 16))n))
#<FUNCTION (LAMBDA (N)) {10041D213B}>

Citez une liste des entrées attendues, comme indiqué par la question:

CL-USER> '("ba5eba11" -> 7421737489
"05AB1E"   -> 17148702
"dec0de"   -> 31375582
"Beef"     -> 114415    
"da7aba5e" -> 7960443486
"500"      -> 5376

"DENNIS" -> "DENNIS"
"Garth"  -> "Garth"
"A_B_C"  -> "A_B_C"
"0x000"  -> "0x000")
("ba5eba11" -> 7421737489 "05AB1E" -> 17148702 "dec0de" -> 31375582 "Beef" ->
 114415 "da7aba5e" -> 7960443486 "500" -> 5376 "DENNIS" -> "DENNIS" "Garth" ->
 "Garth" "A_B_C" -> "A_B_C" "0x000" -> "0x000")

Analyser et collecter les résultats

CL-USER> (loop for (in _ out) on * by #'cdddr
               collect (list in out (funcall ** in)))
(("ba5eba11" 7421737489 7421737489) ("05AB1E" 17148702 17148702)
 ("dec0de" 31375582 31375582) ("Beef" 114415 114415)
 ("da7aba5e" 7960443486 7960443486) ("500" 5376 5376)
 ("DENNIS" "DENNIS" "DENNIS") ("Garth" "Garth" "Garth")
 ("A_B_C" "A_B_C" "A_B_C") ("0x000" "0x000" "0x000"))

Vérifiez que les sorties attendues correspondent aux sorties réelles:

CL-USER> (every (lambda (x) (equalp (second x) (third x))) *)
T

C, 108 octets

i;f(char*s){char*S=malloc(strlen(s)+2);*S=49;strcpy(S+1,s);sscanf(S,"%x%c",&i,&i)<2?printf("%d",i):puts(s);}

Il s'agit d'une fonction qui prend la chaîne en argument et imprime le résultat dans STDOUT.

i;                           // declare i as an int
f(char*s){
char*S=malloc(strlen(s)+2);  // allocate space for a new string with 1 more char
*S=49;                       // set the first char to '1' (ASCII 49)
strcpy(S+1,s);               // copy the original string to the remainder
sscanf(S,"%x%c",&i,&i)       // scan a hex integer followed by any char
<2?                          // if less than 2 items were scanned (i.e. the hex
                             // integer made up the entire string),
printf("%d",i)               // output the hex integer
:puts(s);}                   // otherwise, output the original string

JavaScript: 46 41 octets

s=>/[^\dA-F]/i.test(s)?s:parseInt(1+s,16)

PHP, 42 octets

hex2bin () renvoie false si l'entrée n'est pas une chaîne hexadécimale valide. C'est plus court que d'utiliser l'expression régulière pour rechercher des chiffres non hexadécimaux, mais nous avons besoin de l'opérateur @ car il n'est pas silencieux lorsqu'il échoue.

<?=@hex2bin($s=$argv[1])?hexdec("1$s"):$s;

frapper, 46 35 31 octets

(echo $[0x1$1])2> >(:)||echo $1

Enregistrez en tant que script et passez le nom d'utilisateur en argument.

Python 2 - 63, 52, 50, 46 octets

n=input()
try:n=int("1"+n,16)
except:1
print n

Cela utilise Python int()qui convertit n'importe quelle chaîne avec sa base appropriée en base 10. Dans ce cas, la chaîne est le numéro 1 attaché à l'entrée. Si l'entrée n'est pas valide (a des caractères autres que 0123456789ABCDEF(insensible à la casse), elle renvoie ValueError:

n = input()                   # Get input (with quotes)
try:                          # Trying conversion to base 10
    n = int("1"+n,16)        
except:                       # If invalid string for base 36,
    1                         # do nothing to n
print n                       # Print result

Essayez-le ici!

Merci à @FlipTack pour avoir économisé 15 octets!

Rubis, 47 44 octets

p gets=~/^[a-f\d]+\s$/i?('1'+$&).to_i(16):$_

Je pourrais supprimer 3 octets en changeant putspour p, mais j'ai l'impression que la sortie serait considérée comme incorrecte car elle a une nouvelle ligne à la fin.

Edit: Changement putspour pque sont généralement sauts de lignes acceptées, merci @Mego.

Japt , 11 octets

+`0x1{U}`ªU

Essayez-le en ligne!

Un grand merci à ETHproductions!

Dyalog APL , 37 octets

N'utilise aucune validation intégrée ou conversion hex-dec. Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

{∧/(u←1(819⌶)⍵)∊d←⎕D,6↑⎕A:16⊥1,d⍳u⋄⍵}

Non golfé:

{
    d ← ⎕D , 6 ↑ ⎕A
    u←1 (819⌶) ⍵
    ∧/ u ∊ d: 16 ⊥ 1 , d ⍳ u
    ⍵
}

d ← ⎕D , 6 ↑ ⎕A d obtient D igits suivi des 6 premiers éléments de l' alphabet A

u ← 1 (819⌶) ⍵ u se met en majuscule (819 argument "Big") argument

∧/ u ∊ d: si tous les éléments de u sont membres de d , alors:
 16 ⊥ 1 , d ⍳ u trouver les indices de u dans d , ajouter un 1 au début et évaluer comme base 16

⍵ else: retourne l'argument (non modifié)

TryAPL en ligne:

1. Mettre ⎕IOà zéro, définir un remplacement pour ⌶(interdit sur TryAPL pour des raisons de sécurité), et un ensemble ⎕PP( P Rint P recision) à 10 pour les grands résultats

2. Essayez tous les cas de test

REXX, 49 48 octets

signal on syntax
pull a
a=x2d(1||a)
syntax:
say a

Le signal on syntaxdit à l'interpréteur de sauter à l'étiquette syntaxchaque fois qu'une erreur de syntaxe se produit. Le programme essaie de se réaffecter aavec une version convertie hexadécimale en décimale avec un 1 en tête, mais passe à l' syntaxétiquette en cas d'échec. Si la conversion réussit, elle ignore simplement l'étiquette et génère la variable réaffectée.

PowerShell , 35 octets

param($v)(($h="0x1$v"|iex),$v)[!$h]

Essayez-le en ligne! ou Exécutez tous les cas de test!

Explication

1. Prendre le paramètre ( $v)
2. Créez un tableau à deux éléments où le premier élément ( 0) est le résultat d'une chaîne contenant 0x1$vpiped into Invoke-Expression( iex), tout en affectant simultanément cette valeur à $h. Si la conversion échoue, $hrestera $null.
3. Le deuxième élément du tableau est le paramètre d'origine.
4. Indexez dans le tableau avec la -notvaleur booléenne de $h. Tout ce qui $hest sera implicitement converti en [bool]( $nulldans le cas d'une conversion invalide deviendra $false, un entier positif dans le cas d'une conversion réussie deviendra $true) avant d'être annulé, qui est ensuite implicitement converti en [int]par l'indexeur de tableau []( $truesera 1, $falsesera 0), entraînant ainsi le premier élément du tableau (le résultat de la conversion) choisi si la conversion a réussi, et le deuxième élément choisi si la conversion a échoué.

Scala, 40 octets

s=>try{BigInt("1"+s,16)}catch{case e=>s}

Usage:

val f:(String=>Any)=s=>try{BigInt("1"+s,16)}catch{case e=>s}
f("ba5eba11") //returns 7421737489

Explication:

s=>                //define a anonymous function with a parameter called s
  try {              //try...
    BigInt("1"+s,16)   //to contruct a BigInt from "1" prepended to the number, parsing it as base 16
  } catch {          //if the constructor throws an exception
    case e =>          //in case of an execption which we'll call e
      s                  //return s
  }

C #, 58 octets

u=>{try{u=Convert.ToInt64("1"+u,16)+"";}catch{}return u;};

Non golfé avec des cas de test:

using System;
class Class
{
    public static void Main()
    {
        Func<string, string> convert = 
            u=>
            {
                try
                {
                    u = Convert.ToInt64("1" + u, 16) //Prepends "1" and tries to convert the string to and integer using base 16.
                        + ""; //Appending an empty string converts the integer to a string. Shorter than calling .ToString()
                }
                catch { } //If the conversion fails catch the exception and discard it.
                return u; //Return the result, or the unmodified input if the conversion failed.
            };

        Console.WriteLine(convert("ba5eba11"));
        Console.WriteLine(convert("05AB1E"));
        Console.WriteLine(convert("dec0de"));
        Console.WriteLine(convert("Beef"));
        Console.WriteLine(convert("da7aba5e"));
        Console.WriteLine(convert("500"));
        Console.WriteLine(convert("DENNIS"));
        Console.WriteLine(convert("Garth"));
        Console.WriteLine(convert("A_B_C"));
        Console.WriteLine(convert("0x000"));
        Console.Read();
    }
}

Essayez en ligne

Fléchette, 51 octets

(s)=>int.parse('1$s',radix:16,onError:(_)=>null)??s

Essayez-le ici

La plupart des frais généraux proviennent de paramètres nommés ... Eh bien!

Au moins Dart vous permet de taper dynamiquement, si vous voulez: D