Quine Challenge I

Question

Challenge

In this task you have to write a program that will take input an integer N (-1e9 <= N < 0 && 0 < N <= +1e9), then compute T = (abs(N) % M+1),if N is positive then output the T-th character from the beginning else output the T-th character from the end of your source.

M is the size of your source in bytes.

Example: If your source is: abcd efg/hi

Input:

 2

Output:

 c

Input:

-3

Output:

g 

Input:

-9249678

Output:

b 

Input:

-11

Output:

i 

Constraints

• Don't use any FILE operation
• You can use any language of your choice
• Try to avoid or rather don't use 1 byte submissions, since it spoils all fun.
• Shortest solution wins!

EDIT: Problem statement have been modified so that the solutions could be judged using a random test-data (and same data for all solutions) hence please update your solution accordingly,sorry for the inconvenience (if any).

Answer 1

x86 assembly (32-bit Linux, AT&T syntax): 548

No newline at end of file:

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 "

I compiled it with gcc -nostartfiles -m32 qc1.S -o qc1

Verification, positive numbers:

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

Verification, negative numbers:

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

Edit got it right about the weird numbering scheme. I think. It didn't change the length.

Answer 2

Whaddaya know, HQ9+ makes its great return!

Q

No need to bother indexing when there's only one character to choose from!

Answer 3

Ruby 1.9, 66 characters

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

Not much difference to a normal quine, actually.

• Edit: Follows the new specs now.

Answer 4

GolfScript 26 characters

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

Quines were more fun before the invention of dynamic languages.

Edit: For the whiners, here is a "real" GolfScript quine, no ` and ~ only used for parsing the input.

Handicapped GolfScript 44 characters

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

Notice how nicely it is the same string repeated twice, so the string literal just need a ' hacked in front of it and it's ready for use.

Answer 5

Lenguage, 4 bytes

Source code consists of 4 null bytes. Regardless of the input, the output should thus be a null byte, which is accomplished by one . instruction.

Answer 6

Runic Enchantments, 17 bytes

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

Try it online!

Just uses standard quine to generate the program string, then uses string-based modulo operator¹ to get the character at a given index (which natively support negative and positive indicies, behavior influenced by Python).

1. _{The , "divide" command cuts the string up into chunks (logical enough inverse of * duplicating the string x times), + concatenates, and - removes x characters from the end (a logical enough inverse of +). So the % command takes the role of charAt(x): the only basic string operation remaining (after stack-like operations being handled by the same commands that deal with the stack; eg. l is the size of the stack so l͍ is the length of a string).}

Answer 7

JavaScript (ES6), 28 bytes

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

A modified quine.

A value larger than 28 is handled by %28, a value less than 0 is handled by .substr().

Answer 8

Smalltalk, 94 90 59 52

for example, in the Object class, compile:

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

then send q:<n> to any object; here an integer:

verification:

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

or better:
(0 to:100) collect:[:n|1 q:n]as:String
-> ')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)collect:[:n|1 q:n]as:String
-> ')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('

explanation for non-Smalltalkers:
thisContext is the current stack frame, which can be asked for its method, which can be asked for its source.