c code to python code converter code example

Example 1: c to python 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("sameeraz.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}")
	
		read_file.close()
		write_file.close()
except:
	print("file not found")

Example 2: 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 3: 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 4: 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()