introduction
Je veux construire une échelle. Pour cela, j'ai récupéré de la casse deux longues planches avec des trous, et je veux placer les marches dans ces trous. Cependant, les trous ne sont pas placés uniformément, donc les étapes seront un peu bancales, et j'ai du mal à estimer la quantité de tige dont j'ai besoin. Votre travail consiste à faire les calculs pour moi.
Contribution
Votre entrée est des vecteurs à deux bits, donnés sous forme de tableaux d'entiers, qui représentent les deux cartes. A 0
représente un segment d'un aud ( unité arbitraire de distance ) sans trou, et a 1
représente un segment d'un aud avec un seul trou. Les tableaux peuvent être de longueurs différentes et contenir un nombre différent de 1
s, mais ils ne seront pas vides.
Je vais construire mon échelle comme suit. Tout d'abord, je place les deux planches exactement à une distance l'une de l'autre et j'aligne leurs extrémités gauches. Pour chaque index i
, je mesure la distance entre le i
trou de la première planche avec le i
trou de la deuxième planche , je coupe un morceau de tige et je le fixe entre les deux trous. Je m'arrête une fois que je n'ai plus de trous dans l'une des planches.
Sortie
Votre sortie est la quantité totale de tige dont j'ai besoin pour les étapes, mesurée en auds. La sortie doit être correcte avec au moins six chiffres significatifs.
Exemple
Considérez les entrées [0,1,1,0,1,1,1,1,0,0]
et [1,0,0,1,1,1,0,0,1]
. L'échelle résultante ressemble à ceci:
La longueur totale de la tige dans cette échelle est 7.06449510224598
auds.
Règles
Vous pouvez écrire soit une fonction soit un programme complet. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.
Cas de test
[0] [0] -> 0.0
[0] [1,0] -> 0.0
[1,0,0] [1,1,1,1,1] -> 1.0
[0,1,0,1] [1,0,0,1] -> 2.414213562373095
[0,1,1,0,1,1,1,1,0,0] [1,0,0,1,1,1,0,0,1] -> 7.06449510224598
[1,1,1,1,1] [0,0,1,1,0,1,0,0,1] -> 12.733433128760744
[0,0,0,1,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0] [0,0,1,1,0,1,1,1,0,0,0,0,0,1,1,0,1,1,0,0,0,1] -> 20.38177416534678
Réponses:
J, 20 octets
Il utilise l'astuce dans la réponse R de MickyT .
(<0 1)|:
donne la diagonale d'une matrice. Pour les explications des autres parties, voir la réponse de FUZxxl .la source
J, 22 caractères
Pas inspiré par la réponse de randomra. La
I.
pièce est égale car c'est la manière immédiatement évidente de trouver les trous.I. y
- tous les indices dey
répétés aussi souvent que l'élément correspondant dey
. Soit dit en passant, siy
est un vecteur de booléens,I. y
contient les indices auxquelsy
est1
. Par exemple, lesI. 1 0 0 1 1 1 0 0 1
rendements0 3 4 5 8
.x u&v y
- le même que(v x) u (v y)
. Appliqué commex u&I. y
, nous obtenons(I. x) u (I. y)
. Continuons avec l'entrée transformée.x <.&# y
- la moindre des longueurs dex
ety
.x -/@,: y
- la différence des éléments dex
ety
. Si un vecteur est plus long, il est rempli de zéros.x $ y
-y
remodelé à la forme spécifiée parx
. Plus précisément, s'ilx
s'agit d'un scalaire, lesx
éléments sont extraits dey
. Dans cette utilisation,x (<.&# $ -/@,:) y
s'assure que les trous de fuite sont ignorés.4 o. y
- la fonction%: 1 + *: y
, c'est-à-dire sqrt (1 + y ²). Soit dit en passant, cette fonction établit une correspondance entre la distance entre les trous et la longueur des tiges.+/ y
- la somme des éléments dey
.la source
Python, 85
Cela s'est avéré similaire à la solution de Mac . Convertissez les listes de 0 et de 1 en listes ordonnées des un-indices, puis additionnez la distance entre les éléments respectifs.
la source
J,
3228 octetsLe verbe
I.
renvoie les positions de1
s dans une chaîne binaire, ce qui est d'une grande aide.Pour une meilleure solution J, vérifiez la réponse de FUZxxl .
la source
R, 67
Utilise extérieur pour faire une différence pour les trous indexés. Diag renvoie les différences requises. Additionnez ensuite les distances calculées
Test exécuté dans R Fiddle. Je l'ai enveloppé dans une impression pour montrer que le retour est conforme aux spécifications.
la source
a==1
peut êtrea>0
ou!!a
.Haskell,
7773 octetsUtilisation:
[0,1,0,1] # [1,0,0,1]
quelles sorties2.414213562373095
Comment ça marche: la fonction
r
retourne une liste des positions des trous d'une planche, par exempler [0,1,0,1]
->[2,4]
.#
zippe deux de ces listes et les transforme en une liste de distances entre les trous correspondants et finalement la somme.la source
CJam,
3633 octetsApproche très naïve ... il attend l'entrée en tant que tableaux de style CJam sur STDIN
Voici un faisceau de test pour toutes les entrées d'exemple. Les résultats dans le champ de saisie sont utilisés avant l'appel du code réel. Vous pouvez les supprimer si vous ne me faites pas confiance. ;)
Explication
la source
Python, 86
Une solution récursive de bas niveau et naïve sans recherche de liste.
Les listes d'entrée sont
a
etb
. Si l'un ou l'autre est vide, retournez0
.Sinon, laissez
x
ety
soyez leurs premiers éléments (le code ne les attribue pas réellement parce que vous ne pouvez pas faire les affectations dans alambda
, mais cela facilitera l'explication). Si les deux sont 1, c'est-à-dire que leur produit est 1, alors ils contribuent à la distance de la tige. Nous gardons une trace de la distance dans le nombre complexei
, de sorte que la distance est la valeur absolue. En fait, nous le calculons indépendamment, puis le multiplions parx*y
.Ensuite, nous récurons. L'idée est de décaler les deux listes d'une étape, à moins qu'une liste ne commence par un 0 et l'autre par un, auquel cas nous ne décalons que la liste 0. De cette façon, les 1 sont toujours consommés par paires. Nous pourrions vérifier ces conditions avec
x<y
ety<x
, mais il est plus court de profiter de la comparaison de liste en tant quea[:1]<=b
. Enfin, nous ajustons le déplacement complexe entre les éléments actuels parx-y
.la source
a>[]<b
para>0<b
. Cela fonctionne depuis les deux[]
et0
est faux, ils sont donc équivalents.a:
?([] > []) != ([] > 0)
et en python3 c'est une erreur (types non triables).a:
fait partie de la tranche[b[:1]<=a:]
.Python,
105102100 octetsAssez basique, convertit simplement les listes d'entrée en listes d'indices de trous, puis calcule la distance entre chaque paire de ces indices.
Cas de test:
Nous remercions @FryAmTheEggman pour quelques suggestions d'économie d'octets. Il s'avère que cela peut être approfondi, comme le montre la réponse de xnor .
la source
enumerate(l)
et le0.5
(qui pourrait juste être 0,5).l=lambda*a:sum(((a-b)**2+1)**.5for a,b in zip(*map(i,a)))
Pyth, 30 octets
Essayez-le en ligne avec l'entrée
[0,1,1,0,1,1,1,1,0,0], [1,0,0,1,1,1,0,0,1]
.Explication:
Je convertir les listes dans des listes d'indices
[2, 3, 5, 6, 7, 8]
et[1, 4, 5, 6, 9]
et compressez- les ensemble[(2,1), (3,4), (5,5), (6,6), (7,9)]
. Ensuite, je soustrais les valeurs, je les évalue au carré, j'ajoute 1 et je fais la somme de toutes les racines carrées.Dommage que
sum
cela ne fonctionne pas pour les listes vides.la source
Python,
116115 octetsIl s'agit d'une solution récursive.
Cela est devenu assez ennuyeux quand j'ai trouvé que
index()
lève juste une erreur lorsqu'aucune valeur n'est trouvée, mais je l'ai fait fonctionner. Malheureusement, je ne peux pas utiliser de lambda. Cela m'a aussi énervé delist.remove()
ne pas retourner la liste, mais de revenirNone
.Exécutez en ligne ici: http://repl.it/c5L/2
la source
Clip 3 ,
55 4738Pour la liste avec le moins de trous, le programme le parcourt et relie chaque trou au trou correspondant de l'autre liste. Les tailles sont calculées et additionnées.
Explication
Si nous sommes très libéraux sur le format d'entrée, nous pouvons le réduire à 36 octets en les supprimant chacun
k
. Cela nécessite que l'entrée soit une chaîne de caractères de caractères de contrôle\0
et\1
.la source
ECMAScript 6, 86 octets
Cela a commencé à l'origine à l'aide de réduire (je voulais voir si cela pouvait être fait en une seule boucle par opposition à la réponse @ edc65).
Mais en utilisant @ edc65 pour
map
et&&t
pour renvoyer la valeur, j'ai pu la raccourcir un peu.la source
reduce
plus de sens sur le plan sémantique, mais à part cela, il est en fait assez délicat à utiliser. Bien sûr, depuis quand les golfeurs du code se préoccupent-ils de la sémantique.Java, 151
Cela marche juste à la
a
recherche de ceux-là, puis marcheb
quand il en trouve un. Si lafloat
précision est acceptable, je pourrais économiser quelques octets, mais je suis allé avecdouble
pour faire correspondre la sortie de test.Avec espace:
la source
JavaScript (ES6) 108
Le point principal est la fonction f qui mappe les tableaux d'entrée 0..1 en tableaux de positions de trous. Ensuite, les tableaux sont balayés en calculant la longueur totale des tiges à l'aide du théorème de Pythagore. La
|0
fin proche est nécessaire pour convertir les NaN qui peuvent résulter lorsque le tableau de pilotes (le premier) est plus long que le second.Test dans la console Firefox / FireBug
la source
Octave,
605942la source
Perl 98
Lisible:
Essai:
la source
APL,
3528 octetsUtilise un algorithme similaire à la solution J, mais APL a moins de fonctions intégrées.
Exemple d'entrée:
la source