source code software penghitung nilai resistor pada rangkaian seri paralel campuran dengan bahasa c++ :

=========================begin===============================
#include
#include
#include

int menu,jumcampur,jumseri,jum,jumsp,jump,loop,z,y,x,n,i,j,m;
char menu1;
float resistor[100],serin[100],seripa[100],serip,a=1,b,Seri,atas,bawah=1,perrp,rp,tot,sp;

float seri()
{
printf(“Program untuk menghitung rangkaian Resistor Seri\n”);
printf(“jumlah res : “);scanf(“%d”, &jum);
for (loop=0; loop
{
printf (“masukkan nilai resistor ke %d: “,loop+1);
scanf(“%g”, &resistor[loop]);
Seri=Seri+resistor[loop];
}
printf(“Resistor Seri adalah %g\n”, Seri);
}

float paralel()
{
printf(“Program untuk menghitung rangkaian Resistor Paralel\n”);
printf(“Jumlah resistor yang diparalel : “);scanf(“%d”, &jum);
for (loop=0; loop
{
printf (“Masukkan nilai resistor ke %d: “,loop+1);
scanf(“%g”, &resistor[loop]);
}

for (y=0; y
{
a=a*resistor[y];
}

for (z=0; z
{
b=b+(a/resistor[z]);
}
atas=b;
for(x=0; x
{
bawah=bawah*resistor[x];
}
perrp=atas/bawah;
rp=bawah/atas;
printf(“Resistor 1/rp adalah %g\n”, perrp);
printf(“Resistor Paralel adalah %g\n”, rp);
}

float seriparalel()
{
Seri,sp,rp=0;
printf(“Program untuk menghitung rangkaian Resistor Campuran\n”);
printf(“Apakah ada resistor seri yang tidak diparalel? (y/n)”);
scanf(“%s”, &menu1);
if ((menu1==’Y') || (menu1==’y'))
{
printf(“Jumlah res seri: “);
scanf(“%d”, &jumseri);
for (i=0; i
{
printf (“Masukkan nilai resistor seri ke %d: “,i+1);
scanf(“%g”, &resistor[i]);
Seri=Seri+resistor[i];
}
}
else
{
printf(“\n”);
}

printf(“\n”);

printf(“Apakah ada resistor seri yang diparalel? (y/n)”);
scanf(“%s”, &menu1);
if ((menu1==’Y') || (menu1==’y'))
{
printf(“Jumlah resistor seri yang diparalel : “);
scanf(“%d”, &jumsp);
for (m=0; m
{
serip=0;
printf (“Masukan jumlah resistor seri paralel ke %d: “,m+1);
scanf(“%d”, &n);
for (x=0; x
{
printf (“masukkan nilai resistor seri ke %d untuk resistor seri paralel ke %d: “,x+1,m+1);
scanf(“%g”, &serin[x]);
serip=serip+serin[x];
}
seripa[m]=serip;
}
for (y=0; y
{
a=a*seripa[y];
}
for (z=0; z
{
b=b+(a/seripa[z]);
}
atas=b;
for(j=0; j
{
bawah=bawah*seripa[j];
}
sp=bawah/atas;
}
else
{
printf(“\n”);
}
a,bawah=1;
b=0;
printf(“\n\nApakah ada resistor paralel tanpa seri? (y/n)”);
scanf(“%s”, &menu1);
if ((menu1==’Y') || (menu1==’y'))
{
printf(“\n\nMasukkan jumlah resistor paralel : “);scanf(“%d”, &jump);
for (loop=0; loop
{
printf (“masukkan nilai resistor paralel ke %d: “,loop+1);
scanf(“%g”, &resistor[loop]);
}
for (y=0; y
{
a=a*resistor[y];
}
for (z=0; z
{
b=b+(a/resistor[z]);
}
atas=b;
for(x=0; x
{
bawah=bawah*resistor[x];
}
rp=bawah/atas;
}
else
{
printf(“\n”);
}

tot=Seri+sp+rp;
printf(“Nilai Total rangkaian = %g\n”,tot);
}

main()
{

puts(“Menu menghitung rangkaian resistor\n”);
puts(“1. Rangkaian Resistor Seri\n”);
puts(“2. Rangkaian Resistor Paralel\n”);
puts(“3. Rangkaian Resistor Campuran\n”);
puts(“4. Exit\n”);
printf(“Masukkan Angka (1-4) untuk memilih menu : “);
scanf(“%d”, &menu);

switch (menu)
{
case 1:seri();break;
case 2:paralel();break;
case 3:seriparalel();break;
}
getch();
}

/**********************************************/
/* salam, admin http://inilahjalanku.com */
/**********************************************/

=========================end================================

namun sayangnya, masih terdapat error untuk event-event terentu. namun secara garis besar program ini sudah berjalan baik. dan anda bisa menyempurnakanya.

untuk source code lengkapnya jika anda malas copas (copas ja malas… ckckck ) bisa download di :

disini

/*rata array*/
#include “stdio.h”

main()

{
int maks;
float arr [100];
float total;
float rata;
int i;

printf (“Masukkan jumlah data : “);
scanf (“%d”, &maks);
for (i=0; i<maks; i++)
{
printf (“masukkan nilai : “);
scanf(“%f”, &arr[i]);
}

for (i=0; i<maks; i++)
{
total=0;
for (i=0; i<maks; i++)
total=total+arr[i];
}
rata=total/maks;
printf(“rata=%.2f\n”, rata);
}

nih source code nya… tapi inget, pelajari lho ya? jangan asal copas…

#include
#include “conio.h”

int minimum(int []); /* prototype fungsi dlm ANSI */
int maksimum (int []);

int main()
{
int nilai[100], i, j, k, kecil, besar, min, maks, N;
printf (“Masukkan jmlah angka yang ingin di cari nilai max&min : “);
scanf (“%d”, &N);
printf(“Masukkan %d bil integer dipisahkan dgn spasi :\n”, N);
for (i=0; i
scanf(“%d”, &nilai[i]);
min = nilai[0];
for (j=1; j < N; j++)
if (nilai[j] < min)
min = nilai[j];
maks = nilai[0];
for (k=1; k < N; k++) if (nilai[k] > maks)
maks = nilai[k];
kecil = min;
besar = maks;
printf(“\nBilangan terkecil adalah %d\n”, kecil);
printf(“\nBilangan terbesar adalah %d\n”, besar);
getche();
}

/*int minimum(int nilai[100])
{
int min, j, N;
min = nilai[0];
for (j=1; j < N; j++)
if (nilai[j] < min)
min = nilai[j];
return(min);
}

int maksimum(int nilai[100])
{
int maks, k, N;
maks = nilai[0];
for (k=1; k < N; k++) if (nilai[k] > maks)
maks = nilai[k];
return(maks);
}*/

hehehe…. seperti biasa, ada versi downloadnya… biar enak.. monggo, silakan download

download disini

oke, ga usah kebanyakan teori, kita langsung ke contoh source code:

stack.h
————————————-begin—————————
#define stack_H
#define stack_H

#include
#include
#include
#include
#include

#define nil NULL
#define info(P) (P)->info
#define next(P) (P)->next
#define firstStack(S) ((S).firstStack)
#define lastStack(S) ((S).lastStack)

typedef int infotype;
typedef struct tElmtStack *address;
typedef struct tElmtStack{
infotype info;
address next;
}ElmtStack;
typedef struct{
address firstStack;
address lastStack;
}Stack;

bool stackEmpty(Stack S);
void createStack(Stack *S);
void bacaStack(infotype *x);
void tulisStack(Stack S);
address Alokasi(infotype x);
void Dealokasi(address P);
void Push(Stack *S,infotype x);
void Pop(Stack *S);

bool stackEmpty(Stack S){
return ((firstStack(S)==nil)&&(lastStack(S)==nil));
}

void createStack(Stack *S){
firstStack(*S)=nil;
lastStack(*S)=nil;
}

void bacaStack(infotype *x){
printf(“\nMasukkan data: “);scanf(“%d”,&(*x));
}

void tulisStack(Stack S){
address P;
P=firstStack(S);
printf(“Data Stack:\n”);
while(P!=nil)
{
printf(“%d\n”,info(P));
P=next(P);
}
}

address Alokasi(infotype x){
address P;
P=(address)malloc(sizeof(ElmtStack));
if(P!=nil)
{
info(P)=x;
next(P)=nil;
}
return P;
}

void Dealokasi(address P){
free(P);
}

void Push(Stack *S,infotype x)
{
address P;
P=Alokasi(x);
if(P!=nil)
{
if(stackEmpty(*S))
{
lastStack(*S)=P;
}
next(P)=firstStack(*S);
firstStack(*S)=P;
}
}

void Pop(Stack *S)
{
address P;
P=firstStack(*S);
if(!stackEmpty(*S))
{
if(P==lastStack(*S))
{
Dealokasi(P);
firstStack(*S)=nil;
lastStack(*S)=nil;
}
else
{
firstStack(*S)=next(P);
Dealokasi(P);
}
}
}
——————————end———————————–



teststack.cpp
——————————-begin—————————–
#include
#include”stack.h”

main(){
Stack S;
infotype x;
createStack(&S);

bacaStack(&x);
Push(&S, x);
cout<<”Push\n”<
tulisStack(S);

bacaStack(&x);
Push(&S, x);
cout<<”Push\n”<
tulisStack(S);

bacaStack(&x);
Push(&S, x);
cout<<”Push\n”<
tulisStack(S);

Pop(&S);
cout<<” Pop\n”<
tulisStack(S);

Pop(&S);
cout<<” Pop\n”<
tulisStack(S);

}
———————————-end————————-

yah… seperti biasa.. saya selalu baik hati… jadi saya siapkan link download untuk mendownload file cpp dan header nya… silakan..

download disini

operator terhadap list adalah sebagai berikut:
Insert / tambah : menyisipkan sebuah elemen list
Delete / hapus : menghapus sebuah elemen list

Operator tambahan untuk list adalah :
Empty List : fungsi boolean yang mengirimkan nilai true jika list kosong.
Inisialisasi list : menginisialisasi (memberi nilai awal) list
Allocate : memesan alamat (address) yang belum digunakan
Deallocate : membebaskan alamat yang sudah tidak diperlukan lagi.

dan berikut saya sertakan source code linked list sederhana dengan bahasa c++ beserta sedikit penjelasan dalam wujud coment. lagi-lagi saya mohon kepada anda, kawan-kawan untuk tidak sekedar copy-paste code. melainkan mempelajari kemudian mengembangkannya. ini demi kebaikan anda juga.

source code:
list.h
———————————begin——————————

#ifndef list_H
#define list_H

#include
#include
#include
#include
#include

#define nil NULL
#define info(P) (P)->info
#define next(P) (P)->next
#define first(L) ((L).first)
#define last(L) ((L).last)

typedef int infotype;
typedef struct tElmtList *address;
typedef struct tElmtList
{
infotype info;
address next;
} ElmtList;
typedef struct
{
address first;
address last;
} List;

/* PROTOTYPE */

/* TEST LIST KOSONG */
bool ListEmpty(List L);
/* mengirimkan firs(L)==nil dan list(L)==nil */

/* PEMBUATAN LIST KOSONG */
void CreateList(List *L);
/* membuat list kosong first(*L)=nil dan list(*L)=nil */

/* INPUT /OUTPUT */
void BacaList(infotype *x);
/* menerima dan mengirimkan masukan list */
void TulisList(List L);
/* menampilkan elemen list */

/* MANAJEMEN MEMORY */
address Alokasi(infotype x);
/* mengirimkan address hasil alokasi sebuah elemen */
/* jika alokasi berhasil,address tidak nil */
/* jika alokasi gagal,mengirimkan nil */
void Dealokasi(address P);
/* menerima input P yang terdefinisi */
/* address P dikembalikan ke sistem */
/* melakukan dealokasi/pengembalian address P */

/* PENAMBAHAN ELEMEN */
void InsertFirst(List *L,infotype x);
/* melakukan alokasi untuk elemen x */
/* menambahkan elemen pada posisi pertama jika alokasi berhasil */
void InsertPos(List *L,infotype x,int Pos);
/* mnelakukan alokasi untuk elemen x */
/* mencari posisi untuk menempatkan elemen x */
/* menambahkan elemen x posisi yang sudah di tentukan */
void InsertLast(List *L,infotype x);
/* melakukan alokasi untuk elemen x */
/* jika list kosong,maka melakukan InsertFirst */
/* menambahkan elemen x pada posisi terakhir jika alokasi berhasil */

/* PENGHAPUSAN ELEMEN */
void DeleteFirst(List *L);
/* jika list kosong maka tidak melakukan apa-apa */
/* jika hanya satu elemen maka first(*L)=nil dan last(*L)=nil,dealokasi alamat P */
/* jika lebih dari satu elemen,dealokasi alamat P yang pertama */
void DeletePos(List *L,int Pos);
/* jika list kosong maka tidak melakukan apa-apa */
/* jika Posisi elemen yang ingin di hapus tidak ketemu maka tidak melakukan apa-apa */
/* jika Posisi ditemukan maka dealokasi alamat pada posisi tersebut */
void DeleteLast(List *L);
/* jika list kosong maka tidak melakukan apa-apa */
/* jika hanya satu elemen maka melakukan DeleteFirst */
/* jika lebih dari satu elemen,maka menghapus posisi terakhir dan dealokasi alamat terakhir */
void Max(List L);
void Min(List L);
void Search(List L);

/* BODY */
void Max(List L)
{
address P;
P=first(L);
int x;
x=0;
while (P!=nil){
if(x<=info(P))
{
x=info(P);
}
P=next(P);
}
cout<=info(P))
{
x=info(P);
}
P=next(P);
}
cout<
}

void Search(List L)
{
address P;
P=first(L);
int s,k=2;
cout<<”\nNilai yang ingin dicari: “;
while(P!=nil){
if(s==info(P)){
cout<
break;
}
P=next(P);
k++;
}
}

/* TEST LIST KOSONG */
bool ListEmpty(List L)
{
return ((first(L)==nil)&&(last(L)==nil)); /* mengirimkan first(L)==nil dan list(L)==nil */
}

/* PEMBUATAN LIST KOSONG */
void CreateList(List *L)
{
first(*L)=nil;
last(*L)=nil;
}

/* INPUT /OUTPUT */
void BacaList(infotype *x)
{
printf(“\nMasukkan data : “); scanf(“%d”,&(*x));
printf(“”);
}

void TulisList(List L)
{
address P;
P=first(L);
printf(“Data List=”);
while (P!=nil)
{
printf(” %d”,info(P));
P=next(P);
}
}

/* MANAJEMEN MEMORY */
address Alokasi(infotype x)
{
address P;
P=(address)malloc(sizeof(ElmtList));
if (P!=nil)
{
info(P)=x;
next(P)=nil;
} /* end if (P!=nil) */
return P; /* mengirimkan alamat hasil alokasi */
}

void Dealokasi(address P)
{
free(P); /* melakukan dealokasi/pengembalian address P */
}

/* PENAMBAHAN ELEMEN */
void InsertFirst(List *L,infotype x)
{
address P;
P=Alokasi(x); /* alokasi memori unruk elemen x */
if (P!=nil)
{ /* jika alokasi P tidak nil */
if (ListEmpty(*L))
{ /* jika list kosong */
last(*L)=P;
} /* end if list kosong */
next(P)=first(*L);
first(*L)=P; /* elemen pertama di isi P */
} /* end if alokasi tidak nil */
}

void InsertPos(List *L,infotype x,int Pos)
{
address P,Ppos;
int i=1;
Ppos=Alokasi(x);
P=first(*L);
if ((P==nil)&&(Pos==1))
{ /* jika list kosong dan posisi = 1*/
next(Ppos)=P;
first(*L)=Ppos;
last(*L)=Ppos;
}
else
{
if ((P!=nil)&&(Pos==1))
{
next(Ppos)=P;
first(*L)=Ppos;
}
else
{ /* jika listtidak kosong dan posisi != 1*/
while ((next(P)!=nil)&&((i+1)

{ /* masuk looping ketika ((next(P)!=nil)&&(i+1
i+=1; /* setiap looping i bertambah 1 */
P=next(P);
} /* end while ((next(P)!=nil)&&(i+1
if (((i+1)==Pos)&&(next(P)!=nil))
{ /* jika (i+1==Pos) */
next(Ppos)=next(P);
next(P)=Ppos;
}
else
{ /* jika (i+1!=Pos) */
next(P)=Ppos;
last(*L)=Ppos;
} /* endif (i+1==Pos) */
}
} /* end if ((P==nil)&&(Pos==1)) */
}

void InsertLast(List *L,infotype x)
{
address P;
P=Alokasi(x);
if (ListEmpty(*L))
{ /* jika list kosong */
first(*L)=P;
last(*L)=P;
}
else
{ /* jika list tidak kosong */
next(last(*L))=P;
last(*L)=P;
} /* end if (ListEmpty(*L)) */
}

/* PENGHAPUSAN ELEMEN */
void DeleteFirst(List *L)
{
address P;
P=first(*L);
if (!ListEmpty(*L))
{ /* jika list tidak kosong */
if (P==last(*L))
{ /* jika dalam list hanya ada 1 elemen*/
Dealokasi(P);
first(*L)=nil;
last(*L)=nil;
}
else
{ /* jika dalam list ada lebih dari satu elemen */
first(*L)=next(P);
Dealokasi(P);
} /* end if (P==last(*L)) */
} /* end if (P!=nil) */
}

void DeletePos(List *L,int Pos)
{
address P,temp;
int i=1;
P=first(*L);
if (!ListEmpty(*L))
{ /* jika list tidak kosong */
if ((P==last(*L))&&(Pos==1))
{ /* jika dalam elemen list hanya ada 1 elemen dan posisi yang akan di hapus adalah elemen 1 */
Dealokasi(P);
first(*L)=nil;
last(*L)=nil;
}
else
{
if ((next(P)!=nil)&&(Pos==1))
{
first(*L)=next(P);
Dealokasi(P);
}
else
{ /* jika dalam elemen list ada lebih dari satu elemen */
while ((next(P)!=nil)&&((i+1)
{ /* loopig ketika ((next(P)!=nil)&&((i+1)
i+=1;
P=next(P);
} /* end while ((next(P)!=nil)&&((i+1)
if (next(P)!=nil)
{ /* jika posisi yang akan dihapus bukan elemen terakhir */
temp=next(P);
next(P)=next(next(P));
Dealokasi(temp);
} /* endif (next(P)!=nil) */
}
} /* end if ((P==last(*L))&&(Pos==1)) */
} /* end if (!ListEmpty(*L)) */
}

void DeleteLast(List *L)
{
address P;
P=first(*L);
if (!ListEmpty(*L))
{ /* jika list tidak kosong */
if (P==last(*L))
{ /* jika dalam list hanya ada 1 elemen*/
Dealokasi(P);
first(*L)=nil;
last(*L)=nil;
}
else
{ /* jika dalam list ada lebih dari satu elemen */
while (next(P)!=last(*L))
{ /* looping ketika (next(P)!=last(*L)) */
P=next(P);
} /* end while (next(P)!=last(*L)) */
Dealokasi(last(*L));
next(P)=nil;
last(*L)=P;
} /* endif (P==last(*L)) */
} /* end if (!ListEmpty(*L)) */
}
#endif
——————————–end—————————————-

testlist.cpp
——————————–begin———————————-

#include
#include”list.h”
#include
#include
#include
#include

main(){
List L;
infotype x;
CreateList(&L);

BacaList( &x);
InsertFirst( &L, x);
cout<<”Angka ini dimasukkan sbg elemen pertama\n”;
TulisList(L);

BacaList( &x);
InsertFirst( &L, x);
cout<<”Angka ini dimasukkan sebagai elemen pertama\n”;
TulisList(L);

BacaList( &x);
InsertLast(&L, x);
cout<<”Angka ini dimasukkan sebagai elemen terakhir\n”;
TulisList(L);

BacaList( &x);
InsertLast(&L,x);
cout<<”Angka ini dimasukkan sebagai elemen terakhir\n”;
TulisList(L);

BacaList( &x);
InsertPos( &L, x, 2);
cout<<”Angka ini dimasukkan sbg elemen ke-2\n”;
TulisList(L);

cout<<”\nMenghapus elemen terakhir\n”;
DeleteLast(&L);
TulisList(L);

cout<<”\nMenghapus elemen pertama\n”;
DeleteFirst(&L);
TulisList(L);

cout<<”\nMenghapus elemen ke 3\n”;
DeletePos(&L,3);
TulisList(L);

cout<<”\nNilai maksimum: “;
Max(L);
cout<<”\nNilai minimum: “;
Min(L);

Search(L);
}
———————————–end—————————————–

karena saya baik hati, maka untuk memudahkan anda, silahkan download source code tersebut di sini

dalam artikel ini, tidak akan saya jelaskan bagaimana program ini bekerja, silakan anda pelajari sendiri source code ini. dan jika anda sampai ke artikel ini karena mendapat tugas dalam sebuah mata kuliah, saya mohon, jangan hanya copy-paste tapi pelajarilah. karena itu jauh lebih bermanfaat, jauh lebih baik.

berikut adalah contoh source code sederhana queue menggunakan bahasa c++ :

file :queue.h

—————————begin———————–

#ifndef queue_H
#define queue_H

#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>
#include<malloc.h>
#include<conio.h>

#define nil NULL
#define info(P) (P)->info
#define next(P) (P)->next
#define firstQueue(Q) ((Q).firstQueue)
#define lastQueue(Q) ((Q).lastQueue)

typedef int infotype;
typedef struct tElmtQueue *address;
typedef struct tElmtQueue
{
infotype info;
address next;
}ElmtQueue;
typedef struct
{
address firstQueue;
address lastQueue;
} Queue;

bool queueEmpty(Queue Q);

void CreateQueue(Queue *Q);
void BacaQueue(infotype *x);
void TulisQueue(Queue Q);
address Alokasi(infotype x);
void Dealokasi(address P);
void Enqueue(Queue *Q,infotype x);
void Dequeue(Queue *Q);

bool queueEmpty(Queue Q)
{
return ((firstQueue(Q) == nil)&&(lastQueue(Q) == nil));
}

void CreateQueue(Queue *Q)
{
firstQueue(*Q)=nil;
lastQueue(*Q)=nil;
}
void BacaQueue(infotype *x)
{
printf(“\n\nMasukkan data: “);scanf(“%d”,&(*x));
}
void TulisQueue(Queue Q)
{
address P;
P=firstQueue(Q);
printf(“Data Queue : “);
while(P!=nil)
{
printf(“%d    “,info(P));
P=next(P);
}
}

address Alokasi(infotype x)
{
address P;
P=(address)malloc(sizeof(ElmtQueue));
if (P!=nil)
{
info(P)=x;
next(P)=nil;
}
return P;
}

void Dealokasi(address P)
{
free(P);
}

void Enqueue(Queue *Q,infotype x)
{
address P;
P=Alokasi(x);
if(queueEmpty(*Q))
{
firstQueue(*Q)=P;
lastQueue(*Q)=P;
}
else
{
next(lastQueue(*Q))=P;
lastQueue(*Q)=P;
}
printf(“angka %d dimasukkan (enqueue)\n”,x);
}

void Dequeue(Queue *Q)
{
address P;
P=firstQueue(*Q);
if(!queueEmpty(*Q))
{
if(P==lastQueue(*Q))
{
Dealokasi(P);
firstQueue(*Q)=nil;
lastQueue(*Q)=nil;
}
else
{
firstQueue(*Q)=next(P);
Dealokasi(P);
}
}
printf(“\nangka pertama dlm queue terhapus (dequeue)\n\n”);
}

#endif

————————————–end—————————————

file:testqueue.cpp

—————————————begin———————————-

#include “queue.h”
#include “stdio.h”
#include “iostream.h”

main(){
Queue Q;
infotype x;

CreateQueue(&Q);

BacaQueue(&x);
Enqueue(&Q,x);
TulisQueue(Q);

BacaQueue(&x);
Enqueue(&Q,x);
TulisQueue(Q);

BacaQueue(&x);
Enqueue(&Q,x);
TulisQueue(Q);

BacaQueue(&x);
Enqueue(&Q,x);
TulisQueue(Q);

Dequeue(&Q);
TulisQueue(Q);

cout<<”\n\nby code4769″ <<endl;
}

————————————————end——————————————————–

untuk lebih mudah, silakan

download disini.

berikut adalah source codenya :



—————————————————–begin—————————————————–

#include <iostream.h>
#include <conio.h>
#include <iomanip.h>

int A[1000][1000],B[1000][1000],C[1000][1000],i,j,k, barisa, koloma, barisb, kolomb, barisc, kolomc, loop;
void hitung();
void matrika();
void matrikb();
void cek();
void ulang();

void main()
{
do
{
matrika();
matrikb();
cek();
ulang();
}while (loop!=0);
}

void matrika()
{
cout<<”masukkan ordo matriks A :”<<endl;
cout<<”jumlah baris : “;
cin>>barisa;
cout<<”jumlah kolom : “;
cin>>koloma;

//masukkan matrix A
cout<<”Silahkan input matrik A : \n”;
for(i=0;i<barisa;i++)
{
for(j=0;j<koloma;j++)
{
cout<<”Elemen ke “<<(i+1)<<”,”<<(j+1)<<” : “;
cin>>A[i][j];
}
}

//cetak matrix A
cout<<”\nMatrik A : \n”;;
for(i=0;i<barisa;i++)
{
for(j=0;j<koloma;j++)
{
cout<<setw(4)<<A[i][j];
}
cout<<endl;
}
cout<<endl;
}

void matrikb()
{
//masukkan matriks B
cout<<”masukkan ordo matriks B :”<<endl;
cout<<”jumlah baris : “;
cin>>barisb;
cout<<”jumlah kolom : “;
cin>>kolomb;

cout<<”Silahkan input matrik B : \n”;
for(i=0;i<barisb;i++)
{
for(j=0;j<kolomb;j++)
{
cout<<”Elemen ke “<<(i+1)<<”,”<<(j+1)<<” : “;
cin>>B[i][j];
}
}

//cetak matrix B
cout<<”\nMatrik B : \n”;
for(i=0;i<barisb;i++)
{
for(j=0;j<kolomb;j++)
{
cout<<setw(4)<<B[i][j];
}
cout<<endl;
}
}

void hitung()
{
//Operasi Perkalian
for (i=0;i<barisa;i++)
{
for (j=0;j<kolomb;j++)
{
C[i][j]=0;
for (k=0;k< barisb;k++)
{
C[i][j]+= A[i][k]*B[k][j];
}
}
}

//Menampilkan hasil

cout<<”\nMatrik C, Hasil : \n”;
for(i=0;i<barisa;i++)
{
for(j=0;j<kolomb;j++)
{
cout<<setw(4)<<C[i][j];
}
cout<<endl;
}
cout<<endl;
getche();
}

void ulang()
{
int status, l;
char pilih;
do
{
cout<<”anda ingin memakai program ini lagi (y/n)?”;
cin>>pilih;
switch (pilih)
{
case ‘Y’ : status=1; loop=1; l=0;  break;
case ‘y’ : status=1; loop=1; l=0;  break;
case ‘N’ : status=0; l=0; cout<<”exit”<<endl; getche(); exit(0); break;
case ‘n’ : status=0; l=0; cout<<”exit”<<endl; getche(); exit(0); break;
default : cout<<”ketik y untuk ulangi program, n untuk tutup program (tidak case sensitif)”<<endl;
}
}while(l!=0);
}

void cek()
{
if (koloma==barisb)
{
hitung();
}
if (koloma!=barisb)
{
cout<<”operasi perkalian tidak bisa dilakukan. Anda salah memasukkan ordo matrik.”<<endl;
getche();
}

}

————————————————————————–end———————————————————

#include “iostream.h”

void bbsort(int a[], int ukuran);
void selectsort(int a[], int ukuran);
void isort(int arr[], int n);
int fm(int arr[], int b, int n);

//Fungsi Bubble Sort
void bbsort(int a[], int ukuran)
{
int tukar = 1;
int tampung = 0;
int i = 0;
int j = 0;

ukuran -= 1;

for(i = 0; i < ukuran && tukar; i++)
{
tukar = 0;
for(j = 0; j < ukuran - i; j++)
if(a[j] > a[j+1])
{
tukar = 1;
tampung = a[j];
a[j] = a[j + 1];
a[j + 1] = tampung;
}
}
}

//Fungsi Insertion Sort
int fm(int arr[], int b, int n)
{
int f = b;
int c;

for(c = b + 1; c < n; c++)
if(arr[c] < arr[f])
f = c;

return f;
}

void isort(int arr[], int n)
{
int s, w;
int sm;

for(s = 0; s < n - 1; s++)
{
w = fm(arr, s, n);
sm = arr[w];
arr[w] = arr[s];
arr[s] = sm;
}
}

//Fungsi Selection Sort
void selectsort(int a[], int ukuran)
{
int i = 0;
int j = 0;
int besar = 0;
int index = 0;

for(i = ukuran - 1; i > 0; i–)
{
besar = a[0];
index = 0;
for(j = 1; j <= i; j++)
if(a[j] > besar)
{
besar = a[j];
index = j;
}
a[index] = a[i];
a[i] = besar;
}
}

#define maxarr 9
//Program Utama
int main(void)
{
int arr[maxarr] = {45, 15, 7, 16, 30, 5, 80, 20, 60};
int i = 0;
int pilih;
int salah=1, jum=0, itung=0;
float rata;

cout<<"Sebelum Diurutkan :\n";
for(i = 0; i {
jum = jum + arr[i] ;
cout<<" "< }
rata=jum/maxarr;
cout<<"\n";

do
{
cout<<"\nPilih Metode Pengurutan : \n 1. Bubble Sort"
"\n 2. Insertion Sort\n 3. Selection Sort \n";
cout<<"Tentukan Pilihan anda : ";
cin>>pilih;
switch(pilih)
{
case 1 :
{
cout<<"\n 1. Bubble Sort ";
bbsort(arr,maxarr);
salah=1;
}
break;
case 2:
{
cout<<"\n 2. Insertion Sort";
isort(arr,maxarr);
salah=1;
}
break;
case 3:
{
cout<<"\n 3. Selection Sort";
selectsort(arr,maxarr);
salah=1;
}
break;
default:
{
cout<<"Anda salah dalam menentukan pilihan \n";
salah=0;
}
}
} while (salah!=1);

cout<<"Setelah Diurutkan: \n";
for(i = 0; i < maxarr; i++)
{
cout<<" "< if (arr[i] }
cout<<"\n";
cout<<"Nilai Terkecil adalah "< cout<<"Nilai Terbesar adalah "< cout<<"Nilai total seluruh array adalah "< cout<<"Rata-rata dari seluruh adalah "< cout<<"Jumlah Nilai array yang dibawah rata-rata sebanyak "< cout<<"\n";

return 0;
}
-----------------------------------------------end----------------------------------------------
mohon untuk tidak hanya copas source code tersebut, namun mohon dipelajari juga, demi kebaikan anda kalo cuma kopas, kapan pinternya?? uke prend?!

//PROGRAM MENGHITUNG NILAI SUATU RESISTOR DENGAN MEMBACA GELANG WARNANYA – BAHASA C
//Ditulis oleh: captbbx
/*
<!– this is begin of the program –> */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <conio.h>
//pendeklarasian fungsi
int salah();
int kerja();
int htgkembali();
int hitungcetak(double x, double y, double z);

void main()//bagian utama program
{
kerja();//memanggil fungsi kerja
}

int kerja()
{
int a, b, c, g, z, gel[3]; //pendeklarasian variabel dan array bertipe integer
double g1,g2,x,y; //pendeklarasian veriabel bertipe double
printf(“PROGRAM MENGHITUNG NILAI SUATU RESISTOR DENGAN MEMBACA GELANG WARNANYA\n”);
printf(“[0] Hitam\n[1] Coklat\n[2] Merah\n[3] jingga\n[4] Kuning\n[5] Hijau\n”);
printf(“[6] Biru\n[7] Ungu\n[8] Abu-Abu\n[9] Putih\n”);
printf(“[10] Emas\n[11] Perak\n[12] Tak Berwarna\n\n”);
printf(“nb: ketik angka/hurufnya saja!\n\n”);
for (g=0;g<=3;g++) //perulangan untuk menginput warna gelang
{
printf(“Ketikkan warna gelang ke-%d : “, g+1);
scanf(“%d”,&gel[g]); //dibaca dan dimasukkan ke dalam array gel[]
}
switch (gel[0]) //penyeleksian kondisi pada gelang pertama
{
case 0 : g1=0; break;
case 1 : g1=1; break;
case 2 : g1=2; break;
case 3 : g1=3; break;
case 4 : g1=4; break;
case 5 : g1=5; break;
case 6 : g1=6; break;
case 7 : g1=7; break;
case 8 : g1=8; break;
case 9 : g1=9; break;
default : {printf(“Masukan gelang pertama salah!\n”);}
}
switch (gel[1]) //penyeleksian kondisi pada gelang kedua
{
case 0 : g2=0; break;
case 1 : g2=1; break;
case 2 : g2=2; break;
case 3 : g2=3; break;
case 4 : g2=4; break;
case 5 : g2=5; break;
case 6 : g2=6; break;
case 7 : g2=7; break;
case 8 : g2=8; break;
case 9 : g2=9; break;
default : {printf(“Masukan gelang kedua salah!\n”);}
}
//pada bagian ini nilai resistor ditentukan berdasarkan warna gelang
switch (gel[2]) //penyeleksian kondisi pada gelang ketiga
{
case 0 : x=g1*(pow(10,1));y=g2*(pow(10,0));break;
case 1 : x=g1*(pow(10,2));y=g2*(pow(10,1));break;
case 2 : x=g1*(pow(10,3));y=g2*(pow(10,2));break;
case 3 : x=g1*(pow(10,4));y=g2*(pow(10,3));break;
case 4 : x=g1*(pow(10,5));y=g2*(pow(10,4));break;
case 5 : x=g1*(pow(10,6));y=g2*(pow(10,5));break;
case 6 : x=g1*(pow(10,7));y=g2*(pow(10,6));break;
case 7 : x=g1*(pow(10,8));y=g2*(pow(10,7));break;
case 8 : x=g1*(pow(10,9));y=g2*(pow(10,8));break;
case 9 : x=g1*(pow(10,10));y=g2*(pow(10,9));break;
case 10 : x=g1*(pow(10,0));y=g2*(pow(10,-1));break;
default : {printf(“Masukan gelang ketiga salah!\n”);}
}
//penentuan nilai toleransi
switch (gel[3]) //penyeleksian kondisi pada gelang keempat
{
case 10 : z=5;break;
case 11 : z=10;break;
case 12 : z=20;break;
default : {}
}
if ((x<=0) || (y<=0) || (z<=0)) {salah();}//jika terjadi kesalahan dalam menginput, maka akan tampil pesan ini

else
{
hitungcetak(x, y, z); //pemanggilan fungsi hitungcetak
}
}

int hitungcetak(double x,double y, double z) //fungsi untuk menghitung dan mencetak hasil
{

float res,tol, maks, min,w;//pendeklarasian veriabel bertipe float
res=x+y; //penghitungan nilai dengan menjumlahkan variabel x dan y
tol=z; //assigment pada variabel tol dengan nilai yang ada pada variabel z
maks=res+(tol/100*res); //penghitungan nilai maksimum
min=res-(tol/100*res); //penghitungan nilai minimum
puts(“\n\nBerikut hasil pengitungan:\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++”);
printf(“Nilai Resistor tersebut adalah       = %.0f OHM “, res); //nilai hambatan
printf(“atau %.2f K.OHM\n”, res/1000); //konversi ke Kilo Ohm
printf(“Dengan toleransi                     = %.0f persen\n”, tol); //mencetak nilai toleransi
printf(“Maka nilai maksimumnya adalah        = %.0f Ohm\n”, maks); //mencetak nilai maksimum
printf(“dan nilai minimumnya adalah          = %.0f Ohm\n”, min); //mencetak nilai minimum
puts(“++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\nPenghitungan selesai!\n\n”);
htgkembali();
}

int htgkembali()//fungsi konfirmasi apakah kita akan menghitung kembali
{
char k;
scanf(“%c”,&k);
{
switch(k)
{
case ‘y’: kerja();break;
case ‘Y’: kerja();break;
case ‘n’: printf(“\n\n\nTerima kasih atas penggunaan program ini.\nSemoga bermanfaat.\n”);getche;exit(0);break;
case ‘N’: printf(“\n\n\nTerima kasih atas penggunaan program ini.\nSemoga bermanfaat.\n”);getche;exit(0);break;
default: {printf(“Apakah anda ingin menghitung kembali?[jawab y atau n]“);htgkembali();}
}
}

}

int salah()//fungsi yang dipanggil jika input salah
{
char s;
printf(“\nOopss!\nMasukan anda ternyata ada yang salah!\n”);
scanf(“%c”,&s);
{
switch(s)
{
case ‘y’: htgkembali();break;
case ‘Y’: htgkembali();break;
case ‘n’: exit(0);break;
case ‘N’: exit(0);break;
default:{printf(“Apakah anda ingin mengulanginya?”);htgkembali();}
}
}
}
// <!– this is end of the program –> sorry, if this project too simple… thank you…