Desafio

Neste desafio, você deve pegar um número como entrada e enviar a letra correspondente do alfabeto e vice-versa. (1 <=> A, 2 <=> B) etc.

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

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

Regras

• Isso é código-golfe , então o código mais curto em bytes vence.
• A entrada consistirá apenas em uma letra maiúscula de Apara Zou um número inteiro de 1até 26inclusivo.
• Espaços em branco à direita (espaço e nova linha) são permitidos.

Na verdade, 7 bytes

ú' +ûEí

Experimente online!

Explicação:

ú' +û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)

Se minúsculas são aceitáveis, são 6 bytes:

ú' +Eí

Experimente online!

Pure Bash, 51

A maioria das demais respostas usa algum tipo de condicional. Este dispensa totalmente os condicionais e, em vez disso, trata a entrada como um número base-36 que indexa em uma matriz bash-cinta-expansão adequadamente construída:

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

Ideone.

Erlang, 26 bytes

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

Uma das poucas vezes em que o comportamento de string de Erlang é útil.

Python 2, 38 bytes

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

Teste em Ideone .

Python 3, 43 bytes

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

O interessante dessa solução é que ela incorpora todos os sentidos de OR, OR bit a bit |, OR lógico or, XOR bit a bit ^e XOR lógico !=...

2sable , 9 8 bytes

Código:

.bAu¹kr,

Explicação:

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

Usa a codificação CP-1252 . Experimente online! .

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

Função anônima. Usa um truque de manipulação de exceção, como na solução Python do @ KarlNapf .

-3 bytes de @manatwork

Experimente online

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

Versão original do programa completa, com o nsinalizador para 40 bytes e leituras de STDIN:

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

Queijo Cheddar, 34 32 bytes

Guardado 2 bytes graças a @LeakyNun

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

Eu gostaria que houvesse uma maneira mais curta de verificar se string ou número.

Experimente online! ou conjunto de teste

Explicação

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==nverifica se é uma string de maneira simples. "%s"é um formato de string, posso formatar com, %por exemplo, "a %s c" % "b"é igual a "a b c". %sespecifica que é uma string, se um dígito for passado, ele permanecerá como %s.

Mathematica 54 41 Bytes

Com uma sugestão absolutamente inteligente do LegionMammal978 que salva 13 bytes.

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

If[#>0,FromLetterNumber,,LetterNumber]serve ao único propósito de decidir se deve aplicar FromLetterNumberou LetterNumberà entrada.

#>0ficará satisfeito se a entrada,, #for um número, caso em que FromLetterNumberserá selecionado.

No entanto #>0, não será verdadeiro nem falso, se #for uma letra, e LetterNumberserá selecionado.

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

4

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

d

Em Mathematica, FromLetterNumbere LetterNumbertambém irá trabalhar com outros alfabetos. Isso requer apenas mais alguns bytes.

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

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

O sistema estrito de Haskell é uma verdadeira dor aqui. Além disso, todos os caracteres curtos <-> int funcionam como chre ordprecisam de uma importação, então eu tenho que fazer isso manualmente. Para a letra -> int case, por exemplo, preciso converter String-> Char(via !!0) -> Integer(via fromEnum) -> String(via 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}

Explicação:

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

Exemplo:

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;

Transmite para Func<int, object>.

Entrada: charconverte implicitamente em intassim pode ser chamado com int(1-26) ou char('A'-Z').

Saída: A charou int.

PHP, 49 41 40 bytes

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

Eu não acho que existe uma boa alternativa para a is_numericdireita?

Isso é executado a partir da linha de comando ( $argv[1]é a primeira variável fornecida)

Graças a:

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

@manatwork: Reduzido com 1 byte. Substitua 0<por +. O que acontece nesse caso é que o sinal + converterá o "Z" (ou qualquer outra letra) em um 0. Isso resultará em falso. Portanto, qualquer letra é sempre falsa e um número é sempre verdadeiro.

Python 2, 61 bytes

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

Sim, eu poderia mudar para o Python 3 para input

PowerShell v2 +, 42 bytes

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

Recebe entrada $n(como um número inteiro ou caractere explícito) e usa um pseudo-ternário para escolher entre dois elementos de uma matriz. A condicional é $n-ge65(ou seja, é a entrada ASCII Aou superior). Nesse caso, simplesmente lançamos a entrada como int e subtraímos 64. Caso contrário, adicionamos 64ao número inteiro de entrada e o convertemos como a [char]. Em ambos os casos, o resultado é deixado no pipeline e a impressão está implícita.

Exemplos

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;+,@;-.@

Como a pergunta dizia que você receberá um 1-26ou umA-Z eu assumi que isso significava o número 26 ou o personagem AZ. A maioria dos intérpretes luta para inserir códigos ALT, portanto, é mais fácil usar &e inserir valores como 26 para 26 ou 90 para 'Z', em oposição a ~.

Pseudo-có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

Teste aqui (no Windows) !

* Isso é tecnicamente Unefunge-98, porque usa apenas 1 dimensão, mas esse nome pode ser desconhecido.

Befunge 93 , 144 90 66 54 36 19 bytes

Não tem 100% de certeza se isso é permitido, mas se você pode digitar A como 65, B como 66 etc., então (por [minha] conveniência):

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

Caso contrário, em 36 bytes:

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

(Obrigado a tngreene pelas sugestões!)

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

(Agradecemos ao Sp3000 por salvar 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*-.@

Ungolfed:

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

Este é o meu primeiro programa de trabalho da Befunge, e sinto a necessidade de jogar mais. Qualquer ajuda seria muito apreciada.

Você pode testar o código Befunge aqui .

Brainfuck, 445 caracteres

Mais uma prova de conceito do que um código de golfe. Requer Brainfuck sem sinal e sem embalagem.

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

Com Comentários

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

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}

Experimente online!

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

Explicação:

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

Experimente online! com entradas numéricas.
Experimente online! com entradas alfabéticas.

Python 3, 49 48 53 50 bytes

De alguma forma, eu entendi errado a contagem de bytes; _; obrigado dahuglenny

isalpha é mais curto que isnumeric

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

recebe entrada como string, que pode ser uma letra ou 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);
}

Chamar f('A')invoca a primeira função, ajustando um int1; chamando f(1)invoca a segunda função, retornando o char"A".

Javascript 86 77 66 60 bytes

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

• salvou 7 bytes após comentários sobre o uso das funções de seta
• salvou outros 11 bytes removendo os colchetes / retorno, conforme observado por @manatwork
• salvou outros 6 bytes graças a @manatwork

ASM: 10 bytes

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

Explicação: Esta é a representação montada de um programa que faz exatamente o que é solicitado. Não é totalmente funcional, porque precisa de algumas diretivas, mas se for adicionado ao segmento de código de um programa de montagem, ele deverá funcionar. Ele recebe a entrada no registro AL e, se for uma letra, subtrai 40h do valor do código ASCII, deixando apenas o número (ou seja, B = 42h, 42h-40h = 2h). Se a entrada for um número, execute o procedimento oposto adicionando 40h. Deixa o resultado no registro AL. Abaixo está o código fonte da montagem

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

Além disso, se você converter todas as outras respostas em código de máquina, tenho certeza de que as minhas seriam as menores.

Excel, 33 bytes

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

Braquilog , 10 bytes

;.L∧Ṇi₁pL∧

Experimente online!

O núcleo disso é de apenas 4 bytes , mas a E / S para essa versão é um pouco menos que sã.

Japonês , 11 bytes

;BbU Ī´UgB

Tente

;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