Wyzwanie

W tym wyzwaniu musisz wziąć liczbę jako dane wejściowe i wyjściowe odpowiedniej litery alfabetu i odwrotnie. (1 <=> A, 2 <=> B) itp.

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

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

Zasady

• To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.
• Dane wejściowe będą się składać wyłącznie z dużej litery od Ado Zlub liczby całkowitej od 1do 26włącznie.
• Końcowe białe znaki (spacja i nowa linia) są dozwolone.

Właściwie 7 bajtów

ú' +ûEí

Wypróbuj online!

Wyjaśnienie:

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

Jeśli dopuszczalne są małe litery, jest to 6 bajtów:

ú' +Eí

Wypróbuj online!

Pure Bash, 51

Większość pozostałych odpowiedzi używa pewnego rodzaju warunkowych. Ten całkowicie rezygnuje z warunkowych i zamiast tego traktuje dane wejściowe jako liczbę podstawową 36, która indeksuje w odpowiednio skonstruowaną tablicę rozszerzeń bash-nawias klamrowy:

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

Ideone.

Erlang, 26 bajtów

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

Jeden z niewielu przypadków, w których zachowanie łańcucha Erlanga jest przydatne.

Python 2, 38 bajtów

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

Przetestuj na Ideone .

Python 3, 43 bajty

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

Ciekawą rzeczą w tym rozwiązaniu jest to, że zawiera wszystkie zmysły OR, bitowe OR |, logiczne OR or, bitowe XOR ^i logiczne XOR !=...

2sable , 9 8 bajtów

Kod:

.bAu¹kr,

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Rubinowy, 47 39 + nflaga = 40 bajtów 33 34 31 bajtów

Funkcja anonimowa. Wykorzystuje sztuczkę związaną z obsługą wyjątków, jak w rozwiązaniu Python @ KarlNapf .

-3 bajty z @manatwork

Wypróbuj online

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

Oryginalna pełna wersja programu z nflagą na 40 bajtów i odczytywana ze STDIN:

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

Cheddar, 34 32 bajty

Zaoszczędź 2 bajty dzięki @LeakyNun

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

Chciałbym, aby istniał krótszy sposób sprawdzenia, czy łańcuch lub liczba.

Wypróbuj online! lub pakiet testowy

Wyjaśnienie

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==nw prosty sposób sprawdza, czy jest to ciąg znaków. "%s"jest formatem ciągu, który mogę sformatować %np. "a %s c" % "b"jest równy "a b c". %sokreśla, że ​​jest to ciąg znaków, jeśli cyfra zostanie przekazana, pozostanie jako %s.

Mathematica 54 41 bajtów

Z absolutnie sprytną sugestią LegionMammal978, która oszczędza 13 bajtów.

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

If[#>0,FromLetterNumber,,LetterNumber]służy wyłącznie do podjęcia decyzji, czy zastosować, FromLetterNumberczy LetterNumberdo wkładu.

#>0będzie spełniony, jeśli wejście,, #jest liczbą, w którym to przypadku FromLetterNumberzostanie wybrany.

Jednak #>0nie będzie ani prawdą, ani fałszem, jeśli #jest literą i LetterNumberzostanie wybrana zamiast tego.

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

4

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

re

W Mathematica, FromLetterNumbera LetterNumbertakże będzie działać z innymi alfabetami. Wymaga to tylko kilku dodatkowych bajtów.

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 bajty

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

Przykład użycia: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

System ścisłego pisania Haskella jest tutaj prawdziwym bólem. Dodatkowo wszystkie krótkie char <-> int działają jak chri ordwymagają importu, więc muszę to zrobić ręcznie. W przypadku litery -> int, na przykład muszę przekonwertować String-> Char(przez !!0) -> Integer(przez fromEnum) -> String(przez show).

C, 55 bajtów

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

Perl 6 , 25 bajtów

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

Wyjaśnienie:

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

Przykład:

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 bajty

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

Przesyłanie do Func<int, object>.

Dane wejściowe: chardomyślnie konwertuje na, intwięc można je wywołać za pomocą int(1-26) lub char(„A'-Z”).

Wyjście: albo a charalbo int.

PHP, 49 41 40 bajtów

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

Nie sądzę, że istnieje dobra alternatywa dla is_numericdobra?

Jest to wykonywane z wiersza poleceń ( $argv[1]jest to pierwsza podana zmienna)

Dzięki:

@insertusernamehere: Golfed 8 bajtów. Zastąpienie is_numeric($i=$argv[1])przez 0<($i=$argv[1]).To działa, ponieważ (int)"randomLetter" == 0.

@manatwork: Zmniejszony o 1 bajt. Wymień 0<się +. W tym przypadku dzieje się tak, że sygnał + wyrzuci „Z” (lub dowolną literę) na zero. Spowoduje to fałsz. Dlatego każda litera jest zawsze fałszywa, a liczba jest zawsze prawdziwa.

Python 2, 61 bajtów

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

Tak, mógłbym przejść na Python 3 dla input

PowerShell v2 +, 42 bajty

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

Pobiera dane wejściowe $n(jako liczbę całkowitą lub jawny znak) i używa pseudo-trójki do wyboru między dwoma elementami tablicy. Warunkiem jest $n-ge65(tzn. Wejściowy ASCII Alub wyższy). Jeśli tak, po prostu rzutujemy dane wejściowe jako int i odejmujemy 64. W przeciwnym razie dodajemy 64do wejściowej liczby całkowitej i rzucamy ją jako [char]. W obu przypadkach wynik pozostaje w potoku, a drukowanie jest niejawne.

Przykłady

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 bajtów

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

Ponieważ pytanie brzmiało, że dostaniesz a 1-26lub an A-Z, założyłem, że oznaczało to liczbę 26 lub znak AZ. Większość interpretuje problemy z wprowadzaniem kodów alt, więc łatwiej jest używać &i wprowadzać wartości takie jak 26 dla 26 lub 90 dla „Z”, w przeciwieństwie do ~.

Pseudo 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

Przetestuj to (w systemie Windows) tutaj!

* Technicznie jest to Unefunge-98, ponieważ używa tylko 1 wymiaru, ale ta nazwa może być nieznana.

Befunge 93 , 144 90 66 54 36 19 bajtów

Nie jestem w 100% pewien, czy jest to dozwolone, ale jeśli możesz wpisać A jako 65, B jako 66 itd., To (dla mojej [wygody]):

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

W przeciwnym razie przy 36 bajtach:

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

(Dzięki tngreene za sugestie!)

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

(Dzięki Sp3000 za zaoszczędzenie 12 bajtów przez przestawienie!)

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

Nie golfowany:

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

To mój pierwszy działający program Befunge w historii i czuję potrzebę dalszej gry w golfa. Każda pomoc byłaby bardzo mile widziana.

Można przetestować kod befunge tutaj .

Brainfuck, 445 znaków

Bardziej dowód koncepcji niż kod do gry w golfa. Wymaga Bez podpisu, bez opakowania Brainfuck.

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

Z komentarzami

,[>+>+<<-] 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 bajtów

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

Program testowy :

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 bajtów

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

Wypróbuj online!

R, 73 bajty

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

MATL, 10 bajtów

6WZ~t42>?c

Wyjaśnienie:

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

Wypróbuj online! z wejściami numerycznymi.
Wypróbuj online! z wprowadzaniem alfabetycznym.

Python 3, 49 48 53 50 bajtów

Jakoś źle pomyliłem liczbę bajtów; _; dzięki dahuglenny

isalpha jest krótszy niż isnumeric

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

przyjmuje dane wejściowe jako ciąg znaków, który może być literą lub cyfrą

Java, 61 bajtów

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

Wywołanie f('A')wywołuje pierwszą funkcję, strojenie int1; wywołanie f(1)wywołuje drugą funkcję, zwracając char„A”.

JavaScript 86 77 66 60 bajtów

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

• zapisano 7 bajtów po komentarzach na temat używania funkcji strzałek
• zapisał kolejne 11 bajtów, usuwając return / nawiasy, jak zauważył @manatwork
• zapisał kolejne 6 bajtów dzięki @manatwork

ASM: 10 bajtów

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

Objaśnienie: Jest to złożona reprezentacja programu, który robi dokładnie to, o co proszono. Nie jest w pełni funkcjonalny, ponieważ wymaga pewnych dyrektyw, ale jeśli zostanie dodany do segmentu kodu programu asemblera, powinien działać. Odbiera dane wejściowe do rejestru AL, a jeśli jest to litera, odejmuje 40 godzin od wartości kodu ASCII, pozostawiając tylko liczbę (tj. B = 42h, 42h-40h = 2h). Jeśli wartością wejściową jest liczba, wykonuje odwrotną procedurę, dodając 40 godzin. Pozostawia wynik w rejestrze AL. Poniżej znajduje się kod źródłowy zestawu

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

Ponadto, jeśli przekonwertujesz wszystkie pozostałe odpowiedzi na kod maszynowy, jestem przekonany, że moje byłoby najmniejsze.

Excel, 33 bajty

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

Brachylog , 10 bajtów

;.L∧Ṇi₁pL∧

Wypróbuj online!

Rdzeń tego ma tylko 4 bajty , ale we / wy dla tej wersji jest nieco mniej rozsądne.

Japt , 11 bajtów

;BbU Ī´UgB

Spróbuj

;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