program database (add,del,show record)

/* DEKLARASI FILE HEADER */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

/* DEKLARASI STRUCT */
typedef struct {
int jml;
}HEADER;

typedef struct {
char nrp[10];
char nama[30];
char alamat[50];
} MHS;

/* DEKLARASI VARIABEL GLOBAL */
FILE *fdata;
MHS data;
HEADER buf;
/* PEMANGGGILAN FUNGSI */
void menu();
void add ();
void del ();
void show ();

/* FUNGSI MAIN */
int main (){
int record=1;

/* OPEN FILE */
if((fdata=fopen(“database_mhs.DAT”,”wb+”))==NULL){
printf(“Maap,,anda belum beruntung!!\n”);
exit(1);
}

printf(“Masukkan jumlah data : “);    //input jml data
scanf(“%d”,&buf.jml);
fwrite(&buf, sizeof(buf), 1, fdata);

for(int i=1;i<=buf.jml;i++){
printf(“\nMahasiswa ke-%d\n”, record);
printf(“NRP\t: “);      //input nrp
fflush(stdin);
gets(data.nrp);
printf(“Nama\t: “);     //input nama
fflush(stdin);
gets(data.nama);
printf(“Alamat\t: “);    //input alamat
fflush(stdin);
gets(data.alamat);
record++;
fwrite(&data, sizeof(data), 1, fdata);
}
system(“cls”);
menu();

fclose(fdata);
getch();
return 0;
}

void menu (){
int ulang;
char pilih;
while (pilih !=9){

printf(“\n\nPROGRAM… “);
printf(“  \n============================”);
printf(“\n1. Add record”);
printf(“  \n2. Delete record”);
printf(“  \n3. Show record”);
printf(“  \n9. Quit”);
printf(“\n=============================”);
printf(“\nWhat do you wanna do? “);
fflush (stdin);
scanf (“%c”, &pilih);
printf (“\n”);
switch (pilih) {
case ‘1′:
add ();
break;
case ‘2′:
del ();
break;
case ‘3′:
show ();
break;
case ‘9′:
exit (0);
break;
default :
printf (“Hoei,, pilihannya cuma 1, 2, 3, ama 9!! …\n”);
}
}
}

void add (){
fseek(fdata, sizeof(buf)+(buf.jml)*(sizeof(data)), SEEK_SET);
printf(“NRP\t: “);
fflush(stdin);
gets(data.nrp);
printf(“Nama\t: “);
fflush(stdin);
gets(data.nama);
printf(“Alamat\t: “);
fflush(stdin);
gets(data.alamat);
fwrite(&data, sizeof(data), 1, fdata);
buf.jml++;
}

void del (){
int record;
printf(“\nMasukkan indeks record yang akan di-delete : “);
scanf(“%d”, &record);

fseek(fdata, sizeof(buf)+(buf.jml-1)*(sizeof(data)), SEEK_SET);
fread(&data, sizeof(data), 1, fdata);
fseek(fdata, sizeof(buf)+((record-1)*sizeof(data)), SEEK_SET);
fwrite(&data, sizeof(data), 1, fdata);
buf.jml–;
}

void show (){
char *nrp;
char *nama;
char *alamat;
int no = 1;
// malloc digunakan u/ mengalokasikan sebuah blok dg ukuran byte dari memori
nrp=(char*)malloc(10);
nama=(char*)malloc(30);
alamat=(char*)malloc(50);

fseek(fdata, sizeof(buf), SEEK_SET);
printf(“%2s. %-10s\t%-15s\t%-20s\n\n”, “No”, “NRP”, “Nama”, “Alamat”);
for(int i=0; i<buf.jml; i++)
{
fread(&data, sizeof(data), 1, fdata);
strncpy(nrp, data.nrp, 10);
nrp[10]=”;
strncpy(nama, data.nama, 30);
nama[30]=”;
strncpy(alamat, data.alamat, 50);
alamat[50]=”;
printf(“%2d. %-10s\t%-15s\t%-20s\n”, no, nrp, nama, alamat);
no++;
}
}

allegro – explosion ball

// Inisialisasi animasi dan sound disiapkan sefolder dg file .cpp
// Input warna dan ukuran bola dari inputan file
// hanya bisa dijalankan di dev-C++ yg berpackage Allegro

#include <allegro.h>
#include <stdio.h>

void init();
//void deinit();

int main() {
init();

/* Inisialisasi buffer */
BITMAP *buffer = create_bitmap(640,480);

/* Inisialisasi animasi ledakan */
BITMAP *bexplo = load_bitmap (“bexplo2.bmp”,NULL);

/* Inisialisasi sound effect */
SAMPLE *sound = load_wav(“Explosion7.wav”);

/* Posisi bola di awal program berjalan */
int x = 640;
int y = 480;
int cl;
int sz;

/* Memanggil file eksternal */
FILE *col = fopen(“ballcolor.txt”, “r”);
FILE *size = fopen(“ballsize.txt”, “r”);

/* Indikator kondisi bola */
bool normal=true;
bool explosion=false;

/* PROGRAM */
fscanf(col,”%i”, &cl);
fscanf(size,”%i”, &sz);

while (!key[KEY_ESC]) {
if (normal==true){
if (x)          // gerak horizontal
x=mouse_x;
if (x < 640)    // kalo g dikasi ni, pas bola di pinggir,
x=(mouse_x-sz);   // bolanya kecantol g bisa balik

if (y)          // gerak vertikal
y=mouse_y;
if (y < 480)    // kalo g dikasi ni, pas bola di atas,
y=(mouse_y-sz);    // bolanya kecantol g bisa balik

clear(buffer);
circlefill(buffer, x, y, sz, cl);
blit (buffer,screen,0,0,0,0,640,480);
}

/* Animasi ledakan */
if (explosion==true)
{
clear(buffer);
blit (bexplo,buffer,0,0,x-37,y-37,640,480);
draw_sprite(screen,buffer,0,0);
play_sample(sound, 127, 127, 1000, 0);
}

explosion=false;  // Untuk menghentikan animasi ledakan

/* Animasi ledakan akan berjalan jika mouse kiri di-klik */
if (mouse_b & 1)
{
explosion=true;
normal=false;
}

/* Jika ditekan tombol spasi, bola akan dimunculkan lagi */
if (key[KEY_SPACE])
{
normal=true;
}

}
//deinit();
fclose(col);
fclose(size);
return 0;
}
END_OF_MAIN()

void init() {
int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}

install_timer();
install_keyboard();
install_mouse();
install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,NULL);
}

//void deinit() {
//    clear_keybuf();

//}

allegro – tuts piano

// preparasi tuts dan sound disiapkan sefolder dg file .cpp
// hanya bisa dijalankan di dev-C++ yg berpackage Allegro

#include <allegro.h>

void init();
void deinit();
volatile int speed_counter = 0;

int main() {
init();

BITMAP *buffer = create_bitmap (588,256);

/* PREPARASI TUTS */
BITMAP *dot = load_bitmap(“do1.bmp”,NULL);
BITMAP *dotb = load_bitmap(“do1b.bmp”,NULL);
BITMAP *ret = load_bitmap(“re.bmp”,NULL);
BITMAP *retb = load_bitmap(“reb.bmp”,NULL);
BITMAP *mit = load_bitmap(“mi.bmp”,NULL);
BITMAP *mitb = load_bitmap(“mib.bmp”,NULL);
BITMAP *fat = load_bitmap(“fa.bmp”,NULL);
BITMAP *fatb = load_bitmap(“fab.bmp”,NULL);
BITMAP *solt = load_bitmap(“sol.bmp”,NULL);
BITMAP *soltb = load_bitmap(“solb.bmp”,NULL);
BITMAP *lat = load_bitmap(“la.bmp”,NULL);
BITMAP *latb = load_bitmap(“lab.bmp”,NULL);
BITMAP *sit = load_bitmap(“si.bmp”,NULL);
BITMAP *sitb = load_bitmap(“sib.bmp”,NULL);

/* PREPARASI SOUND */
SAMPLE *do1 = load_wav(“do.wav”);
SAMPLE *re = load_wav(“re.wav”);
SAMPLE *mi = load_wav(“mi.wav”);
SAMPLE *fa = load_wav(“fa.wav”);
SAMPLE *sol = load_wav(“sol.wav”);
SAMPLE *la = load_wav(“la.wav”);
SAMPLE *si = load_wav(“si.wav”);
//SAMPLE *do2 = load_wav(“fx.wav”);

/* NGE-BLIT TUTS */
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,680,256);

draw_sprite (screen,buffer,0,0);

while (!key[KEY_ESC]) {

if(key[KEY_C]){
clear_bitmap(buffer);
blit (dotb,buffer,0,0,0,0,680,256);
blit (ret,buffer,0,0,85,0,680,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (do1,255,0,2000,0);
blit (dot,buffer,0,0,0,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_D]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (retb,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (re,255,0,2000,0);
blit (ret,buffer,0,0,85,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_E]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mitb,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (mi,255,0,2000,0);
blit (mit,buffer,0,0,170,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_F]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fatb,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (fa,255,0,2000,0);
blit (fat,buffer,0,0,255,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_G]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (soltb,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (sol,255,0,2000,0);
blit (solt,buffer,0,0,340,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_A]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (latb,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (la,255,0,2000,0);
blit (lat,buffer,0,0,425,0,588,256);
draw_sprite (screen,buffer,0,0);
}
else if(key[KEY_B]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sitb,buffer,0,0,510,0,588,256);
//blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (si,255,0,2000,0);
blit (sit,buffer,0,0,510,0,588,256);
draw_sprite (screen,buffer,0,0);
}
/*else if(key[KEY_L]){
clear_bitmap(buffer);
blit (dot,buffer,0,0,0,0,588,256);
blit (ret,buffer,0,0,85,0,588,256);
blit (mit,buffer,0,0,170,0,588,256);
blit (fat,buffer,0,0,255,0,588,256);
blit (solt,buffer,0,0,340,0,588,256);
blit (lat,buffer,0,0,425,0,588,256);
blit (sit,buffer,0,0,510,0,588,256);
blit (dotb,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
play_sample (do2,255,0,2000,0);
blit (dot,buffer,0,0,595,0,588,256);
draw_sprite (screen,buffer,0,0);
}*/

}

deinit();
return 0;
}
END_OF_MAIN()

void init() {
int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 588, 256, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}

install_timer();
install_keyboard();
install_mouse();

install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,NULL);
/* add other initializations here */
}

void deinit() {
clear_keybuf();
/* add other deinitializations here */
}

program database perpustakaan

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

int main (){
struct perpus{
char judul [30];
char pengarang [30];
char penerbit [30];
int jumlah;
}buku;

FILE *pf;
FILE *pr = fopen (“perpustakaan.dat”,”rb”);

int nomor;
char ulang,pilih;
do {
puts(“\n\nMENU …\n\n”);
puts(“1.Inputkan Data”);
puts(“2.Tampilkan Data\n\n”);
printf (“Pilihan Anda : “);

pilih = getche();

switch(pilih){
case ‘1′:
pf = fopen (“perpustakaan.dat”,”ab”);

if (pr==NULL){
puts(“Anda belum beruntung..!”);
exit(1); }
fflush (stdin);
puts (“\n”);
printf (“Judul Buku \t:”);gets(buku.judul);
printf (“Pengarang \t:”);gets(buku.pengarang);
printf (“Penerbit \t:”);gets(buku.penerbit);
printf (“Jumlah buku \t:”);scanf(“%i”,&buku.jumlah);

fwrite (&buku,sizeof(buku),1,pf);
//fseek (pf,0,SEEK_SET);
fclose(pf);
break;
case ‘2′:
//fseek (pr,0,SEEK_SET);
puts (“\n”);

printf(“%2s. %-10s\t%-10s\t%-10s\t%s\n\n”, “No”, “Judul Buku”, “Nama Pengarang”, “Penerbit”, “Jumlah”);
nomor=1;
while (fread (&buku,sizeof(buku),1,pr)==1){
printf (“%2d. %-10s\t%-10s\t%-10s\t%d\n\n”, nomor++, buku.judul, buku.pengarang, buku.penerbit, buku.jumlah);

} break;

default :
continue;
}
do{
printf (“\n\nIngin mengulang??”);
ulang = getche();
}while (!(ulang == ‘y’ || ulang == ‘Y’ || ulang == ‘t’ || ulang == ‘T’));

} while (ulang == ‘y’ || ulang == ‘Y’);

fclose(pf);
fclose(pr);
getch();
return 1;

}

program find and replace

// input dan output file .txt telah diciptakan dulu

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
char kalimat_baru[30];
void replace(char *input,char *diganti, char *pengganti);

int main (){
FILE *fr;
FILE *fp;
int huruf;
char jawaban;
int sudah_benar;
char nama_file[50];//string[30];
//struct {
char input [30];
char diganti [30];
char pengganti [30];
//}kata;
printf(“Masukkan nama file : “);
scanf(“%s”,nama_file);

if ((fp = fopen(nama_file,”r”))==NULL){
printf(“File tidak dapat diciptakan !! \n”);
exit (1);}

int a=0;
while(huruf != EOF) {
huruf=fgetc(fp);
if(huruf != EOF)
{input[a]=huruf;}
else
{input[a] = ”;}
a++;
}

puts(input);

do {
printf(“masukkan string yang ingin diganti :”);
fflush(stdin);
gets(diganti);
printf(“diganti dengan :”);
gets(pengganti);
replace(input,diganti,pengganti); //yang di akses bukan input tetatpi string dalam file replce.txt

// fprintf(fp, “!!!%s \t%s \t%s”,input, diganti, pengganti);

if ((fr = fopen(“replace-1.TXT”,”w”))==NULL){
printf(“File tidak dapat diciptakan !! \n”);
exit (1);}

fprintf(fr,”%s\n”,kalimat_baru);           //akses melalui file replace.txt

printf(“\n”);

printf(“Mau menginputkan data lagi?? [y/t]“);
do{
jawaban = getchar();
sudah_benar = ((jawaban==’Y')||(jawaban==’y')||(jawaban==’T')||(jawaban==’t'));
}while(!sudah_benar);
printf(“\n”);
} while (jawaban==’Y'||jawaban==’y');

fclose(fr);
fclose(fp);

getch();
}

void replace(char *input,char *diganti, char *pengganti)
{

char temp[30];
int p_pengganti,p_input,p_diganti;
int idx_temp,idx_kal=0,idx_pgganti=0,idx_dganti=0;

p_input=strlen(input);
p_diganti=strlen(diganti);
p_pengganti=strlen(pengganti);

if(p_pengganti>1)
{
for(int i=0; i<p_input; i++)
{
strncpy(temp, &input[i], p_diganti);
temp[p_diganti+i]=”;
if(strcmp(diganti, temp)==0)
{
strncat(kalimat_baru, input,i);
kalimat_baru[i+1]=”;
strcat(kalimat_baru, pengganti);
strcat(kalimat_baru, &input[i + p_diganti]);
}
}printf(“\nKalimat yang baru: %s”, kalimat_baru);
}

else
{
for(int i=0; i<p_input; i++)
{
if(input[i]==diganti[0])
{
idx_temp=i;
strncpy(temp,&input[i],i);
for(int a=p_pengganti;a>0;a–)

input[idx_temp]=pengganti[idx_pgganti];
idx_temp++; {
}
}
}printf(“\nKalimat yang baru: %s”,input);
}
}

program pemantau IPK

// output file .txt

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

struct daftar {
char nama[20];
float ipk;
} ranking[20];

FILE *pw;
void kategori(int n);
void sorting(int n);

main(){
int i,n;
char jawab;

if((pw=fopen(“pptmod4-1.txt”,”wt”))==NULL){
printf(“File tidak dapat diciptakan!!\n”);
exit(1);
}

do{
printf(“Masukkan jumlah mahasiswa : “);
scanf(“%d”,&n);

for(i=0;i<n;i++)
{
printf(“\nMasukkan nama mahasiswa ke-%d : “,i+1);
fflush (stdin);
gets(ranking[i].nama);
printf(“Masukkan IPK : “);
fflush (stdin);
scanf(“%f”, &ranking[i].ipk);
}

printf(“\n\nMau mengulang (y/t) ?? “);
fflush(stdin);
jawab=getch();
printf(“%c\n”,jawab);
}while (jawab==’y'||jawab==’Y');

sorting(n);
kategori(n);
fclose(pw);

getch();
}

void sorting(int n){
daftar temp[20];

for (int i=0; i<=n; i++)
{
for (int j=0; j<=n; j++)
{
if(ranking[i].ipk>ranking[j].ipk)
{
temp[i]=ranking[i];
ranking[i]=ranking[j];
ranking[j]=temp[i];
}
}
}

}

void kategori(int n){
int i;int x=0;
fprintf(pw,”\n*** Dengan Pujian ***\n”);
for ( i=0;i<n;i++)
{
if(ranking[i].ipk>=3.51 && ranking[i].ipk<=4.00)
{fprintf(pw,”%s\t%.2f\n”,ranking[i].nama,ranking[i].ipk);x++;}
else
{
break;
}
}
if (x==0)
fprintf (pw,”Tidak ada\n”);
x=0;

fprintf(pw,”\n*** Sangat Memuaskan ***\n”);
for (  ;i<n;i++)
{
if(ranking[i].ipk>=2.76 && ranking[i].ipk<=3.50)
{fprintf(pw,”%s\t%.2f\n”,ranking[i].nama,ranking[i].ipk);x++;}
else
{
break;
}
}
if (x==0)
fprintf (pw,”Tidak ada\n”);
x=0;

fprintf(pw,”\n*** Memuaskan ***\n”);
for (  ;i<n;i++)
{
if(ranking[i].ipk>=2.00 && ranking[i].ipk<=2.75)
{fprintf(pw,”%s\t%.2f\n”,ranking[i].nama,ranking[i].ipk);x++;}
else
{
break;
}
}
if (x==0)
fprintf (pw,”Tidak ada\n”);
x=0;

fprintf(pw,”\n*** Tidak Lulus ***\n”);
for (  ;i<n;i++)
{
if(ranking[i].ipk<2.00)
{fprintf(pw,”%s\t%.2f\n”,ranking[i].nama,ranking[i].ipk);x++;}
else
{
break;
}
}
if (x==0)
fprintf (pw,”Tidak ada\n”);

fprintf(pw,”\n*** Ranking IPK ***\n”);
for (int i=0;i<n;i++)
{
fprintf(pw,”%s\t%.2f\n”,ranking[i].nama,ranking[i].ipk);
}

}

program simulasi pemilu

#include <stdio.h>
#include <conio.h>
#define MAX_PARTY 10
#define MAX_REGION 10

void tampilkanDataTabel(int tabel[][MAX_REGION], char partai[][30], char wilayah[][30], int totalPartai, int totalWilayah);
void registrasi(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30], char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION]);
void update(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION]);
void totalPerPartai(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION]);
void totalPerWilayah(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION]);

int main() {
//deklarasi variabel string penyimpan nama partai dan nama wilayah
char namaPartai[MAX_PARTY][30];
char namaWilayah[MAX_REGION][30];
//deklarasi variabel pendukung tabel partai
int tabelPartai[MAX_PARTY][MAX_REGION];
int totalPartai;
int totalWilayah;
int datanil[MAX_REGION][MAX_REGION];

printf (“=============================================================\n”);
printf (“=============      PROGRAM SIMULASI PEMILU      =============\n”);
printf (“=============================================================\n”);

//input total partai dan total wilayah
printf(“\nBerapa jumlah partai yang ingin diujikan: “);
fflush(stdin);
scanf(“%d”, &totalPartai);
printf(“\nBerapa jumlah wilayah yang ingin diujikan: “);
fflush(stdin);
scanf(“%d”, &totalWilayah);
printf(“\n\n”);
//input nama wilayah dan nama partai
for (int i=0; i<totalPartai; i++) {
printf(“\nNama Partai ke-%d -> “,i+1);
fflush(stdin);
scanf(“%s”, namaPartai[i]);
}
printf(“\n\n”);
for (int i=0; i<totalWilayah; i++) {
printf(“\nNama Wilayah ke-%d -> “,i+1);
fflush(stdin);
scanf(“%s”, namaWilayah[i]);
}

char ulang = ‘t’;
do {
char pilih;
printf(“\n\n\nProgram telah siap. “);
printf(“    \n=============================================================”);
printf(“  \n\n1. Tampilkan data tabel sementara.”);
printf(“    \n2. Registrasi data awal.”);
printf(“    \n3. Update data.”);
printf(“    \n4. Tampilkan data total suara per partai untuk semua wilayah.”);
printf(“    \n5. Tampilkan data total suara per wilayah untuk semua partai.”);
printf(“  \n\n=============================================================”);
printf(“\n\n\nApa yang ingin Anda lakukan: “);
fflush (stdin);
scanf (“%c”, &pilih);
switch (pilih) {
case ‘1′:
tampilkanDataTabel(tabelPartai, namaPartai, namaWilayah, totalPartai, totalWilayah);
break;
case ‘2′:
registrasi(totalPartai,totalWilayah,namaPartai,namaWilayah,datanil);
break;
case ‘3′:
update(totalPartai,totalWilayah,namaPartai,namaWilayah,datanil);
break;
case ‘4′:
totalPerPartai(totalPartai,totalWilayah,namaPartai,namaWilayah,datanil);
break;
case ‘5′:
totalPerWilayah(totalPartai,totalWilayah,namaPartai,namaWilayah,datanil);
break;
case ‘6′:
printf (“Anda ingin keluar program?? Klik aja tanda silang di pojok kanan atas!!”);
break;
default :
printf (“Pilihan Anda salah …\n”);
}

do{
printf (“\n\nAnda Ingin Mengulang Pilihan? (y/t)”);
fflush (stdin);
scanf (“%c”, &ulang);
}while(ulang!=’y'&&ulang!=’t'&&ulang!=’Y'&&ulang!=’T');
}while(ulang==’y'||ulang==’Y');
}

void tampilkanDataTabel(int tabel[][MAX_REGION], char partai[][30], char wilayah[][30], int totalPartai, int totalWilayah){
printf (“\n\n\nDATA TABEL\n============\n”);

printf (“INDEKS PARTAI:\n=======\n\n”);
for (int i=0; i<totalPartai; i++) {
printf (“%d) %s\t”, i+1, partai[i]);
}
char iterasi=’a';
printf (“\n\nINDEKS WILAYAH:\n=======\n\n”);
for (int i=0; i<totalWilayah; i++) {
printf (“%c) %s\t”, iterasi, wilayah[i]);
iterasi++;
}
}

void registrasi(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION])
{
int i,j;
printf(“\nMasukkan Jumlah Suara\n”);
for(i=0;i<totalPartai;i++)
{
printf(“\nPartai %s\n”,namaPartai[i]);
for(j=0;j<totalWilayah;j++)
{
printf(“Wilayah %s = “,namaWilayah[j]);
scanf(“%d”,&datanil[i][j]);
}
printf(“\n”);
}
}

void update(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION])
{
printf(“\nTabel Perolehan suara :\n”);
int i,j,m,n;
for(j=0;j<=totalPartai+1;j++)
{
for(i=0;i<=totalWilayah+1;i++)
{
if(i==0 && j==0)
printf(“\t”);
else if(j==0 && i!=0)
{
if(i==totalWilayah+1)
printf(“Jumlah”);
else
printf(“  %s\t”,namaWilayah[i-1]);
}
else if(i==0 && j!=0)
{
if(j==totalPartai+1)
printf(“Jumlah\t”);
else
printf(“%s\t”,namaPartai[j-1]);
}
else if(i!=0 && j==totalPartai+1 && i!=totalWilayah+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
sum=sum+datanil[n][i-1];
printf(“%3d\t”,sum);
}
else if(j!=0 && i==totalWilayah+1 && j!=totalPartai+1)
{
int sum=0;
for(n=0;n<totalWilayah;n++)
sum=sum+datanil[j-1][n];
printf(“%3d\t”,sum);
}
else if(i==totalWilayah+1 && j==totalPartai+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
{
for(m=0;m<totalWilayah;m++)
{
sum=sum+datanil[n][m];
}
}
printf(“%3d”,sum);
}
else
printf(“%3d\t”,datanil[j-1][i-1]);
}
printf(“\n”);
}
}

void totalPerPartai(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION])
{
printf(“\nTabel Perolehan suara :\n”);
int i,j,m,n;
for(j=0;j<=totalPartai+1;j++)
{
for(i=0;i<=totalWilayah+1;i++)
{
if(i==0 && j==0)
printf(“\t”);
else if(j==0 && i!=0)
{
if(i==totalWilayah+1)
printf(“Jumlah”);
else
printf(“  %s\t”,namaWilayah[i-1]);
}
else if(i==0 && j!=0)
{
if(j==totalPartai+1)
printf(“      \t”);
else
printf(“%s\t”,namaPartai[j-1]);
}
else if(i!=0 && j==totalPartai+1 && i!=totalWilayah+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
sum=sum+datanil[n][i-1];
//printf(“%3d\t”,sum);
}
else if(j!=0 && i==totalWilayah+1 && j!=totalPartai+1)
{
int sum=0;
for(n=0;n<totalWilayah;n++)
sum=sum+datanil[j-1][n];
printf(“%3d\t”,sum);
}
else if(i==totalWilayah+1 && j==totalPartai+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
{
for(m=0;m<totalWilayah;m++)
{
sum=sum+datanil[n][m];
}
}
//printf(“%3d”,sum);
}
else
printf(“%3d\t”,datanil[j-1][i-1]);
}
printf(“\n”);
}
}

void totalPerWilayah(int totalPartai,int totalWilayah,char namaPartai[MAX_PARTY][30],char namaWilayah[MAX_REGION][30],int datanil[MAX_REGION][MAX_REGION])
{
printf(“\nTabel Perolehan suara :\n”);
int i,j,m,n;
for(j=0;j<=totalPartai+1;j++)
{
for(i=0;i<=totalWilayah+1;i++)
{
if(i==0 && j==0)
printf(“\t”);
else if(j==0 && i!=0)
{
if(i==totalWilayah+1)
printf(” “);
else
printf(“  %s\t”,namaWilayah[i-1]);
}
else if(i==0 && j!=0)
{
if(j==totalPartai+1)
printf(“Jumlah\t”);
else
printf(“%s\t”,namaPartai[j-1]);
}
else if(i!=0 && j==totalPartai+1 && i!=totalWilayah+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
sum=sum+datanil[n][i-1];
printf(“%3d\t”,sum);
}
else if(j!=0 && i==totalWilayah+1 && j!=totalPartai+1)
{
int sum=0;
for(n=0;n<totalWilayah;n++)
sum=sum+datanil[j-1][n];
//printf(“%3d\t”,sum);
}
else if(i==totalWilayah+1 && j==totalPartai+1)
{
int sum=0;
for(n=0;n<totalPartai;n++)
{
for(m=0;m<totalWilayah;m++)
{
sum=sum+datanil[n][m];
}
}
//printf(“%3d”,sum);
}
else
printf(“%3d\t”,datanil[j-1][i-1]);
}
printf(“\n”);
}
}

program blob-check

#include <stdio.h>
#include <conio.h>
int a,b;
int jumlah = 0;
void input_blob(int [7][7]);
void blob_check(int [7][7],int x,int y);

main()
{
printf (“============================================\n”);
printf (” Praktikum Pemrograman Terstruktur Modul 3 shift 1\n”);
printf (” PROGRAM BLOB_CHECK\n”);
printf (“============================================\n\n\n”);

int array[7][7];
input_blob(array);
if(array[a][b]==1){
blob_check(array,a,b);
printf(“Jumlah blob : %d”,jumlah+1);}
else if(array[a][b] == 0)
printf(“Input Anda bukan termasuk anggota blob”);

getch();
}

//unt input blob
void input_blob(int array[7][7]){
printf (“Masukkan blob ke dalam array 5×5\n”);
printf (” 1 untuk mengisi blob\n 0 untuk mengosongkan blob”);
printf (” \n<pengisian dilakukan secara horizontal>\n\n”);

for(int p = 1 ; p <6; p++)
{
for(int q = 1; q <6; q++)
{
array[p][q] = 0;
}
}

int tes;
for(int x=1;x<6;x++)
{
for(int y=1;y<6;y++)
{
do{
printf(“array [%d][%d] : “,x,y); //input blob
fflush(stdin);
tes = scanf(“%d”,&array[x][y]);
}while(tes==0 || array[x][y]<0 || array[x][y]>1);
}
}

printf(“\nArray: \n”);
for(int x=1; x<6; x++)
{
for(int y=1; y<6; y++)
{
printf(“%4d”, array[x][y]);
}
printf(“\n”);
}
printf(“\n”);

printf(“\nMasukkan posisi blob dalam array yang akan dicheck\n “);
printf (” x (1-5)= “);
scanf(“%d”,&a);
printf (” y (1-5)= “);
scanf(“%d”,&b);
}

void blob_check(int array[7][7],int x,int y){
array[x][y] = 0;
for(int i=-1;i<=1;i++)
for(int j=-1;j<=1;j++)
{
if(array[x+i][y+j] == 1)
{
jumlah++;
blob_check(array,x+i,y+j);
}
}

}

program enkripsi-dekripsi

#include<stdio.h>
#include<conio.h>

float enkripsi (char s[20],int key[]);
float dekripsi (char s[20],int key[]);
int length(char s[]);

int main()
{
int i,n;
char s[50];
printf(“Ketikkan suatu string : “);
scanf(“%s”,&s);

printf (“\n”);

length(s);
n=length(s);

int key[n];

for(int i=0;i<n;i++)
{
printf(“Pergeseran karakter ke-%d = “,i+1);
scanf(“%d”,&key[i]);
}

enkripsi (s,key);
dekripsi (s,key);

getch();
}

float enkripsi (char s[20],int key[])
{
for(int i=0;s[i]!=”;i++)
s[i]=s[i]+key[i];
printf(“\nEnkripsi : %s\n”,s);
}

float dekripsi (char s[20],int key[])
{
for(int i=0;s[i]!=”;i++)
s[i]=s[i]-key[i];
printf(“\nDekripsi : %s\n”,s);
}

int length(char s[])
{
int n=0;
while (s[n]!=”){
n++;}
return n ;
}

program konversi uang ke koin

# include <stdio.h>
# include <conio.h>
int konversi(int koin1,int koin2, int koin3, int koin4, int n, int i,int jumkoin);
int main(){
int koin1,koin2,koin3,koin4;
int n=100, i=1;

printf (“=================================================\n”);
printf (“                         PROGRAM TUKAR UANG JADI KOIN\n”);
printf (“=================================================\n\n\n”);
//printf(“\n\n”);
printf(“Masukkan nilai koin ke-1: “);
scanf(“%d”,&koin1);
//printf(“\n”);
printf(“Masukkan nilai koin ke-2: “);
scanf(“%d”,&koin2);
//printf(“\n”);
printf(“Masukkan nilai koin ke-3: “);
scanf(“%d”,&koin3);
//printf(“\n”);
printf(“Masukkan nilai koin ke-4: “);
scanf(“%d”,&koin4);
printf(“\n”);

for (i=1;i<=n;i++){
printf(“Rp %3d,00 = “,i);
konversi(koin1,koin2,koin3,koin4,n,i,1);
printf(“\n”);
}

getch();
}

int konversi(int koin1,int koin2, int koin3, int koin4, int n, int i,int jumkoin){
int p;
if(jumkoin==5)
return 1;
else
p=i;
while (p>=koin4){
printf (” %3d “, koin4);
p=p-koin4;
jumkoin++;
if (jumkoin>=7){
printf (“  Melebihi jumlah koin yg dijatah”);
return 1; }
}

while (p>=koin3){
printf (” %3d “, koin3);
p=p-koin3;
jumkoin++;
if (jumkoin>=7){
printf (“  Melebihi jumlah koin yg dijatah”);
return 1; }
}

while (p>=koin2){
printf (” %3d “, koin2);
p=p-koin2;
jumkoin++;
if (jumkoin>=7){
printf (“  Melebihi jumlah koin yg dijatah”);
return 1; }
}

while (p>=koin1){
printf (” %3d “, koin1);
p=p-koin1;
jumkoin++;
if (jumkoin>=7){
printf (“  Melebihi jumlah koin yg dijatah”);
return 1; }
}

}