Desafío

En esta tarea, debe escribir un programa que ingrese un número entero N (-1e9 <= N <0 && 0 <N <= + 1e9) , luego calcule T = (abs (N)% M + 1) , si N es positivo, luego genera el carácter T-th desde el principio; de lo contrario, genera el carácter T-th desde el final de su fuente.

M es el tamaño de su fuente en bytes.

Ejemplo: si su fuente es:abcd efg/hi

Entrada:

 2

Salida:

 c

Entrada :

-3

Salida:

g 

Entrada :

-9249678

Salida:

b 

Entrada :

-11

Salida:

i 

Restricciones

• No use ninguna operación de ARCHIVO
• Puedes usar cualquier idioma de tu elección
• Intente evitar o, mejor dicho, no use envíos de 1 byte, ya que arruina toda la diversión.
• ¡La solución más corta gana!

EDITAR: La declaración del problema se ha modificado para que las soluciones puedan juzgarse utilizando datos de prueba aleatorios (y los mismos datos para todas las soluciones), por lo tanto, actualice su solución en consecuencia, disculpe las molestias (si las hubiera).

Ensamblaje x86 (Linux de 32 bits, sintaxis de AT&T): 548

No hay nueva línea al final del archivo:

pushl 8(%esp)
call atoi
mov $274,%ebx
cmp $0,%eax
jg a
dec %eax
a:cdq
idiv %ebx
cmp $0,%edx
jge p
add %ebx,%edx
p:add $s,%edx
cmp $s+273,%edx
jl l
push $34
mov %esp,%edx
l:mov $4,%eax
mov $1,%ebx
mov %edx,%ecx
mov $1,%edx
int $128
mov $0,%ebx
mov $1,%eax
int $128
s:.ascii "pushl 8(%esp)
call atoi
mov $274,%ebx
cmp $0,%eax
jg a
dec %eax
a:cdq
idiv %ebx
cmp $0,%edx
jge p
add %ebx,%edx
p:add $s,%edx
cmp $s+273,%edx
jl l
push $34
mov %esp,%edx
l:mov $4,%eax
mov $1,%ebx
mov %edx,%ecx
mov $1,%edx
int $128
mov $0,%ebx
mov $1,%eax
int $128
s:.ascii "

Lo compilé con gcc -nostartfiles -m32 qc1.S -o qc1

Verificación, números positivos:

$ for i in $(seq 548 1095); do ./qc1 $i; done | cmp - qc1.S && echo Good
Good

Verificación, números negativos:

$ for i in $(seq -1095 -548); do ./qc1 $i; done | cmp - qc1.S && echo Good
Good

Edit lo hizo bien sobre el extraño esquema de numeración. Yo creo que. No cambió la longitud.

¡Lo sé, HQ9 + hace su gran regreso!

Q

¡No hay necesidad de molestarse en indexar cuando solo hay un personaje para elegir!

Ruby 1.9, 66 caracteres

z=gets.to_i;s="z=gets.to_i;s=%p;$><<(s%%s)[z%%66]";$><<(s%s)[z%66]

No hay mucha diferencia con una quine normal, en realidad.

• Editar: Sigue las nuevas especificaciones ahora.

GolfScript 26 caracteres

{':f`f'+1/\~.1<- 26%=}:f`f

Las quines eran más divertidas antes de la invención de los lenguajes dinámicos.

Editar: Para los quejumbrosos, aquí hay una quine de GolfScript "real", no 'y ~ solo se usa para analizar la entrada.

GolfScript para discapacitados 44 caracteres

'"\x27"\+1/\~.1<- 22%='"\x27"\+1/\~.1<- 22%=

Observe qué tan bien es la misma cadena repetida dos veces, por lo que el literal de cadena solo necesita un 'pirateo delante y está listo para usar.

Lenguage, 4 bytes

El código fuente consta de 4 bytes nulos. Independientemente de la entrada, la salida debería ser un byte nulo, que se realiza mediante una .instrucción.

Smalltalk, 94 90 59 52

por ejemplo, en la clase Object, compile:

q:n|s|s:=thisContext method source.^s at:n\\s size+1

luego envíe q: <n> a cualquier objeto; aquí un entero:

verificación:

1 q: 0 -> q
1 q: 1 ->:
1 q: 2 -> n
...
1 q: -1 ->)
1 q: -2 ->)
1 q: -3 -> 1

o mejor:
(0 a: 100) recolectar: ​​[: n | 1 q: n] como: Cadena
->')q:n|s m|s:=thisContext method source.m:=s size.^s at:(n>=0ifTrue:n-1\\m+1ifFalse:m-(0-n\\m))q:n|s m|'

(-1 downTo: -500) recolectar: ​​[: n | 1 q: n] como: Cadena
->')m\\n-0(-m:eslaFfi1+m\\1-n:eurTfi0=>n(:ta s^.ezis s=:m.ecruos dohtem txetnoCsiht=:s|m s|n:q))m\\n-0('

explicación para los que no son Smalltalkers:
thisContext es el marco de pila actual, al que se le puede pedir su método , al que se le puede preguntar su origen .

Encantamientos rúnicos , 17 bytes

"3X4+kSq:l͍iS%%@

Pruébalo en línea!

Simplemente usa quine estándar para generar la cadena del programa, luego usa el operador de módulo ¹ basado en cadenas para obtener el carácter en un índice dado (que admite de forma nativa las indicaciones negativas y positivas, el comportamiento influenciado por Python).

1. _{El ,comando "dividir" corta la cadena en trozos (lo suficientemente lógico inverso de *duplicar los xtiempos de la cadena ), +concatena y -elimina los xcaracteres del final (un inverso lo suficientemente lógico de +). Por lo tanto, el %comando toma el rol de charAt(x): la única operación de cadena básica restante (después de que las operaciones similares a la pila sean manejadas por los mismos comandos que se ocupan de la pila; por ejemplo, les el tamaño de la pila, por lo que l͍es la longitud de una cadena).}

JavaScript (ES6), 28 bytes

f=n=>("f="+f).substr(n%28,1)

Una quine modificada.

Un valor mayor que 28 es manejado por %28, un valor menor que 0 es manejado por .substr().