Yusran Adhitya Kurniawan’s Blog

C/C++ Programmes

DO-WHILE
#include

int I, Y, Z;
int N;
int Sum;
main (){
printf(“Masukan bilangan yang akan dijumlahkan : \n “);
scanf(“%d”,&N),
Sum = 0; Y = 0;
I = 1;
while (Y<(N-1)){
Z = I + Y; printf(“%d “, Z);
Y++; Sum = Sum + Z;
I = Z;
}; printf (“jumlah bilangan adalah %d \n “, Sum);
return 0;}
SWITCHCASE
#include
#include “conio.h”
main(){
int kode;
//clrsr();
puts(“Menentukan pilihan”) ;
puts(“1 = Januari”);
puts(“2 = Februari”);
puts(“3 = Maret”);
puts(“4 = April”);
puts(“5 = Mei”);
puts(“6 = Jni”);
puts(“7 = Juli”);
puts(“8 = Agustus”);
puts(“9 = September”);
puts(“10 = Oktober”);
puts(“11 = November”);
puts(“12 = Desember”);
printf (“\nMasukkan pilihan anda (1..12):”);
scanf (“%d”,&kode);
switch (kode){
case 1: puts (“Bulan Januari”); break;
case 2: puts (“Bulan Februari”); break;
case 3: puts (“Bulan Maret”); break;
case 4: puts (“Bulan April”); break;
case 5: puts (“Bulan Mei”); break;
case 6: puts (“Bulan Juni”); break;
case 7: puts (“Bulan Juli”); break;
case 8: puts (“Bulan Agustus”); break;
case 9: puts (“Bulan September”); break;
case 10: puts (“Bulan Oktober”); break;
case 11: puts (“Bulan November”); break;
case 12: puts (“Bulan Desember”); break;
default: puts (“Yang anda masukkan bukan pilhan (1..12) kan ?”);
}
}
IF-ELSE
#include
#include
#include

int a, b, c, D;
float x1, x2;
main()
{
clrscr();
printf(“XXXXXXXXXXXXXXXX\n”);
printf(“Program Penghitung Persamaan akar kuadrat”);
printf(“Masukkan Nilai a, b, dan c\n (dipisahkan dengan spasi/enter!\n”);
scanf(“%d %d %d”, &a, &b, &c);
printf(“xxxxxxxxxxxxxxx\n”);
printf(“persamaan kuadrat: (%d)x^2 + (%d)x + (%d) \n”, a, b, c);
D=(b+b) – (4*a*c);
if (D > 0) {
x1 = (-b + sqrt(D))/(2*a);
x2 = (-b – sqrt(D))/(2*a);
printf (“akar ke-1 = %f dan akar ke-2 = %f\n”, x1, x2); }
else{
printf(“D akar imaginer!!!\n”);
}
return 0;
}
FORSTAT
#include
/* menjumlah deret 1+2+3+…+N dengan N adalah bilangan bulat positif yang
dibaca dari piranti masukan Jumlah deret dicetak ke output*/
main() {
//deklarasi//
int N;
int angka;
int jumlah;
printf(“Berapa n = “); scanf(“%d”,&N);
jumlah=0 ;
for(angka=1;angka<=N;angka++){
jumlah=jumlah + angka;
}
printf(“jumlah deret = %d”, jumlah);
}
ARRAY
#include
/*Program Array
;Nama File: array.c
;Tgl : 17 April 2008
;——————
;Contoh program kecil untuk mendeklarasikan, mengisi array melalui 2 cara
;yaiut assignment statement dan masukkan dari keyboard
;———————————-
*/

/*Kamus*/
int bil[5];
int i;

/*Algoritma*/
main()
{
/*——–ASSIGNMENT STATEMENT*/
bil[0]=1;
bil[1]=6;
bil[2]=8;
bil[3]=9;
bil[4]=10;
i=1;

/*——OUTPUT*/
while (i<=5)
{
printf(“%d”, (bil[i-1]));
i++;
}
/*Masukkan nilai array melalui input dari keyboard*/
/*—-INPUT——-*/
i=1;
do
{ printf(“\n Masukkan Bilangan:”);
scanf(“%d”, &(bil[i-1]));
i++;
}
while (i<=5);
i=1;
do
{
printf(“%d”,(bil[i-1]));
i++;
}
while(i<=5);
}
ARRAY-FOR
#include
/*Program Array
;Nama File: array.c
;Tgl : 17 April 2008
;——————
;Contoh program kecil untuk mendeklarasikan, mengisi array melalui 2 cara
;yaiut assignment statement dan masukkan dari keyboard
;———————————-
*/

/*Kamus*/
int bil[5];
int i;

/*Algoritma*/
main()
{
/*——–ASSIGNMENT STATEMENT*/
bil[0]=1;
bil[1]=6;
bil[2]=8;
bil[3]=9;
bil[4]=10;

/*——OUTPUT*/
for(i=1;i<=5;i++);
printf(“%d”, (bil[i-1]));
/*Masukkan nilai array melalui input dari keyboard*/
/*—-INPUT——-*/
for(i=1;i<=5;i++);
{
printf(“\n Masukkan Bilangan:”);
scanf(“%d”, &(bil[i-1]));
}
for(i=1;i<=5;i++);
{
printf(“%d”,(bil[i-1]));
}
}
STRUKTUR-KOMPOSISI
#include
/*Program masukkan nilai titik
;Nama File : komposisi.c
;Tgl : 16 April 2008
Menunggu masukkan dua bilangan yang menyatakan absis dan ordinat dari keyboard*/

/*Kmaus*/
/*Definisi nama type*/
typedef struct
{ float X;
float Y;
} Point;

/*Deklarasi nama variabel titik*/
Point T1;

/*ALGORITMA*/
void main()
{
printf(“Masukkan Komponen X dan Y:\n”);
scanf(“%f %f”, &T1.X, &T1.Y);
printf(“Nilai: %f dan Y: %f”,T1.X, T1.Y);
}
JAM 1 IF ELSE
/*JUDUL*/
/*Program Jam (1)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s;

/*ALGORITMA*/
void main ()
{
printf (“————JAM (1)————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
printf (“———–TERIMA KASIH———–\n”);
getch();
getch();
}
JAM 2
/*JUDUL*/
/*Program Jam (2)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J[100];
int h, m, s, jml /*jumlah elemen array*/ , i;

/*ALGORITMA*/
void main ()
{
printf (“————JAM (2)————–\n”);
printf (“Masukkan banyaknya jam: “);
scanf (“%d”, &jml);
printf (“\n”);
while (i<=(jml-1)) /*valid jika 0=jml-1*/
{
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
printf (“————TERIMA KASIH—————\n”);
getch();
getch();
}
JAM 3
/*JUDUL*/
/*Program Jam (3)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, x, Jdetik, Jm, Jumlah, Sisa;

/*ALGORITMA*/
void main ()
{
/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
J.HH=0;
J.MM=0;
J.SS=0;
printf (“———–Create jam————-\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
printf (“————Baca jam————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s<60)
{
J.HH=h;
J.MM=m;
J.SS=s;
printf(“\n”);
/*tulis jam*/
/*menuliskan nilai jam dengan format */
printf (“————-tulis jam————\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if (s>=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
printf (“————Tambah jam————-\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s<60)
{
printf (“Masukkan nilai tambah menit: “);
scanf (“%d”, &x);
Jdetik=(h*3600+m*60+s);
Jm=(x*60);
Jumlah=Jdetik+Jm;
h=Jumlah/3600;
if (h=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*Konversi jam ke detik*/
printf (“——–konversi jam ke detik——–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*konversi detik ke jam*/
printf (“——–konversi detik ke jam——–\n”);
printf (“masukan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &Jdetik);
if (Jdetik>=0)
{
h=Jdetik/3600;
if (h<24)
{
Sisa=Jdetik%3600;
m=Sisa/60;
s=Sisa%60;
J.HH=h;
J.MM=m;
J.SS=s;
printf (“\n”);
printf (“%d detik = %d:%d:%d \n”, Jdetik, J.HH, J.MM, J.SS);
printf (“\n”);
}
else
{
printf (“\n”);
printf (“Maaf melebihi batas jam!!!!\n”);
printf (“\n”);
}
}
else
{
printf (“\n”);
printf (“Jumlah menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*next jam*/
/*memajukan komponen HH plus 1*/
printf (“————next jam—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s<60)
{
J.HH=h;
J.MM=m;
J.SS=s;
if (J.HH<23)
{
J.HH++;
printf (“\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if (J.HH=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*next menit*/
/*memajukan komponen MM plus 1*/
printf (“————next menit—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s<60)
{
J.HH=h;
J.MM=m;
J.SS=s;
if (J.MM<59)
{
J.MM++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if(J.MM<60)
{
J.MM=0;
if (J.HH<23)
{
J.HH++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if (J.HH=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
/*next detik*/
/*memajukan komponen SS plus 1*/
printf (“————next detik—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (h<24)
{
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (m<60)
{
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s<0)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
else if (s<60)
{
J.HH=h;
J.MM=m;
J.SS=s;
if (J.SS<59)
{
J.SS++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if (J.SS<60)
{
J.SS=0;
if (J.MM<59)
{
J.MM++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if(J.MM<60)
{
J.MM=0;
if (J.HH<23)
{
J.HH++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
}
else if (J.HH=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!! \n”);
printf (“Coba ulangi kembali!!!! \n”);
printf (“\n”);
}
printf (“————TERIMA KASIH—————\n”);
getch();
getch();
}
JAM 4
/*JUDUL*/
/*Program Jam (4)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, detik, S, x;

/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
void CreateJam (Jam *JJ)
{
(*JJ).HH=0;
(*JJ).MM=0;
(*JJ).SS=0;
}
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
void BacaJam (Jam *JJ)
{
printf (“Masukkan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (h<24)
{
printf (“Masukkan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (m<60)
{
printf (“Masukkan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
(*JJ).HH=h;
(*JJ).MM=m;
(*JJ).SS=s;
}
/*tulis jam*/
/*menuliskan nilai jam dengan format */
void TulisJam (Jam JJ)
{
if (JJ.HH<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.HH<24)
{
if (JJ.MM<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.MM<60)
{
if (JJ.SS<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.SS=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.MM>=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.HH>=24)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
/*konversi Jam ke Detik*/
int JamToDetik (Jam JJ)
{
return (JJ.HH*3600+JJ.MM*60+JJ.SS);
}
/*konversi detik ke jam*/
Jam DetikToJam (int SS)
{
int h, m, s, Sisa;
Jam JJ;
h=(SS/3600);
Sisa=(SS%3600);
m=Sisa/60;
s=Sisa%60;
JJ.HH=h;
JJ.MM=m;
JJ.SS=s;
return JJ;
}
/*Tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
void TambahJam (Jam *JJ, int m)
{
int JJdetik, JJm, Hasil;
JJdetik=JamToDetik (*JJ);
JJm=m*60;
Hasil=JJdetik+JJm;
*JJ=DetikToJam (Hasil);
}
/*next jam*/
/*memajukan komponen HH plus 1*/
void NextJam (Jam *JJ)
{
if ((*JJ).HH<0)
{
}
else if ((*JJ).HH<23)
{
(*JJ).HH++;
}
else if ((*JJ).HH==23)
{
(*JJ).HH=0;
}
}
/*next minute*/
/*memajukan komponen MM plus 1*/
void NextMinute (Jam *JJ)
{
if ((*JJ).MM<0)
{
}
else if ((*JJ).MM<59)
{
(*JJ).MM++;
}
else if ((*JJ).MM==59)
{
(*JJ).MM=0;
NextJam (JJ);
}
}
/*next detik*/
/*memajukan komponen SS plus 1*/
void NextDetik (Jam *JJ)
{
if ((*JJ).SS<0)
{
}
if ((*JJ).SS<59)
{
(*JJ).SS++;
}
else if ((*JJ).SS==59)
{
(*JJ).SS=0;
NextMinute (JJ);
}
}

/*ALGORITMA*/
void main ()
{
/* memanggil procedure create jam*/
printf (“——-create jam——– \n”);
CreateJam (&J);
TulisJam (J);
printf (“\n”);
/*memanggil procedure BacaJam*/
printf (“——–Baca jam——— \n”);
BacaJam (&J);
printf (“\n”);
/* memanggil procedure TulisJam*/
printf (“——–Tulis jam——– \n”);
TulisJam (J);
printf (“\n”);
/*memanggil function konversi jam ke detik*/
printf (“–Konversi Jam ke Detik– \n”);
BacaJam (&J);
detik=JamToDetik (J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS<60)
{
printf (“\n”);
printf (“jam %d:%d:%d = %d detik\n”, J.HH, J.MM, J.SS, detik);
printf (“\n”);
}
}
}
printf (“\n”);
/*memanggil function konversi detik ke jam*/
printf (“–Konversi Detik ke Jam– \n”);
printf (“Masukkan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &S);
J=DetikToJam (S);
TulisJam (J);
printf (“\n”);
/*memanggil procedure tambah jam*/
printf (“——-Tambah Jam——– \n”);
BacaJam(&J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS<60)
{
printf (“Masukkan penambahan nilai menit: “);
scanf (“%d”, &x);
TambahJam (&J,x);
TulisJam (J);
}
}
}
printf (“\n”);
/*memanggil procedure next jam*/
printf (“——–next jam——— \n”);
BacaJam (&J);
NextJam (&J);
TulisJam(J);
printf (“\n”);
/*memanggil procedure next minute*/
printf (“——next minute——– \n”);
BacaJam (&J);
NextMinute (&J);
TulisJam (J);
printf (“\n”);
/*memanggil procedure next detik*/
printf (“——-next detik——– \n”);
BacaJam (&J);
NextDetik (&J);
TulisJam (J);
printf (“\n”);
printf (“———TERIMA KASIH——– \n”);
getch();
getch();
}
JAM TANPA IF-ELSE
/*JUDUL*/
/*Program Jam (4)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, detik, S, x;

/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
void CreateJam (Jam *JJ)
{
(*JJ).HH=0;
(*JJ).MM=0;
(*JJ).SS=0;
}
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
void BacaJam (Jam *JJ)
{
printf (“Masukkan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (h<24)
{
printf (“Masukkan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (m<60)
{
printf (“Masukkan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
(*JJ).HH=h;
(*JJ).MM=m;
(*JJ).SS=s;
}
/*tulis jam*/
/*menuliskan nilai jam dengan format */
void TulisJam (Jam JJ)
{
if (JJ.HH<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.HH<24)
{
if (JJ.MM<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.MM<60)
{
if (JJ.SS<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.SS=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.MM>=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.HH>=24)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
/*konversi Jam ke Detik*/
int JamToDetik (Jam JJ)
{
return (JJ.HH*3600+JJ.MM*60+JJ.SS);
}
/*konversi detik ke jam*/
Jam DetikToJam (int SS)
{
int h, m, s, Sisa;
Jam JJ;
h=(SS/3600);
Sisa=(SS%3600);
m=Sisa/60;
s=Sisa%60;
JJ.HH=h;
JJ.MM=m;
JJ.SS=s;
return JJ;
}
/*Tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
void TambahJam (Jam *JJ, int m)
{
int JJdetik, JJm, Hasil;
JJdetik=JamToDetik (*JJ);
JJm=m*60;
Hasil=JJdetik+JJm;
*JJ=DetikToJam (Hasil);
}
/*next jam*/
/*memajukan komponen HH plus 1*/
void NextJam (Jam *JJ)
{
if ((*JJ).HH<0)
{
}
else if ((*JJ).HH<23)
{
(*JJ).HH++;
}
else if ((*JJ).HH==23)
{
(*JJ).HH=0;
}
}
/*next minute*/
/*memajukan komponen MM plus 1*/
void NextMinute (Jam *JJ)
{
if ((*JJ).MM<0)
{
}
else if ((*JJ).MM<59)
{
(*JJ).MM++;
}
else if ((*JJ).MM==59)
{
(*JJ).MM=0;
NextJam (JJ);
}
}
/*next detik*/
/*memajukan komponen SS plus 1*/
void NextDetik (Jam *JJ)
{
if ((*JJ).SS<0)
{
}
if ((*JJ).SS<59)
{
(*JJ).SS++;
}
else if ((*JJ).SS==59)
{
(*JJ).SS=0;
NextMinute (JJ);
}
}

/*ALGORITMA*/
void main ()
{
/* memanggil procedure create jam*/
printf (“——-create jam——– \n”);
CreateJam (&J);
TulisJam (J);
printf (“\n”);
/*memanggil procedure BacaJam*/
printf (“——–Baca jam——— \n”);
BacaJam (&J);
printf (“\n”);
/* memanggil procedure TulisJam*/
printf (“——–Tulis jam——– \n”);
TulisJam (J);
printf (“\n”);
/*memanggil function konversi jam ke detik*/
printf (“–Konversi Jam ke Detik– \n”);
BacaJam (&J);
detik=JamToDetik (J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS<60)
{
printf (“\n”);
printf (“jam %d:%d:%d = %d detik\n”, J.HH, J.MM, J.SS, detik);
printf (“\n”);
}
}
}
printf (“\n”);
/*memanggil function konversi detik ke jam*/
printf (“–Konversi Detik ke Jam– \n”);
printf (“Masukkan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &S);
J=DetikToJam (S);
TulisJam (J);
printf (“\n”);
/*memanggil procedure tambah jam*/
printf (“——-Tambah Jam——– \n”);
BacaJam(&J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS<60)
{
printf (“Masukkan penambahan nilai menit: “);
scanf (“%d”, &x);
TambahJam (&J,x);
TulisJam (J);
}
}
}
printf (“\n”);
/*memanggil procedure next jam*/
printf (“——–next jam——— \n”);
BacaJam (&J);
NextJam (&J);
TulisJam(J);
printf (“\n”);
/*memanggil procedure next minute*/
printf (“——next minute——– \n”);
BacaJam (&J);
NextMinute (&J);
TulisJam (J);
printf (“\n”);
/*memanggil procedure next detik*/
printf (“——-next detik——– \n”);
BacaJam (&J);
NextDetik (&J);
TulisJam (J);
printf (“\n”);
printf (“———TERIMA KASIH——– \n”);
getch();
getch();
}
JAM 2 TANPA IF-ELSE
/*JUDUL*/
/*Program Jam (2)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J [100];
int h, m, s, jml, i;

/*ALGORITMA*/
void main ()
{
printf (“masukkan banyaknya jam: “);
scanf (“%d”, &jml);
printf (“\n”);
while (i<=(jml-1))
{
printf (“————JAM(2)————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J[i].HH=h;
J[i].MM=m;
J[i].SS=s;
printf(“\n”);
printf (“Nilai jam yang ke-%i: %d:%d:%d \n”, i+1, J[i].HH, J[i].MM, J[i].SS);
printf (“\n”);
i++;
}
printf (“———–TERIMA KASIH————- \n”);
getch();
getch();
}
JAM 3 TANPA IDF-ELSE
/*JUDUL*/
/*Program Jam (3)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, x, Jdetik, Jm, Jumlah, Sisa;

/*ALGORITMA*/
void main ()
{
/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
J.HH=0;
J.MM=0;
J.SS=0;
printf (“———–Create jam————-\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
printf (“————Baca jam————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
printf(“\n”);
/*tulis jam*/
/*menuliskan nilai jam dengan format */
printf (“————-tulis jam————\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
printf (“————Tambah jam————-\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
printf (“Masukan nilai tambah: “);
scanf (“%d”, &x);
Jdetik=(h*3600+m*60+s);
Jm=(x*60);
Jumlah=Jdetik+Jm;
h=Jumlah/3600;
Sisa=Jumlah%3600;
m=Sisa/60;
s=Sisa%60;
J.HH=h;
J.MM=m;
J.SS=s;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*Konversi jam ke detik*/
printf (“——–konversi jam ke detik——–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
Jdetik=(J.HH*3600+J.MM*60+J.SS);
printf (“%d:%d:%d = %d detik \n”, J.HH, J.MM, J.SS, Jdetik);
printf (“\n”);
/*konversi detik ke jam*/
printf (“——–konversi detik ke jam——–\n”);
printf (“masukan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &Jdetik);
h=Jdetik/3600;
Sisa=Jdetik%3600;
m=Sisa/60;
s=Sisa%60;
J.HH=h;
J.MM=m;
J.SS=s;
printf (“%d detik = %d:%d:%d \n”, Jdetik, J.HH, J.MM, J.SS);
printf (“\n”);
/*next jam*/
/*memajukan komponen HH plus 1*/
printf (“————next jam—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.HH++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*next menit*/
/*memajukan komponen MM plus 1*/
printf (“————next menit—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.MM++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*next detik*/
/*memajukan komponen SS plus 1*/
printf (“————next detik—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.SS++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
printf (“————TERIMA KASIH—————\n”);
getch();
getch();
}
JAM 4 TANPA IF-ELSE
/*JUDUL*/
/*Program Jam (3)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, x, Jdetik, Jm, Jumlah, Sisa;

/*ALGORITMA*/
void main ()
{
/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
J.HH=0;
J.MM=0;
J.SS=0;
printf (“———–Create jam————-\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
printf (“————Baca jam————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
printf(“\n”);
/*tulis jam*/
/*menuliskan nilai jam dengan format */
printf (“————-tulis jam————\n”);
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
printf (“————Tambah jam————-\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
printf (“Masukan nilai tambah: “);
scanf (“%d”, &x);
Jdetik=(h*3600+m*60+s);
Jm=(x*60);
Jumlah=Jdetik+Jm;
h=Jumlah/3600;
Sisa=Jumlah%3600;
m=Sisa/60;
s=Sisa%60;
J.HH=h;
J.MM=m;
J.SS=s;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*Konversi jam ke detik*/
printf (“——–konversi jam ke detik——–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
Jdetik=(J.HH*3600+J.MM*60+J.SS);
printf (“%d:%d:%d = %d detik \n”, J.HH, J.MM, J.SS, Jdetik);
printf (“\n”);
/*konversi detik ke jam*/
printf (“——–konversi detik ke jam——–\n”);
printf (“masukan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &Jdetik);
h=Jdetik/3600;
Sisa=Jdetik%3600;
m=Sisa/60;
s=Sisa%60;
J.HH=h;
J.MM=m;
J.SS=s;
printf (“%d detik = %d:%d:%d \n”, Jdetik, J.HH, J.MM, J.SS);
printf (“\n”);
/*next jam*/
/*memajukan komponen HH plus 1*/
printf (“————next jam—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.HH++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*next menit*/
/*memajukan komponen MM plus 1*/
printf (“————next menit—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.MM++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
/*next detik*/
/*memajukan komponen SS plus 1*/
printf (“————next detik—————–\n”);
printf (“masukan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
printf (“Masukan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
printf (“Masukan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
J.HH=h;
J.MM=m;
J.SS=s;
J.SS++;
printf (“Nilai jam: %d:%d:%d \n”, J.HH, J.MM, J.SS);
printf (“\n”);
printf (“————TERIMA KASIH—————\n”);
getch();
getch();
}
MENU OPERASI JAM
/*JUDUL*/
/*Program Jam (4)*/
/*membaca bilangan dari keyboard, bilangan ditampung dalam variabel h, m, s.
Nilai variabel h memiliki range [0..23], variabel m dan s memiliki range
[0..59], nilai variabel h, m, s akan dikonstruksikan dalam struktur komposisi
Jam yang terdiri dari . Diketahui variabel J bertipe Jam, maka
J.HH, J.MM, J.SS dapat diakses*/

#include
#include

/*KAMUS*/
typedef struct Jam
{
int HH, MM, SS;
};

Jam J;
int h, m, s, detik, S, x;

/*create jam*/
/*membentuk sebuah nilai bertipe jam dengan */
void CreateJam (Jam *JJ)
{
(*JJ).HH=0;
(*JJ).MM=0;
(*JJ).SS=0;
}
/*Baca Jam*/
/*menerima masukan nilai jam dari pengguna*/
void BacaJam (Jam *JJ)
{
printf (“Masukkan nilai jam (antara 0-23): “);
scanf (“%d”, &h);
if (h<0)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (h<24)
{
printf (“Masukkan nilai menit (antara 0-59): “);
scanf (“%d”, &m);
if (m<0)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
else if (m<60)
{
printf (“Masukkan nilai detik (antara 0-59): “);
scanf (“%d”, &s);
if (s=60)
{
printf (“\n”);
printf (“Nilai detik yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (m>=60)
{
printf (“\n”);
printf (“Nilai menit yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
}
else if (h>=24)
{
printf (“\n”);
printf (“Nilai jam yang anda masukkan salah!!!!\n”);
printf (“Silahkan ulangi kembali!!!!\n”);
}
(*JJ).HH=h;
(*JJ).MM=m;
(*JJ).SS=s;
}
/*tulis jam*/
/*menuliskan nilai jam dengan format */
void TulisJam (Jam JJ)
{
if (JJ.HH<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.HH<24)
{
if (JJ.MM<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.MM<60)
{
if (JJ.SS<0)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
else if (JJ.SS=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.MM>=60)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
else if (JJ.HH>=24)
{
printf (“\n”);
printf (“Maaf sudah melebihi batas jam!!! \n”);
}
}
/*konversi Jam ke Detik*/
int JamToDetik (Jam JJ)
{
return (JJ.HH*3600+JJ.MM*60+JJ.SS);
}

/*konversi detik ke jam*/
Jam DetikToJam (int SS)
{
int h, m, s, Sisa;
Jam JJ;
h=(SS/3600);
Sisa=(SS%3600);
m=Sisa/60;
s=Sisa%60;
JJ.HH=h;
JJ.MM=m;
JJ.SS=s;
return JJ;
}
/*Tambah jam*/
/*menambahkan jumlah menit ke suatu jam current*/
void TambahJam (Jam *JJ, int m)
{
int JJdetik, JJm, Hasil;
JJdetik=JamToDetik (*JJ);
JJm=m*60;
Hasil=JJdetik+JJm;
*JJ=DetikToJam (Hasil);
}
/*next jam*/
/*memajukan komponen HH plus 1*/
void NextJam (Jam *JJ)
{
if ((*JJ).HH<0)
{
}
else if ((*JJ).HH<23)
{
(*JJ).HH++;
}
else if ((*JJ).HH==23)
{
(*JJ).HH=0;
}
}
/*next minute*/
/*memajukan komponen MM plus 1*/
void NextMinute (Jam *JJ)
{
if ((*JJ).MM<0)
{
}
else if ((*JJ).MM<59)
{
(*JJ).MM++;
}
else if ((*JJ).MM==59)
{
(*JJ).MM=0;
NextJam (JJ);
}
}
/*next detik*/
/*memajukan komponen SS plus 1*/
void NextDetik (Jam *JJ)
{
if ((*JJ).SS<0)
{
}
if ((*JJ).SS<59)
{
(*JJ).SS++;
}
else if ((*JJ).SS==59)
{
(*JJ).SS=0;
NextMinute (JJ);
}
}

/*ALGORITMA*/
void main ()
{
int i, kode;
printf (“Pilihlah menu operasi yang dapat dilakukan jam di bawah ini: \n”);
printf (” 1. Create Jam \n”);
printf (” 2. Baca Jam \n”);
printf (” 3. Tulis Jam \n”);
printf (” 4. Konversi Jam ke detik \n”);
printf (” 5. Konversi detik ke jam \n”);
printf (” 6. Tambah Jam \n”);
printf (” 7. Next Jam \n”);
printf (” 8. Next Minute \n”);
printf (” 9. Next Detik \n”);
printf (“\n”);
printf (“Anda memilih menu nomor: “);
scanf (“%d”, &i);
printf (“\n”);
if (i<1)
{
printf (“Maaf anda memasukkan angka yang salah!!!!\n”);
printf (“\n”);
}
else if (i==1)
{
printf (“———–Create jam———— \n”);
CreateJam (&J);
TulisJam (J);
}
else if (i==2)
{
printf (“———–Baca Jam———— \n”);
BacaJam(&J);
TulisJam(J);
}
else if (i==3)
{
printf (“———–Tulis Jam———— \n”);
BacaJam (&J);
TulisJam (J);
}
else if (i==4)
{
printf (“——Konversi Jam ke Detik——– \n”);
BacaJam (&J);
detik=JamToDetik(J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS<60)
{
printf (“\n”);
printf (“jam %d:%d:%d = %d detik \n”, J.HH, J.MM, J.SS, detik);
}
}
}
}
else if (i==5)
{
printf (“——Konversi Detik ke Jam——– \n”);
printf (“\n”);
printf (“Masukkan besarnya detik yang akan dikonversi: “);
scanf (“%d”, &S);
J=DetikToJam (S);
TulisJam (J);
}
else if (i==6)
{
printf (“———–Tambah Jam———— \n”);
BacaJam(&J);
if (J.HH<0)
{
}
else if (J.HH<24)
{
if (J.MM<0)
{
}
else if (J.MM<60)
{
if (J.SS<0)
{
}
else if (J.SS9)
{
printf (“Maaf anda memasukkan angka yang salah!!!!\n”);
printf (“\n”);
}
printf (“\n”);
printf (“———TERIMA KASIH———– \n”);
getch();
getch();
}
BATAVIA AIR LINES
#include
#include

typedef struct{
int jam;
int menit;
} waktu;
typedef struct {
char KP[99];
waktu WK;
int SBB;
} Pesawat;
Pesawat P [99];
int i, x=0;

void urutan (Pesawat T[99], int n) {
int x,c;
char temp [99];
while (c<n)
{
if ((T[x]).WK.jam<(T[x+1]).WK.jam)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
else
if ((T[x]).WK.jam==(T[x+1]).WK.jam)
{
if ((T[x]).WK.menit<(T[x+1]).WK.menit)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
else
if ((T[x]).WK.menit==(T[x+1]).WK.menit)
{
if ((T[x]).SBB<(T[x]).SBB)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
}
}
for (x=0;x<i;x++) {
cout << “pesawat ke-“<<x+1<< “:” << P[x+1].KP << ” “<<
P[x+1].WK.jam << “:” << P[x+1].WK.menit << ” ” <<
P[x+1].SBB<< endl;}
}
}

int main()
{
cout <> i;
if (i>0 && i<=100) {
while (x<i){
cout <> P[x].KP;
cout << “masukkan waktu kedatangan: ” << endl <> P[x].WK.jam;
if (P[x].WK.jam>0 && P[x].WK.jam<24) {
cout <> P[x].WK.menit;
if (P[x].WK.menit>0 && P[x].WK.menit<60){
cout <> P[x].SBB;
x++;}
else
cout << “silahkan ulangi kembali \n”;}
else
cout << “silahkan ulangi kembali\n”;}}
else
cout << “Tidak memenuhi kuota yang disediakan” << endl;
urutan (&P[x],i);
system(“PAUSE”);
return 0;
}
MENARA HANOI
#include
#include

typedef struct{
int jam;
int menit;
} waktu;
typedef struct {
char KP[99];
waktu WK;
int SBB;
} Pesawat;
Pesawat P [99];
int i, x=0;

void urutan (Pesawat T[99], int n) {
int x,c;
char temp [99];
while (c<n)
{
if ((T[x]).WK.jam<(T[x+1]).WK.jam)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
else
if ((T[x]).WK.jam==(T[x+1]).WK.jam)
{
if ((T[x]).WK.menit<(T[x+1]).WK.menit)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
else
if ((T[x]).WK.menit==(T[x+1]).WK.menit)
{
if ((T[x]).SBB<(T[x]).SBB)
{
temp=(T[x]).KP;
(T[x]).KP=(T[x+1]).KP;
(T[x+1]).KP=temp;
}
}
}
for (x=0;x<i;x++) {
cout << “pesawat ke-“<<x+1<< “:” << P[x+1].KP << ” “<<
P[x+1].WK.jam << “:” << P[x+1].WK.menit << ” ” <<
P[x+1].SBB<< endl;}
}
}

int main()
{
cout <> i;
if (i>0 && i<=100) {
while (x<i){
cout <> P[x].KP;
cout << “masukkan waktu kedatangan: ” << endl <> P[x].WK.jam;
if (P[x].WK.jam>0 && P[x].WK.jam<24) {
cout <> P[x].WK.menit;
if (P[x].WK.menit>0 && P[x].WK.menit<60){
cout <> P[x].SBB;
x++;}
else
cout << “silahkan ulangi kembali \n”;}
else
cout << “silahkan ulangi kembali\n”;}}
else
cout << “Tidak memenuhi kuota yang disediakan” << endl;
urutan (&P[x],i);
system(“PAUSE”);
return 0;
}
PROBLEM 2-A
#include
#include

struct converted{
char res[100];
int n;
};

char initSymbol(int x);

converted reverse(converted con);

converted convertBase(int a, int b);

int comparedSymbol(converted ab, converted ac);

int simSymbol(int A, int B, int C);

int main()
{
int i, N, A, B, C;
int sim[10], ret;

scanf(“%d”, &N);

for (i = 0; i < N; i++){
scanf(“%d”, &A);
scanf(“%d”, &B);
scanf(“%d”, &C);
sim[i] = simSymbol(A, B, C);
}

scanf(“%d”, &ret);

for (i = 0; i < N; i++){
printf(“%d\n\n”, sim[i]);
}
system(“PAUSE”);
return ret;
}

char initSymbol(int x){
int i;
char c;

for(i = 10, c = ‘A’ ; i < 49; i++, c++){
if(i==36) c = ‘a';
if(x==i) return c;
}
}

converted reverse(converted con){
int i, max = con.n;
char temp;

for(i = 0; i = b){
con.res[i] = initSymbol(a%b);
con.n++;
a /= b;
i++;
}
if (a!=0) con.res[i] = initSymbol(a);

return reverse(con);
}

int comparedSymbol(converted ab, converted ac){
int i, j, count = 0;

for(i = 0; i < ab.n; i++){
for(j = 0; j < ac.n; j++){
if(ab.res[i]==ac.res[j]) count++;
}
}

return count;
}

int simSymbol(int A, int B, int C){
converted AB, AC;

AB = convertBase(A, B);
AC = convertBase(A, C);

return comparedSymbol(AB, AC);
}
STRUKTUR GERBONG
#include
#include
typedef struct
{
int nokursi;
int statuskursi;
} InfoKursi;

typedef struct
{
InfoKursi Kursi[4][10];
}Gbg;

Gbg Gerbong[10];

main()
{
/* Inisialisasi nomor kursi */
int gb, kolom, baris;
gb=0;
while (gb < 10)
{
kolom = 0;
while (kolom < 10)
{
baris = 0;
while (baris < 4 )
{
Gerbong[gb].Kursi[baris][kolom].nokursi = 4 * (kolom) + (baris+1);
// Gerbong[gb].Kursi[baris][kolom].statuskursi = 0;
baris++;
}
kolom++;
}
gb++;
}

/* cetak nomor kursi */
baris = 0;
while (baris < 4)
{
int kolom = 0;
while (kolom < 10 )
{
printf (“%d “,Gerbong[0].Kursi[baris][kolom].nokursi);
kolom++;
}
printf(“\n”);
baris++;
}

system(“pause”);
}
MESIN KARAKTER
#include
#include

#include
#include
#include
#define bool unsigned char
#define true 1
#define false 0

struct TabKar{
char Kar[100];
int Neff;
};

struct TabReal{
float Real[20];
int Neff;
};

bool Angka(char x){
if((isspace(x)) || (x==’.’)) return false;
else return true;
}

void CreateTab(TabKar* T){
(*T).Neff = 0;
}

void IsiTab(TabKar* T){
int i = 0;
printf(“Isi pita : “);
scanf(“%s”, (*T).Kar);
for (i ; i < 100; i++){
(*T).Neff++;
if ((*T).Kar[i]==’.’) break;
}
}

void TransformAngka(TabKar T, TabReal* TR){
int i;
int j = 0;
int k = 0;
char nilai[10];

for (i = 0; i < T.Neff; i++){

while(Angka(T.Kar[i])){
nilai[j] = T.Kar[i];
i++;
j++;
}

(*TR).Real[k] = atof(nilai);
(*TR).Neff++;
k++;
farfree(nilai;
j = 0;

while(!Angka(T.Kar[i])) i++; i -= 1;
}
}

void CariAngkaTerbesar(TabReal TR){
struct {
float First;
float Second;
float Third;
} Biggest;

int i;
Biggest.First = TR.Real[0];
for (i = 1; i Biggest.First)r:{
Biggest.Third = Biggest.Second;
Biggest.Second = Biggest. First;
Biggest.First = TR.Real[i];}
else {if (TR.Real[i] > Biggest.Second){
Biggest.Second = Biggest. First;
Biggest.First = TR.Real[i];}
else if (TR.Real[i] > Biggest.Third)
Biggest.Third = TR.Real[i];}
}

printf(“Angka terbesar : \n”);
printf(“%.1f\n”, Biggest.First);
printf(“%.1f\n”, Biggest.Second);
printf(“%.1f\n”, Biggest.Third);
}

int main(){
TabKar T;
TabReal TR;
CreateTab(&T);
IsiTab(&T);
TransformAngka(T, &TR);
CariAngkaTerbesar(TR);
return 0;
}
MINESWEEPER
/* ========================================================================== */
/* */
/* Minesweeper.c */
/* (c) 2001 Agam Maulana */
/* */
/* Description */
/* */
/* ========================================================================== */

#include

struct Minesweeper{
int Map[100][100];
int Rows;
int Columns;
int Mines;
};

void CreateMap(Minesweeper* MW);
int CountMine(int Row, int Column, Minesweeper MW);
void PrintMap(Minesweeper MW);

int main()
{
Minesweeper MW;
int i;
int Row, Column;

scanf(“%d %d”, &MW.Columns, &MW.Rows);
scanf(“%d”, &MW.Mines);
for (i = 0; i < MW.Mines; i++){
scanf(“%d %d”, &Row, &Column);
MW.Map[Row-1][Column-1] = 9; // int 9 mewakili mine (*)
}

CreateMap(&MW);
PrintMap(MW);

return 0;
}

void CreateMap(Minesweeper* MW){
int Row, Column;

for(Row = 0; Row < (*MW).Rows; Row++){
for(Column = 0; Column < (*MW).Columns; Row++){
if ((*MW).Map[Row][Column]!=9)
(*MW).Map[Row][Column] = CountMine(Row, Column, *MW); // menghitung jumlah mine di sekeliling cell
}
}
}

int CountMine(int Row, int Column, Minesweeper MW){
int Count = 0;
int i, j;

for (i = Row – 1; i <= Row + 1; i++){
for (j = Column – 1; j <= Column + 1; j++){
if (MW.Map[i][j]==9) Count++;
}
}

return Count;
}

void PrintMap(Minesweeper MW){
int i, j;

for (i = 0; i < MW.Rows; i++){
for (j = 0; j < MW.Columns; j++){
printf(“%d”, MW.Map[i][j]);
}
printf(“\n”);
}
}
REKENING BANK
#include
#include

void Satuan(long bilangan){
switch (bilangan){
case 1 : printf(“satu “);break;
case 2 : printf(“dua “);break;
case 3 : printf(“tiga “);break;
case 4 : printf(“empat “);break;
case 5 : printf(“lima “);break;
case 6 : printf(“enam “);break;
case 7 : printf(“tujuh “);break;
case 8 : printf(“delapan “);break;
case 9 : printf(“sembilan “);break;
}
}
void Puluhan(long bilangan){
long bagi = bilangan/10, sisa = bilangan%10;
if (bagi>=2){
Satuan(bagi);printf(“puluh “);}
else{
if (sisa==0)
printf(“sepuluh “);
else{
if (sisa==1){
printf(“sebelas “);printf(“\n”);}
else{
Satuan(sisa);printf(“belas “);
}
}
}
}

void Ratusan(long bilangan){
long bagi = bilangan/100, sisa = bilangan%100;
if (bagi<2)
printf(“seratus “);
else{
Satuan(bagi);printf(“ratus “);}
}

void Ribuan(long bilangan){
long bagi = bilangan/1000, sisa = bilangan%1000;
if (bagi<2)
printf(“seribu “);
else{
Satuan(bagi);printf(“ribu “);}
}

void Jutaan(int bilangan){
long bagi = bilangan/1000000, sisa = bilangan%1000000;
Satuan(bagi);printf(“juta “);
}

void Konversi(long bilangan){
if (bilangan = 10)
Puluhan(bilangan);
else
if (bilangan < 10)
Satuan(bilangan);}
else{
if (bilangan <100){
Puluhan(bilangan);
Konversi(bilangan % 10);}
else{
if (bilangan < 1000){
Ratusan(bilangan);
Konversi(bilangan % 100);}
else{
if (bilangan < 1000000){
Konversi(bilangan / 1000);printf(“ribu “);
Konversi(bilangan % 1000);}
else{
Konversi(bilangan / 1000000);printf(“juta “);
Konversi(bilangan % 1000000);}}}}
}

main()
{
long bil;
printf(“Masukkan bilangan yang akan dikonversi : “);
scanf(“%d”, &bil);
Konversi(bil);
printf(“\n”);
system(“pause”);
}
MASUKAN BILANGAN
#include
#include
int main()
{awal:
int x;
int digs;
printf (“masukan bilangan”);
scanf (“%d”,&x);
x=sqrt(x*x) ;
char buffer[33];
itoa (x,buffer,10);
printf (buffer);
digs=strlen (buffer);
printf (“banyaknya digit adalah:%u “,digs);

goto awal;
}
MASUKAN SATU ABJAD
#include
#include
#include
#include

int main()
{awal:
char abjad;
printf (“masukan satu abjad:”);
scanf (“%c”,&abjad);
switch (abjad)
{
case ‘A': printf (“1\n”);break;
case ‘a': printf (“1\n”);break;
case ‘B': printf (“2\n”);break;
case ‘b': printf (“2\n”);break;
case ‘C': printf (“3\n”);break;
case ‘c': printf (“3\n”);break;
case ‘D': printf (“4\n”);break;
case ‘d': printf (“4\n”);break;
case ‘E': printf (“5\n”);break;
case ‘e': printf (“5\n”);break;
case ‘F': printf (“6\n”);break;
case ‘f': printf (“6\n”);break;
case ‘G': printf (“7\n”);break;
case ‘g': printf (“7\n”);break;
case ‘H': printf (“8\n”);break;
case ‘h': printf (“8\n”);break;
case ‘I': printf (“9\n”);break;
case ‘i': printf (“9\n”);break;
case ‘J': printf (“10\n”);break;
case ‘j': printf (“10\n”);break;
case ‘K': printf (“11\n”);break;
case ‘k': printf (“11\n”);break;
case ‘L': printf (“12\n”);break;
case ‘l': printf (“12\n”);break;
case ‘M': printf (“13\n”);break;
case ‘m': printf (“13\n”);break;
case ‘N': printf (“14\n”);break;
case ‘n': printf (“14\n”);break;
case ‘O': printf (“15\n”);break;
case ‘o': printf (“15\n”);break;
case ‘P': printf (“16\n”);break;
case ‘p': printf (“16\n”);break;
case ‘Q': printf (“17\n”);break;
case ‘q': printf (“17\n”);break;
case ‘R': printf (“18\n”);break;
case ‘r': printf (“18\n”);break;
case ‘S': printf (“19\n”);break;
case ‘s': printf (“19\n”);break;
case ‘T': printf (“20\n”);break;
case ‘t': printf (“20\n”);break;
case ‘U': printf (“21\n”);break;
case ‘u': printf (“21\n”);break;
case ‘V': printf (“22\n”);break;
case ‘v': printf (“22\n”);break;
case ‘W': printf (“23\n”);break;
case ‘w': printf (“23\n”);break;
case ‘X': printf (“24\n”);break;
case ‘x': printf (“24\n”);break;
case ‘Y': printf (“25\n”);break;
case ‘y': printf (“25\n”);break;
case ‘Z': printf (“26\n”);break;
case ‘z': printf (“26\n”);break;
default: printf (“satu huruf aja yak…..\n”);

}
goto awal;

}
MASUKAN KOMPONEN ARRAY
#include
#include
#include
int big;
int n,i,a,c,b=0;
int ket=0;
int nums[10000];
int bandingkan(int x)
{
if (x>10)
{
return 1;

}
else
{
return 0;
}
}
int main()
{ awal:
printf (“\n berapa komponen array yang anda inginkan?\n”);
scanf (“%d”,&n);
while (i<n)
{ printf (“\n masukan komponen array ke %d: \n”,i+1) ;
scanf (“%d”,&nums[i]);
printf (“nilai array ke %d adalah: %d”,i+1,nums[i]);
i+=1;
}

while (i<n)
{
if (bandingkan (nums [i+1])==1)
ket +=1 ;
i +=1;
}
if (ket==0)
{
big=0;
}
else
{
while (i10)
a=nums[i+1]-10;
c=a-b;
if (c<0)
{
b=a;
}
}
big=b ;

}
printf (“%d”,big) ;

goto awal;
system(“PAUSE”);
return 0;
}

Looking for something?

Use the form below to search the site:

Still not finding what you're looking for? Drop a comment on a post or contact us so we can take care of it!