Vous collectez des données depuis un Advanced Collecting Device Controller ™ depuis longtemps. Vous consultez les journaux, et à votre horreur vous découvrez que quelque chose a terriblement mal tourné: les données ne contiennent que les derniers bits des chiffres!
Heureusement, vous connaissez la valeur de départ et la valeur ne change jamais rapidement. Cela signifie que vous pouvez récupérer le reste en trouvant simplement la distance depuis le début.
Défi
Vous écrirez un programme ou une fonction pour calculer le montant d'une valeur a changé, étant donné un module N
et une liste des valeurs intermédiaires modulo N
.
Le changement entre chaque paire de nombres est toujours inférieur àN/2
, il n'y aura donc qu'une seule réponse valide pour chaque cas de test.
Vous recevrez en entrée un entier N
> 2 et une liste de valeurs, dans un format de votre choix. L'entrée peut être donnée via STDIN ou la ligne de commande ou des arguments de fonction.
Vous afficherez un seul entier, le montant de la valeur d'origine a changé. La sortie peut être imprimée sur STDOUT ou renvoyée.
Règles
- Votre programme doit fonctionner pour n'importe quelle distance et module inférieur à
2^20
. - Vous pouvez supposer que:
N
est au moins3
.- La liste a au moins 2 valeurs.
- Toutes les valeurs de la liste sont au moins 0 et inférieures à
N
. - Tous les changements dans les nombres sont inférieurs à
N/2
.
- Tout le reste est une entrée invalide et votre programme peut faire ce qu'il veut.
- Les failles standard, toutes les bibliothèques non standard et les fonctions intégrées à cet effet sont interdites.
- Il s'agit de code-golf , donc le programme le plus court en octets l'emporte.
Exemples de cas de test
Contribution:
3
0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
Production:
4
Explication (avec exemple de valeur):
Value mod 3: 0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
Value: 0 1 2 2 3 4 3 2 1 2 3 4 5 4 4
Contribution:
10
5 2 8 9 5
Production:
-10
Explication (avec exemple de valeur):
Value mod 10: 5 2 8 9 5
Value: 15 12 8 9 5
Entrées non valides:
2
0 0 0 0 0
(module trop petit)
6
2 5 4 2
(changement trop important entre 2 et 5)
:^;[5 2 8 9 5](\
?Réponses:
TI-BASIC, 15 octets
Prend la liste de
Ans
et le module deInput
.la source
Python 2, 53 octets
Réponse super simple. Je me demande s'il y a un chemin plus court.
la source
.:_2
générer des paires avant d'avoir vu votre réponse - j'utilisais zip.Mathematica, 30 octets
Il s'agit d'une fonction anonyme qui prend deux arguments. Exemple d'utilisation:
Cela fonctionne en prenant les
Differences
éléments successifs, en les enveloppant dans la plage-n/2
à+n/2
avecMod
et son paramètre de décalage, puis en prenant le total avecTr
(trace matricielle, somme des éléments diagonaux).Notez que même non golfé c'est seulement 43 octets!
la source
@
est inutile lorsque vous appelez déjà la fonction entre crochets. Avoir les deux est une erreur de syntaxe.J, 24 octets
Usage:
Je vais essayer de jouer au golf plus et ajouter quelques explications après cela.
Essayez-le en ligne ici.
la source
Pyth,
2019 octetsEtole
.:_2
de Jakube, idée de Mauris.la source
R, 38 octets
Cela crée une fonction sans nom qui accepte un entier et un vecteur en entrée et renvoie un seul entier. Pour l'appeler, donnez-lui un nom, par exemple
f=function(n,v)...
.Non golfé + explication:
Exemples:
la source
MatLab, 33 octets
Mes excuses, c'est ma première réponse sur ce site. Taper ceci dans MatLab puis utiliser l'entrée
ans(modulus_value, [intermediate_values])
renverra la valeur demandée, où 'module_value' est la valeur du module, et 'intermediaire_values' est une liste des valeurs intermédiaires séparées par des espaces ou des virgules.Exemple:
La fonction anonyme tire parti de MatLab
mod
,diff
et dessum
fonctions pour calculer la réponse. Tout d'abord, la différence entre chacune des valeurs intermédiaires est calculée. Le résultat est ensuite compensé par le module divisé par deux, résultant en un ensemble de valeurs de différence qui est lié par [-modulus / 2 module / 2]. Le résultat est ensuite décalé et additionné à nouveau.Je pense que cela peut être joué plus, je reviendrai bientôt avec une mise à jour. Un merci spécial à @ 2012rcampion pour l'idée.
Edit: Matlab's
unwrap
fonction fonctionne presque ici, mais c'est difficile de jouer au golf. Le code suivant retourne un tableau où la dernière valeur est le montant que la première valeur a changé:@(x,y)unwrap(y/x*2*pi)/2/pi*x-y(1)
Les valeurs intermédiaires sont mises à l'échelle dans la plage de [-pi pi], puis "dépliées" de sorte qu'aucune valeur consécutive ne soit à plus de pi. Ces valeurs sont ensuite redimensionnées et décalées, résultant en un tableau de distances par rapport à la valeur de départ.
Intéressant, mais pas très pratique pour ce défi: D
la source
Pyth, 29 octets
Essayez-le en ligne: Pyth Compiler / Executor
la source
CJam, 27 octets
Testez-le ici.
la source
Pip , 39 octets
Nécessite la liste des données comme arguments de ligne de commande et le module sur STDIN. Si c'est trop étiré, j'ai une version qui prend deux arguments de ligne de commande pour 5 octets de plus.
Explication:
Et juste pour prouver que ce score moins compétitif reflète mieux mes compétences de golf que ma langue, voici un portage de la solution Python de Mauris en 30 octets :
la source
Gelée , non compétitive
6 octets Cette réponse n'est pas concurrente, car le défi est antérieur à la création de Jelly.
Essayez-le en ligne!
Comment ça fonctionne
la source