Pure Bash, 51

Most of the rest of the answers use some sort of conditional. This one dispenses with conditionals entirely, and instead treats the input as a base-36 number which indexes into an appropriately constructed bash-brace-expansion array:

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

One of the few times where Erlang's string behavior is useful.

Python 2, 38 bytes

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

Test it on Ideone.

Python 3, 43 bytes

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

The interesting thing about this solution is that it incorporates all the senses of OR, bitwise OR |, logical OR or, bitwise XOR ^ and logical XOR != ...

2sable, 9 8 bytes

Code:

.bAu¹kr, 

Explanation:

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

Uses the CP-1252 encoding. Try it online!.

Ruby, 47 39 + n flag = 40 bytes 33 34 31 bytes

Anonymous function. Uses an exception handling trick like in @KarlNapf's Python solution.

-3 bytes from @manatwork

Try it online

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

Original full program version with the n flag for 40 bytes and reads from STDIN:

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

Cheddar, 34 32 bytes

Saved 2 bytes thanks to @LeakyNun

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

I wish there was shorter way to check if string or number.

Try it online! or Test Suite

Explanation

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==n checks if it is a string in a simple way. "%s" is a string format, I can format with % e.g. "a %s c" % "b" is equal to "a b c". %s specifies it is a string, if a digit is passed it'll remain as %s.

Mathematica 54 41 Bytes

With an absolutely clever suggestion from LegionMammal978 that saves 13 bytes.

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

If[#>0,FromLetterNumber,,LetterNumber] serves the sole purpose of deciding whether to apply FromLetterNumber or LetterNumber to the input.

#>0 will be satisfied if the input, #, is a number, in which case FromLetterNumberwill be selected.

However #>0 will be neither true nor false if # is a letter, and LetterNumber will be selected instead.

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

4

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

d

In Mathematica, FromLetterNumber and LetterNumber will also work with other alphabets. This requires only a few more 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 

Usage example: map f ["1","26","A","Z"] -> ["A","Z","1","26"].

Haskell's strict type system is a real pain here. Additionally all the short char <-> int functions like chr and ord need an import, so I have to do it by hand. For the letter -> int case, for example I need to convert 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} 

Explanation:

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

Example:

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; 

Casts to Func<int, object>.

Input: char implicitely converts to int so can be called with int (1-26) or char ('A'-Z').

Output: Either a char or int.

PHP, 49 41 40 bytes

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

I do not think there is a good alternative to is_numeric right?

This is executed from command line ($argv[1] is the first variable given)

Thanks to:

@insertusernamehere: Golfed 8 bytes. Replacing is_numeric($i=$argv[1]) with 0<($i=$argv[1]).This works because (int)"randomLetter" == 0.

@manatwork: Reduced with 1 byte. Replace 0< with +. What happens in this case is that the + signal will cast the "Z" (or whatever letter) to an 0. This will result in false. Therefor any letter is always false and a number is always true.

Excel, 33 bytes

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

Japt, 11 10 bytes

¤?UdI:InUc 

Try it

¤?UdI:InUc :Implicit input of integer or string U ¤ :Convert to binary string if integer (always truthy) ¤ :Slice off first 2 character if string (always falsey) ? :If truthy Ud : Get character at codepoint U I : After first adding 64 : :Else In : Subtract 64 from Uc : Codepoint of U 

><> (Fish), ^{27 24 21} 19 bytes

<o+v?)0-}:"@": n-$< 

Try it with a number test case

Try it with a letter test case

Takes input on the stack, which is a default input method for stack-based languages, and outputs with error.

Python 2, 61 bytes

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

Yes I could switch to Python 3 for input

PowerShell v2+, 42 bytes

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

Takes input $n (as an integer or an explicit char) and uses a pseudo-ternary to choose between two elements of an array. The conditional is $n-ge65 (i.e., is the input ASCII A or greater). If so, we simply cast the input as an int and subtract 64. Otherwise, we add 64 to the input integer, and cast it as a [char]. In either case, the result is left on the pipeline and printing is implicit.

Examples

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

Because the question said you'll receive a 1-26 or an A-Z I assumed this meant the number 26 or the character A-Z. Most interprets struggle with entering alt-codes, so it is easier to use & and enter values like 26 for 26 or 90 for 'Z', as opposed to ~.

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 

Test it out (on Windows) here!

*This is technically Unefunge-98 because it only uses 1 dimension, but that name might be unfamiliar.

Befunge 93, 144 90 66 54 36 19 bytes

Not 100% sure if this is allowed, but if you are allowed to type A as 65, B as 66, etc., then (for [my] convenience's sake):

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

Otherwise, at 36 bytes:

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

(Thanks to tngreene for the suggestions!)

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

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

This is my first working Befunge program ever, and I feel the need to golf this further. Any help would be greatly appreciated.

You can test Befunge code here.

Brainfuck, 445 Characters

More a proof of concept than a golfed code. Requires Unsigned, Non-wrapping Brainfuck.

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

With Comments

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

Test Program:

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 

Forth (gforth), 67 bytes

: f 2dup s>number? if d>s 64 + emit else 2drop d>s c@ 64 - . then ; 

Try it online!

Input is passed as a string to the function

Code Explanation

: f \ start a new word definition 2dup \ make a copy of the input string s>number? \ attempt to convert to a number in base 10 if \ check if successful d>s \ drop a number (don't need double-precision) 64 + emit \ add to 64 and output the ascii letter at that value else \ if not successful (input was a letter) 2drop d>s \ get rid of garbage number conversion result and string-length c@ 64 - . \ get ascii value of char, subtract 64 and output then \ end the if block ; \ end the word definition 

Jelly, 7 bytes

i@ịe?ØA 

Try it online!

How it works

i@ịe?ØA - Main link. Takes an input A on the left ØA - Set the right argument to "ABC...XYZ" ? - If statement: e - Condition: left in right; is A in the alphabet? i@ - If so: return the 1-index of A in the alphabet ị - Else: yield the A'th element of the alphabet 

q, 29 bytes

{@[1+.Q.A?;x;{.Q.A y-1}[;x]]} 

Find the index at which our letter occurs in the built-in list of uppercase letters

If it errors, index into the same list with the input instead

Adding and taking away ones as q indexing starts at 0, not 1

JavaScript (ES6), 49 bytes

s=>s>0?String.fromCharCode(s|64):parseInt(s,36)-9 

Accepts integers in either number or string format, always return integers as a number. 42 bytes if I can return lower case and don't need to handle integers in string format:

s=>s>0?(s+9).toString(36):parseInt(s,36)-9 

Fourier, 30 bytes

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

Try it 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 

Explanation:

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 

Try it online! with numeric inputs.
Try it online! with alphabetic inputs.