#include <stdio.

h>
#include <stdlib.h>
#define MAX_BIT 100

int w [MAX_BIT];
int z [MAX_BIT];
int v [MAX_BIT];

void gestioneSequenza (void);

int immissionePrimo (void);
int immissioneSecondo (void);
int confrontoAND (int posizoneC, int posizioneD);
int confrontoOR (int posizioneE, int posizioneF);
void confrontoNOT (int ritornoAND, int ritornoOR);
int costruisciVettore ( int dimensionePrimo, int dimensioneSecondo);
void stampaTerzo ( int dimensioneTerzo);
void cercaPrimo ( int posizioneA, int dimensionePrimo);
void cercaSecondo ( int posizioneB, int dimensioneSecondo);

int main(int argc, char *argv[]) {

gestioneSequenza();
}

int immissionePrimo () {

int n;
int i;

do {
printf ("\nQuanti bit desideri inserire? ");
scanf ("%d", &n);
}
while ( n < 1 || n > MAX_BIT);

for ( i = 0; i < n; i++){

do{
printf ("\nInserisci %d � bit: ", i+1);
scanf ("%d", &w[i]);
}
while ( w[i] != 0 && w[i] != 1);
}

return n;

int immissioneSecondo () {

int i;
int n;

do {
printf ("\nQuanti bit desideri inserire? ");
scanf ("%d", &n);
}
while ( n < 1 || n > MAX_BIT);

for ( i = 0; i < n; i++){

 do {
printf ("\nInserisci %d � bit: ", i+1);
scanf ("%d", &z[i]);
}
while ( z[i] != 0 && z[i] != 1);
}

return n;
}

int confrontoAND (int posizioneC, int posizioneD) {

unsigned int a = w [posizioneC];

unsigned int b = z [posizioneD];
unsigned int c = 0;

c = a & b;

printf ("\nL'operazione 'AND' tra %d e %d risulta: %d\n", a, b, c);

return c;

int confrontoOR (int posizioneE, int posizioneF) {

unsigned int a = w [posizioneE];

unsigned int b = z [posizioneF];
unsigned int c = 0;

c = a | b;

printf ("\nL'operazione 'OR' tra %d e %d risulta: %d\n", a, b, c);

return c;

void confrontoNOT (int ritornoAND, int ritornoOR) {

int a = 0;
int b = 0;

a = ritornoAND & ritornoOR;

b = ~a;

printf ("\nL'esito dell' operazione NOT %d e': %d\n", a, b);

int costruisciVettore ( int dimensionePrimo, int dimensioneSecondo){

int i = 0;
int j = 0;
int k, a;

if ( dimensionePrimo < dimensioneSecondo) {

 a = dimensionePrimo;
}
else {
a = dimensioneSecondo;
}

for ( k = 0; k < a; k++){

v [k] = w [i] & z [j];

i++;
j++;
}

return a;
}

void stampaTerzo ( int dimensioneTerzo) {

int i;

for ( i = 0; i < dimensioneTerzo; i++){

printf ("\n %d � bit: %d\n", i+1, v[i]);
}
}

void cercaPrimo ( int posizioneA, int dimensionePrimo) {

if ( posizioneA >= 0 && posizioneA < dimensionePrimo) {

printf ("\nLa posizione %d e' occupata dal bit: %d\n", posizioneA, w
[ posizioneA ]);
}
else {
printf ("\nImmetti una posizione valida e riprova!\n");
}
}

void cercaSecondo ( int posizioneB, int dimensioneSecondo) {

if ( posizioneB >= 0 && posizioneB < dimensioneSecondo) {

printf ("\nLa posizione %d e' occupata dal bit: %d\n", posizioneB, z
[ posizioneB ]);
}
else {
printf ("\nImmetti una posizione valida e riprova!\n");
}
}

void gestioneSequenza () {

int scelta = -1;

int posizioneA, posizioneB, posizioneC, posizioneD, posizioneE, posizioneF;
int dimensionePrimo;
int dimensioneSecondo;
int dimensioneTerzo;
int i, j;
int ritornoAND, ritornoOR;

while ( scelta != 0){

printf("\n *** MENU ***");
 printf ("\n1. Riempi primo vettore.\n");
printf ("\n2. Riempi secondo vettore.\n");
printf ("\n3. Stampa primo vettore.\n");
printf ("\n4. Stampa secondo vettore.\n");
printf ("\n5. Ricerca elemento del primo vettore.\n");
printf ("\n6. Ricerca elemento del secondo vettore.\n");
printf ("\n7. Esegui operazione di 'AND' tra due elementi dei
vettori.\n");
printf ("\n8. Esegui operazione di 'OR' tra due elementi dei
vettori.\n");
printf ("\n9. Esegui operazione di 'NOT' tra l'esito delle operazioni
'7 AND 6'.\n");
printf ("\n10. Riempi un vettore con esito AND degli elementi dei due
vettori.\n");
printf ("\n11. Stampa terzo vettore.\n");
printf ("\n0. Esci dal programma.");
printf ("\n *** FINE MENU ***\n");
printf ("\nScegli un' opzione dal MENU: ");
scanf ("%d", &scelta);
switch (scelta) {
case 1: dimensionePrimo = immissionePrimo ();
break;
case 2: dimensioneSecondo = immissioneSecondo ();
break;
case 3: printf ("\nAdesso stampo il primo vettore...\n");
for ( i = 0; i < dimensionePrimo; i++){
printf ("\n %d � bit: %d", i+1, w[i]);
}
printf ("\n");
break;
case 4: printf ("\nAdesso stampo il secondo vettore...\n");
for ( j = 0; j < dimensioneSecondo; j++){
printf ("\n %d � bit: %d", j+1, z[j]);
}
printf ("\n");
break;
case 5: printf ("\nInserisci posizione del primo vettore che
desideri visualizzare: ");
scanf ("%d", &posizioneA);
cercaPrimo (posizioneA, dimensionePrimo);
break;
case 6: printf ("\nInserisci posizione del secondo vettore
che desideri visualizzare: ");
scanf ("%d", &posizioneB);
cercaSecondo (posizioneB, dimensioneSecondo);
break;
case 7:
do {
printf ("\nInserisci posizione del primo vettore: ");
scanf ("%d", &posizioneC);
} while ( posizioneC < 0 || posizioneC > dimensionePrimo);
do {
printf ("\nInserisci posizione del secondo vettore: ");
scanf ("%d", &posizioneD);
} while ( posizioneD < 0 || posizioneD > dimensioneSecondo);

ritornoAND = confrontoAND (posizioneC, posizioneD);

break;
case 8:
 do {
printf ("\nInserisci posizione del primo vettore: ");
scanf ("%d", &posizioneE);
} while ( posizioneE < 0 || posizioneE > dimensionePrimo);
do {
printf ("\nInserisci posizione del secondo vettore: ");
scanf ("%d", &posizioneF);
} while ( posizioneF < 0 || posizioneF > dimensioneSecondo);

ritornoOR = confrontoOR (posizioneE, posizioneF);

break;
case 9: confrontoNOT (ritornoAND, ritornoOR);
break;
case 10: printf ("\nAdesso costruisco il vettore...\n");
dimensioneTerzo = costruisciVettore (dimensionePrimo,
dimensioneSecondo);
printf ("\nFatto! Premi '11' per visualizzare!\n");
break;
case 11: stampaTerzo (dimensioneTerzo);
break;
} // switch
} //while
}