contract Conference {

address public organizer;

mapping (address =>uint)
public registrantsPaid;
uint public numRegistrants;
uint public quota;
// so you can log these
events
event Deposit(address
_from, uint _amount);
event Refund(address _to,
uint _amount);
function Conference() {
// Constructor
organizer = msg.sender;
quota = 500;
numRegistrants = 0;
}
function buyTicket()
public returns (bool
success) {
if (numRegistrants>=
quota) { return false; } //
see footnote
registrantsPaid[msg.sender]
= msg.value;
numRegistrants++;
Deposit(msg.sender,
msg.value);
return true;
}
function
changeQuota(uintnewquota)
public {
if (msg.sender !=
organizer) { return; }
quota = newquota;
}
function
refundTicket(address
recipient, uint amount)
public {
if (msg.sender !=
organizer) { return; }
if
(registrantsPaid[recipient]
== amount) {
address myAddress =
this;
if
(myAddress.balance>=
amount) {
recipient.send(amount);
registrantsPaid[recipient]
= 0;
numRegistrants--;
Refund(recipient,
amount);
}
}
}
 function destroy() { //
so funds not locked in
contract forever
if (msg.sender ==
organizer) {
suicide(organizer);
// send funds to organizer
}
}
}

Program 1:

/* Another very basic contract. It demonstrates that a contract can retrieve and store the balance of its creator address.
Note that the creatorbalance value captured in the constructor is a snapshot in time. Later on, creator.balance will reflect whatever
it is now.
*/
pragma solidity >=0.4.0 <0.6.0;
contractcreatorBalanceChecker {
address creator;
uintcreatorbalance;
functioncreatorBalanceChecker() public
{
creator = msg.sender;
creatorbalance = creator.balance;
}

functiongetContractAddress() public view returns (address)

{
return this;
}

functiongetCreatorBalance() public view returns (uint) {

returncreatorbalance;
}

functiongetCreatorDotBalance() public view returns (uint) {

returncreator.balance;
}

/**********
Standard kill() function to recover funds
**********/

/* function kill() public

{
if (msg.sender == creator)
suicide(creator); // kills this contract and sends remaining funds back to creator
}*/

}
=====================================================================================================

pragma
solidity
^0.4.18;
contract Election {
 // Model a Candidate
struct Candidate {
uint id;
string name;
uintvoteCount;
}
// Store accounts that have voted
mapping(address => bool) public voters;
// Store Candidates
// Fetch Candidate
mapping(uint => Candidate) public candidates;
// Store Candidates Count
uint public candidatesCount;
// voted event
event votedEvent (
uint indexed _candidateId
);
function Election () public {
addCandidate("KamalHaasan");
addCandidate("RajniKanth");
}
function addCandidate (string _name) private {
candidatesCount ++;
candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
}
function vote (uint _candidateId) public {
// require that they haven't voted before
require(!voters[msg.sender]);
// require a valid candidate
require(_candidateId> 0 && _candidateId<= candidatesCount);
// record that voter has voted
voters[msg.sender] = true;
// update candidate vote Count
candidates[_candidateId].voteCount ++;
// trigger voted event
votedEvent(_candidateId);
}
}

//section 1
pragma solidity ^0.4.18;
contractmysecondcontract{
string private name;
uint private age;

functionsetname(string newName) {
name=newName;
}
functiongetName() returns (string) {
return name;
}

functionsetAge(uintnewAge) {
age=newAge;
}
functiongetAge() returns (uint) {
return age;
}

pragma solidity ^0.4.19;

contractmyfirstcontract{

string public greeting;

address public owner;

eventGreetingChanged(string oldGreeting, string newGreeting);

functionmyfirstcontract(string _greeting) {

greeting= _greeting;

owner=msg.sender;

functionsetGreeting(string _greeting) {

require(owner ==msg.sender);

GreetingChanged(greeting, _greeting);

greeting= _greeting;

pragma solidity ^0.4.18;

contract Counter {
uint256 count; // persistent contract storage

function Counter(uint256 _count) public {

count = _count;
}

function increment() public {

count += 1;
}

functiongetCount() public view returns (uint256) {

return count;
}
}
pragma solidity ^0.4.22;
contracthelloWorld {
functionrenderHelloWorld () public pure returns (string) {
return 'helloWorld';
}
}

pragma solidity ^0.5.0;

contract Calculator {

function add(int a, int b) public pure returns (int){

return (a+b);
}
function sub(int a, int b) public pure returns (int){
return (a-b);
}
functionmul(int a, int b) public pure returns (int){
return (a*b);
}
function div(int a, int b) public pure returns (int){
return (a/b);
}
}

pragma solidity >=0.4.0 <0.6.0;

contractSimpleStorage {
uintstoredData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
returnstoredData;
}
}

pragma solidity ^0.4.8;

contractRevenueSharing {
address public creator;
mapping(uint => address) public shareholders;
uint public numShareholders;

event Disburse(uint _amount, uint _numShareholders);

functionRevenueSharing(address[] addresses) {
creator = msg.sender;
numShareholders = addresses.length;
for (uint i=0; i<addresses.length; i++) {
shareholders[i] = addresses[i];
}
}

functionshareRevenue() payable returns (bool success) {

uint amount = msg.value / numShareholders;
for (uint i=0; i<numShareholders; i++) {
if (!shareholders[i].send(amount)) revert();
}
Disburse(msg.value, numShareholders);
return true;
}

function kill() {
if (msg.sender == creator) selfdestruct(creator);
}
}
pragma solidity ^0.4.18;

contractshapeCalc {
function rectangle(uint h, uint w) public view returns (uint p, uint s) {
p = 2 * (h + w);
s = h * w;
}
}

pragma solidity^0.4.21;

contractStack{
uint[]stack;

functionpush(uintdata)public{
stack.push(data);
}

functionpop()publicreturns(uintdata){
data=stack[stack.length-1];

stack.length-=1;
}
}
https://medium.com/openberry/deploying-smart-contracts-with-truffle-1c056b452cde