Reto

En este desafío, debe tomar un número como entrada y salida de la letra correspondiente del alfabeto, y viceversa. (1 <=> A, 2 <=> B) etc.

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

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

Reglas

• Este es el código de golf , por lo que gana el código más corto en bytes.
• La entrada solo consistirá en una letra mayúscula de Aa Zo un número entero de 1a 26inclusive.
• Se permiten espacios en blanco al final (espacio y nueva línea).

En realidad, 7 bytes

ú' +ûEí

Pruébalo en línea!

Explicación:

ú' +û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 se aceptan minúsculas, esto es 6 bytes:

ú' +Eí

Pruébalo en línea!

Pure Bash, 51

La mayoría del resto de las respuestas usan algún tipo de condicional. Éste prescinde por completo de condicionales y, en su lugar, trata la entrada como un número base 36 que se indexa en una matriz bash-brace-expansion adecuadamente construida:

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

Ideona

Erlang, 26 bytes

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

Una de las pocas veces en que el comportamiento de cadena de Erlang es útil.

Python 2, 38 bytes

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

Pruébalo en Ideone .

Python 3, 43 bytes

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

Lo interesante de esta solución es que incorpora todos los sentidos de OR, OR bit a bit |, OR lógico or, XOR bit a bit ^y XOR lógico !=...

2sable , 9 8 bytes

Código:

.bAu¹kr,

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Ruby, 47 39 + nbandera = 40 bytes 33 34 31 bytes

Función anónima. Utiliza un truco de manejo de excepciones como en la solución Python de @ KarlNapf .

-3 bytes de @manatwork

Pruébalo en línea

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

Versión original del programa completo con la nbandera de 40 bytes y lecturas de STDIN:

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

Cheddar, 34 32 bytes

Guardado 2 bytes gracias a @LeakyNun

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

Desearía que hubiera una forma más corta de verificar si la cadena o el número.

Pruébalo en línea! o Test Suite

Explicación

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==ncomprueba si es una cadena de una manera simple. "%s"es un formato de cadena, puedo formatear con, %por ejemplo, "a %s c" % "b"es igual a "a b c". %sespecifica que es una cadena, si se pasa un dígito permanecerá como %s.

Mathematica 54 41 Bytes

Con una sugerencia absolutamente inteligente de LegionMammal978 que ahorra 13 bytes.

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

If[#>0,FromLetterNumber,,LetterNumber]tiene el único propósito de decidir si se aplica FromLetterNumbero no LetterNumbera la entrada.

#>0se satisfará si la entrada,, #es un número, en cuyo caso FromLetterNumberse seleccionará.

Sin embargo #>0, no será verdadero ni falso si #es una letra, y LetterNumberse seleccionará en su lugar.

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

4 4

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

re

En Mathematica, FromLetterNumbery LetterNumbertambién funcionará con otros alfabetos. Esto requiere solo unos pocos bytes más.

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 bytes

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

Ejemplo de uso: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

El estricto sistema de tipos de Haskell es un verdadero dolor aquí. Además, todas las funciones cortas de char <-> int tienen gusto chry ordnecesitan una importación, así que tengo que hacerlo a mano. Para la letra -> int, por ejemplo, necesito convertir String-> Char(vía !!0) -> Integer(vía fromEnum) -> String(vía show).

C, 55 bytes

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

Perl 6 , 25 bytes

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

Explicación:

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

Ejemplo:

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 bytes

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

Lanza a Func<int, object>.

Entrada: las charconversiones implícitas intse pueden llamar con int(1-26) o char('A'-Z').

Salida: A charo int.

PHP, 49 41 40 bytes

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

No creo que haya una buena alternativa al is_numericderecho?

Esto se ejecuta desde la línea de comando ($argv[1] es la primera variable dada)

Gracias a:

@insertusernamehere: Golfed 8 bytes. Reemplazar is_numeric($i=$argv[1])con 0<($i=$argv[1]). Esto funciona porque(int)"randomLetter" == 0 .

@manatwork: reducido con 1 byte. Reemplazar 0<con +. Lo que sucede en este caso es que la señal + arrojará la "Z" (o cualquier letra) a un 0. Esto dará como resultado falso. Por lo tanto, cualquier letra es siempre falsa y un número siempre es verdadero.

Python 2, 61 bytes

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

Sí, podría cambiar a Python 3 por input

PowerShell v2 +, 42 bytes

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

Toma información $n(como un entero o un carácter explícito) y usa un pseudoternario para elegir entre dos elementos de una matriz. El condicional es $n-ge65( es decir, es la entrada ASCII Ao mayor). Si es así, simplemente emitimos la entrada como int y restamos 64. De lo contrario, agregamos 64al entero de entrada y lo convertimos como un[char] . En cualquier caso, el resultado se deja en la tubería y la impresión es implícita.

Ejemplos

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 bytes

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

Debido a que la pregunta decía que recibirías un 1-26o un A-Z, supuse que esto significaba el número 26 o el carácter AZ. La mayoría de los intérpretes tienen dificultades para ingresar códigos alternativos, por lo que es más fácil usar &e ingresar valores como 26 para 26 o 90 para 'Z', en lugar de ~.

Pseudocódigo

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

¡Pruébelo (en Windows) aquí!

* Esto es técnicamente Unefunge-98 porque solo usa 1 dimensión, pero ese nombre puede ser desconocido.

Befunge 93 , 144 90 66 54 36 19 bytes

No estoy 100% seguro si esto está permitido, pero si puede escribir A como 65, B como 66, etc., entonces (por el bien de [mi] conveniencia):

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

De lo contrario, a 36 bytes:

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

(¡Gracias a tngreene por las sugerencias!)

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

(¡Gracias a Sp3000 por guardar 12 bytes reorganizando!)

~: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*-.@

Sin golf:

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

Este es mi primer programa Befunge en funcionamiento, y siento la necesidad de seguir jugando al golf. Cualquier ayuda sería muy apreciada.

Puede probar el código Befunge aquí .

Brainfuck, 445 Personajes

Más una prueba de concepto que un código de golf. Requiere Brainfuck sin envolver, sin firmar.

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

Con comentarios

,[>+>+<<-] 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 bytes

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

Programa de prueba :

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 bytes

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

Pruébalo en línea!

R, 73 bytes

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

MATL, 10 bytes

6WZ~t42>?c

Explicación:

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

Pruébalo en línea! con entradas numéricas
Pruébalo en línea! con entradas alfabéticas.

Pitón 3, 49 48 53 50 bytes

De alguna manera me equivoqué en el conteo de bytes; _; gracias dahuglenny

isalpha es más corto que isnumeric

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

toma la entrada como una cadena, que podría ser una letra o un número

Java, 61 bytes

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

Ungolf'd:

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

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

Llamar f('A')invoca la primera función, reajustando un int1; llamar f(1)invoca la segunda función, devolviendo la char"A".

Javascript 86 77 66 60 bytes

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

• guardado 7 bytes después de los comentarios sobre el uso de las funciones de flecha
• guardó otros 11 bytes al eliminar return / corchetes como lo señaló @manatwork
• ahorró otros 6 bytes gracias a @manatwork

ASM: 10 bytes

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

Explicación: Esta es la representación ensamblada de un programa que hace exactamente lo que se le pide. No es totalmente funcional, porque necesita algunas directivas, pero si se agrega al segmento de código de un programa de ensamblaje, debería funcionar. Recibe la entrada en el registro AL, y si es una letra, resta 40h del valor del código ASCII, dejando solo el número (es decir, B = 42h, 42h-40h = 2h). Si la entrada es un número, realiza el procedimiento contrario al sumar 40h. Deja el resultado en el registro AL. A continuación se muestra el código fuente del ensamblaje

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

Además, si convierte todas las otras respuestas al código de máquina, estoy seguro de que la mía sería la más pequeña.

Excel, 33 bytes

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

Brachylog , 10 bytes

;.L∧Ṇi₁pL∧

Pruébalo en línea!

El núcleo de esto es solo 4 bytes , pero la E / S para esa versión es un poco menos que sensata.

Japt , 11 bytes

;BbU Ī´UgB

Intentalo

;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