Solidity Exercise - Inheritance/NestedArray/...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

// You may not modify this contract
contract Number {
    function getNumber() public view virtual returns (uint256) {
        return 3;
    }
}

contract InheritanceOverride is Number {
    /*
        This exercise assumes you know how overriding a function works.
        1. Override `getNumber` function in the parent contract.
        2. `getNumber` function should return uint 10.
    */
    
    // prettier-ignore
    // your code here
}

1
2
3
    function getNumber() public view override returns(uint256){
        return 10;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract InsertInArray {
    uint256[10] public arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];

    /**
     * This function is to be used to set/override the value stored at particular index in the array above (named "arr")
     */
    function replaceAtIndex(uint256 index, uint256 newValue) public {
        // your code here
        arr[index] = newValue;
    }
}

1
2
3
4
5
6
7
8
9
10
11
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract IsPrime {
    /**
     * The goal of this exercise is to return if "number" is prime or not (true or false)
     */
    function isPrime(uint256 number) public view returns (bool) {
        // your code here
    }
}

1
2
3
4
5
6
7
8
9
    function isPrime(uint256 number) public pure returns (bool) {
        // your code here
        if (number < 2) return false;
        if (number == 2) return true;
        for (uint i = 2; i < number; i++) {
            if (number % i == 0) return false;
        }
        return true;
    }

1
2
3
4
5
6
7
8
9
10
11
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract IsSorted {
    /**
     * The goal of this exercise is to return true if the members of "arr" is sorted (in ascending order) or false if its not.
     */
    function isSorted(uint256[] calldata arr) public view returns (bool) {
        // your code here
    }
}

1
2
3
4
5
6
7
    function isSorted(uint256[] calldata arr) public view returns (bool) {
        // your code here
        for (uint256 i = 0; i < arr.length; i++) {
            if ((i+1) < arr.length && arr[i] > arr[i+1]) return false;
        }
        return true;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract Mean {
    /**
     * The goal of this exercise is to return the mean of the numbers in "arr"
     */
    function mean(uint256[] calldata arr) public view returns (uint256) {
        // your code here
        uint256 sum = 0;
        for(uint32 i=0; i<arr.length; i++){
            sum += arr[i];
        }
        return sum / arr.length;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract X {
    uint256 public constant x = 42;
}

contract Y {
    uint256 public constant y = 24;
}

contract MultiInheritance {
    /**
     * The goal of this exercise is to use the functionality of contracts X and Y without pasting their code here or making an external call or delegate call
     */
    uint256 public x;
    uint256 public y;
    constructor(){
        X contractX = new X();
        Y contractY = new Y();
        x = contractX.x();
        y = contractY.y();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract NestedArray {
    uint256[][] public arr;

    function setArr(uint256[][] memory newArr) public {
        arr = newArr;
    }

    /**
     * This function is expected to get the sum of all members of each nested array and finally return the sum of all the nested sums
     * Example: [[1,2], [3,4]] this should return 1 + 2 + 3 + 4 = 10
     */
    function getNestedSum() public view returns (uint256) {
        // your code here
        uint256 sum = 0;
        for (uint256 i=0; i < arr.length; i++){
            for (uint256 j=0; j < arr[i].length; j++){
                sum += arr[i][j];
            }
        }

        return sum;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract NestedMapping {
    /* This exercise assumes you know how nested mappings work.
        1. Create a public nested mapping of (address => uint256 => bool).
        2. The name of the mapping must be `nestedBool`
        3. Set the boolean value of the arguments to `true` in the 'setNestedDetails' function
        4. use the 'returnNestedDetails' function to return the values of a nested data
    */

    function setNestedDetails(address _addr, uint256 _num) public {
        // your code here
    }

    function returnNestedDetails(
        address _addr,
        uint256 _num
    ) public view returns (bool) {
        // your code here
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    mapping(address => mapping(uint256 => bool)) nestedBool;

    function setNestedDetails(address _addr, uint256 _num) public {
        // your code here
        nestedBool[_addr][_num] = true;
    }

    function returnNestedDetails(
        address _addr,
        uint256 _num
    ) public view returns (bool) {
        // your code here
        return nestedBool[_addr][_num];
    }

1
2
3
4
5
6
7
8
9
10
11
12
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract NotEnough {
    /* This exercise assumes you know how require statements works.
    The function below should only be called with a number greater than 10,
    else it reverts. */
    function largeEnough(uint256 _number) external pure {
        // add code here
        require(_number > 10, "_number should greater than 10");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;
import "forge-std/console.sol";

contract OneWeekLockup {
    /**
     * In this exercise you are expected to create functions that let users deposit ether
     * Users can also withdraw their ether (not more than their deposit) but should only be able to do a week after their last deposit
     * Consider edge cases by which users might utilize to deposit ether
     *
     * Required function
     * - depositEther()
     * - withdrawEther(uint256 )
     * - balanceOf(address )
     */

    mapping(address => uint256) userBalance;
    mapping(address => uint256) lastDeposit;

    function balanceOf(address user) public view returns (uint256) {
        // return the user's balance in the contract
        return userBalance[user];
    }

    function depositEther() external payable {
        /// add code here
        userBalance[msg.sender] += msg.value;
        lastDeposit[msg.sender] = block.timestamp;
    }

    function withdrawEther(uint256 amount) external {
        /// add code here
        console.log("last deposit: ", lastDeposit[msg.sender]);
        console.log("last deposit + 1 weeks: ", lastDeposit[msg.sender] + 1 weeks);
        console.log("timestamp: ", block.timestamp);
        require(amount <= userBalance[msg.sender], "widthdraw amount should not greater than balance");
        require(block.timestamp >= (lastDeposit[msg.sender] + 1 weeks), "should only be able to widthdraw a week after their last deposit");

        payable(msg.sender).transfer(amount);
    }
}

1
2
3
4
5
6
7
8
9
10
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract PriceIsRight {
    /// @dev make this function revert unless exactly 1 ether is sent as value in the function call
    function buy() public payable {
        /// your code here
        require(msg.value == 1 ether);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract Receive {
    // solidity smart contracts cannot receive
    // ether by default. They need a receive
    // function. See here:
    // https://docs.soliditylang.org/en/v0.8.17/contracts.html#receive-ether-function
    function receive() external payable{

    }
}

1
2
3
    receive() external payable{

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract SelfDestroyer {
    /* This exercise assumes you know the selfdestruct function works.
        1. The contract has some ether in it, 
        destroy the contract and send all ether to an address 
        2. The name of the function must be `destroy`,
        that takes a non-payable address input
    */

    constructor() payable {}

    function destroy(address taker) external {
        // your code here
        selfdestruct(payable(taker));
    }

    function getBalance() public view returns (uint256 balance) {
        balance = address(this).balance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;
import "forge-std/console.sol";
contract Stack {
    /*
        This exercise assumes you understand what a stack is and know how to manipulate it.
        1. Implement a stack using an array `stack` with the following functions:
            a. `push` function appends a new value to the end of the array.
            b. `peek` function returns the last element of the array without removing it, 
               but first checks if the stack is not empty.
            c. `pop` function returns the last element of the array and removes it from 
               the stack, but also checks if the stack is not empty.
            d. `size` function returns the length of the array, which corresponds to
               the number of elements in the stack.
            e. `getStack` function returns the stack.
    */

    uint256[] stack;

    constructor(uint256[] memory _stack) {
        stack = _stack;
    }

    // your code here
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    function push(uint256 n) public {
        stack.push(n);
        console.log("length of array: ", stack.length);
    }

    function peek() public returns(uint256 e){
        e = stack[stack.length-1];
        console.log("length of array: ", stack.length);
    }

    function pop() public returns(uint256 e){
        e = stack[stack.length-1];
        stack.pop();
    }

    function size() public returns(uint256 s) {
        s = stack.length;
    }

    function getStack() public returns(uint256[] memory){
        return stack;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract StudentDB {
    /* This exercise assumes you know how structs works.
   create a struct `Student` for a student who's name is `John` and age is `12`.
   Return John's age in the function below */

    struct Student {
        string name;
        uint256 age;
    }
    Student student;

    constructor() {
        createStudent("John", 12);
    }

    // create Student's data
    function createStudent(string memory _name, uint256 _age) public {
        // your code here
        student = Student(_name, _age);
    }

    // return struct data
    function getEntireStruct() public view returns (Student memory) {
        // your code here
        return student;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract SumArray {
    function sumArray(uint256[] calldata arr) public pure returns (uint256) {
        // your code here
        // arr is a list of unsigned integers
        // return the sum of them. If the array
        // is empty, return 0
        if (arr.length < 1) return 0;
        uint256 sum = 0;
        for (uint256 i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract TicTacToe {
    /* 
        This exercise assumes you know how to manipulate nested array.
        1. This contract checks if TicTacToe board is winning or not.
        2. Write your code in `isWinning` function that returns true if a board is winning
           or false if not.
        3. Board contains 1's and 0's elements and it is also a 3x3 nested array.
    */

    function isWinning(uint8[3][3] memory board) public pure returns (bool) {
        // your code here
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    function isWinning(uint8[3][3] memory board) public pure returns (bool) {
        // your code here
        if (checkWin(board[0]) ||
            checkWin(board[1]) ||
            checkWin(board[2]) ||

            checkWin([board[0][0], board[1][0], board[2][0]]) ||
            checkWin([board[0][1], board[1][1], board[2][1]]) || 
            checkWin([board[0][2], board[1][2], board[2][2]]) ||

            checkWin([board[0][0], board[1][1], board[2][2]]) ||
            checkWin([board[0][2], board[1][1], board[2][0]]) 
            ) {
                return true;
        }

        return false;

    }

    function checkWin(uint8[3] memory arr) private pure returns(bool) {
        uint8 sum = 0;
        for (uint8 i =0; i<arr.length; i++) {
            sum += arr[i];
        }

        return sum == 3;
    }