Thử thách

Trong thử thách này, bạn phải lấy một số làm đầu vào và đầu ra chữ cái tương ứng của bảng chữ cái và ngược lại. (1 <=> A, 2 <=> B), v.v.

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

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

Quy tắc

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.
• Các đầu vào sẽ chỉ bao gồm hoặc là một chữ cái viết hoa từ Ađến Zhoặc một số nguyên từ 1để 26toàn diện.
• Trailing whitespaces (không gian và dòng mới) được cho phép.

Trên thực tế, 7 byte

ú' +ûEí

Hãy thử trực tuyến!

Giải trình:

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

Nếu chữ thường được chấp nhận, đây là 6 byte:

ú' +Eí

Hãy thử trực tuyến!

Bash thuần khiết, 51

Hầu hết các câu trả lời còn lại sử dụng một số loại điều kiện. Điều này hoàn toàn phân phối với các điều kiện hoàn toàn, và thay vào đó coi đầu vào là một số cơ sở 36, được lập chỉ mục thành một mảng bash-brace-mở rộng được xây dựng phù hợp:

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

Ideone.

Erlang, 26 byte

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

Một trong số ít lần hành vi chuỗi của Erlang hữu ích.

Python 2, 38 byte

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

Kiểm tra nó trên Ideone .

Python 3, 43 byte

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

Điều thú vị về giải pháp này là nó kết hợp tất cả các giác quan của OR, bitwise OR |, logic OR or, bitwise XOR ^và XOR logic !=...

2sable , 9 8 byte

Mã số:

.bAu¹kr,

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Ruby, 47 39 + ncờ = 40 byte 33 34 31 byte

Chức năng ẩn danh. Sử dụng một mẹo xử lý ngoại lệ như trong giải pháp Python của @ KarlNapf .

-3 byte từ @manatwork

Dùng thử trực tuyến

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

Phiên bản chương trình đầy đủ gốc với ncờ cho 40 byte và đọc từ STDIN:

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

Cheddar, 34 32 byte

Đã lưu 2 byte nhờ @LeakyNun

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

Tôi muốn có cách ngắn hơn để kiểm tra nếu chuỗi hoặc số.

Hãy thử trực tuyến! hoặc bộ kiểm tra

Giải trình

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==nkiểm tra nếu nó là một chuỗi một cách đơn giản. "%s"là một định dạng chuỗi, tôi có thể định dạng với %ví dụ "a %s c" % "b"bằng "a b c". %sxác định nó là một chuỗi, nếu một chữ số được thông qua, nó sẽ vẫn là %s.

Toán học 54 41 byte

Với một gợi ý hoàn toàn thông minh từ LegionMammal978 giúp tiết kiệm 13 byte.

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

If[#>0,FromLetterNumber,,LetterNumber]phục vụ mục đích duy nhất là quyết định áp dụng FromLetterNumberhay LetterNumbercho đầu vào.

#>0sẽ được thỏa mãn nếu đầu vào, #là một số, trong trường hợp đó FromLetterNumbersẽ được chọn.

Tuy nhiên #>0sẽ không đúng cũng không sai nếu #là một chữ cái và LetterNumbersẽ được chọn thay thế.

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

4

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

d

Trong Mathematica, FromLetterNumbervà LetterNumbercũng sẽ làm việc với các bảng chữ cái khác. Điều này chỉ cần thêm một vài byte.

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

delta
г
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 byte

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

Ví dụ sử dụng: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

Hệ thống loại nghiêm ngặt của Haskell là một nỗi đau thực sự ở đây. Ngoài ra, tất cả các hàm char <-> int ngắn chrvà ordcần nhập, vì vậy tôi phải thực hiện bằng tay. Đối với chữ cái -> int case, ví dụ tôi cần chuyển đổi String-> Char(thông qua !!0) -> Integer(thông qua fromEnum) -> String(thông qua show).

C, 55 byte

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

Perl 6 , 25 byte

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

Giải trình:

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

Thí dụ:

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 byte

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

Diễn viên đến Func<int, object>.

Đầu vào: charhoàn toàn chuyển đổi thành intcó thể được gọi bằng int(1-26) hoặc char('A'-Z').

Đầu ra: Hoặc là một charhoặc int.

PHP, 49 41 40 byte

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

Tôi không nghĩ rằng có một sự thay thế tốt is_numericphải không?

Điều này được thực hiện từ dòng lệnh ( $argv[1]là biến đầu tiên được đưa ra)

Nhờ vào:

@insertusernamehere: Chơi gôn 8 byte. Thay thế is_numeric($i=$argv[1])bằng 0<($i=$argv[1]). Điều này hoạt động vì (int)"randomLetter" == 0.

@manatwork: Giảm với 1 byte. Thay thế 0<bằng +. Điều xảy ra trong trường hợp này là tín hiệu + sẽ chuyển "Z" (hoặc bất kỳ chữ cái nào) thành 0. Điều này sẽ dẫn đến sai. Do đó, bất kỳ chữ cái nào luôn luôn sai và một số luôn luôn đúng.

Python 2, 61 byte

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

Có, tôi có thể chuyển sang Python 3 cho input

PowerShell v2 +, 42 byte

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

Lấy đầu vào $n(dưới dạng số nguyên hoặc char rõ ràng) và sử dụng giả ba để chọn giữa hai phần tử của một mảng. Điều kiện là $n-ge65(nghĩa là ASCII đầu vào Ahoặc lớn hơn). Nếu vậy, chúng ta chỉ cần bỏ đầu vào là int và trừ 64. Mặt khác, chúng ta thêm 64vào số nguyên đầu vào và chọn nó là a [char]. Trong cả hai trường hợp, kết quả được để lại trên đường ống và in ấn là ẩn.

Ví dụ

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 byte

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

Bởi vì câu hỏi cho biết bạn sẽ nhận được một 1-26hoặc A-Ztôi giả sử điều này có nghĩa là số 26 hoặc ký tự AZ. Hầu hết các phiên dịch đấu tranh với việc nhập mã alt, vì vậy việc sử dụng &và nhập các giá trị như 26 cho 26 hoặc 90 cho 'Z' sẽ dễ dàng hơn , trái ngược với ~.

Mã giả

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

Kiểm tra nó (trên Windows) ở đây!

* Đây là về mặt kỹ thuật Unefunge-98 vì nó chỉ sử dụng 1 chiều, nhưng tên đó có thể không quen thuộc.

Befunge 93 , 144 90 66 54 36 19 byte

Không chắc chắn 100% nếu điều này được cho phép, nhưng nếu bạn được phép gõ A là 65, B là 66, v.v., thì (vì lợi ích của [tôi]):

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

Mặt khác, ở mức 36 byte:

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

(Cảm ơn tngreene vì những gợi ý!)

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

(Cảm ơn Sp3000 vì đã lưu 12 byte bằng cách sắp xếp lại!)

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

Ung dung:

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

Đây là chương trình Befunge hoạt động đầu tiên của tôi từ trước đến nay và tôi cảm thấy cần phải chơi gôn hơn nữa. Mọi sự trợ giúp sẽ rất được trân trọng.

Bạn có thể kiểm tra mã Befunge tại đây .

Brainfuck, 445 ký tự

Nhiều bằng chứng về khái niệm hơn là một mã golf. Yêu cầu Brainfuck không được ký, không gói.

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

Với nhận xét

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

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

Chương trình kiểm tra :

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 byte

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

Hãy thử trực tuyến!

R, 73 byte

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

MATL, 10 byte

6WZ~t42>?c

Giải trình:

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

Hãy thử trực tuyến! với đầu vào số.
Hãy thử trực tuyến! với đầu vào chữ cái.

Python 3, 49 48 53 50 byte

Bằng cách nào đó tôi đã đếm sai số byte; _; cảm ơn dahuglenny

isalpha ngắn hơn isnumeric

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

lấy đầu vào dưới dạng chuỗi, có thể là một chữ cái hoặc số

Java, 61 byte

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

Gọi f('A')gọi hàm đầu tiên, trả về int1; gọi f(1)hàm thứ hai, trả về char"A".

Javascript 86 77 66 60 byte

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

• đã lưu 7 byte sau khi nhận xét về việc sử dụng các hàm mũi tên
• đã lưu thêm 11 byte bằng cách xóa return / ngoặc như ghi chú của @manatwork
• đã lưu thêm 6 byte nhờ @manatwork

ASM: 10 byte

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

Giải thích: Đây là đại diện lắp ráp của một chương trình thực hiện chính xác những gì được yêu cầu. Nó không đầy đủ chức năng, bởi vì nó cần một số chỉ thị, nhưng nếu nó được thêm vào đoạn mã của chương trình lắp ráp thì nó sẽ hoạt động. Nó nhận được đầu vào trong thanh ghi AL và nếu một chữ cái của nó, nó trừ 40h khỏi giá trị mã ASCII, chỉ để lại số (tức là B = 42h, 42h-40h = 2h). Nếu đầu vào là một số, nó làm thủ tục ngược lại bằng cách thêm 40h. Nó để lại kết quả trong thanh ghi AL. Dưới đây là mã nguồn lắp ráp

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

Ngoài ra, nếu bạn chuyển đổi tất cả các câu trả lời khác thành mã máy, tôi khẳng định rằng câu trả lời của tôi sẽ là nhỏ nhất.

Excel, 33 byte

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

Brachylog , 10 byte

;.L∧Ṇi₁pL∧

Hãy thử trực tuyến!

Cốt lõi của điều này chỉ có 4 byte , nhưng I / O cho phiên bản đó ít hơn một chút so với lành mạnh.

Japt , 11 byte

;BbU Ī´UgB

Thử nó

;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