python code to c code converter

1#include<iostream>
2// Defining MAX size to 10
3#define MAX 10
4
5using namespace std;
6
7typedef struct Edge
8{
9  int source;
10  int destination;
11  int weight;
12}Edge;
13
14void bellman_ford_algo(int nodevertex,Edge edge[],int source_graph,int nodeedge)
15{
16  int u,v,weight,i,j=0;
17  int distance[MAX];
18
19  for(i=0;i<nodevertex;i++)
20  {
21    distance[i]=999;
22  }
23
24  // distance of source vertex
25  distance[source_graph]=0;
26
27  // free all the edges nodevertex - 1 times
28  for(i=0;i<nodevertex-1;i++)
29  {
30    for(j=0;j<nodeedge;j++)
31    {
32      u=edge[j].source;
33      v=edge[j].destination;
34      weight=edge[j].weight;
35
36
37      if(distance[u]!=999 && distance[u]+weight < distance[v])
38      {
39        distance[v]=distance[u]+weight;
40      }
41    }
42
43  }
44
45  // checking for negative cycle
46  for(j=0;j<nodeedge;j++)
47  {
48    u=edge[j].source;
49    v=edge[j].destination;
50    weight=edge[j].weight;
51
52    if(distance[u]+weight < distance[v])
53    {
54      cout<<"\n\nNegative Cycle present..!!\n";
55      return;
56    }
57  }
58
59  cout<<"\nVertex"<<"  Distance from source";
60  for(i=1;i<=nodevertex;i++)
61  {
62    cout<<"\n"<<i<<"\t"<<distance[i];
63  }
64
65}
66
67
68int main()
69{
70  int nodevertex,nodeedge,source_graph;
71  Edge edge[MAX];
72
73  cout<<"Enter the number of vertices you want : ";
74  cin>>nodevertex;
75
76
77  printf("Enter the source vertex of the graph: ");
78  cin>>source_graph;
79
80  cout<<"\nEnter no. of edges you want : ";
81  cin>>nodeedge;
82
83  for(int i=0;i<nodeedge;i++)
84  {
85    cout<<"\nEdge Number "<<i+1<<"=";
86    cout<<"\nEnter source vertex here :";
87    cin>>edge[i].source;
88    cout<<"Enter destination vertex here:";
89    cin>>edge[i].destination;
90    cout<<"Enter weight here :";
91    cin>>edge[i].weight;
92  }
93
94  bellman_ford_algo(nodevertex,edge,source_graph,nodeedge);
95
96  return 0;
97}

1class Buffer:
2
3    def __init__(self,size_max):
4        self.max = size_max
5        self.data = []
6
7    class __Full:
8
9        def append(self, x):
10
11            self.data[self.cur] = x
12            self.cur = (self.cur+1) % self.max
13        def get(self):
14
15            return self.data[self.cur:]+self.data[:self.cur]
16
17    def append(self,x):
18
19        self.data.append(x)
20        if len(self.data) == self.max:
21            self.cur = 0
22
23            self.__class__ = self.__Full
24
25    def get(self):
26
27        return self.data
28
29
30if __name__=='__main__':
31    n=input('Enter the occupide size of the buffer : ')
32    x=Buffer(int(n))
33
34    x.append(1); x.append(2); x.append(3); x.append(4)
35
36    print (x.__class__, x.get(  ))
37    l=len(x.data)
38    print(f"The free buffer is :{l}")
39    print(f"The left size buffer is :{int(n)-int(l)}")
40
41    x.append(5)
42
43    print (x.__class__, x.get(  ))
44    x.append(6)
45    print (x.data, x.get(  ))
46    x.append(7); x.append(8); x.append(9); x.append(10)
47    print (x.data, x.get(  ))

1def main():
2  # 4 x 4 csr matrix
3  #    [1, 0, 0, 0],
4  #    [2, 0, 3, 0],
5  #    [0, 0, 0, 0],
6  #    [0, 4, 0, 0],
7  csr_values = [2, 3, 1, 4,5]
8  col_idx    = [1, 2, 0, 1,1]
9  row_ptr    = [0, 2, 4,5]
10  csr_matrix = [
11      csr_values,
12      col_idx,
13      row_ptr
14      ]
15
16  dense_matrix = [
17      [0, 3, 0],
18      [1, 4, 5],
19      [2, 0, 0],
20      ]
21
22  res = [
23      [0, 0, 0],
24      [0, 0, 0],
25      [0, 0, 0],
26      ]
27
28  # matrix order, assumes both matrices are square
29  n = len(dense_matrix)
30
31  # res = dense X csr
32  csr_row = 0 # Current row in CSR matrix
33  for i in range(n):
34    start, end = row_ptr[i], row_ptr[i + 1]
35    for j in range(start, end):
36      col, csr_value = col_idx[j], csr_values[j]
37      for k in range(n):
38        dense_value = dense_matrix[k][csr_row]
39        res[k][col] += csr_value * dense_value
40    csr_row += 1
41
42  print(res) 
43
44
45if __name__ == '__main__':
46  main()
47

1np.linspace(0,1,11)