Виклик

У цьому виклику ви повинні взяти число як введення та виведення відповідної літери алфавіту, і навпаки. (1 <=> А, 2 <=> Б) тощо.

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

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

Правила

• Це код-гольф , тому найкоротший код у байтах виграє.
• Вхід буде складатися тільки з будь-яких великої літери від Aдо Zабо цілого числа від 1до 26включно.
• Допускаються пробіли білого простору (пробіл та нова лінія).

Власне, 7 байт

ú' +ûEí

Спробуйте в Інтернеті!

Пояснення:

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

Якщо малі регістри прийнятні, це 6 байт:

ú' +Eí

Спробуйте в Інтернеті!

Чистий Баш, 51 рік

Більшість решти відповідей використовують якусь умовну. Цей додаток не видає условні умови повністю, а натомість трактує вхід як базове число 36, яке індексує на належним чином побудований масив bash-brace-extension:

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

Ідеон.

Ерланг, 26 байт

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

Один з небагатьох випадків, коли поведінка Ерланга є корисною.

Python 2, 38 байт

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

Перевірте це на Ideone .

Python 3, 43 байти

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

Цікавим у цьому рішенні є те, що воно включає в себе всі почуття АБО, порозрядне АБО |, логічне АБО or, побітне ХОР ^та логічне ХОР !=...

2 , 9 8 байт

Код:

.bAu¹kr,

Пояснення:

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

Використовує кодування CP-1252 . Спробуйте в Інтернеті! .

Рубі, 47 39 + nпрапор = 40 байт 33 34 31 байт

Анонімна функція. Використовує хитрість обробки винятків, як у рішенні Python @ KarlNapf .

-3 байти від @manatwork

Спробуйте в Інтернеті

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

Оригінальна повна версія програми з nпрапором на 40 байт і читається з STDIN:

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

Чеддар, 34 32 байти

Збережено 2 байти завдяки @LeakyNun

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

Я хотів би, щоб був коротший спосіб перевірити, чи рядок чи число.

Спробуйте в Інтернеті! або Тестовий набір

Пояснення

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перевіряє, чи це рядок простим способом. "%s"- це рядковий формат, який я можу форматувати, %наприклад "a %s c" % "b", дорівнює "a b c". %sвизначає, що це рядок, якщо цифра буде передана, вона залишиться як %s.

Математика 54 41 байт

З абсолютно розумною пропозицією від LegionMammal978, яка зберігає 13 байт.

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

If[#>0,FromLetterNumber,,LetterNumber] служить єдиній меті вирішити, чи потрібно подавати заявку FromLetterNumber чиLetterNumber подати її

#>0 буде задоволений, якщо вхід, # - це число, в цьому випадкуFromLetterNumber буде вибрано.

Однак #>0не буде ні істинним, ні хибним, якщо #це лист, і LetterNumberбуде вибрано замість нього.

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

4

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

г

В Mathematica, FromLetterNumberа LetterNumberтакож буде працювати з іншими алфавітами. Для цього потрібно лише кілька байтів.

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 байти

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

Приклад використання: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

Система суворого типу Хаскелла тут справжня біль. Крім того, всі короткі символи char <-> int люблять chrі ordпотребують імпорту, тому я маю це робити вручну. Наприклад, для літери -> int, мені потрібно перетворити String-> Char(через !!0) -> Integer(через fromEnum) -> String(через show).

C, 55 байт

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

Perl 6 , 25 байт

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

Пояснення:

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

Приклад:

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 байти

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

Касти до Func<int, object>.

Вхід: charнеявно перетворюється на intтак, що можна назвати за допомогою int(1-26) або char('A'-Z').

Висновок: Або charабо int.

PHP, 49 41 40 байт

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

Я не думаю, що є хороша альтернатива is_numericправі?

Це виконується з командного рядка ($argv[1] дана перша змінна)

Завдяки:

@insertusernameтут: 8 байтів у поле для гольфу. Заміна is_numeric($i=$argv[1])на 0<($i=$argv[1]). Це працює, тому що (int)"randomLetter" == 0.

@manatwork: зменшено на 1 байт. Замініть 0<на +. У цьому випадку відбувається те, що сигнал + передасть "Z" (або будь-яку літеру) до 0. Це призведе до помилки. Для цього будь-яка літера завжди хибна, а цифра - завжди правдива.

Python 2, 61 байт

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

Так, я міг би перейти на Python 3 для input

PowerShell v2 +, 42 байти

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

Бере введення $n(як ціле чи явне значення) і використовує псевдотермінал для вибору між двома елементами масиву. Умовним є $n-ge65(тобто вхідний ASCII Aабо більше). Якщо так, ми просто подаємо введення як int і віднімання 64. В іншому випадку ми додаємо 64до вхідного цілого числа та додаємо його як a[char] . У будь-якому випадку результат залишається на конвеєрі, а друк неявний.

Приклади

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 байт

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

Оскільки в запитанні було сказано, що ви отримаєте a 1-26або A-ZI, я припустив, що це означало число 26 або символ AZ. Більшість тлумачів бореться з введенням alt-кодів, тому їх легше використовувати& та вводити значення "26" для 26 або 90 для "Z" ~.

Псевдокод

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

Спробуйте це (у Windows) тут!

* Це технічно Unefunge-98, оскільки він використовує лише 1 вимір, але це ім'я може бути незнайомим.

Befunge 93 , 144 90 66 54 36 19 байт

Не на 100% впевнений, що це дозволено, але якщо вам дозволено вводити A як 65, B як 66 і т.д., то (для [моєї] зручності):

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

Інакше в 36 байт:

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

(Дякую tngreene за пропозиції!)

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

(Завдяки Sp3000 за збереження 12 байт шляхом перестановки!)

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

Безголівки:

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

Це моя перша робоча програма Befunge коли-небудь, і я відчуваю необхідність додатково займатися цим гольфом. Будь-яка допомога буде дуже вдячна.

Ви можете протестувати код Befunge тут .

Brainfuck, 445 персонажів

Більше доказ концепції, ніж код для гольфу. Потрібен непідписаний Brainfuck.

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

З коментарями

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

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

Ява, 104 98 97 83 54 53 51 50 30 байт

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

Тестова програма :

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}

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.

Python 3, 49 48 53 50 bytes

Somehow I got the byte count wrong ;_; thanks dahuglenny

isalpha is shorter than isnumeric

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

takes input as string, which could be a letter or number

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);
}

Calling f('A') invokes the first function, retuning an int 1; calling f(1) invokes the second function, returning the char "A".

Javascript 86 77 66 60 bytes

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

• saved 7 bytes after comments about using arrow functions
• saved another 11 bytes by removing return / brackets as noted by @manatwork
• saved another 6 bytes thanks to @manatwork

ASM: 10 bytes

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

Explanation: This is the assembled representation of a program that does exactly what is asked. It is not fully functional, because it needs some directives, but if it is added to the code segment of an assembly program it should work. It receives the input in the AL register, and if its a letter it subtracts 40h from the ASCII code value, leaving just the number(i.e B=42h, 42h-40h=2h). If the input is a number it does the opposite procedure by adding 40h. It leaves the result in the AL register. Below is the assembly source code

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

Also, if you convert all the other answers to machine code, I am positive that mine would be the smallest.

Excel, 33 bytes

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

Brachylog, 10 bytes

;.L∧Ṇi₁pL∧

Try it online!

The core of this is only 4 bytes, but the I/O for that version is a bit less than sane.

Japt, 11 bytes

;BbU Ī´UgB

Try it

;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