Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.8.1+commit.df193b15.js&optimize=false&runs=200&gist=

1_Storage.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}

2_Owner.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

3_Ballot.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.8.0;

/** 
 * @title Ballot
 * @dev Implements voting process along with vote delegation
 */
contract Ballot {
   
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    struct Proposal {
        // If you can limit the length to a certain number of bytes, 
        // always use one of bytes1 to bytes32 because they are much cheaper
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /** 
     * @dev Create a new ballot to choose one of 'proposalNames'.
     * @param proposalNames names of proposals
     */
    constructor(bytes32[] memory proposalNames) {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            // 'Proposal({...})' creates a temporary
            // Proposal object and 'proposals.push(...)'
            // appends it to the end of 'proposals'.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    
    /** 
     * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
     * @param voter address of voter
     */
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    /**
     * @dev Delegate your vote to the voter 'to'.
     * @param to address to which vote is delegated
     */
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");
        require(to != msg.sender, "Self-delegation is disallowed.");

        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    /**
     * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
     * @param proposal index of proposal in the proposals array
     */
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If 'proposal' is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    /** 
     * @dev Computes the winning proposal taking all previous votes into account.
     * @return winningProposal_ index of winning proposal in the proposals array
     */
    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    /** 
     * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
     * @return winnerName_ the name of the winner
     */
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

chap5.sol

pragma solidity 0.8.0;

contract Practice1{
    
function PaymentInput() public payable {
    
}

function CheckBalance() public view returns(uint) {
    return address(this).balance;
}

function getVAlue(int a) public view returns(string memory) {
    if (a >= 80 && a <= 100) {
        return "Grade A"; }
}

    
}

conversion.sol

pragma solidity 0.8.0;

contract Practice1{

//impl
// function impPractice() public view returns(int16) {
//     int8 a = 30;
//     int16 b = a;
//     return b;
// }

// expl
// function expPractice() public view returns(uint8) {
//   uint16 a = 500;
//   uint8 b = uint8(a);
//   return b;
// }

// expl
// function expPractice1() public view returns(uint16) {
//   uint16 a = 500;
//   uint8 b = uint8(a);
//   return b;
// }

function bytePractice() public view returns(bytes memory) {
    string memory abc = "mudassir";
    bytes memory bConver = bytes(abc);
    return bConver;
}
}

faucet.sol

pragma solidity 0.5.0;

contract Faucet {

    // give out ether to anyone who wants it
    function withdraw (uint withdraw_amount) public {
        
        //limit withrawl amount
        require(withdraw_amount <= 1000000000000000000);
        
        // send the amount the address that requrested it
        msg.sender.transfer(withdraw_amount);
    }
    
    //accept any incomeing amount
    function () external payable {}
}

function-qual.sol

pragma solidity ^0.5.0;

contract qualifier {
    
    uint8 age = 45;
    
    function anOther() public pure {
      
    }
    
    function getAge() public view returns (uint8) {
        uint8 a = age*2;
        anOther();
        return a;
    }
    
}

inheritance.sol

pragma solidity ^0.8.0;

contract Human {
    uint private age;
    function getAge() public view returns(uint) {
        return age;
        
    }
    
    function setAge(uint _age) public {
        age = _age;
    }
}

contract Tariq is Human {
    
     Human ah = new Human();
    function setTariqBio(uint b) public returns(uint) {
       
        setAge(b);
        return getAge();
    }
}

mapping.sol

pragma solidity 0.8.0;

contract Practice1{

mapping(int => string) names;

function updateValue(int a , string memory b) public {
    names[a] = b;
}

function getValue(int a) public view returns(string memory) {
    return names[a];
}
}

mapping2.sol

pragma solidity 0.8.0;

contract Practice1{

mapping(string => mapping(int => string)) PiaicCourses;


function addCourses(string memory RollNo, int KeyVal ,string memory course) public{
    PiaicCourses[RollNo][KeyVal] = course;
    
}

function getCourses(string memory RollNo , int KeyVal) public view returns(string memory){
    return PiaicCourses[RollNo][KeyVal];
}
}

modify.sol

pragma solidity ^0.5.0;
//pragma experimental ABIEncoderV2;
/// Created by Tariq Saeed

contract myModifiers {
  
    event daikhLo(string);
    
    modifier verifyAge(uint8 a) {
        
        if(a > 18) {
            _;
        } 
        else { 
            emit daikhLo("He is Under age kid");
                    }
    }
    
    function watchMovie(uint8 Age) public verifyAge(Age) returns (string memory) {
        
        return "You can watch any movie buddy";
//         return true;
    }
}

myfirst.sol

pragma solidity 0.8.0;

contract Variables{
    
    int internal age = 20;
    string name = "Tariq";
    bool isFeePaid = true;
    uint8 count = 34;
    
    
}

prac1.sol

pragma solidity ^0.4.24;

contract MyContractn {
    string value;
    
    constructor() public{
        value = "myValue";
    }
    
    function get() public view returns(string){
        return value;
        
    }
    function set(string _value) public{
        value = _value;
    } 
}

prac2.sol

pragma solidity 0.8.0;

contract modifierFunction {
 
 modifier verifyAge(uint a) {
     if(a > 18){
         _;
     }
 }
 
  modifier verifyHeight(uint h) {
     if(h > 6){
         _;
     }
 }
 
 function getModifier(uint _age , uint _height) public view verifyAge(_age) verifyHeight(_height) returns(string memory) {
     return "yes both values are true";
 }
 
//   function getModifier(uint _age) public view verifyAge(_age) returns(uint) {
//      return _age;
//  }
 
}

struct.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

contract Structures {

    enum Gender {
        male,
        female
    }

    
    struct Student {
        
        string name;
        uint8 age;
        bool isFeePaid;
        Gender gender;
    }
    
    function getRecord() public view returns (Student memory) {
        
        Student memory s1 = Student("Tariq Saeed", 45, false, Gender.male);
        return s1;
    }
    
    
}

structArray.sol

pragma solidity 0.8.0;

contract Practice1{
    struct Human {
        string name;
        unit age;
    }
    
function checkArray() public {
    Human[1] memory human1 = [Human("abc", 20)];
    
}
}

tuple.sol

pragma solidity ^0.5.0;

contract Tuple {

    enum Days {
        sunday,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday,
        saturday
    }    
    
    function getValues() public view returns (uint16 a, bool b) {
       a = 45;
       b = true;
       return (a,b);
       
    }
    
    function getDays() public view returns (Days d){
        
        d = Days.saturday;
        return d;
    }
}