Herausforderung

In dieser Herausforderung müssen Sie eine Zahl als Eingabe nehmen und den entsprechenden Buchstaben des Alphabets ausgeben und umgekehrt. (1 <=> A, 2 <=> B) usw.

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

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

Regeln

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.
• Die Eingabe besteht nur aus einem Großbuchstaben von Abis Zoder einer Ganzzahl von 1bis 26einschließlich.
• Nachgestellte Leerzeichen (Leerzeichen und Zeilenumbrüche) sind zulässig.

Eigentlich 7 Bytes

ú' +ûEí

Probieren Sie es online!

Erläuterung:

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

Wenn Kleinbuchstaben zulässig sind, sind dies 6 Byte:

ú' +Eí

Probieren Sie es online!

Pure Bash, 51

Die meisten anderen Antworten verwenden eine Art von Bedingung. Diese Methode verzichtet vollständig auf Bedingun- gen und behandelt die Eingabe stattdessen als eine Zahl zur Basis 36, die in ein entsprechend aufgebautes Array zur Bash-Brace-Erweiterung indiziert:

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

Ideone.

Erlang, 26 Bytes

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

Eines der wenigen Male, bei denen das Verhalten von Erlang nützlich ist.

Python 2, 38 Bytes

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

Teste es auf Ideone .

Python 3, 43 Bytes

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

Das Interessante an dieser Lösung ist, dass sie alle Sinne von OR, bitweisem OR |, logischem OR or, bitweisem XOR ^und logischem XOR umfasst !=...

2sable , 9 8 Bytes

Code:

.bAu¹kr,

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Ruby, 47 39 + nFlag = 40 Bytes 33 34 31 Bytes

Anonyme Funktion. Verwendet einen Ausnahmebehandlungstrick wie in @ KarlNapfs Python-Lösung .

-3 Bytes von @manatwork

Probieren Sie es online aus

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

Ursprüngliche Vollprogrammversion mit dem nFlag für 40 Bytes und liest aus STDIN:

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

Cheddar, 34 32 Bytes

2 Bytes dank @LeakyNun gespart

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

Ich wünschte, es gäbe eine kürzere Möglichkeit, um zu überprüfen, ob Zeichenfolge oder Nummer.

Probieren Sie es online! oder Test Suite

Erläuterung

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==nprüft auf einfache Weise, ob es sich um eine Zeichenkette handelt. "%s"ist ein string format, mit dem ich %zB "a %s c" % "b"gleich formatieren kann "a b c". %sGibt an, dass es sich um eine Zeichenfolge handelt. Wenn eine Ziffer übergeben wird, bleibt sie wie folgt %s.

Mathematica 54 41 Bytes

Mit einem absolut cleveren Vorschlag von LegionMammal978, der 13 Bytes einspart.

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

If[#>0,FromLetterNumber,,LetterNumber]dient einzig und allein der Entscheidung, ob eine Bewerbung FromLetterNumberoder eine Bewerbung LetterNumbereingereicht werden soll.

#>0Wird erfüllt, wenn die Eingabe,, #eine Zahl ist. In diesem Fall FromLetterNumberwird ausgewählt.

Es ist jedoch #>0weder wahr noch falsch, wenn #es sich um einen Buchstaben handelt, und es LetterNumberwird stattdessen ausgewählt.

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

4

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

d

In Mathematica FromLetterNumberund LetterNumberwird auch mit anderen Alphabeten arbeiten. Dies erfordert nur noch wenige Bytes.

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 Bytes

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

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

Haskells strenges Typensystem ist hier ein echtes Problem. Zusätzlich funktionieren alle kurzen Zeichen <-> int wie chrund ordbrauchen einen Import, also muss ich es von Hand machen. Für den Fall letter -> int muss ich zum Beispiel String-> Char(via !!0) -> Integer(via fromEnum) -> String(via show) konvertieren .

C 55 Bytes

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

Perl 6 , 25 Bytes

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

Erläuterung:

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

Beispiel:

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 Bytes

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

Wirft zu Func<int, object>.

Eingabe: charImplizit konvertiert nach intso kann mit int(1-26) oder char('A'-Z') aufgerufen werden .

Ausgabe: Entweder a charoder int.

PHP, 49 41 40 Bytes

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

Ich glaube nicht, dass es eine gute Alternative gibt is_numeric oder?

Dies wird von der Kommandozeile ausgeführt ($argv[1] ist die erste angegebene Variable)

Dank an:

@insertusernamehere: Golf 8 Bytes. Ersetzen is_numeric($i=$argv[1])durch 0<($i=$argv[1]).Das funktioniert weil (int)"randomLetter" == 0.

@manatwork: Reduziert um 1 Byte. Ersetzen 0<durch +. In diesem Fall wird durch das Signal + das "Z" (oder ein beliebiger Buchstabe) auf 0 gesetzt. Dies führt zu "false". Daher ist jeder Buchstabe immer falsch und eine Zahl ist immer wahr.

Python 2, 61 Bytes

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

Ja, ich könnte zu Python 3 wechseln input

PowerShell v2 +, 42 Byte

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

Übernimmt Eingaben $n(als Ganzzahl oder explizites Zeichen) und verwendet ein Pseudoternär, um zwischen zwei Elementen eines Arrays zu wählen. Die Bedingung ist $n-ge65(dh ist die Eingabe ASCII Aoder höher). In diesem Fall wird die Eingabe einfach als int umgewandelt und subtrahiert 64. Andernfalls fügen wir 64die Eingabe-Ganzzahl hinzu und wandeln sie in eine [char]. In beiden Fällen bleibt das Ergebnis in der Pipeline und das Drucken ist implizit.

Beispiele

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 Bytes

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

Da die Frage besagte, dass Sie ein 1-26oder ein erhalten, nahm A-Zich an, dass dies die Nummer 26 oder das Zeichen AZ bedeutete. Die meisten Interpreten haben Probleme mit der Eingabe von Alt-Codes, daher ist es einfacher, &Werte wie 26 für 26 oder 90 für 'Z' einzugeben, im Gegensatz zu ~.

Pseudocode

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

Testen Sie es hier (unter Windows) !

* Dies ist technisch gesehen Unefunge-98, da nur eine Dimension verwendet wird, der Name jedoch möglicherweise nicht bekannt ist.

Befunge 93 , 144 90 66 54 36 19 Bytes

Nicht 100% sicher, ob dies zulässig ist, aber wenn Sie A als 65, B als 66 usw. eingeben dürfen, dann (aus [meinem] Interesse):

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

Ansonsten bei 36 Bytes:

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

(Danke an tngreene für die Vorschläge!)

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

(Dank an Sp3000 für die Einsparung von 12 Bytes durch Neuanordnung!)

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

Dies ist mein erstes funktionierendes Befunge-Programm überhaupt, und ich habe das Bedürfnis, dieses weiter auszubauen. Jede Hilfe wäre sehr dankbar.

Sie können Befunge Code testen hier .

Brainfuck, 445 Zeichen

Eher ein Proof of Concept als ein Golf-Code. Benötigt nicht signiertes, nicht umwickeltes Brainfuck.

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

Mit Kommentaren

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

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

Testprogramm :

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 Bytes

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

Probieren Sie es online!

R, 73 Bytes

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

MATL, 10 Bytes

6WZ~t42>?c

Erläuterung:

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

Probieren Sie es online! mit numerischen Eingaben.
Probieren Sie es online! mit alphabetischen Eingaben.

Python 3, 49 48 53 50 Bytes

Irgendwie habe ich die Byteanzahl falsch verstanden; _; danke dahuglenny

isalpha ist kürzer als isnumeric

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

Nimmt Eingaben als Zeichenfolge, die ein Buchstabe oder eine Zahl sein kann

Java, 61 Bytes

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

Der Aufruf f('A')ruft die erste Funktion auf und stimmt eine int1 neu ab. Der Aufruf f(1)ruft die zweite Funktion auf und gibt das char"A" zurück.

Javascript 86 77 66 60 Bytes

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

• 7 Bytes nach Kommentaren zur Verwendung von Pfeilfunktionen gespeichert
• sparte weitere 11 Bytes durch Entfernen von return / eckigen Klammern, wie von @manatwork angegeben
• hat dank @manatwork weitere 6 Bytes eingespart

ASM: 10 Bytes

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

Erläuterung: Dies ist die zusammengestellte Darstellung eines Programms, das genau das tut, wonach gefragt wird. Es ist nicht voll funktionsfähig, da es einige Direktiven benötigt, aber wenn es zum Codesegment eines Assembly-Programms hinzugefügt wird, sollte es funktionieren. Es empfängt die Eingabe im AL-Register und subtrahiert, wenn es ein Buchstabe ist, 40h vom ASCII-Codewert, wobei nur die Zahl übrig bleibt (dh B = 42h, 42h-40h = 2h). Wenn die Eingabe eine Zahl ist, erfolgt die umgekehrte Prozedur durch Addieren von 40 Stunden. Das Ergebnis verbleibt im AL-Register. Unten finden Sie den Assembly-Quellcode

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

Auch wenn Sie alle anderen Antworten in Maschinencode konvertieren, bin ich überzeugt, dass meine die kleinste wäre.

Excel, 33 Bytes

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

Brachylog , 10 Bytes

;.L∧Ṇi₁pL∧

Probieren Sie es online!

Der Kern davon ist nur 4 Bytes , aber die E / A für diese Version ist ein bisschen weniger als vernünftig.

Japt , 11 Bytes

;BbU Ī´UgB

Versuch es

;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