Défi

Dans cette tâche, vous devez écrire un programme qui prendra en entrée un entier N (-1e9 <= N <0 && 0 <N <= + 1e9) , puis calculez T = (abs (N)% M + 1) , si N est positif puis sortez le T-ème caractère depuis le début sinon sortez le T-ème caractère depuis la fin de votre source.

M est la taille de votre source en octets.

Exemple: si votre source est:abcd efg/hi

Contribution:

 2

Production:

 c

Entrée :

-3

Production:

g 

Entrée :

-9249678

Production:

b 

Entrée :

-11

Production:

i 

Contraintes

• N'utilisez aucune opération FILE
• Vous pouvez utiliser la langue de votre choix
• Essayez d'éviter ou plutôt de ne pas utiliser les soumissions de 1 octet, car cela gâche tout le plaisir.
• La solution la plus courte gagne!

EDIT: L' énoncé du problème a été modifié afin que les solutions puissent être jugées à l'aide de données de test aléatoires (et des mêmes données pour toutes les solutions), veuillez donc mettre à jour votre solution en conséquence, désolé pour le désagrément (le cas échéant).

Assemblage x86 (Linux 32 bits, syntaxe AT&T): 548

Pas de nouvelle ligne à la fin du fichier:

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 "

Je l'ai compilé avec gcc -nostartfiles -m32 qc1.S -o qc1

Vérification, nombres positifs:

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

Vérification, nombres négatifs:

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

Edit a bien compris le schéma de numérotation étrange. Je pense. Cela n'a pas changé la longueur.

Whaddaya sait, HQ9 + fait son grand retour!

Q

Pas besoin de s'embêter à indexer quand il n'y a qu'un seul personnage à choisir!

Ruby 1.9, 66 caractères

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

Pas beaucoup de différence avec un quine normal, en fait.

• Modifier: suit les nouvelles spécifications maintenant.

GolfScript 26 caractères

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

Les quines étaient plus amusantes avant l'invention des langages dynamiques.

Edit: Pour les pleurnichards, voici un "vrai" GolfScript quine, no `et ~ uniquement utilisé pour l'analyse de l'entrée.

GolfScript handicapé 44 caractères

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

Remarquez à quel point c'est la même chaîne répétée deux fois, donc la chaîne littérale a juste besoin d'être 'piratée devant elle et elle est prête à l'emploi.

Lenguage, 4 octets

Le code source se compose de 4 octets nuls. Quelle que soit l'entrée, la sortie doit donc être un octet nul, ce qui est accompli par une .instruction.

Smalltalk, 94 90 59 52

par exemple, dans la classe Object, compilez:

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

puis envoyez q: <n> à n'importe quel objet; ici un entier:

vérification:

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

ou mieux:
(0 à: 100) collecter: [: 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('

explication pour les non-Smalltalkers:
thisContext est le cadre de pile actuel, qui peut être demandé pour sa méthode , qui peut être demandé pour sa source .

Enchantements runiques , 17 octets

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

Essayez-le en ligne!

Utilise simplement le quine standard pour générer la chaîne de programme, puis utilise l'opérateur modulo basé sur une chaîne ¹ pour obtenir le caractère à un index donné (qui supporte nativement les indices négatifs et positifs, comportement influencé par Python).

1. _{La ,commande "diviser" coupe la chaîne en morceaux (assez inverse logique de la *duplication des xtemps de chaîne ), +concatène et -supprime les xcaractères de la fin (un inverse assez logique de +). Ainsi, la %commande prend le rôle de charAt(x): la seule opération de chaîne de base restante (après que les opérations de type pile soient gérées par les mêmes commandes qui traitent la pile; par exemple, lest la taille de la pile ainsi que l͍la longueur d'une chaîne).}

JavaScript (ES6), 28 octets

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

Un quine modifié.

Une valeur supérieure à 28 est gérée par %28, une valeur inférieure à 0 est gérée par .substr().