Alfabeto a Número y Número a Alfabeto

26

Reto

En este desafío, debe tomar un número como entrada y salida de la letra correspondiente del alfabeto, y viceversa. (1 <=> A, 2 <=> B) etc.

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

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

Reglas

  • Este es el , por lo que gana el código más corto en bytes.
  • La entrada solo consistirá en una letra mayúscula de Aa Zo un número entero de 1a 26inclusive.
  • Se permiten espacios en blanco al final (espacio y nueva línea).
Chad
fuente
1
¿Por qué duplicar? Oo no es igual.
Chad
3
¡Bienvenido a Programming Puzzles y Code Golf! Este desafío podría usar un poco de aclaración. Por ejemplo, podría especificar qué entradas necesitaríamos manejar, ya que hay entradas no válidas. Recomiendo publicar futuros desafíos en el Sandbox donde puedan obtener comentarios significativos antes de ser publicados en el sitio principal.
Leaky Nun
1
¿Recibiremos 26como un entero o "26"como una cadena, o ambos están permitidos?
Leaky Nun
2
¿Tiene que estar en mayúsculas o en minúsculas es aceptable?
Mego
1
En serio, ¿otro desafío del alfabeto? (͡ ° ͜ʖ ͡ °)
shooqie

Respuestas:

6

En realidad, 7 bytes

ú' +ûEí

Pruébalo en línea!

Explicación:

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

Si se aceptan minúsculas, esto es 6 bytes:

ú' +Eí

Pruébalo en línea!

Mego
fuente
1
Estás ganando en este momento, creo que nadie podría hacer un programa con menos 7 bytes.
Chad
1
Me uní solo para preguntar esto. @Mego, ¿qué idioma es este?
FoldedChromatin
2
@FoldedChromatin se parece a github.com/Mego/Seriously
Alfred Bez
1
@FoldedChromatin En realidad, lo es Actually. Por lo tanto Actually, 7 bytes. : P
Dan
2
Momentos como estos me hacen feliz con los nombres que elegí para mis idiomas :)
Mego
12

Pure Bash, 51

La mayoría del resto de las respuestas usan algún tipo de condicional. Éste prescinde por completo de condicionales y, en su lugar, trata la entrada como un número base 36 que se indexa en una matriz bash-brace-expansion adecuadamente construida:

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

Ideona

Trauma digital
fuente
1
Entonces, ¿qué hace el #?
R. Kap
9

Erlang, 26 bytes

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

Una de las pocas veces en que el comportamiento de cadena de Erlang es útil.

un espagueti
fuente
7

Python 3, 43 bytes

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

Lo interesante de esta solución es que incorpora todos los sentidos de OR, OR bit a bit |, OR lógico or, XOR bit a bit ^y XOR lógico !=...

cdlane
fuente
6

2sable , 9 8 bytes

Código:

.bAu¹kr,

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Adnan
fuente
1
¿No puedes borrar? ¿Qué bytes están sin? No necesita imprimir una nueva línea.
Chad
@Chad Nope, eso no funcionará para entradas numéricas :(
Adnan
6

Ruby, 47 39 + nbandera = 40 bytes 33 34 31 bytes

Función anónima. Utiliza un truco de manejo de excepciones como en la solución Python de @ KarlNapf .

-3 bytes de @manatwork

Pruébalo en línea

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

Versión original del programa completo con la nbandera de 40 bytes y lecturas de STDIN:

puts$_!~/\d/?$_.ord-64:(64+$_.to_i).chr
Tinta de valor
fuente
Recibo un error de sintaxis al intentar ejecutar en ideone , ¿puedes decir cómo probar?
Leibrug
@Leibrug ¡Uy! Ya está arreglado
Value Ink el
Se puede reducir mediante la aplicación de más descaradamente Karl Napf 's truco de su solución de Python : ->i{(64+i).chr rescue i.ord-64}.
manatwork
5

Cheddar, 34 32 bytes

Guardado 2 bytes gracias a @LeakyNun

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

Desearía que hubiera una forma más corta de verificar si la cadena o el número.

Pruébalo en línea! o Test Suite

Explicación

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==ncomprueba si es una cadena de una manera simple. "%s"es un formato de cadena, puedo formatear con, %por ejemplo, "a %s c" % "b"es igual a "a b c". %sespecifica que es una cadena, si se pasa un dígito permanecerá como %s.

Downgoat
fuente
"%s"%n==nahorra 2 bytes
Leaky Nun
@LeakyNun oh, eso es inteligente! Estaba tratando de hacerlo "%d"%n==npero eso no estaba funcionando: /
Downgoat
5

Mathematica 54 41 Bytes

Con una sugerencia absolutamente inteligente de LegionMammal978 que ahorra 13 bytes.

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

If[#>0,FromLetterNumber,,LetterNumber]tiene el único propósito de decidir si se aplica FromLetterNumbero no LetterNumbera la entrada.

#>0se satisfará si la entrada,, #es un número, en cuyo caso FromLetterNumberse seleccionará.

Sin embargo #>0, no será verdadero ni falso si #es una letra, y LetterNumberse seleccionará en su lugar.


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

4 4


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

re


En Mathematica, FromLetterNumbery LetterNumbertambién funcionará con otros alfabetos. Esto requiere solo unos pocos bytes más.

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

DavidC
fuente
1
Un poco de golf, llevándolo a 41 bytes:If[#>0,FromLetterNumber,,LetterNumber]@#&
LegionMammal978
Interpreto su sugerencia como: If[#>0,FromLetterNumber[#],LetterNumber@#]‌&. Aunque If[#>0,FromLetterNumber[#],LetterNumber@#]‌&[4]funciona, If[#>0,FromLetterNumber[#],LetterNumber@#]‌&["c"]no lo hace. Aparentemente no puede resolverse "c">0. ¿Entendí mal?
DavidC
El doble ,,es intencional, y también lo es el exterior @#; se evalúa como If[# > 0, FromLetterNumber, Null, LetterNumber][#]&, que usa la forma de 4 argumentos de If(búscalo).
LegionMammal978
Increíble cómo funciona la forma de 4 argumentos If.
DavidC
4

Haskell, 54 bytes

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

Ejemplo de uso: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

El estricto sistema de tipos de Haskell es un verdadero dolor aquí. Además, todas las funciones cortas de char <-> int tienen gusto chry ordnecesitan una importación, así que tengo que hacerlo a mano. Para la letra -> int, por ejemplo, necesito convertir String-> Char(vía !!0) -> Integer(vía fromEnum) -> String(vía show).

nimi
fuente
4

C, 55 bytes

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

Perl 6 , 25 bytes

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

Explicación:

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

Ejemplo:

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)
Brad Gilbert b2gills
fuente
2
A pesar de que la sintaxis es tan diferente, ese mismo mecanismo es el mismo número de bytes en Perl 5: perl -pe '$_=/\d/?chr$_+64:-64+ord'!
Dom Hastings
3

C #, 32 bytes

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

Lanza a Func<int, object>.

Entrada: las charconversiones implícitas intse pueden llamar con int(1-26) o char('A'-Z').

Salida: A charo int.

Leche
fuente
3

PHP, 49 41 40 bytes

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

No creo que haya una buena alternativa al is_numericderecho?

Esto se ejecuta desde la línea de comando ($argv[1] es la primera variable dada)

Gracias a:

@insertusernamehere: Golfed 8 bytes. Reemplazar is_numeric($i=$argv[1])con 0<($i=$argv[1]). Esto funciona porque(int)"randomLetter" == 0 .

@manatwork: reducido con 1 byte. Reemplazar 0<con +. Lo que sucede en este caso es que la señal + arrojará la "Z" (o cualquier letra) a un 0. Esto dará como resultado falso. Por lo tanto, cualquier letra es siempre falsa y un número siempre es verdadero.

Jeroen
fuente
2
Usar en 0<($i=$argv[1])lugar de is_numeric($i=$argv[1])ahorra 8 bytes .
insertusernamehere
1
Continuando con esa idea: 0<+.
manatwork
2

Python 2, 61 bytes

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

Sí, podría cambiar a Python 3 por input

Karl Napf
fuente
Sin input()embargo, use y cambie int(i)a i.
Leaky Nun
Entonces las entradas de caracteres no funcionan.
Karl Napf
2
Tomar entrada como"A"
Leaky Nun
3
Eso es patético. Ao nada.
Karl Napf
Puede eliminar algunos bytes reformulándolo como una función: línea 1: def f(i):línea 2: <espacio> try:o=chr(i+64), línea 3 <espacio> sin cambios, línea 4: <espacio> return o De esa forma, funcionaría en Python 2 o Python 3
cdlane
2

PowerShell v2 +, 42 bytes

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

Toma información $n(como un entero o un carácter explícito) y usa un pseudoternario para elegir entre dos elementos de una matriz. El condicional es $n-ge65( es decir, es la entrada ASCII Ao mayor). Si es así, simplemente emitimos la entrada como int y restamos 64. De lo contrario, agregamos 64al entero de entrada y lo convertimos como un[char] . En cualquier caso, el resultado se deja en la tubería y la impresión es implícita.

Ejemplos

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
AdmBorkBork
fuente
2

Befunge-98 *, 19 bytes

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

Debido a que la pregunta decía que recibirías un 1-26o un A-Z, supuse que esto significaba el número 26 o el carácter AZ. La mayoría de los intérpretes tienen dificultades para ingresar códigos alternativos, por lo que es más fácil usar &e ingresar valores como 26 para 26 o 90 para 'Z', en lugar de ~.

Pseudocódigo

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

¡Pruébelo (en Windows) aquí!

* Esto es técnicamente Unefunge-98 porque solo usa 1 dimensión, pero ese nombre puede ser desconocido.

tngreene
fuente
2

Befunge 93 , 144 90 66 54 36 19 bytes

No estoy 100% seguro si esto está permitido, pero si puede escribir A como 65, B como 66, etc., entonces (por el bien de [mi] conveniencia):

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

De lo contrario, a 36 bytes:

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

(¡Gracias a tngreene por las sugerencias!)

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

(¡Gracias a Sp3000 por guardar 12 bytes reorganizando!)

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

Sin golf:

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

Este es mi primer programa Befunge en funcionamiento, y siento la necesidad de seguir jugando al golf. Cualquier ayuda sería muy apreciada.

Puede probar el código Befunge aquí .

Daniel
fuente
1
Comentario de mirada rápida: Befunge se envuelve, para que pueda mover los últimos 12 caracteres de la segunda línea al frente y obtener52**\28*++,@>~:0`!#^_\68*-
Sp3000
@ Sp3000, oh, no me di cuenta de eso. ¡Gracias!
Daniel
¡Felicitaciones por tu primer programa! Una cosa a considerar sería generar grandes números empujando los valores ASCII en una cadena. Comparar 567+*a "A". Además, no se olvide de ge pinstrucciones para la reutilización de un valor en lugar de tener que construirlo en repetidas ocasiones. Además, no pude encontrar ninguna entrada que llevara la IP a la rama >$ 28* + , @. ¿Para qué es esto? ¿Estás seguro de que es necesario?
tngreene
Por último, admiro su dedicación a analizar "26" o "08". Su método, tal como lo leí, implica muchas matemáticas de conversión de número de símbolo <->, como en ('2' a 2 de nuevo a '2'). Tener su primera y segunda entrada como números antes de comenzar a compararlas podría disminuir la cantidad de aritmética ASCII que está haciendo. Alternativamente, tal vez haya una manera de manejar eficientemente las entradas como símbolos ('2' como en '2'), ¡no se necesita conversión a números!
tngreene
@tngreene, las entradas enteras <10 van a la rama, $28*+,@mientras que esas> = 10 van a la otra. En última instancia, esto se hizo porque no puedo leer la entrada más de una vez hasta donde yo sé.
Daniel
2

Brainfuck, 445 Personajes

Más una prueba de concepto que un código de golf. Requiere Brainfuck sin envolver, sin firmar.

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

Con comentarios

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

+
[>[->+>+<<]>[-<<-[>]>>>[<[-<->]<[>]>>[[-]>>+<]>-<]<<]>>>+<<[-<<+>>]<<<]>>>>>[-<<<<<+>>>>>]<<<<<
-
[->+>+<<]
>[-<++++++++++>]
<[-<->]
++++
[-<++++++++++++>]
++++
[->>++++++++++++<<]
>>.<<<.>
] 
Un taco
fuente
2

Java, 104 98 97 83 54 53 51 50 30 bytes

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

Programa de prueba :

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
Shaun Wild
fuente
1
Puede eliminar unos 20 bytes utilizando un operador ternario como este:return(s.matches("\\d+")?(char)(Integer.parseInt(s)+64)+"":(s.charAt(0)-64)+"");
yitzih
también puede eliminar la conversión a int, lo que le permite reducir en 7 bytes.
user902383
El programa no toma ninguna entrada. El programa no da ningún resultado. ¡Incluso no hay programa!
Nicolas Barbulesco
@NicolasBarbulesco No es necesario que escriba un programa completo a menos que se indique lo contrario.
Shaun Wild
1

R, 73 bytes

f=function(x){L=LETTERS;if(is.numeric(x)){i=L[(x)]}else{i=which(L==x)};i}
Mamie
fuente
¡No es necesario f=, y usted intenta usar la ifelsefunción en la nube para jugar algunos bytes!
Frédéric
1

MATL, 10 bytes

6WZ~t42>?c

Explicación:

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

Pruébalo en línea! con entradas numéricas
Pruébalo en línea! con entradas alfabéticas.

cubilete
fuente
1

Pitón 3, 49 48 53 50 bytes

De alguna manera me equivoqué en el conteo de bytes; _; gracias dahuglenny

isalpha es más corto que isnumeric

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

toma la entrada como una cadena, que podría ser una letra o un número

Limón Destructible
fuente
1
Puede eliminar el espacio entre x.isnumeric()y elsepara guardar un byte.
acrolith
1

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

Llamar f('A')invoca la primera función, reajustando un int1; llamar f(1)invoca la segunda función, devolviendo la char"A".

AJNeufeld
fuente
`tiene que tomar un número como entrada y salida de la letra correspondiente del alfabeto, y viceversa. (1 <=> A, 2 <=> B) etc.` No creo que un conjunto de funciones califique para esto.
Shaun Wild
1
@SeanBean es una sobrecarga de funciones.
NoOneIsHere
1
Eso no requiere ninguna entrada. Eso no da salida. No hay programa!
Nicolas Barbulesco
Debe suponer que la entrada es "A" .. "Z" o "0" .. "9". Como una cadena es la única primitiva que puede contener (no sabe cuál será la entrada), su función debe esperar un argumento de cadena.
RobIII
1

Javascript 86 77 66 60 bytes

i=>typeof i<'s'?String.fromCharCode(i+64):i.charCodeAt(0)-64
  • guardado 7 bytes después de los comentarios sobre el uso de las funciones de flecha
  • guardó otros 11 bytes al eliminar return / corchetes como lo señaló @manatwork
  • ahorró otros 6 bytes gracias a @manatwork
Dylan Meeus
fuente
1
Usar funciones de flecha
Bald Bantha
@BaldBantha aclama, lo cambió :-)
Dylan Meeus
No hay necesidad de returndeclaración: i=>typeof i=='number'?String.fromCharCode(i+64):i.charCodeAt(0)-64.
manatwork
@manatwork ¡Salud!
Dylan Meeus
1
Según la descripción de la tarea, la typeofentrada puede ser solo "número" o "cadena". Por lo tanto, no es necesario verificarlo =='number', <'s'también lo hará.
manatwork
1

ASM: 10 bytes

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

Explicación: Esta es la representación ensamblada de un programa que hace exactamente lo que se le pide. No es totalmente funcional, porque necesita algunas directivas, pero si se agrega al segmento de código de un programa de ensamblaje, debería funcionar. Recibe la entrada en el registro AL, y si es una letra, resta 40h del valor del código ASCII, dejando solo el número (es decir, B = 42h, 42h-40h = 2h). Si la entrada es un número, realiza el procedimiento contrario al sumar 40h. Deja el resultado en el registro AL. A continuación se muestra el código fuente del ensamblaje

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

Además, si convierte todas las otras respuestas al código de máquina, estoy seguro de que la mía sería la más pequeña.

6a75616e
fuente
Creo que hay algunos problemas: 77 02 2Cdebería ser 77 **04** 2C; El suby addestán al revés.
ceilingcat el
Apliqué las correcciones anteriores y creé una "función" a la que puede llamar desde un programa en C en una máquina x86_64. #define F(x) ((int(*)(int))"\x89\xf8\x3c\x40\x76\4\x2c\x40\xeb\2\4\x40\xc3")(x)
ceilingcat el
¿Qué tipo de ensamblaje es este?
mbomb007
Turbo Assembler
6a75616e
1

Excel, 33 bytes

=IFERROR(CHAR(A1+64),CODE(A1)-64)
Wernisch
fuente
1

Japt , 11 bytes

;BbU Ī´UgB

Intentalo

;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
Lanudo
fuente