Programa que demani una lletra i digui si és vocal (incloent accents) o consonant, amb if.
#include <stdio.h> /* Inclou la biblioteca estàndard d'entrada/sortida */
/* Necessària per a printf() i scanf() */
int main(){ /* Funció principal del programa, punt d'entrada d'execució */
char lletra; /* Declara una variable de tipus char per emmagatzemar un sol caràcter */
/* 'char' ocupa 1 byte i pot contenir caràcters ASCII o UTF-8 */
printf("Introdueix una lletra: "); /* Demana a l'usuari que introdueixi una lletra */
/* El missatge apareix a la consola sense salt de línia */
scanf(" %c", &lletra); /* Llegeix un sol caràcter introduït per l'usuari */
/* L'espai abans de %c ignora qualsevol espai o salt de línia pendent */
/* %c és el marcador de format per a caràcters individuals */
/* &lletra passa l'adreça de memòria on s'emmagatzemarà el caràcter */
/* Comprovació de vocals minúscules amb accents */
if(lletra=='a' || lletra=='e' || lletra=='i' || lletra=='o' || lletra=='u')
/* '||' és l'operador lògic OR: es compleix si ALMENYS una condició és certa */
/* Cometes simples '' delimiten caràcters individuals en C */
printf("Es una vocal.\n"); /* Missatge si la lletra és una vocal minúscula sense accent */
/* Comprovació de vocals majúscules amb accents */
else if(lletra=='A' || lletra=='E' || lletra=='I' || lletra=='O' || lletra=='U')
/* 'else if' s'executa només si la condició anterior era falsa */
printf("Es una vocal.\n"); /* Missatge si la lletra és una vocal majúscula sense accent */
/* Comprovació de vocals amb accent (minúscules) */
else if(lletra=='à' || lletra=='è' || lletra=='é' || lletra=='í' || lletra=='ò' || lletra=='ó' || lletra=='ú')
/* Comprovació explícita de caràcters accentuats en minúscula */
/* Cada caràcter accentuat es compara individualment amb == */
printf("Es una vocal accentuada.\n"); /* Missatge específic per a vocals amb accent */
/* Comprovació de vocals amb accent (majúscules) */
else if(lletra=='À' || lletra=='È' || lletra=='É' || lletra=='Í' || lletra=='Ò' || lletra=='Ó' || lletra=='Ú')
/* Comprovació de vocals accentuades en majúscula */
printf("Es una vocal accentuada.\n"); /* Missatge per a vocal accentuada majúscula */
/* Comprovació de consonants (lletres que no són vocals) */
else if((lletra>='a' && lletra<='z') || (lletra>='A' && lletra<='Z'))
/* '&&' és l'operador lògic AND: es compleix si TOTES les condicions són certes */
/* Comprova si el caràcter està en el rang de lletres minúscules (a-z) */
/* O si està en el rang de lletres majúscules (A-Z) */
printf("Es una consonant.\n"); /* Missatge si és una lletra però no és vocal */
else /* S'executa si cap de les condicions anteriors era certa */
printf("No es una lletra valida.\n"); /* Missatge per a caràcters no alfabètics */
return 0; /* Retorna 0 al sistema operatiu indicant execució correcta */
/* El valor 0 és l'estàndard per indicar èxit en C */
}
Amb un bucle while, llegeix enters fins que l'usuari introdueixi 0 i mostra la suma total.
#include <stdio.h> /* Inclou la biblioteca estàndard d'entrada/sortida */
/* Proporciona printf() i scanf() */
int main(){ /* Funció principal del programa */
int nombre; /* Declara una variable enter per emmagatzemar cada nombre introduït */
/* Aquesta variable s'actualitzarà en cada iteració del bucle */
int suma = 0; /* Declara i inicialitza la variable acumuladora a 0 */
/* És crucial inicialitzar a 0 per començar la suma correctament */
/* Sense inicialització, contindria un valor aleatori (escombraries) */
printf("Introdueix nombres enters (0 per acabar):\n"); /* Instruccions per a l'usuari */
/* \n afegeix un salt de línia al final */
printf("Nombre: "); /* Demana el primer nombre */
scanf("%d", &nombre); /* Llegeix un enter i l'emmagatzema a 'nombre' */
/* %d és el marcador per a enters decimals */
/* &nombre passa l'adreça de la variable */
while(nombre != 0){ /* Inicia un bucle while que s'executa mentre nombre sigui diferent de 0 */
/* '!=' és l'operador de comparació 'diferent de' */
/* La condició s'avalua abans de cada iteració */
/* Si la condició és falsa des del principi, el bucle no s'executa */
suma = suma + nombre; /* Acumula el valor actual de 'nombre' a la variable 'suma' */
/* 'suma + nombre' calcula la suma actual */
/* El resultat s'assigna de nou a 'suma' amb l'operador = */
/* Equivalent a: suma += nombre; */
printf("Nombre: "); /* Demana un nou nombre dins del bucle */
scanf("%d", &nombre); /* Llegeix el següent nombre de l'usuari */
/* Aquesta lectura actualitza 'nombre' per a la següent iteració */
} /* Fi del bucle while: torna a comprovar la condició */
printf("La suma total es: %d\n", suma); /* Quan el bucle acaba (nombre==0), mostra la suma */
/* %d mostra el valor enter de 'suma' */
/* \n afegeix un salt de línia al final */
return 0; /* Finalitza el programa retornant 0 (èxit) */
}
Crea una funció char complementaria(char base) que retorni la base complementària (A↔T, C↔G).
#include <stdio.h> /* Inclou la biblioteca estàndard d'entrada/sortida */
/* Necessària per a printf() i scanf() */
/* Declaració (prototip) de la funció complementaria */
/* Això informa al compilador que la funció existeix abans d'usar-la */
char complementaria(char base); /* La funció rep un char i retorna un char */
/* 'char' és el tipus de retorn (el valor que retorna la funció) */
/* 'base' és el paràmetre que rep la funció */
int main(){ /* Funció principal */
char base_adn; /* Variable per emmagatzemar la base d'ADN introduïda */
printf("Introdueix una base d'ADN (A, C, G, T): "); /* Demana una base a l'usuari */
scanf(" %c", &base_adn); /* Llegeix un caràcter i l'emmagatzema */
/* L'espai abans de %c ignora caràcters en blanc */
/* Crida a la funció complementaria i mostra el resultat */
char base_complementaria = complementaria(base_adn); /* Crida la funció amb base_adn com argument */
/* El valor retornat s'emmagatzema a base_complementaria */
/* 'base_adn' és l'argument que es passa a la funció */
if(base_complementaria != '?') /* Comprova si la funció ha retornat un valor vàlid */
/* '?' és el valor d'error que retorna la funció */
printf("Base complementaria: %c\n", base_complementaria); /* Mostra la base complementària */
else
printf("Base no valida.\n"); /* Missatge d'error si la base no era A, C, G o T */
return 0; /* Finalitza el programa */
}
/* Implementació de la funció complementaria */
/* Aquesta és la definició real de la funció declarada anteriorment */
char complementaria(char base){ /* La funció rep un paràmetre 'base' de tipus char */
/* Retorna un valor de tipus char */
if(base == 'A') /* Comprova si la base és Adenina */
return 'T'; /* Si és A, retorna Timina (la seva complementària) */
/* 'return' finalitza la funció i retorna el valor especificat */
else if(base == 'T') /* Comprova si la base és Timina */
return 'A'; /* Si és T, retorna Adenina */
else if(base == 'C') /* Comprova si la base és Citosina */
return 'G'; /* Si és C, retorna Guanina */
else if(base == 'G') /* Comprova si la base és Guanina */
return 'C'; /* Si és G, retorna Citosina */
else
return '?'; /* Si no és cap base vàlida, retorna '?' com a indicador d'error */
/* Això permet al programa principal detectar entrades incorrectes */
}
Escriu una funció que, donada una cadena d'ADN, retorni la seva inversa complementària (ex: "ATGC" → "GCAT").
#include <stdio.h> /* Inclou la biblioteca estàndard per a entrada/sortida */
#include <string.h> /* Inclou la biblioteca per a funcions de manipulació de cadenes */
/* Necessària per a strlen() que calcula la longitud d'una cadena */
/* Declaració de la funció inversa_complementaria */
/* Aquesta funció modifica la cadena original (no retorna un valor) */
void inversa_complementaria(char adn[]); /* 'void' indica que la funció no retorna cap valor */
/* 'char adn[]' és un array de caràcters (cadena) */
/* Els arrays es passen per referència, no per valor */
int main(){ /* Funció principal */
char adn[100]; /* Declara un array de 100 caràcters per emmagatzemar la seqüència */
/* 100 és suficient per a una seqüència de fins a 99 caràcters + '\0' */
printf("Introdueix una sequencia d'ADN: "); /* Demana la seqüència a l'usuari */
scanf("%99s", adn); /* Llegeix fins a 99 caràcters per evitar desbordaments */
/* %99s limita la lectura a 99 caràcters */
/* L'últim espai es reserva per al caràcter nul '\0' */
printf("Sequencia original: %s\n", adn); /* Mostra la seqüència abans de modificar-la */
inversa_complementaria(adn); /* Crida a la funció passant l'array adn */
/* Com que els arrays es passen per referència, */
/* la funció modificarà directament l'array original */
printf("Inversa complementaria: %s\n", adn); /* Mostra la seqüència ja modificada */
return 0; /* Finalitza el programa */
}
/* Implementació de la funció inversa_complementaria */
void inversa_complementaria(char adn[]){ /* Rep un array de caràcters */
/* 'void' significa que no retorna res, modifica l'array directament */
int longitud = strlen(adn); /* Calcula la longitud de la cadena amb strlen() */
/* strlen() compta els caràcters fins a trobar '\0' */
/* El resultat s'emmagatzema en una variable enter */
/* Primera fase: convertir cada base a la seva complementària */
for(int i = 0; i < longitud; i++){ /* Bucle que recorre tota la cadena */
/* i va de 0 fins a longitud-1 */
if(adn[i] == 'A') /* Si el caràcter actual és A */
adn[i] = 'T'; /* El substitueix per T */
else if(adn[i] == 'T') /* Si és T */
adn[i] = 'A'; /* El substitueix per A */
else if(adn[i] == 'C') /* Si és C */
adn[i] = 'G'; /* El substitueix per G */
else if(adn[i] == 'G') /* Si és G */
adn[i] = 'C'; /* El substitueix per C */
/* Si no és cap base vàlida, es deixa igual */
}
/* Segona fase: invertir la cadena (canviar l'ordre dels caràcters) */
for(int i = 0; i < longitud/2; i++){ /* Bucle que recorre fins a la meitat de la cadena */
/* longitud/2 perquè intercanviem parells de caràcters */
char temp = adn[i]; /* Guarda temporalment el caràcter de la posició i */
/* Variable auxiliar per no perdre el valor durant l'intercanvi */
adn[i] = adn[longitud - 1 - i]; /* Assigna a la posició i el caràcter de la posició oposada */
/* 'longitud - 1 - i' calcula la posició simètrica des del final */
adn[longitud - 1 - i] = temp; /* Assigna a la posició oposada el valor guardat temporalment */
/* Així es completa l'intercanvi de posicions */
}
/* La funció acaba sense 'return' perquè és de tipus void */
}
Compta quants codons (triplets) hi ha en una seqüència d'ADN, ignorant els caràcters que no són A,C,G,T.
#include <stdio.h> /* Inclou la biblioteca estàndard d'entrada/sortida */
#include <string.h> /* Inclou la biblioteca per a funcions de cadenes */
/* Necessària per a strlen() */
#include <ctype.h> /* Inclou la biblioteca per a funcions de classificació de caràcters */
/* Necessària per a toupper() que converteix a majúscules */
int main(){ /* Funció principal */
char adn[200]; /* Array per emmagatzemar la seqüència d'ADN (fins a 199 caràcters + '\0') */
int bases_valides = 0; /* Comptador de bases vàlides (A, C, G, T) */
/* S'inicialitza a 0 per començar el recompte */
int codons = 0; /* Variable per emmagatzemar el nombre total de codons */
/* Un codó és un grup de 3 bases consecutives */
printf("Introdueix una sequencia d'ADN: "); /* Demana la seqüència */
scanf("%199s", adn); /* Llegeix fins a 199 caràcters per seguretat */
int longitud = strlen(adn); /* Calcula la longitud total de la cadena introduïda */
/* Bucle per comptar les bases vàlides */
for(int i = 0; i < longitud; i++){ /* Recorre cada caràcter de la cadena */
char base = toupper(adn[i]); /* Converteix el caràcter actual a majúscula */
/* toupper() retorna la versió majúscula del caràcter */
/* Això permet acceptar tant minúscules com majúscules */
/* Comprova si el caràcter (en majúscula) és una base nitrogenada vàlida */
if(base == 'A' || base == 'C' || base == 'G' || base == 'T')
bases_valides++; /* Incrementa el comptador de bases vàlides en 1 */
/* bases_valides++ és equivalent a bases_valides = bases_valides + 1 */
/* Si el caràcter no és A, C, G o T, simplement s'ignora */
}
codons = bases_valides / 3; /* Calcula el nombre de codons com a divisió entera */
/* L'operador / amb enters dóna divisió entera (sense decimals) */
/* Exemple: 7 bases vàlides / 3 = 2 codons complets */
/* Les bases sobrants (1 o 2) no formen un codó complet */
printf("Bases valides trobades: %d\n", bases_valides); /* Mostra el nombre de bases vàlides */
printf("Nombre de codons complets: %d\n", codons); /* Mostra el nombre de codons */
/* Mostra informació addicional sobre possibles bases sobrants */
int residu = bases_valides % 3; /* Calcula les bases que sobren amb l'operador mòdul */
/* % retorna el residu de la divisió entera */
if(residu > 0) /* Si hi ha bases sobrants */
printf("Queden %d base(s) sense formar un codo complet.\n", residu);
return 0; /* Finalitza el programa */
}
Crea un programa que ofereixi un menú amb diverses opcions per analitzar una seqüència d'ADN.
#include <stdio.h> /* Inclou la biblioteca estàndard d'entrada/sortida */
#include <string.h> /* Inclou la biblioteca per a manipulació de cadenes */
#include <ctype.h> /* Inclou la biblioteca per a classificació de caràcters */
/* Variable global per emmagatzemar la seqüència d'ADN */
/* Una variable global és accessible des de qualsevol funció del programa */
/* Es declara fora de totes les funcions */
char sequencia[101]; /* Array de 101 caràcters (100 bases + '\0') */
/* L'àmbit és global: totes les funcions poden accedir-hi */
/* Declaració dels prototips de les funcions */
/* Això permet al compilador conèixer les funcions abans d'usar-les */
void introduir_sequencia(); /* Funció per introduir una nova seqüència */
void calcular_composicio(); /* Funció per calcular el nombre i percentatge de cada base */
void calcular_gc(); /* Funció per calcular el contingut GC */
void mostrar_inversa_complementaria(); /* Funció per mostrar la inversa complementària */
int main(){ /* Funció principal del programa */
int opcio; /* Variable per emmagatzemar l'opció del menú seleccionada */
sequencia[0] = '\0'; /* Inicialitza la seqüència com a cadena buida */
/* '\0' al primer caràcter indica que la cadena està buida */
do{ /* Inicia un bucle do-while: el menú s'executa almenys una vegada */
/* A diferència del while, do-while comprova la condició al final */
/* Mostra el menú d'opcions a l'usuari */
printf("\n=== CALCULADORA DE COMPOSICIO NUCLEOTIDICA ===\n"); /* Títol del menú */
printf("1. Introduir una sequencia d'ADN\n"); /* Opció 1 */
printf("2. Calcular el nombre i percentatge de cada base\n"); /* Opció 2 */
printf("3. Calcular el contingut GC\n"); /* Opció 3 */
printf("4. Mostrar la sequencia complementaria inversa\n"); /* Opció 4 */
printf("0. Sortir\n"); /* Opció per sortir */
printf("Selecciona una opcio: "); /* Demana la selecció */
scanf("%d", &opcio); /* Llegeix l'opció triada per l'usuari */
/* Estructura switch per executar l'opció seleccionada */
/* switch és més eficient que múltiples if-else per a selecció múltiple */
switch(opcio){ /* Avalua el valor de 'opcio' */
case 1: /* Si opcio és 1 */
introduir_sequencia(); /* Crida a la funció per introduir seqüència */
break; /* break surt de l'estructura switch */
/* Sense break, continuaria executant els següents casos */
case 2: /* Si opcio és 2 */
calcular_composicio(); /* Crida a la funció de composició */
break; /* Surt del switch */
case 3: /* Si opcio és 3 */
calcular_gc(); /* Crida a la funció de contingut GC */
break; /* Surt del switch */
case 4: /* Si opcio és 4 */
mostrar_inversa_complementaria(); /* Crida a la funció d'inversa complementària */
break; /* Surt del switch */
case 0: /* Si opcio és 0 */
printf("Adeu! Fins aviat.\n"); /* Missatge de comiat */
break; /* Surt del switch */
default: /* Si opcio no coincideix amb cap cas anterior */
printf("Opcio no valida. Torna-ho a intentar.\n"); /* Missatge d'error */
}
} while(opcio != 0); /* El bucle continua mentre l'opció sigui diferent de 0 */
/* Quan opcio és 0, la condició és falsa i el bucle acaba */
return 0; /* Finalitza el programa amb èxit */
}
/* Funció per introduir una nova seqüència d'ADN */
void introduir_sequencia(){ /* No rep paràmetres, no retorna res (void) */
printf("Introdueix la sequencia d'ADN (maxim 100 bases): "); /* Demana la seqüència */
scanf("%100s", sequencia); /* Llegeix fins a 100 caràcters */
/* %100s limita la lectura per evitar desbordaments */
/* 'sequencia' és la variable global, no necessita & */
/* Converteix tota la seqüència a majúscules per uniformitat */
for(int i = 0; sequencia[i] != '\0'; i++) /* Recorre fins al final de la cadena */
/* '\0' marca el final de qualsevol cadena en C */
sequencia[i] = toupper(sequencia[i]); /* Converteix cada caràcter a majúscula */
/* toupper() ve de la biblioteca ctype.h */
printf("Sequencia emmagatzemada: %s\n", sequencia); /* Confirma la seqüència guardada */
}
/* Funció per calcular el nombre i percentatge de cada base */
void calcular_composicio(){ /* No rep paràmetres, usa la variable global 'sequencia' */
/* Verifica que hi hagi una seqüència introduïda */
if(sequencia[0] == '\0'){ /* Comprova si el primer caràcter és el caràcter nul */
/* Si és '\0', la cadena està buida */
printf("Primer has d'introduir una sequencia (opcio 1).\n"); /* Missatge d'avís */
return; /* Surt de la funció sense fer res més */
/* 'return' en una funció void simplement finalitza l'execució */
}
int comptador[4] = {0, 0, 0, 0}; /* Array per comptar A, C, G, T */
/* índex 0 = A, índex 1 = C, índex 2 = G, índex 3 = T */
/* Tots els comptadors s'inicialitzen a 0 */
int total = 0; /* Comptador del total de bases vàlides */
/* Bucle per comptar cada tipus de base */
for(int i = 0; sequencia[i] != '\0'; i++){ /* Recorre tota la cadena */
switch(sequencia[i]){ /* Avalua el caràcter actual */
case 'A': comptador[0]++; total++; break; /* Si és A, incrementa el comptador d'A i el total */
case 'C': comptador[1]++; total++; break; /* Si és C, incrementa el comptador de C i el total */
case 'G': comptador[2]++; total++; break; /* Si és G, incrementa el comptador de G i el total */
case 'T': comptador[3]++; total++; break; /* Si és T, incrementa el comptador de T i el total */
/* Si el caràcter no és cap base vàlida, s'ignora (no s'incrementa total) */
}
}
/* Mostra els resultats */
printf("\nSequencia: %s\n", sequencia); /* Mostra la seqüència analitzada */
printf("Total de bases valides: %d\n\n", total); /* Mostra el total de bases */
/* Array amb les lletres de les bases per mostrar els resultats */
char bases[] = {'A', 'C', 'G', 'T'}; /* Array de caràcters amb les bases */
for(int i = 0; i < 4; i++){ /* Bucle per mostrar cada base */
float percentatge = 0.0; /* Variable per al percentatge, inicialitzada a 0.0 */
if(total > 0) /* Evita la divisió per zero si no hi ha bases */
percentatge = (float)comptador[i] / total * 100; /* Calcula el percentatge */
/* (float) converteix a decimal per evitar divisió entera */
/* Multiplica per 100 per obtenir el percentatge */
printf("%c: %d (%.1f%%)\n", bases[i], comptador[i], percentatge);
/* Mostra: lletra de la base, recompte i percentatge amb 1 decimal */
/* %.1f mostra un float amb 1 decimal */
/* %% mostra el símbol de percentatge literal */
}
}
/* Funció per calcular el contingut GC */
void calcular_gc(){ /* Calcula el percentatge de Guanina i Citosina */
if(sequencia[0] == '\0'){ /* Verifica que hi hagi una seqüència */
printf("Primer has d'introduir una sequencia (opcio 1).\n");
return; /* Surt si no hi ha seqüència */
}
int gc = 0; /* Comptador de bases G i C */
int total = 0; /* Comptador del total de bases vàlides */
/* Bucle per comptar G, C i el total */
for(int i = 0; sequencia[i] != '\0'; i++){ /* Recorre tota la cadena */
if(sequencia[i] == 'G' || sequencia[i] == 'C'){ /* Si és G o C */
gc++; /* Incrementa el comptador GC */
total++; /* Incrementa el total */
}
else if(sequencia[i] == 'A' || sequencia[i] == 'T'){ /* Si és A o T */
total++; /* Només incrementa el total (no el GC) */
}
/* Altres caràcters s'ignoren completament */
}
/* Calcula i mostra el percentatge GC */
if(total > 0){ /* Si hi ha bases vàlides */
float percentatge_gc = (float)gc / total * 100; /* Calcula el percentatge */
printf("Contingut GC: %d de %d bases (%.1f%%)\n", gc, total, percentatge_gc);
/* Mostra: nombre de G+C, total de bases i percentatge */
}
else
printf("No hi ha bases valides a la sequencia.\n"); /* Missatge si no hi ha bases */
}
/* Funció per mostrar la seqüència complementària inversa */
void mostrar_inversa_complementaria(){
if(sequencia[0] == '\0'){ /* Verifica que hi hagi una seqüència */
printf("Primer has d'introduir una sequencia (opcio 1).\n");
return;
}
char inversa[101]; /* Array per emmagatzemar la inversa complementària */
/* Mida màxima de 100 caràcters + '\0' */
int longitud = strlen(sequencia); /* Calcula la longitud de la seqüència original */
/* Primera fase: obtenir la complementària */
for(int i = 0; i < longitud; i++){ /* Recorre tota la seqüència */
switch(sequencia[i]){ /* Avalua cada base */
case 'A': inversa[i] = 'T'; break; /* A es complementa amb T */
case 'T': inversa[i] = 'A'; break; /* T es complementa amb A */
case 'C': inversa[i] = 'G'; break; /* C es complementa amb G */
case 'G': inversa[i] = 'C'; break; /* G es complementa amb C */
default: inversa[i] = sequencia[i]; /* Caràcters no vàlids es mantenen iguals */
}
}
inversa[longitud] = '\0'; /* Afegeix el caràcter nul al final */
/* Essencial perquè sigui una cadena vàlida */
/* Segona fase: invertir la cadena complementària */
for(int i = 0; i < longitud/2; i++){ /* Recorre fins a la meitat */
char temp = inversa[i]; /* Guarda temporalment el caràcter actual */
inversa[i] = inversa[longitud - 1 - i]; /* Intercanvia amb el caràcter oposat */
inversa[longitud - 1 - i] = temp; /* Completa l'intercanvi */
}
/* Mostra el resultat */
printf("Sequencia original: %s\n", sequencia); /* Mostra l'original */
printf("Inversa complementaria: %s\n", inversa); /* Mostra la inversa complementària */
}