C to solidity

UnitTesting/bit_operators/Bits_test.sol

@@ -3,7 +3,7 @@ import "./Bits.sol";
 
 contract bitsTest {
     using Bits for *;
-    
+
     function setBitTest() public {
         uint a = 35; // 35 in binary 00100011 and 01100011 is 99
         Assert.equal(a.setBit(6), 99, "working");
@@ -34,4 +34,4 @@ contract bitsTest {
         uint a = 35; // 35 in binary 00100011 and index 0 to 4 is 3
         Assert.equal(a.bits(0, 4), uint(3), "Working");
     }
-}
+}

cToSolidity/area_calculate.sol

@@ -0,0 +1,8 @@
+pragma solidity >=0.5.0;
+
+contract Area_calculate {
+    function cal(uint base, uint height) public view returns(string memory, uint) {
+      uint area = (base * height) / 2;
+      return("Area:", area);
+    }
+}

cToSolidity/bubbleSort.sol

@@ -0,0 +1,22 @@
+pragma solidity >=0.5.0;
+
+contract Bubble_sort {
+  uint[4] simpleFixArr;
+
+  function sort(uint[4] memory simpleFixArr) public view returns(uint256[4] memory) {
+      uint length = simpleFixArr.length;
+
+      for(uint i = 0; i < length; i++) {
+        for (uint j = 0; j < (length - i - 1); j++) {
+            //Compare the adjacent positions
+            if(simpleFixArr[j] > simpleFixArr[j+1]) {
+                //Swap the numbers
+                uint tmp = simpleFixArr[j];
+                simpleFixArr[j] = simpleFixArr[j+1];
+                simpleFixArr[j+1] = tmp;
+            }
+        }
+      }
+      return(simpleFixArr);
+  }
+}

cToSolidity/complex.sol

@@ -0,0 +1,20 @@
+pragma solidity ^0.5.0;
+pragma experimental ABIEncoderV2;
+contract complex {
+    struct complex {
+        int x;
+        int y;
+        uint f;
+    }
+    complex public cx;
+    function complexAddition(complex memory a, complex memory b) public view returns(complex memory c) {
+        c.x = a.x + b.x;
+        c.y = a.y + b.y;
+        return c;
+    }
+
+    function assign(int x, int y) public view returns(complex memory c) {
+        c.x = x;
+        c.y = y;
+    }
+}

cToSolidity/factorial.sol

@@ -0,0 +1,15 @@
+pragma solidity >=0.5.0;
+
+contract Factorial {
+  function fact(uint factNum) public view returns(string memory, uint, string memory, uint) {
+    uint factorial = 1;
+    if(factNum < 0) {
+      return("Error! Factorial of a negative number doesnot exist", 0, "", 0);
+    } else {
+      for(uint i = 1; i <= factNum; i++) {
+        factorial = factorial * i;
+      }
+      return("Factorial of", factNum, "is", factorial);
+    }
+  }
+}

cToSolidity/fibanacci.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.5.0;
+
+contract fibanacci {
+    function fib(uint n) public view returns(uint) {
+        uint fib = 0;
+        uint p = 1;
+        uint q = 1;
+        if(n == 1)return fib;
+        if(n == 2 || n == 3){
+            return p;
+        }
+        else {
+            for(uint i = 0; i < n-3; i++) {
+                fib = p + q;
+                p = q;
+                q = fib;
+            }
+        }
+        return q;
+    }
+}

cToSolidity/largerNumber.sol

@@ -0,0 +1,13 @@
+pragma solidity >=0.5.0;
+
+contract Larger_number {
+  function maximum(uint num1, uint num2) public view returns(uint) {
+    uint res = num1 > num2 ? num1 : num2;
+    return res;
+  }
+  function main(uint num1, uint num2, uint num3) public view returns(string memory, uint) {
+    uint max = maximum(num1, num2);
+
+    return("max is:", maximum(max, num3));
+  }
+}

cToSolidity/salary.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.5.0;
+
+contract SalaryCalc{
+    function calc(uint gross) public view returns(string memory, uint, string memory, uint) {
+        uint tax = (14 * gross)/100;
+        uint net = gross -tax;
+        return ("Income:", net, "Tax:", tax);
+    }
+}

cToSolidity/swap.sol

@@ -0,0 +1,9 @@
+pragma solidity >=0.5.0;
+
+contract Swap {
+  function swapNumber(uint num1, uint num2) public view returns(string memory, uint, string memory, uint) {
+    num1 = (num1 + num2) - num1;
+    num2 = (num1 + num2) - num2;
+    return("num1 is:", num1, "num2 is:", num2);
+  }
+}