Herausforderung

In dieser Aufgabe müssen Sie ein Programm schreiben, das eine ganze Zahl N (-1e9 <= N <0 && 0 <N <= + 1e9) eingibt , und dann T = (abs (N)% M + 1) berechnen , wenn N ist positiv, dann geben Sie das T-te Zeichen vom Anfang an aus, ansonsten das T-te Zeichen vom Ende Ihrer Quelle.

M ist die Größe Ihrer Quelle in Bytes.

Beispiel: Wenn Ihre Quelle ist:abcd efg/hi

Eingang:

 2

Ausgabe:

 c

Eingabe :

-3

Ausgabe:

g 

Eingabe :

-9249678

Ausgabe:

b 

Eingabe :

-11

Ausgabe:

i 

Einschränkungen

• Verwenden Sie keine FILE-Operation
• Sie können jede Sprache Ihrer Wahl verwenden
• Versuchen Sie, 1-Byte-Einsendungen zu vermeiden oder besser nicht zu verwenden, da dies den Spaß verdirbt.
• Kürzeste Lösung gewinnt!

BEARBEITEN: Die Problembeschreibung wurde dahingehend geändert, dass die Lösungen anhand von zufälligen Testdaten (und denselben Daten für alle Lösungen) beurteilt werden können. Aktualisieren Sie daher Ihre Lösung entsprechend.

x86-Assembly (32-Bit-Linux-, AT & T-Syntax): 548

Keine neue Zeile am Ende der Datei:

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 "

Ich habe es mit kompiliert gcc -nostartfiles -m32 qc1.S -o qc1

Überprüfung, positive Zahlen:

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

Überprüfung, negative Zahlen:

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

Edit hat das seltsame Nummerierungsschema richtig verstanden. Meiner Ansicht nach. Es hat die Länge nicht verändert.

Wie Sie wissen, macht HQ9 + eine großartige Rendite!

Q

Kein Indizieren mehr nötig, wenn nur ein Charakter zur Auswahl steht!

Ruby 1.9, 66 Zeichen

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

Eigentlich kein großer Unterschied zu einem normalen Quine.

• Bearbeiten: Folgt jetzt den neuen Spezifikationen.

GolfScript 26 Zeichen

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

Quines machten mehr Spaß, als die dynamischen Sprachen erfunden wurden.

Edit: Für die Nörgler gibt es hier ein "echtes" GolfScript-Quine, no `und ~ werden nur zum Parsen der Eingabe verwendet.

Behindertes GolfScript 44 Zeichen

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

Beachten Sie, wie schön es ist, wenn dieselbe Zeichenfolge zweimal wiederholt wird. Das Zeichenfolgenliteral muss also nur noch 'gehackt werden, und es ist einsatzbereit.

Sprache, 4 Bytes

Der Quellcode besteht aus 4 Null-Bytes. Unabhängig von der Eingabe sollte die Ausgabe daher ein Null-Byte sein, was durch eine .Anweisung erreicht wird.

Smalltalk, 94 90 59 52

Kompilieren Sie beispielsweise in der Object-Klasse:

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

dann sende q: <n> an ein beliebiges Objekt; hier eine ganze Zahl:

Nachprüfung:

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

oder besser:
(0 bis: 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) sammle: [: n | 1 q: n] als: 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('

Erklärung für Nicht-Smalltalker:
thisContext ist der aktuelle Stack-Frame, der nach seiner Methode und nach seiner Quelle gefragt werden kann .

Runenverzauberungen , 17 Bytes

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

Probieren Sie es online!

Verwendet einfach Standard-Quine, um den Programm-String zu generieren, und verwendet dann den string-basierten Modulo-Operator ¹ , um das Zeichen an einem bestimmten Index abzurufen (der von Haus aus negative und positive Zeichen unterstützt, Verhalten von Python beeinflusst).

1. _{Der ,Befehl "divide" zerlegt die Zeichenfolge in Blöcke (logisch genug, *um die Zeichenfolgenzeiten zu duplizieren x), +verkettet und -entfernt xZeichen am Ende (logisch genug, um die Zeichenfolgenzeiten zu duplizieren +). Der %Befehl hat also die folgende Funktion charAt(x): die einzige verbleibende grundlegende Zeichenfolgenoperation (nachdem stapelähnliche Operationen von denselben Befehlen behandelt wurden, die sich mit dem Stapel befassen; z. B. list die Größe des Stapels und l͍die Länge einer Zeichenfolge).}

JavaScript (ES6), 28 Byte

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

Eine modifizierte Quine.

Ein Wert größer als 28 wird von behandelt %28, ein Wert kleiner als 0 wird von behandelt .substr().