Algorithms

<pre>import timeit
start = timeit.default_timer()
import math



def fequals(a, b):
	return abs(a-b) < 0.0000001




def matmult(a,b):
    
	zip_b = list(zip(*b))
	return [[sum(ele_a*ele_b for ele_a, ele_b in zip(row_a, col_b)) 
	 for col_b in zip_b] for row_a in a]






def area(theta):
	r = [[math.cos(theta), -math.sin(theta), 0.0],
	[math.sin(theta), math.cos(theta), 0.0],
	[0.0, 0.0, 1.0]]
	
	v = [[1], [-1], [1]]
	
	point = matmult(r, v)
	return abs(point[0][0]*point[2][0])







def position(theta):
	r = [[math.cos(theta), -math.sin(theta), 0.0],
	[math.sin(theta), math.cos(theta), 0.0],
	[0.0, 0.0, 1.0]]
	
	c_o= [[0.5, 0.0, 0.0],
	[0.0, 0.5, 0.0],
	[0.0, 0.0, 0.5]]
	
	result = matmult(r, c_o)

	return(result)



def OptimizeTheta(A):
	if fequals(A, 1.0):
		return position(0.0)
	elif fequals(A, 1.414213):
		return position(math.pi / 4.0)
	l = 0.0
	m = math.pi / 4.0
	while True:
		mid = (l + m)/2.0
		a = area(mid)
		if fequals(A, a):
			return position(mid)
		if a < A:
			l = mid
		else:
			m = mid
	



t =int(input())
for i in range(t):
	A = float(input())
	cube = OptimizeTheta(A)
	print("Case #{}:".format(i+1))
	print(cube[0][0], cube[1][0], cube[2][0])

	print(cube[0][1], cube[1][1], cube[2][1])

	print(cube[0][2], cube[1][2], cube[2][2])


                                                                                                                                                                            #GHOST999



stop = timeit.default_timer()
execution_time = stop - start

Im building a indoor putting ramp and it will be possible to hit straight puts but also I will create breaks for variation.
I asking for help for an algorithm and the easy part of this is that the slopes will be fixed.

Imagine this like a pooltable. If a raise one side with 3cm. Which is 3 degrees  to make it easy.
How much do I have to change my aim point compared to the straight putt?


Summary:
What I would like for this in the beginning.

Distance 1,2,3 Meters.
Fixed break. (Means the slope is the same on the entire surface)
Break 1,2,3,4 degrees.

2 different speeds:
One speed that the ball just make it to the hole.
Second speed that the ball ends up 70 cm behind the ball?

Why different speeds?
To show and illustrate how the aim point changes depending on how hard you roll the ball.

int mySqrt(int x, int left, int right)
{
    static int result = 0;
    if (left <= right)
    {
        int middle = left + (right - left) / 2;
        if ((middle != 0 && middle <= x / middle) ||
            (middle == 0 && middle <= x / (middle + 1)))
        {
            result = middle;
            return mySqrt(x, middle + 1, right);
        }
        else
        {
            return mySqrt(x, left, middle - 1);
        }
    }
    return result;
}

const GROUPS_COUNTER = 10;
const MIN_ASCII = 65;
const MAX_ASCII = 69;

/*
 * generate children pairs.
 */
function generateGroups($n) {
    $matrix = [];
    $exist = [];
    echo "************************\n";

    for ($i = 0; $i < $n; $i++) {
        $a = chr(rand(MIN_ASCII, MAX_ASCII));
        $b = chr(rand(MIN_ASCII, MAX_ASCII));

        if ($a == $b || isset($exist[$a][$b]) || isset($exist[$b][$a])) {
            $i--;
            continue;
        }

        $matrix[$i][0] = $a;
        $matrix[$i][1] = $b;
        $exist[$a][$b] = true;

        echo $a . " " . $b . "\n";
    }

    echo "************************\n";

    return $matrix;
}

/*
 * find all children which are not like by parent.
 */
function findGroups($groups) {
    $dislikeList = [];
    $checked = [];

    foreach ($groups as $groupParent) {
        if (isset($checked[$groupParent[0]])) {
            continue;
        }

        $groupChildList = [];

        foreach ($groups as $groupChild) {
            if ($groupParent[0] == $groupChild[0]) {
                array_push($groupChildList, $groupChild[1]);
            }
        }

        echo $groupParent[0] . " => " . implode(", ", $groupChildList) . "\n";
        $dislikeList[$groupParent[0]] = $groupChildList;
        $checked[$groupParent[0]] = true;
    }

    echo "************************\n";

    return $dislikeList;
}

/*
 * phpTarjanEntry() iterates through the graph array rows, executing phpTarjan().
 */
function phpTarjanEntry($groups) {
    global $cycles;
    global $marked;
    global $markedStack;
    global $pointStack;

    $cycles = array();
    $marked = array();
    $markedStack = array();
    $pointStack = array();

    $marked = array();

    foreach ($groups as $key => $value) {
        $marked[$key] = FALSE;
    }

    foreach ($groups as $key => $value) {
        phpTarjan($key, $key);

        while (!empty($markedStack)) {
            $marked[array_pop($markedStack)] = FALSE;
        }
    }

    $cycles = array_keys($cycles);

    return $cycles;
}

/*
 * Recursive function to detect strongly connected components (cycles, loops).
 */
function phpTarjan($s, $v) {
    global $G;
    global $cycles;
    global $marked;
    global $markedStack;
    global $pointStack;

    $f = FALSE;
    $pointStack[] = $v;
    $marked[$v] = TRUE;
    $markedStack[] = $v;

    foreach ($G[$v] as $w) {
        if ($w < $s) {
            $G[$w] = array();
        } else if ($w == $s) {
            $cycles[implode('|', $pointStack)] = TRUE;
            $f = TRUE;
        } else if (isset($marked[$w]) && $marked[$w] === FALSE) {
            $g = phpTarjan($s, $w);

            if (!empty($f) OR ! empty($g)) {
                $f = TRUE;
            }
        }
    }

    if ($f === TRUE) {
        while (end($markedStack) != $v) {
            $marked[array_pop($markedStack)] = FALSE;
        }

        array_pop($markedStack);
        $marked[$v] = FALSE;
    }

    array_pop($pointStack);
    return $f;
}

$mixGroups = generateGroups(GROUPS_COUNTER);
$res = findGroups($mixGroups);
$G = $res;
$cycles = phpTarjanEntry($res);

echo '<p>Cycles found: ' . count($cycles);
print_r($cycles);