online python to c converter

1def djikstra(graph, initial):
2    visited_weight_map = {initial: 0}
3    nodes = set(graph.nodes)
4
5    # Haven't visited every node
6    while nodes:
7        next_node = min(
8          node for node in nodes if node in visited 
9        )
10
11        if next_node is None:
12            # If we've gone through them all
13            break
14
15        nodes.remove(next_node)
16        current_weight = visited_weight_map[next_node]
17
18        for edge in graph.edges[next_node]:
19            # Go over every edge connected to the node
20            weight = current_weight + graph.distances[(next_node, edge)]
21            if edge not in visited_weight_map or weight < visited_weight_map[edge]:
22                visited_weight_map[edge] = weight
23
24    return visited
25

1# A brute force approach based
2# implementation to find if a number
3# can be written as sum of two squares.
4 
5# function to check if there exist two
6# numbers sum of whose squares is n.
7def sumSquare( n) :
8    i = 1
9    while i * i <= n :
10        j = 1
11        while(j * j <= n) :
12            if (i * i + j * j == n) :
13                print(i, "^2 + ", j , "^2" )
14                return True
15            j = j + 1
16        i = i + 1
17         
18    return False
19  
20# driver Program
21n = 25
22if (sumSquare(n)) :
23    print("Yes")
24else :
25    print( "No")
26     

1    for i in range(gradient1b.shape[0]):
2        for j in range(gradient1b.shape[1]):
3            if gradient1b[i, j] > thresholdHi:
4                gradient2b[i, j] = 0
5            elif ((gradient1b[i, j] <= thresholdHi) and (gradient1b[i, j] > thresholdLo)):
6                #gradient2b[i, j] = gradient1b[i, j] #255  #Binary thresholding
7                gradient2b[i, j] = 255  #Binary thresholding
8            else:
9                gradient2b[i, j] = 0

1Python convert to c

1print("Hellow world")

1n=int(input())
2for i in range (n):
3    a,b,k=(map(int,input().split()))
4    if a>=b:
5        print(k//b)
6    else:
7        print(k//a)

1lista[2:10] = [7]

1asxxwdwdqwdqw

1def maxProd(n):
2    if (n == 2 or n == 3):
3        return (n - 1)
4    res = 1
5    while (n > 4):
6        n -= 3;
7        res *= 3;
8    return (n * res)
9n=int(input())
10print(maxProd(10));

1from collections import deque
2
3def BFS(a, b, target):
4	
5	# Map is used to store the states, every
6	# state is hashed to binary value to
7	# indicate either that state is visited
8	# before or not
9	m = {}
10	isSolvable = False
11	path = []
12	
13	# Queue to maintain states
14	q = deque()
15	
16	# Initialing with initial state
17	q.append((0, 0))
18
19	while (len(q) > 0):
20		
21		# Current state
22		u = q.popleft()
23
24		#q.pop() #pop off used state
25
26		# If this state is already visited
27		if ((u[0], u[1]) in m):
28			continue
29
30		# Doesn't met jug constraints
31		if ((u[0] > a or u[1] > b or
32			u[0] < 0 or u[1] < 0)):
33			continue
34
35		# Filling the vector for constructing
36		# the solution path
37		path.append([u[0], u[1]])
38
39		# Marking current state as visited
40		m[(u[0], u[1])] = 1
41
42		# If we reach solution state, put ans=1
43		if (u[0] == target or u[1] == target):
44			isSolvable = True
45			
46			if (u[0] == target):
47				if (u[1] != 0):
48					
49					# Fill final state
50					path.append([u[0], 0])
51			else:
52				if (u[0] != 0):
53
54					# Fill final state
55					path.append([0, u[1]])
56
57			# Print the solution path
58			sz = len(path)
59			for i in range(sz):
60				print("(", path[i][0], ",",
61						path[i][1], ")")
62			break
63
64		# If we have not reached final state
65		# then, start developing intermediate
66		# states to reach solution state
67		q.append([u[0], b]) # Fill Jug2
68		q.append([a, u[1]]) # Fill Jug1
69
70		for ap in range(max(a, b) + 1):
71
72			# Pour amount ap from Jug2 to Jug1
73			c = u[0] + ap
74			d = u[1] - ap
75
76			# Check if this state is possible or not
77			if (c == a or (d == 0 and d >= 0)):
78				q.append([c, d])
79
80			# Pour amount ap from Jug 1 to Jug2
81			c = u[0] - ap
82			d = u[1] + ap
83
84			# Check if this state is possible or not
85			if ((c == 0 and c >= 0) or d == b):
86				q.append([c, d])
87		
88		# Empty Jug2
89		q.append([a, 0])
90		
91		# Empty Jug1
92		q.append([0, b])
93
94	# No, solution exists if ans=0
95	if (not isSolvable):
96		print ("No solution")
97
98# Driver code
99if __name__ == '__main__':
100	
101	Jug1, Jug2, target = 4, 3, 2
102	print("Path from initial state "
103		"to solution state ::")
104	
105	BFS(Jug1, Jug2, target)
106
107# This code is contributed by mohit kumar 29
108