Meydan okuma

Bu mücadelede girdi olarak bir sayı almanız ve alfabenin karşılık gelen harfini çıkarmanız gerekir; (1 <=> A, 2 <=> B) vb.

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

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

kurallar

• Bu kod golf , bayt cinsinden en kısa kod kazanır.
• Girişi sadece bir büyük harf ya da oluşacak Akadar Zya da başka bir tam sayıya 1kadar 26dahildir.
• İzleyen boşluklarda (boşluk ve yeni satır) izin verilir.

Aslında, 7 bayt

ú' +ûEí

Çevrimiçi deneyin!

Açıklama:

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

Küçük harf kabul edilebilir ise, bu 6 bayttır:

ú' +Eí

Çevrimiçi deneyin!

Saf Bash, 51

Cevapların çoğu bir tür koşullu kullanır. Bu durum koşulsuzluklardan tamamen vazgeçer ve bunun yerine girdiyi uygun şekilde oluşturulmuş bir bas-ayraç-genişletme dizisine endeksleyen bir baz-36 sayısı olarak görür:

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

Ideone.

Erlang, 26 bayt

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

Erlang'ın sicim davranışının yararlı olduğu birkaç zamandan biri.

Python 2,38 bayt

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

İdeone üzerinde test et .

Python 3, 43 bayt

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

Bu çözümle ilgili ilginç olan şey; OR, bit yönünde VEYA |, mantıksal OR or, bit yönünde XOR ^ve mantıksal XOR'un tüm duyularını içermesidir !=...

2sable , 9 8 bayt

Kod:

.bAu¹kr,

Açıklama:

.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 kodlamasını kullanır . Çevrimiçi deneyin! .

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

Anonim işlev @ KarlNapf'ın Python çözümünde olduğu gibi bir istisna işleme numarası kullanır .

@Manatwork gelen -3 bayt

Çevrimiçi deneyin

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

n40 baytlık bayrağın bulunduğu orijinal tam program sürümü ve STDIN'den okur:

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

Çedar, 34 32 bayt

@LeakyNun sayesinde 2 bayt kaydedildi

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

Dize veya sayı olup olmadığını kontrol etmek için kısa bir yol olsaydı keşke.

Çevrimiçi deneyin! veya Test Paketi

açıklama

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==nBasit bir şekilde bir dize olup olmadığını kontrol eder. "%s"bir dize formatıdır, %örneğin "a %s c" % "b"ile eşleştirebilirim "a b c". %sonun bir dize olduğunu belirtir, eğer bir basamaktan geçilirse olduğu gibi kalır %s.

Mathematica 54 41 Bayt

LegionMammal978'den kesinlikle akıllıca bir öneri ile 13 byte tasarruf sağlıyor.

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

If[#>0,FromLetterNumber,,LetterNumber]uygulanıp uygulanmayacağına karar verme amacına hizmet eder FromLetterNumberya da LetterNumbergirişine.

#>0giriş,, #bir rakam ise, bu durumda FromLetterNumberseçilecektir.

Bununla birlikte , bir harf #>0ise #, ne doğru ne de yanlış LetterNumberolacaktır ve bunun yerine seçilecektir.

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

4

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

d

Mathematica'da FromLetterNumberve LetterNumberdiğer alfabe ile de çalışacak. Bu sadece birkaç bayt gerektirir.

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 bayt

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

Kullanım örneği: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

Haskell'in katı tip sistemi burada gerçek bir acıdır. Buna ek olarak, tüm kısa karakter <-> int gibi bir içe aktarma işlevi görür chrve ordbu nedenle el ile yapmam gerekir. -> int harfi için, örneğin, String-> Char(via !!0) -> Integer(via fromEnum) -> String(via show) ' ya dönüştürmem gerekiyor .

C, 55 bayt

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

Perl 6 , 25 bayt

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

Açıklama:

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

Örnek:

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 bayt

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

Atmalarını Func<int, object>.

Girdi: chariçin metotunun dönüştürür int, böylece ile çağrılabilir int(1-26) ya da char(A 'Z').

Çıktı: Bir charya da int.

PHP, 49 41 40 bayt

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

is_numericSağa iyi bir alternatif olduğunu sanmıyorum ?

Bu komut satırından çalıştırılır ( $argv[1]verilen ilk değişkendir)

Sayesinde:

@insertusernamehere: Golf 8 bayt. İle değiştirin is_numeric($i=$argv[1]). 0<($i=$argv[1])Bu çünkü çalışır (int)"randomLetter" == 0.

@manatwork: 1 byte ile azaltıldı. Değiştir 0<ile +. Bu durumda olan, + sinyalinin "Z" yi (veya hangi harfle) 0'a çevireceğidir. Bu yanlış olur. Herhangi bir harf her zaman yanlıştır ve bir sayı her zaman doğrudur.

Python 2,61 bayt

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

Evet, Python 3’e geçebilirim. input

PowerShell v2 +, 42 bayt

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

Girdiyi alır $n(bir tam sayı veya açık bir karakter olarak) ve bir dizinin iki öğesi arasında seçim yapmak için bir sahte üçlü kullanır. Koşullu $n-ge65(yani, ASCII Aveya daha büyük bir girdidir ). Öyleyse, girişi basitçe bir int olarak çıkarır ve çıkarırız 64. Aksi takdirde, 64giriş tamsayısına ekleriz ve a olarak basarız [char]. Her iki durumda da sonuç, boru hattında bırakılır ve yazdırma çok açıktır.

Örnekler

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 bayt

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

Çünkü soru alacağınızı 1-26veya bir A-Zvarsayım alacağınızı söylemiştim , 26 sayı veya AZ karakteri anlamına geliyordu. Çoğu yorumlayıcı alt kodları girmekle uğraşır, bu nedenle kullanımı &'Z' için 26 ya da 90 için 26 gibi değerler kullanmak daha kolaydır ~.

Sözde kod

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

Burada test edin (Windows'ta) !

* Bu teknik olarak Unefunge-98'dir, çünkü yalnızca 1 boyut kullanır, ancak bu ad yabancı olabilir.

Befunge 93 , 144 90 66 54 36 19 bayt

Buna izin verilip verilmediğine% 100 emin değil, ancak A, 65, B, 66, vb.

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

Aksi takdirde, 36 baytta:

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

(Önerileriniz için tngreene'ye teşekkürler!)

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

(Yeniden düzenleyerek 12 bayt tasarruf için Sp3000 sayesinde!)

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

Bu benim ilk çalışan Befunge programım ve bunu daha fazla golf oynamaya ihtiyaç duyuyorum. Herhangi bir yardım çok takdir edilecektir.

Befunge kodunu burada test edebilirsiniz .

Brainfuck, 445 Karakterler

Golf kurallarından daha çok bir konsept kanıtı. İmzasız, Sargısız Brainfuck Gerektirir.

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

Yorumlar ile

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

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

Test Programı :

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 bayt

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

Çevrimiçi deneyin!

R, 73 bayt

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

MATL, 10 bayt

6WZ~t42>?c

Açıklama:

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

Çevrimiçi deneyin! sayısal girişler.
Çevrimiçi deneyin! alfabetik girişlerle.

Python 3, 49 48 53 50 bayt

Her nasılsa, bayt sayısını yanlış anladım; teşekkürler dahuglenny

isalpha daha kısa isnumeric

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

bir harf ya da sayı olabilecek dize olarak girdi alır

Java, 61 bayt

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

Arayan f('A')bir retuning birinci fonksiyon çağırmaktadır int1; çağırarak f(1)ikinci işlevi çağırır, char"A" döndürür .

Javascript 86 77 66 60 bayt

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

• ok işlevlerini kullanma hakkındaki yorumlardan sonra 7 bayt kaydedildi
• @manatwork tarafından belirtilen geri dönüş / parantezleri kaldırarak 11 bayt daha kaydetti
• @ manatwork sayesinde 6 bayt daha kaydedildi

ASM: 10 bayt

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

Açıklama: Bu, tam olarak sorulanı yapan bir programın toplanmış temsilidir. Tamamen işlevsel değildir, çünkü bazı direktiflere ihtiyaç duyar, ancak bir montaj programının kod bölümüne eklenirse çalışması gerekir. AL kaydındaki girişi alır ve eğer bir harfi ASCII kod değerinden 40 saat çıkarsa, sadece sayıyı bırakır (yani B = 42h, 42h-40h = 2h). Giriş bir sayı ise, 40 saat ekleyerek ters işlemi gerçekleştirir. Sonucu AL kaydında bırakır. Aşağıda derleme kaynak kodu

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

Ayrıca, diğer tüm cevapları makine koduna dönüştürürseniz, benimkilerin en küçük olacağı kanısındayım.

Excel, 33 bayt

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

Brachylog , 10 bayt

;.L∧Ṇi₁pL∧

Çevrimiçi deneyin!

Bunun çekirdeği sadece 4 byte , ancak bu versiyon için I / O aklı başında biraz daha az.

Japt , 11 bayt

;BbU Ī´UgB

Dene

;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