Sfida

In questa attività devi scrivere un programma che prenderà in input un numero intero N (-1e9 <= N <0 && 0 <N <= + 1e9) , quindi calcola T = (abs (N)% M + 1) , se N è positivo quindi emette il carattere T-esima dall'inizio, altrimenti emette il carattere T-esima dalla fine della sorgente.

M è la dimensione della fonte in byte.

Esempio: se la tua fonte è:abcd efg/hi

Ingresso:

 2

Produzione:

 c

Input :

-3

Produzione:

g 

Input :

-9249678

Produzione:

b 

Input :

-11

Produzione:

i 

vincoli

• Non utilizzare alcuna operazione FILE
• Puoi usare qualsiasi lingua tu scelga
• Cerca di evitare o piuttosto di non utilizzare invii da 1 byte, poiché rovina tutto il divertimento.
• Vince la soluzione più breve!

EDIT: la dichiarazione del problema è stata modificata in modo tale che le soluzioni possano essere valutate utilizzando dati di test casuali (e stessi dati per tutte le soluzioni), quindi si prega di aggiornare la soluzione di conseguenza, ci scusiamo per l'inconveniente (se presente).

assembly x86 (Linux a 32 bit, sintassi AT&T): 548

Nessuna nuova riga alla fine del 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 "

L'ho compilato con gcc -nostartfiles -m32 qc1.S -o qc1

Verifica, numeri positivi:

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

Verifica, numeri negativi:

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

Modifica ha capito bene lo strano schema di numerazione. Penso. Non ha cambiato la lunghezza.

Whaddaya, HQ9 + fa il suo grande ritorno!

Q

Non c'è bisogno di preoccuparsi dell'indicizzazione quando c'è un solo personaggio tra cui scegliere!

Ruby 1.9, 66 caratteri

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

Non molta differenza rispetto a un normale quine, in realtà.

• Modifica: segue ora le nuove specifiche.

GolfScript 26 caratteri

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

Le quine erano più divertenti prima dell'invenzione dei linguaggi dinamici.

Modifica: per i piagnucoloni, ecco un quine GolfScript "reale", no `e ~ usato solo per analizzare l'input.

GolfScript per disabili 44 caratteri

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

Nota quanto è ripetuta la stessa stringa due volte, quindi la stringa letterale ha solo bisogno di essere 'hackerata davanti ed è pronta per l'uso.

Lenguage, 4 byte

Il codice sorgente è composto da 4 byte nulli. Indipendentemente dall'input, l'output dovrebbe quindi essere un byte null, che viene realizzato da .un'istruzione.

Smalltalk, 94 90 59 52

ad esempio, nella classe Object, compilare:

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

quindi invia q: <n> a qualsiasi oggetto; qui un numero intero:

verifica:

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

o meglio:
(da 0 a: 100) raccoglie: [: n | 1 q: n] come: 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) collection: [: 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('

spiegazione per i non-Smalltalker:
thisContext è l'attuale frame dello stack, a cui può essere richiesto il suo metodo , a cui può essere chiesta la fonte .

Incantesimi runici , 17 byte

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

Provalo online!

Utilizza semplicemente quine standard per generare la stringa di programma, quindi utilizza l'operatore modulo basato su stringa ¹ per ottenere il carattere in un determinato indice (che supporta nativamente indicazioni negative e positive, comportamento influenzato da Python).

1. _{Il ,comando "divide" suddivide la stringa in blocchi (inverso abbastanza logico di *duplicare i xtempi della stringa ), +concatena e -rimuove i xcaratteri dalla fine (un inverso abbastanza logico di +). Quindi il %comando assume il ruolo di charAt(x): l'unica operazione di stringa di base rimanente (dopo che le operazioni simili a stack sono gestite dagli stessi comandi che si occupano dello stack; ad es. lÈ la dimensione dello stack così l͍è la lunghezza di una stringa).}

JavaScript (ES6), 28 byte

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

Un quine modificato.

Un valore maggiore di 28 viene gestito da %28, un valore inferiore a 0 viene gestito da .substr().