Вызов

В этом задании вы должны взять число в качестве ввода и вывести соответствующую букву алфавита, и наоборот. (1 <=> A, 2 <=> B) и т. Д.

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

В большинстве остальных ответов используются условные выражения. Этот полностью исключает условные выражения и вместо этого обрабатывает входные данные как число base-36, которое индексируется в правильно сконструированный массив bash-brace-extension:

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

Ideone.

Эрланг, 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, побитового XOR ^и логического XOR !=...

2sable , 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 . Попробуйте онлайн! ,

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

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

d

В Mathematica, FromLetterNumberа LetterNumberтакже будет работать с другими алфавитами. Для этого требуется всего несколько байтов.

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

δ
г
б

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

Вывод: либо a, charлибо int.

PHP, 49 41 40 байт

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

Я не думаю, что есть хорошая альтернатива is_numericправильно?

Это выполняется из командной строки ( $argv[1]указана первая переменная)

Благодаря:

@insertusernamehere: Гольф 8 байтов. Замена is_numeric($i=$argv[1])на. 0<($i=$argv[1])Это работает, потому что (int)"randomLetter" == 0.

@manatwork: уменьшается на 1 байт. Заменить 0<на +. В этом случае происходит то, что сигнал + приводит «Z» (или любую другую букву) к 0. Это приводит к значению false. Поэтому любая буква всегда ложна, а число всегда верно.

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или выше). Если это так, мы просто приводим входные данные как целые и вычитаем 64. В противном случае мы добавляем 64к входному целому числу и приводим его как [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;+,@;-.@

Поскольку в вопросе говорилось, что вы получите 1-26или, A-Zя предположил, что это означает число 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*-.@

Ungolfed:

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

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

Java, 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

Фурье, 30 байт

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

Попробуйте онлайн!

R, 73 байта

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

MATL, 10 байт

6WZ~t42>?c

Объяснение:

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

Попробуйте онлайн! с числовыми входами.
Попробуйте онлайн! с буквенным вводом.

Python 3, 49 48 53 50 байт

Каким-то образом я неправильно подсчитал число байтов; _; спасибо, дахугленный

isalpha короче чем isnumeric

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

принимает входные данные в виде строки, которая может быть буквой или цифрой

Java, 61 байт

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

Вызов f('A')вызывает первую функцию, возвращая int1; Вызов f(1)вызывает вторую функцию, возвращая char«А».

Javascript 86 77 66 60 байт

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

• сохранено 7 байт после комментариев об использовании функций стрелок
• сохранил еще 11 байтов, удалив возврат / скобки, как отмечено @manatwork
• сэкономили еще 6 байтов благодаря @manatwork

ASM: 10 байт

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

Объяснение: Это собранное представление программы, которая делает именно то, что запрашивается. Он не полностью функционален, потому что ему нужны некоторые директивы, но если он добавлен в сегмент кода программы сборки, он должен работать. Он получает входные данные в регистр AL и, если это буква, вычитает 40h из значения кода ASCII, оставляя только число (т. Е. B = 42h, 42h-40h = 2h). Если ввод является числом, он делает противоположную процедуру, добавляя 40h. Оставляет результат в регистре AL. Ниже приведен исходный код сборки

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

Кроме того, если вы преобразуете все остальные ответы в машинный код, я уверен, что мой будет наименьшим.

Excel, 33 байта

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

Брахилог , 10 байт

;.L∧Ṇi₁pL∧

Попробуйте онлайн!

Ядро этого составляет всего 4 байта , но ввод / вывод для этой версии немного меньше, чем в здравом уме.

Japt , 11 байт

;BbU Ī´UgB

Попытайся

;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