Défi

Dans ce défi, vous devez prendre un nombre comme entrée et sortir la lettre correspondante de l'alphabet, et vice versa. (1 <=> A, 2 <=> B) etc.

1 -> A
2 -> B
...
26 -> Z

A -> 1
B -> 2
...
Z -> 26

Règles

• C'est le code-golf , donc le code le plus court en octets gagne.
• L'entrée se composera uniquement d'une lettre majuscule de Aà Zou d'un entier de 1à 26inclus.
• Les espaces blancs de fin (espace et nouvelle ligne) sont autorisés.

En fait, 7 octets

ú' +ûEí

Essayez-le en ligne!

Explication:

ú' +ûEí
ú' +     lowercase English alphabet, prepend space
    û    uppercase
     E   element (pushes the nth letter if input is an integer, leaves stack alone otherwise)
      í  index (pushes index of input if input is a string, leaves stack alone otherwise)

Si les minuscules sont acceptables, cela représente 6 octets:

ú' +Eí

Essayez-le en ligne!

Pure Bash, 51

La plupart des autres réponses utilisent une sorte de conditionnel. Celui-ci supprime entièrement les conditions et traite plutôt l'entrée comme un nombre en base 36 qui indexe dans un tableau d'expansion bash-brace de construction appropriée:

a=(_ {A..I} {1..26} {J..Z} {A..Z})
echo ${a[36#$1]}

Ideone.

Erlang, 26 octets

f([X])->X-64;f(X)->[X+64].

L'une des rares fois où le comportement de chaîne d'Erlang est utile.

Python 2, 38 octets

lambda x:x>''and 64^ord(x)or chr(64^x)

Testez-le sur Ideone .

Python 3, 43 octets

lambda x:x!=str(x)and chr(64|x)or ord(x)^64

La chose intéressante à propos de cette solution est qu'elle intègre tous les sens de OR, OR au niveau du bit, OR |logique or, XOR au niveau du bit ^et XOR logique !=...

2sable , 9 8 octets

Code:

.bAu¹kr,

Explication:

.b        # Convert 1 -> A, 2 -> B, etc.
  A       # Push the alphabet.
   u      # Convert it to uppercase.
    ¹k    # Find the index of the letter in the alphabet.
      r   # Reverse the stack.
       ,  # Pop and print with a newline.

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Ruby, 47 39 + ndrapeau = 40 octets 33 34 31 octets

Fonction anonyme. Utilise une astuce de gestion des exceptions comme dans la solution Python de @ KarlNapf .

-3 octets de @manatwork

Essayez-le en ligne

->i{(64+i).chr rescue i.ord-64}

Version originale du programme complet avec l' nindicateur de 40 octets et lit à partir de STDIN:

puts$_!~/\d/?$_.ord-64:(64+$_.to_i).chr

Cheddar, 34 32 octets

Enregistré 2 octets grâce à @LeakyNun

n->"%s"%n==n?n.ord()-64:@"(n+64)

Je souhaite qu'il y ait un moyen plus court de vérifier si la chaîne ou le nombre.

Essayez-le en ligne! ou Suite de tests

Explication

n ->                // func with arg `n`
    "%s"%n==n ?     // if n is string... (see below)
       n.ord() - 64  // return code point - 64
    :               // else...
    @"(n+64)         // chr(n+64)

"%s"%n==nvérifie s'il s'agit d'une chaîne de manière simple. "%s"est un format de chaîne, je peux formater avec %par exemple "a %s c" % "b"est égal à "a b c". %sspécifie qu'il s'agit d'une chaîne, si un chiffre est passé, il restera comme %s.

Mathematica 54 41 octets

Avec une suggestion absolument intelligente de LegionMammal978 qui économise 13 octets.

If[#>0,FromLetterNumber,,LetterNumber]@#&

If[#>0,FromLetterNumber,,LetterNumber]sert le seul but de décider s'il convient d'appliquer FromLetterNumberou LetterNumberà l'entrée.

#>0sera satisfait si l'entrée,, #est un nombre, auquel cas FromLetterNumberil sera sélectionné.

Cependant, #>0ne sera ni vrai ni faux s'il #s'agit d'une lettre et LetterNumbersera sélectionné à la place.

If[#>0,FromLetterNumber,,LetterNumber]@#&["d"]

4

If[#>0,FromLetterNumber,,LetterNumber]@#&[4]

ré

Dans Mathematica, FromLetterNumberet LetterNumberfonctionnera également avec d'autres alphabets. Cela ne nécessite que quelques octets supplémentaires.

If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Greek"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Russian"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Romanian"]

δ
г
b

If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[δ, "Greek"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[г, "Russian"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[b, "Romanian"]

4
4
4

Haskell, 54 octets

f s|s<"A"=[['@'..]!!read s]|1<2=show$fromEnum(s!!0)-64

Exemple d'utilisation: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

Le système de type strict de Haskell est une vraie douleur ici. De plus, toutes les fonctions char <-> int courtes aiment chret ordnécessitent une importation, donc je dois le faire à la main. Pour la lettre -> int, par exemple, je dois convertir String-> Char(via !!0) -> Integer(via fromEnum) -> String(via show).

C, 55 octets

i;f(char*s){i=atol(s);printf(i?"%c":"%d",64^(i?i:*s));}

Perl 6 , 25 octets

{+$_??chr $_+64!!.ord-64}

Explication:

# bare block lambda with implicit parameter of ｢$_｣
{
    +$_         # is the input numeric
  ??
    chr $_ + 64 # if it is add 64 and get the character
  !!
    $_.ord - 64 # otherwise get the ordinal and subtract 64
}

Exemple:

say ('A'..'Z').map: {+$_??chr $_+64!!.ord-64}
# (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)

say (1..26).map: {+$_??chr $_+64!!.ord-64}
# (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)

C #, 32 octets

n=>(n^=64)>26?(object)(char)n:n;

S'exécute vers Func<int, object>.

Input: charconvertit implicitement en intdonc peut être appelé avec int(1-26) ou char('A'-Z').

Sortie: Soit a charou int.

PHP, 49 41 40 octets

<?=+($i=$argv[1])?chr($i+64):ord($i)-64;

Je ne pense pas qu'il existe une bonne alternative à is_numericdroite?

Ceci est exécuté à partir de la ligne de commande ( $argv[1]est la première variable donnée)

Grâce à:

@insertusernamehere: Golfé 8 octets. Remplacer is_numeric($i=$argv[1])par 0<($i=$argv[1]). Cela fonctionne parce que (int)"randomLetter" == 0.

@manatwork: réduit de 1 octet. Remplacez 0<par +. Ce qui se passe dans ce cas, c'est que le signal + convertira le "Z" (ou n'importe quelle lettre) en 0. Cela se traduira par faux. Par conséquent, toute lettre est toujours fausse et un nombre est toujours vrai.

Python 2, 61 octets

i=raw_input()
try:o=chr(int(i)+64)
except:o=ord(i)-64
print o

Oui, je pourrais passer à Python 3 pour input

PowerShell v2 +, 42 octets

param($n)([char](64+$n),(+$n-64))[$n-ge65]

Prend l'entrée $n(comme un entier ou un caractère explicite) et utilise un pseudo-ternaire pour choisir entre deux éléments d'un tableau. Le conditionnel est $n-ge65(c.-à-d. Est l'entrée ASCII Aou plus). Si c'est le cas, nous convertissons simplement l'entrée en entier et en soustrayant 64. Sinon, nous ajoutons 64à l'entier d'entrée et le convertissons en a [char]. Dans les deux cas, le résultat est laissé sur le pipeline et l'impression est implicite.

Exemples

PS C:\Tools\Scripts\golfing> ([char[]](65..90)|%{.\alphabet-to-number.ps1 $_})-join','
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26

PS C:\Tools\Scripts\golfing> (1..26|%{.\alphabet-to-number.ps1 $_})-join','
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z

Befunge-98 *, 19 octets

&:39*\`'@\j;+,@;-.@

Parce que la question disait que vous recevrez un 1-26ou un, A-Zj'ai supposé que cela signifiait le numéro 26 ou le caractère AZ. La plupart des interprètes ont du mal à saisir des alt-codes, il est donc plus facile à utiliser &et à saisir des valeurs comme 26 pour 26 ou 90 pour «Z», par opposition à ~.

Pseudo-code

int c = get stdin
push the value of 27
bool is_number =  27 > c
push the value of `@` (64)
if is_number == 1
   jump to adding 64 to c //putting it the ASCII range
   print as ASCII
   end
else
   jump to subtracting 64 from c //putting it in the numerical range
   print as number
   end

Testez-le (sous Windows) ici!

* Ceci est techniquement Unfunge-98 car il n'utilise qu'une seule dimension, mais ce nom peut ne pas être familier.

Befunge 93 , 144 90 66 54 36 19 octets

Je ne suis pas sûr à 100% si cela est autorisé, mais si vous êtes autorisé à taper A comme 65, B comme 66, etc., alors (pour [mon] souci de commodité):

&:"@"`"@"\#. #-_+,@

Sinon, à 36 octets:

~:0\"A"-`#v_88*-.@
**~28*++,@>68*-52

(Merci à tngreene pour les suggestions!)

~:0\567+*-`#v_88*-.>$28*+,@
52**\28*++,@>~:0`!#^_\68*-

(Merci à Sp3000 pour avoir économisé 12 octets en réorganisant!)

~:0\567+*-`#v_88*-.>$82*+,@
            >~:0`!#^_\68*-52**\28*++,@


v                   >$28*+,@
             >~:0`!#^_\68*-52**\28*++,@
>~:0\567+*-`#^_88*-.@


v                    >$28*+,@
~           >11g~:0`!|
1                    >\68*-52**\28*++,@
1
p           
>011g567+*-`|
            >11g88*-.@

Non golfé:

v                       >$ 28* + , @
                 >~:0 `!|
                        >\ 68* - 52* * \ 28* + + , @
>~:0\ 5 67+ * - `|
                 >88* - . @

Il s'agit de mon premier programme Befunge de travail, et je ressens le besoin de continuer à jouer au golf. Toute aide serait grandement appréciée.

Vous pouvez tester le code Befunge ici .

Brainfuck, 445 personnages

Plus une preuve de concept qu'un code golfé. Nécessite Brainfuck non signé et sans emballage.

,[>+>+<<-]>[<+>-]>>++[->++++++<]>[-<<<+++++>>>]<<<<[->-<]>[,<++++[->------------<]++++[->>------------<<][-<<++++++++++>>]>[-<+>]>[-<<++++++++++>>]>++[->++++++<]>+[-<+++++>]<-[-<<<+>>>]<<<.>]>[[-<+<+>>]>++[->++++++<]>+[-<+++++>]<-[-<<->>]<<[->+>+<<]>>>++++++++++<+[>[->+>+<<]>[-<<-[>]>>>[<[-<->]<[>]>>[[-]>>+<]>-<]<<]>>>+<<[-<<+>>]<<<]>>>>>[-<<<<<+>>>>>]<<<<<-[->+>+<<]>[-<++++++++++>]<[-<->]++++[-<++++++++++++>]++++[->>++++++++++++<<]>>.<<<.>]

Avec commentaires

,[>+>+<<-] Firstly Duplicate it across two buffers
>[<+>-] Move the second buffer back to the first buffer
>>++[->++++++<]>[-<<<+++++>>>] Establish 60 in the second buffer
<<<<
Compare Buffers 1 and 2
[->-<]
>
[ If there's still data in buffer 2
, Write the value in the units column to buffer two
<
++++
[->------------<] Subtract 12 from the units buffer
++++
[->>------------<<] Subtract 12 from the tens buffer
[-<<++++++++++>>] Multiply buffer three by ten into buffer 1
>
[-<+>] Add the units
>
[-<<++++++++++>>] Add the tens
>++ Add 65 to the buffer
[->++++++<]>+
[-<+++++>]
<- Actually we need 64 because A is 1
[-<<<+>>>] Add 64 to the first buffer
<<<
. Print the new letter
> Move to blank buffer
]
>
[ Otherwise we're a letter
[-<+<+>>] Copy it back over the first two buffers
>++ Write 64 to the buffer
[->++++++<]>+
[-<+++++>]
<-
[-<<->>] Subtract 64 from the letter
<<[->+>+<<]
>>>++++++++++< Copy pasted Division step x = current buffer y = 10 rest of the buffers are conveniently blank

+
[>[->+>+<<]>[-<<-[>]>>>[<[-<->]<[>]>>[[-]>>+<]>-<]<<]>>>+<<[-<<+>>]<<<]>>>>>[-<<<<<+>>>>>]<<<<<
-
[->+>+<<]
>[-<++++++++++>]
<[-<->]
++++
[-<++++++++++++>]
++++
[->>++++++++++++<<]
>>.<<<.>
] 

Java, 104 98 97 83 54 53 51 50 30 octets

x->(x^=64)>64?(char)x+"":x+"";

Programme de test :

IntFunction<String> f = x -> (x ^= 64) > 64 ? (char) x + "" : x + "";
out.println(f.apply('A')); // 1
out.println(f.apply('Z')); // 26
out.println((f.apply(1))); // A
out.println((f.apply(26))); //Z

Fourier, 30 octets

I~F<64{1}{F+64a}F>64{1}{F-64o}

Essayez-le en ligne!

R, 73 octets

f=function(x){L=LETTERS;if(is.numeric(x)){i=L[(x)]}else{i=which(L==x)};i}

MATL, 10 octets

6WZ~t42>?c

Explication:

6W              % 2**6 = 64, but golfier looking
  Z~            % bit-wise XOR with input
    t42>?       % if result is greater than 42
         c      % convert it to a character 
                % else, don't

Essayez-le en ligne! avec entrées numériques.
Essayez-le en ligne! avec entrées alphabétiques.

Python 3, 49 48 53 50 octets

D'une manière ou d'une autre, le nombre d'octets est incorrect; _; merci dahuglenny

isalpha est plus court que isnumeric

lambda x:x.isalpha()and ord(x)-64or chr(int(x)+64)

prend l'entrée sous forme de chaîne, qui peut être une lettre ou un chiffre

Java, 61 octets

int f(char c){return c^64;}char f(int i){return(char)(i^64);}

Non golfé:

int f(char c) {
    return c^64;
}

char f(int i) {
    return (char) (i^64);
}

L'appel f('A')appelle la première fonction, réaccordant un int1; L'appel f(1)appelle la deuxième fonction, renvoyant le char"A".

Javascript 86 77 66 60 octets

i=>typeof i<'s'?String.fromCharCode(i+64):i.charCodeAt(0)-64

• enregistré 7 octets après les commentaires sur l'utilisation des fonctions fléchées
• enregistré encore 11 octets en supprimant les retours / crochets comme indiqué par @manatwork
• sauvé encore 6 octets grâce à @manatwork

ASM: 10 octets

3C 40 77 04 2C 40 EB 02 04 40

Explication: Il s'agit de la représentation assemblée d'un programme qui fait exactement ce qui est demandé. Il n'est pas entièrement fonctionnel, car il a besoin de quelques directives, mais s'il est ajouté au segment de code d'un programme d'assemblage, il devrait fonctionner. Il reçoit l'entrée dans le registre AL, et s'il s'agit d'une lettre, il soustrait 40h de la valeur du code ASCII, ne laissant que le nombre (c'est-à-dire B = 42h, 42h-40h = 2h). Si l'entrée est un nombre, elle fait la procédure inverse en ajoutant 40h. Il laisse le résultat dans le registre AL. Ci-dessous le code source de l'assembly

cmp al,40h
ja letter_to_number
sub al,40h
jmp continue
letter_to_number: add ax,40h
continue:

De plus, si vous convertissez toutes les autres réponses en code machine, je suis certain que la mienne serait la plus petite.

Excel, 33 octets

=IFERROR(CHAR(A1+64),CODE(A1)-64)

Brachylog , 10 octets

;.L∧Ṇi₁pL∧

Essayez-le en ligne!

Le cœur de ceci n'est que de 4 octets , mais les E / S pour cette version sont un peu moins saines.

Japt , 11 octets

;BbU Ī´UgB

Essayez-le

;BbU Ī´UgB     :Implicit input of integer or string U
;B              :Uppercase alphabet
  bU            :0-based index of U (-1 if not found)
     Ä          :Add 1
      ª         :Logical OR with
       ´U       :Decrement U
         gB     :Index into the uppercase alphabet