# Clock Hand Syzygy

(massive thanks to El'endia Starman and Sp3000 for helping me design test cases for this!)

Given a positive integer n and a list of positive integer rotational periods for a number of clock hands (in seconds), output the smallest positive integer x where x seconds after starting the clock with all of the hands aligned, exactly n of the hands are aligned. They do not have to be aligned at the starting position - any position is fine, as long as x is an integer and is minimized. In addition, not all of the hands have to be aligned at the same position - for n=4, a solution where 2 groups of 2 hands are aligned is valid. Groups must be of size 2 or greater - two unaligned hands do not constitute 2 groups of 1 aligned hand, and thus is not a valid solution.

You may assume that only inputs where it is possible to have exactly n hands aligned after an integer number of seconds will be given - 2, [3,3,3] is not a valid input, because after any number of seconds, all 3 hands will be aligned, and so it is impossible to get exactly 2 aligned.

Examples:

2, [3,4] -> 12
(the only option is a multiple of 12, so we pick 12 - 4 and 3 full rotations, respectively)

3, [3,5,6,9,29] -> 18
(picking 3, 6, and 9, the hands would align after 6, 3, and 2 rotations, respectively)

2, [1,1,4,5,10] -> 1
(picking 1 and 1 - note that 0 is not a valid answer because it is not a positive integer)

3, [2,2,6,7,11] -> 3
(picking 2, 2, and 6 - the 2s would be halfway through their second revolution, and the 6 would be halfway through its first revolution)

2, [2,7,5,3,3] -> 1
(picking 3 and 3, they are always aligned, so 1 is the minimum)

5, [4, 14, 36, 50, 63, 180, 210] -> 45
(after 45 seconds, the first, third, and sixth are aligned, as well as the second and seventh, for a total of 5)

### Test Data:

7, [10, 22, 7, 6, 12, 21, 19] -> 87780
6, [25, 6, 2, 19, 11, 12] -> 62700
6, [23, 1, 8, 10, 9, 25] -> 41400
7, [6, 4, 1, 8, 10, 24, 23] -> 920
3, [18, 5, 23, 20, 21] -> 180
5, [10, 8, 14, 17, 5, 9] -> 2520
6, [1, 18, 12, 9, 8, 10, 23] -> 360
6, [12, 11, 6, 23, 25, 18, 13] -> 118404
4, [18, 11, 2, 9, 12, 8, 3] -> 8
7, [18, 25, 9, 13, 3, 5, 20] -> 11700
2, [17, 20, 15, 8, 23, 3] -> 15
3, [16, 3, 24, 13, 15, 2] -> 24
5, [7, 23, 24, 8, 21] -> 1932
6, [16, 10, 12, 24, 18, 2, 21] -> 720
6, [1, 17, 16, 13, 19, 4, 15] -> 53040
2, [3, 4, 20] -> 5
3, [9, 4, 16, 14, 1, 21] -> 16
5, [5, 17, 10, 20, 12, 11] -> 330
2, [21, 5, 22, 18] -> 90
4, [7, 25, 2, 8, 13, 24] -> 84
4, [13, 19, 2, 20, 7, 3] -> 420
5, [4, 14, 36, 50, 63, 180, 210] -> 45
5, [43, 69, 16, 7, 13, 57, 21] -> 27664
3, [22, 46, 92, 43, 89, 12] -> 276
4, [42, 3, 49, 88, 63, 81] -> 882
6, [2, 4, 7, 10, 20, 21, 52, 260] -> 65
6, [2, 3, 4, 7, 10, 20, 21, 52, 260] -> 35
2, [3, 4] -> 12
3, [3, 5, 6, 9, 29] -> 18
2, [1, 1, 4, 5, 10] -> 1
3, [2, 2, 6, 7, 11] -> 3
3, [41, 13, 31, 35, 11] -> 4433
3, [27, 15, 37, 44, 20, 38] -> 540
5, [36, 11, 14, 32, 44] -> 22176
3, [171, 1615, 3420] -> 3060
3, [46, 36, 12, 42, 28, 3, 26, 40] -> 36
5, [36, 25, 20, 49, 10, 27, 38, 42] -> 1350
4, [40, 28, 34, 36, 42, 25] -> 2142
5, [24, 26, 47, 22, 6, 17, 39, 5, 37, 32] -> 1248
4, [9, 27, 12, 6, 44, 10] -> 108

### Rules:

• Standard loopholes are forbidden
• This is , so shortest code wins!

The Stack Snippet at the bottom of this post generates the leaderboard from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

• Wow, I didn't even know this is a word. What an awesome, hangman-winning, scrabble-winning word! – Digital Trauma Nov 21 '15 at 0:11
• @DigitalTrauma Good luck finding 3 Y tiles. – SuperJedi224 Dec 8 '15 at 15:33

# Pyth, 2827 24 bytes

fqs-hMrS.RR7%R1cLTQ8 1vz

Try it online in the Pyth Compiler.

### How it works

fqs-hMrS.RR7%R1cLTQ8 1vz

(implicit) Save the input number in z (as string).
(implicit) Save the input list in Q.

f                         Find the first positive integer T such that:
cLTQ         Compute T/α for each α in Q.
%R1             Get the fractional part of each result.
.RR7                Round each fractional part to 7 decimal digits.
S                    Sort the resulting numbers.
r            8        Perform run-length encoding.
hM                      Get the lengths of the runs.
-                 1      Discard runs of length 1.
q                    vz    Check is the sum matches the input number.
If it does, break and return T.

$cat input 7\n[10, 22, 7, 6, 12, 21, 19]\n87780 6\n[25, 6, 2, 19, 11, 12]\n62700 6\n[23, 1, 8, 10, 9, 25]\n41400 7\n[6, 4, 1, 8, 10, 24, 23]\n920 3\n[18, 5, 23, 20, 21]\n180 5\n[10, 8, 14, 17, 5, 9]\n2520 6\n[1, 18, 12, 9, 8, 10, 23]\n360 6\n[12, 11, 6, 23, 25, 18, 13]\n118404 4\n[18, 11, 2, 9, 12, 8, 3]\n8 7\n[18, 25, 9, 13, 3, 5, 20]\n11700 2\n[17, 20, 15, 8, 23, 3]\n15 3\n[16, 3, 24, 13, 15, 2]\n24 5\n[7, 23, 24, 8, 21]\n1932 6\n[16, 10, 12, 24, 18, 2, 21]\n720 6\n[1, 17, 16, 13, 19, 4, 15]\n53040 2\n[3, 4, 20]\n5 3\n[9, 4, 16, 14, 1, 21]\n16 5\n[5, 17, 10, 20, 12, 11]\n330 2\n[21, 5, 22, 18]\n90 4\n[7, 25, 2, 8, 13, 24]\n84 4\n[13, 19, 2, 20, 7, 3]\n420 5\n[4, 14, 36, 50, 63, 180, 210]\n45 5\n[43, 69, 16, 7, 13, 57, 21]\n27664 3\n[22, 46, 92, 43, 89, 12]\n276 4\n[42, 3, 49, 88, 63, 81]\n882 6\n[2, 4, 7, 10, 20, 21, 52, 260]\n65 6\n[2, 3, 4, 7, 10, 20, 21, 52, 260]\n35 2\n[3, 4]\n12 3\n[3, 5, 6, 9, 29]\n18 2\n[1, 1, 4, 5, 10]\n1 3\n[2, 2, 6, 7, 11]\n3 3\n[41, 13, 31, 35, 11]\n4433 3\n[27, 15, 37, 44, 20, 38]\n540 5\n[36, 11, 14, 32, 44]\n22176 3\n[171, 1615, 3420]\n3060 3\n[46, 36, 12, 42, 28, 3, 26, 40]\n36 5\n[36, 25, 20, 49, 10, 27, 38, 42]\n1350 4\n[40, 28, 34, 36, 42, 25]\n2142 5\n[24, 26, 47, 22, 6, 17, 39, 5, 37, 32]\n1248 4\n[9, 27, 12, 6, 44, 10]\n108$ while read -r; do echo -e "$REPLY" | pyth -c 'qvwfqs-hMrS.RR7%R1cLTQ8 1vz'; done < input True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True True # Jelly, 19 16 bytes P:×ⱮP%PĠẈḟ1Sʋ€iƓ Takes the array as argument, the integer from STDIN. Way too slow and memory hungry for most of the test cases. Try it online! ### Alternate version, 14 bytes P÷€%1ĠẈḟ1Sʋ€iƓ This works in theory, but it may fail due to floating-point inaccuracies. Try it online! ### How it works P:×ⱮP%PĠẈḟ1Sʋ€iƓ Main link. Argument: A (array) P P P Yield the product of A. : Divide the product by each n in A. ×Ɱ Multiply the quotients by each k in [1, ..., prod(A)]. % Take the results modulo the product. € Map the link to the left over the array of remainders. ʋ Combine the links to the left into a dyadic chain. Ġ Group indices of identical elements. Ẉ Widths; yield the lengths of the groups. ḟ1 Filterfalse; remove all copies of 1. S Take the sum. Ɠ Read an integer j from STDIN. i Find the first index of j in the array of sums. # CJam, 4234 33 bytes 0{)_eas~@d\f/1f%7fmO$e0f=1m1b-}g

Try this fiddle or this test suite in the CJam interpreter.

### How it works

0       e# Push 0 (accumulator).
{       e# Do:
)_    e#   Increment the accumulator and push a copy.
eas~  e#   Push the command-line args, flatten and evaluate.
e#   This pushes a number and an array.
@d    e#   Rotate the accumulator copy on top and cast to Double.
\f/   e#   Divide it by each of the integers in the array.
1f%   e#   Get the fractional part of each result.
7fmO  e#   Round all fractional parts to seven decimal digits.
\$e   e#   Sort and perform run-length encoding.
0f=   e#   Select the lengths of the runs.
X-    e#   Discard runs of length 1.
Xb    e#   Compute the sum of the remaining runs.
-     e#   Subtract the sum from the input number (target).
}g      e# If this pushes a non-zero value, we've missed the target;
e# repeat the loop.

# Jelly, 15 bytes

÷_:ĠẈḟ1S⁼⁴
1ç1#

Try it online!

Full program.

Suffers from floating-point inaccuracies.