Example 1: c code to python code converter online
#include<iostream>
// Defining MAX size to 10
#define MAX 10
using namespace std;
typedef struct Edge
{
int source;
int destination;
int weight;
}Edge;
void bellman_ford_algo(int nodevertex,Edge edge[],int source_graph,int nodeedge)
{
int u,v,weight,i,j=0;
int distance[MAX];
for(i=0;i<nodevertex;i++)
{
distance[i]=999;
}
// distance of source vertex
distance[source_graph]=0;
// free all the edges nodevertex - 1 times
for(i=0;i<nodevertex-1;i++)
{
for(j=0;j<nodeedge;j++)
{
u=edge[j].source;
v=edge[j].destination;
weight=edge[j].weight;
if(distance[u]!=999 && distance[u]+weight < distance[v])
{
distance[v]=distance[u]+weight;
}
}
}
// checking for negative cycle
for(j=0;j<nodeedge;j++)
{
u=edge[j].source;
v=edge[j].destination;
weight=edge[j].weight;
if(distance[u]+weight < distance[v])
{
cout<<"\n\nNegative Cycle present..!!\n";
return;
}
}
cout<<"\nVertex"<<" Distance from source";
for(i=1;i<=nodevertex;i++)
{
cout<<"\n"<<i<<"\t"<<distance[i];
}
}
int main()
{
int nodevertex,nodeedge,source_graph;
Edge edge[MAX];
cout<<"Enter the number of vertices you want : ";
cin>>nodevertex;
printf("Enter the source vertex of the graph: ");
cin>>source_graph;
cout<<"\nEnter no. of edges you want : ";
cin>>nodeedge;
for(int i=0;i<nodeedge;i++)
{
cout<<"\nEdge Number "<<i+1<<"=";
cout<<"\nEnter source vertex here :";
cin>>edge[i].source;
cout<<"Enter destination vertex here:";
cin>>edge[i].destination;
cout<<"Enter weight here :";
cin>>edge[i].weight;
}
bellman_ford_algo(nodevertex,edge,source_graph,nodeedge);
return 0;
}
Example 2: python to c converter
import sys
def mergesort_2ndstep(l, r):
len_l = len(l)
len_r = len(r)
# initializing a list of length zero
sorted_array = []
i,j = 0,0
while i < len_l:
num1 = l[i]
for x in range(j,len_r):
num2 = r[x]
if num2 < num1 :
sorted_array.append(num2)
j += 1
sorted_array.append(num1)
i += 1
if len(sorted_array) != len_l + len_r:
# Checking extreme conditions
sorted_array[i+j:] = r[j:]
return sorted_array
def mergesort_1ststep(L,start,stop):
# a list can be divided into two
# if length of list is atleast two
if stop - start > 1:
l = mergesort_1ststep(L,start,start + (stop-start)//2)
r = mergesort_1ststep(L,start + (stop-start)//2,stop)
# mergeing two lists(sorting the l and r parts)
L[start:stop] = mergesort_2ndstep(l,r)
return L[start:stop]
# START
List_of_nums = []
file_to_open = "input1.txt"
try:
read_file = open(file_to_open,"r")
write_file = open("output.txt","w")
if read_file != None:
# appending every num from file to list_of_nums
for line in read_file:
line = int(line)
List_of_nums.append(line)
# applying mergesort
mergesort_1ststep(List_of_nums,0, len(List_of_nums))
# writing to an output file
# excluding the last element
k = List_of_nums.pop()
for num in List_of_nums:
write_file.write(f"{num}\n")
# writing last element without next line
write_file.write(f"{k}")
# closing files
read_file.close()
write_file.close()
except:
print("file not found")
Example 3: online c code to python code conversion
#include<stdio.h>
using namespace std;
void main()
{
for (int i=1, i<=5, i++)
{
for(int j=1, j<=i,j++)
{
printf("%c",64+j)
}
printf("\n")
}
}
Example 4: python code to c code converter
class Buffer:
def __init__(self,size_max):
self.max = size_max
self.data = []
class __Full:
def append(self, x):
self.data[self.cur] = x
self.cur = (self.cur+1) % self.max
def get(self):
return self.data[self.cur:]+self.data[:self.cur]
def append(self,x):
self.data.append(x)
if len(self.data) == self.max:
self.cur = 0
self.__class__ = self.__Full
def get(self):
return self.data
if __name__=='__main__':
n=input('Enter the occupide size of the buffer : ')
x=Buffer(int(n))
x.append(1); x.append(2); x.append(3); x.append(4)
print (x.__class__, x.get( ))
l=len(x.data)
print(f"The free buffer is :{l}")
print(f"The left size buffer is :{int(n)-int(l)}")
x.append(5)
print (x.__class__, x.get( ))
x.append(6)
print (x.data, x.get( ))
x.append(7); x.append(8); x.append(9); x.append(10)
print (x.data, x.get( ))
Example 5: convert python code to c online
def main():
# 4 x 4 csr matrix
# [1, 0, 0, 0],
# [2, 0, 3, 0],
# [0, 0, 0, 0],
# [0, 4, 0, 0],
csr_values = [2, 3, 1, 4,5]
col_idx = [1, 2, 0, 1,1]
row_ptr = [0, 2, 4,5]
csr_matrix = [
csr_values,
col_idx,
row_ptr
]
dense_matrix = [
[0, 3, 0],
[1, 4, 5],
[2, 0, 0],
]
res = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
]
# matrix order, assumes both matrices are square
n = len(dense_matrix)
# res = dense X csr
csr_row = 0 # Current row in CSR matrix
for i in range(n):
start, end = row_ptr[i], row_ptr[i + 1]
for j in range(start, end):
col, csr_value = col_idx[j], csr_values[j]
for k in range(n):
dense_value = dense_matrix[k][csr_row]
res[k][col] += csr_value * dense_value
csr_row += 1
print(res)
if __name__ == '__main__':
main()
Example 6: python to c converter online
np.linspace(0,1,11)