Tantangan

Dalam tantangan ini Anda harus mengambil angka sebagai input dan output huruf alfabet yang sesuai, dan sebaliknya. (1 <=> A, 2 <=> B) dll.

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

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

Aturan

• Ini adalah kode-golf , jadi kode terpendek dalam byte menang.
• Input hanya akan terdiri dari baik huruf besar dari Ake Zatau bilangan bulat dari 1ke 26inklusif.
• Ruang putih trailing (spasi dan baris baru) diizinkan.

Sebenarnya, 7 byte

ú' +ûEí

Cobalah online!

Penjelasan:

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

Jika huruf kecil dapat diterima, ini adalah 6 byte:

ú' +Eí

Cobalah online!

Pure Bash, 51

Sebagian besar sisa jawaban menggunakan semacam persyaratan. Yang ini mengeluarkan sepenuhnya dengan kondisional, dan sebaliknya memperlakukan input sebagai nomor basis-36 yang mengindeks ke dalam array ekspansi bash-brace yang dibangun dengan tepat:

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

Salah satu dari beberapa kali di mana perilaku string Erlang berguna.

Python 2, 38 byte

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

Uji di Ideone .

Python 3, 43 byte

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

Yang menarik tentang solusi ini adalah bahwa ia menggabungkan semua indera ATAU, bitwise ATAU |, logis ATAU or, XOR bitwise ^dan XOR logis !=...

2sable , 9 8 byte

Kode:

.bAu¹kr,

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online! .

Ruby, 47 39 + nflag = 40 byte 33 34 31 byte

Fungsi anonim. Menggunakan trik penanganan pengecualian seperti pada solusi Python @ KarlNapf .

-3 byte dari @manatwork

Cobalah online

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

Versi program lengkap asli dengan nbendera untuk 40 byte dan dibaca dari STDIN:

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

Cheddar, 34 32 byte

Disimpan 2 byte berkat @LeakyNun

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

Saya berharap ada cara yang lebih pendek untuk memeriksa apakah string atau nomor.

Cobalah online! atau Test Suite

Penjelasan

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==nmemeriksa apakah itu string dengan cara yang sederhana. "%s"adalah format string, saya bisa memformat dengan %misalnya "a %s c" % "b"sama dengan "a b c". %smenetapkan itu adalah string, jika angka dilewatkan akan tetap seperti %s.

Mathematica 54 41 Bytes

Dengan saran yang benar-benar cerdas dari LegionMammal978 yang menghemat 13 byte.

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

If[#>0,FromLetterNumber,,LetterNumber]melayani tujuan tunggal memutuskan apakah akan menerapkan FromLetterNumberatau LetterNumberinput.

#>0akan puas jika input #,, adalah angka, dalam hal FromLetterNumberini akan dipilih.

Namun #>0tidak akan benar atau salah jika #surat, dan LetterNumberakan dipilih sebagai gantinya.

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

4

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

d

Di Mathematica, FromLetterNumberdan LetterNumberjuga akan bekerja dengan huruf lain. Ini hanya membutuhkan beberapa byte lagi.

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 byte

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

Contoh penggunaan: map f ["1","26","A","Z"] -> ["A","Z","1","26"].

Sistem tipe ketat Haskell sangat menyusahkan di sini. Selain itu semua char <-> int fungsi pendek suka chrdan ordperlu impor, jadi saya harus melakukannya dengan tangan. Untuk huruf -> int case, misalnya saya perlu mengonversi String-> Char(via !!0) -> Integer(via fromEnum) -> String(via 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}

Penjelasan:

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

Contoh:

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;

Diputar ke Func<int, object> .

Input: charsecara implisit dikonversi ke intsehingga dapat dipanggil dengan int(1-26) atau char('A'-Z').

Output: Baik a charatau int.

PHP, 49 41 40 byte

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

Saya rasa tidak ada alternatif yang baik untuk is_numericbenar?

Ini dieksekusi dari baris perintah ( $argv[1]adalah variabel pertama yang diberikan)

Terimakasih untuk:

@insertusernamehere: Golfed 8 byte. Mengganti is_numeric($i=$argv[1])dengan 0<($i=$argv[1]).Ini bekerja karena (int)"randomLetter" == 0.

@manatwork: Dikurangi dengan 1 byte. Ganti 0<dengan +. Apa yang terjadi dalam kasus ini adalah bahwa + sinyal akan melemparkan "Z" (atau huruf apa pun) ke 0. Ini akan menghasilkan false. Karenanya setiap huruf selalu salah dan angka selalu benar.

Python 2, 61 byte

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

Ya saya bisa beralih ke Python 3 untuk input

PowerShell v2 +, 42 byte

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

Mengambil input $n(sebagai bilangan bulat atau karakter eksplisit) dan menggunakan pseudo-ternary untuk memilih antara dua elemen dari array. Syaratnya adalah $n-ge65(yaitu, input ASCII Aatau lebih besar). Jika demikian, kami cukup memasukkan input sebagai int dan kurangi 64. Kalau tidak, kita menambah 64integer input, dan melemparkannya sebagai a [char]. Dalam kedua kasus, hasilnya dibiarkan di jalur pipa dan pencetakan tersirat.

Contohnya

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

Karena pertanyaannya mengatakan Anda akan menerima a 1-26atau a, A-Zsaya berasumsi ini berarti angka 26 atau karakter AZ. Sebagian besar penafsir kesulitan dalam memasukkan kode alt, sehingga lebih mudah untuk menggunakan &dan memasukkan nilai seperti 26 untuk 26 atau 90 untuk 'Z', dibandingkan dengan ~.

Kode semu

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

Uji (di Windows) di sini!

* Ini secara teknis Unefunge-98 karena hanya menggunakan 1 dimensi, tetapi nama itu mungkin tidak dikenal.

Befunge 93 , 144 90 66 54 36 19 byte

Tidak 100% yakin apakah ini diizinkan, tetapi jika Anda diizinkan mengetik A 65, B 66, dll., Maka (demi kenyamanan saya):

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

Jika tidak, pada 36 byte:

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

(Terima kasih kepada tngreene untuk sarannya!)

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

(Terima kasih kepada Sp3000 karena telah menghemat 12 byte dengan mengatur ulang!)

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

Tidak Disatukan:

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

Ini adalah program Befunge pertama saya yang pernah bekerja, dan saya merasa perlu untuk bermain golf lebih jauh. Bantuan apa pun akan sangat dihargai.

Anda dapat menguji kode Befunge di sini .

Brainfuck, 445 Karakter

Lebih banyak bukti konsep daripada kode golf. Membutuhkan Brainfuck yang Tidak Ditandatangani dan Tidak Membungkus.

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

Dengan Komentar

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

Program Tes :

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}

Cobalah online!

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

Penjelasan:

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

Cobalah online! dengan input numerik.
Cobalah online! dengan input alfabet.

Python 3, 49 48 53 50 byte

Entah bagaimana saya salah menghitung byte; _; terimakasih dahuglenny

isalpha lebih pendek dari isnumeric

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

mengambil input sebagai string, yang bisa berupa huruf atau angka

Java, 61 byte

int f(char c){return c^64;}char f(int i){return(char)(i^64);}

Tidak Digolkan:

int f(char c) {
    return c^64;
}

char f(int i) {
    return (char) (i^64);
}

Memanggil f('A')memanggil fungsi pertama, mengembalikan satu int1; panggilan f(1)memanggil fungsi kedua, mengembalikan char"A".

Javascript 86 77 66 60 byte

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

• disimpan 7 byte setelah komentar tentang penggunaan fungsi panah
• menyimpan 11 byte lainnya dengan menghapus return / kurung seperti yang dicatat oleh @manatwork
• menyimpan 6 byte lagi berkat @manatwork

ASM: 10 byte

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

Penjelasan: Ini adalah representasi rakitan dari suatu program yang melakukan persis apa yang diminta. Ini tidak berfungsi penuh, karena memerlukan beberapa arahan, tetapi jika ditambahkan ke segmen kode dari program perakitan, ia harus bekerja. Ia menerima input dalam register AL, dan jika hurufnya mengurangi 40h dari nilai kode ASCII, hanya menyisakan angka (yaitu B = 42j, 42j-40j = 2j). Jika input adalah angka, ia melakukan prosedur sebaliknya dengan menambahkan 40 jam. Itu meninggalkan hasilnya di register AL. Di bawah ini adalah kode sumber perakitan

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

Juga, jika Anda mengonversi semua jawaban lain ke kode mesin, saya yakin bahwa jawaban saya akan menjadi yang terkecil.

Excel, 33 byte

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

Brachylog , 10 byte

;.L∧Ṇi₁pL∧

Cobalah online!

Inti dari ini hanya 4 byte , tetapi I / O untuk versi itu sedikit kurang waras.

Japt , 11 byte

;BbU Ī´UgB

Cobalah

;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