ท้าทาย

ในการท้าทายนี้คุณจะต้องใช้ตัวเลขเป็นตัวอักษรอินพุทและเอาท์พุทที่สอดคล้องกันและในทางกลับกัน (1 <=> A, 2 <=> B) เป็นต้น

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

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

กฎระเบียบ

• นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ
• ข้อมูลที่ป้อนจะประกอบด้วยตัวอักษรตัวพิมพ์ใหญ่จาก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í

ลองออนไลน์!

Pure Bash, 51

คำตอบที่เหลือส่วนใหญ่ใช้เงื่อนไขบางอย่าง สิ่งนี้เป็นการแจกจ่ายโดยมีเงื่อนไขทั้งหมดและถือว่าการป้อนข้อมูลเป็นตัวเลขฐาน -36 ซึ่งจะจัดทำดัชนีเป็นอาร์เรย์ bash-brace-expansion ที่สร้างขึ้นอย่างเหมาะสม:

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

Ideone

Erlang, 26 ไบต์

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

หนึ่งในไม่กี่ครั้งที่การทำงานของสตริงของ Erlang มีประโยชน์

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, bitwise OR |, ตรรกะ OR or, XOR bitwise ^และ 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 + nflag = 40 ไบต์ 33 34 31 bytes

ฟังก์ชั่นไม่ระบุชื่อ ใช้เคล็ดลับการจัดการข้อยกเว้นเช่นในโซลูชัน Pythonของ @ KarlNapfการแก้ปัญหาหลาม

-3 ไบต์จาก @manatwork

ลองออนไลน์

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

เวอร์ชันเต็มของโปรแกรมดั้งเดิมพร้อมnแฟล็ก 40 ไบต์และอ่านจาก STDIN:

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

Cheddar, 34 32 bytes

บันทึก 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"]

ระบบการพิมพ์ที่เข้มงวดของ Haskell เป็นความเจ็บปวดที่แท้จริงที่นี่ นอกจากนี้ฟังก์ชั่น int ถ่านสั้น <-> ทั้งหมดต้องการchrและordนำเข้าดังนั้นฉันต้องทำด้วยมือ สำหรับจดหมาย -> กรณีตัวอย่างเช่นฉันต้องการแปลง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แปลงเป็น implicitely เพื่อintให้สามารถเรียกใช้ด้วยint(1-26) หรือchar ('A'-Z')

ขาออกทั้งหรือcharint

PHP, 49 41 40 ไบต์

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

ฉันไม่คิดว่าจะมีทางเลือกที่ดีis_numericใช่มั้ย

นี้จะดำเนินการจากบรรทัดคำสั่ง ( $argv[1]เป็นตัวแปรแรกให้

ขอบคุณที่:

@insertusernamehere: Golfed 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จำนวนเต็มเข้าและโยนมันเป็น[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 และอื่น ๆ ดังนั้น (เพื่อประโยชน์ของ [my] เพื่อความสะดวก):

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

มิฉะนั้นที่ 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 ตัวละคร

พิสูจน์แนวคิดมากกว่ารหัส golfed ต้องใช้ 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 ไบต์

ยังไงฉันก็นับไบต์ผิด; _; ขอบคุณ dahuglenny

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"A"

Javascript 86 77 66 60 ไบต์

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

• บันทึก 7 ไบต์หลังจากความคิดเห็นเกี่ยวกับการใช้ฟังก์ชั่นลูกศร
• บันทึกอีก 11 ไบต์ด้วยการลบ return / brackets ตามที่ระบุไว้โดย @manatwork
• บันทึกอีก 6 ไบต์ด้วย @manatwork

ASM: 10 ไบต์

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

คำอธิบาย: นี่เป็นการนำเสนอแอสเซมบลีของโปรแกรมที่ทำสิ่งที่ถูกถาม มันไม่ทำงานอย่างเต็มที่เพราะมันต้องการคำสั่งบางอย่าง แต่ถ้ามันถูกเพิ่มไปยังส่วนรหัสของโปรแกรมประกอบมันควรจะทำงาน มันได้รับอินพุตในการลงทะเบียน AL และถ้าตัวอักษรมันลบ 40h จากค่ารหัส ASCII เหลือเพียงตัวเลข (เช่น B = 42h, 42h-40h = 2h) ถ้าอินพุตเป็นตัวเลขมันจะทำโพรซีเดอร์ตรงกันข้ามโดยการเพิ่ม 40h มันทิ้งผลในการลงทะเบียนอัล ด้านล่างเป็นรหัสที่มาประกอบ

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)

Brachylogขนาด 10 ไบต์

;.L∧Ṇi₁pL∧

ลองออนไลน์!

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