Desafio

Nesta tarefa, você deve escrever um programa que receba um número inteiro N (-1e9 <= N <0 && 0 <N <= + 1e9) e calcule T = (abs (N)% M + 1) , se N é positivo e, em seguida, gera o caractere T-ésimo do começo, ou o caractere T-ésimo do final da sua fonte.

M é o tamanho da sua fonte em bytes.

Exemplo: se sua fonte é:abcd efg/hi

Entrada:

 2

Resultado:

 c

Entrada :

-3

Resultado:

g 

Entrada :

-9249678

Resultado:

b 

Entrada :

-11

Resultado:

i 

Restrições

• Não use nenhuma operação FILE
• Você pode usar qualquer idioma de sua escolha
• Tente evitar, ou melhor, não use envios de 1 byte, pois isso estraga toda a diversão.
• A solução mais curta vence!

EDIT: A declaração do problema foi modificada para que as soluções pudessem ser julgadas usando dados de teste aleatórios (e os mesmos dados para todas as soluções); portanto, atualize sua solução adequadamente. Desculpe-nos pela inconveniência (se houver).

assembly x86 (Linux de 32 bits, sintaxe AT&T): 548

Nenhuma nova linha no final do arquivo:

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 "

Eu compilei com gcc -nostartfiles -m32 qc1.S -o qc1

Verificação, números positivos:

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

Verificação, números negativos:

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

Edit acertou no esquema de numeração estranho. Eu acho que. Não mudou o comprimento.

Whaddaya sabe, HQ9 + faz seu grande retorno!

Q

Não há necessidade de incomodar a indexação quando há apenas um caractere para escolher!

Ruby 1.9, 66 caracteres

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

Não há muita diferença para um quine normal, na verdade.

• Editar: segue as novas especificações agora.

GolfScript 26 caracteres

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

Quines era mais divertido antes da invenção de linguagens dinâmicas.

Edit: Para os whiners, aqui está um quine "real" do GolfScript, não `e ~ usado apenas para analisar a entrada.

GolfScript para deficientes 44 caracteres

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

Observe o quão bem ela é a mesma string repetida duas vezes, portanto, a literal da string só precisa ser 'hackeada na frente e está pronta para uso.

Linguagem, 4 bytes

O código fonte consiste em 4 bytes nulos. Independentemente da entrada, a saída deve ser um byte nulo, que é realizado por uma .instrução.

Smalltalk, 94 90 59 52

por exemplo, na classe Object, compile:

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

então envie q: <n> para qualquer objeto; aqui um número inteiro:

verificação:

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

ou melhor:
(0 a: 100) colete: [: n | 1 q: n] como: 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) colete: [: n | 1 q: n] como: 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('

explicação para não-Smalltalkers:
thisContext é o quadro de pilha atual, que pode ser solicitado por seu método , que pode ser solicitado por sua origem .

Encantos Rúnicos , 17 bytes

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

Experimente online!

Apenas usa quine padrão para gerar a string do programa e, em seguida, usa o operador de módulo baseado em string ¹ para obter o caractere em um determinado índice (que suporta nativamente indicações negativas e positivas, comportamento influenciado pelo Python).

1. _{O ,comando "dividir" corta a cadeia em pedaços (é inverso o suficiente para *duplicar os xtempos da sequência ), +concatena e -remove os xcaracteres do final (é inverso o suficiente +). Portanto, o %comando assume o papel de charAt(x): a única operação básica de sequência restante (após operações semelhantes a pilha serem tratadas pelos mesmos comandos que lidam com a pilha; por exemplo, lé o tamanho da pilha e l͍o comprimento de uma sequência).}

JavaScript (ES6), 28 bytes

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

Uma solução modificada.

Um valor maior que 28 é tratado por %28, um valor menor que 0 é tratado por .substr().