#include <stdio.

h>
#include <stdlib.h>

int sumasus(int a, int b);

int main ()
{
int n1, n2;

printf("Digite primer num: ");

scanf("%d", &n1);

printf("\nDigite segundo num: ");

scanf("%d", &n2);

int suma = 0;
// 4*3 = 4+4+4;
for(int i=1; i<=n2; i++){
suma += n1;
}

printf("La multiplicacion por sumas sucesivas es: %d", suma);

printf("\n\nFR, La multiplicacion por sumas sucesivas es: %d", sumasus(n1,n2));

printf("\n");
system("PAUSE");
return 0;
}

int sumasus(int a, int b){

if(a==0 || b==0){
return 0;
}

return a + sumasus(a,b-1);
}

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

int sumarecur(int n1, int n2);

int main ()
{

int n1, n2;

printf("Digite primer num: ");

scanf("%d", &n1);

printf("\nDigite segundo num: ");

scanf("%d", &n2);

int suma = n1 + n2;

printf("\nLa suma de estos dos numeros es: %d", suma);

int sumarrecursi = sumarecur(n1,n2);

printf("\n FR, La suma de estos dos numeros es: %d", sumarrecursi);

printf("\n");
system("PAUSE");
return 0;
}

int sumarecur(int n1, int n2)

{

if(n1==0)
{
return n2;
}
if(n2==0)
{
return n1;
}

return sumarecur(n1-1,n2+1);

}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void printinvstr(char *st);

int main(){
char *string;
char c;
int i=0;
printf("Digite la cadena: ");
while((c=getchar())!='\n'){
if(i==0){
string = (char *)malloc(sizeof(char));
}
else {
string = (char *)realloc(string, (i+1)*sizeof(char));
}
*(string+i) = c;
i++;
}
*(string+i)='\0';
printf("\nString digitado: ");
puts(string);

printf("\nString invertido (con for): ");

for(int i=strlen(string)-1; i>=0; i--){
printf("%c", *(string+i));
}
printf("\n");

printf("String invertido (recursivo): ");

printinvstr(string);
printf("\n");

free(string);
system("PAUSE");
return 0;
}

void printinvstr(char *st){

// Caso base: si llegamos al final de la cadena (\0)
if(*st == '\0'){
return;
}

// Llamada recursiva con el siguiente carácter

printinvstr(st + 1);

// Después de la recursión, imprime el carácter actual

printf("%c", *st);
}

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

int fiborecur(int i);

int main ()
{
int n;
do
{
printf("Introducir la cantidad de num (minimo 20): ");
scanf("%d", &n);

if(n<20)
{
printf("Digite cantidad valida...\n");
system("PAUSE");
system("cls");
}

}
while(n<20);

long *fibo;
fibo = (long *)malloc(n * sizeof(long));

*(fibo + 0) = 1;
*(fibo + 1) = 1;

// Calcular todos los Fibonacci

for(int i=2; i<n; i++)
{
*(fibo + i) = *(fibo + i - 1) + *(fibo + i - 2);
}

// Imprimir todos los calculados

printf("\nTodos los numeros generados:\n");
for(int i=0; i<n; i++)
{
printf("%ld ", *(fibo + i));
}

printf("\n\nPrimeros 15 num de la serie:\n");

for(int i=0; i<15; i++)
{
 printf(" %ld", *(fibo + i));
}

printf("\n\nAprox al sig. num (n*1.618):\n");

float aprox;
for(int i=0; i<20; i++)
{
aprox = *(fibo + i) * 1.618;
printf(" %.4f", aprox);
}

printf("\n\nDiferencia entre aproximacion y real:\n");

float dif;
for(int i=0; i<19; i++)
{
aprox = *(fibo + i) * 1.618;
dif = aprox - *(fibo + i + 1);
printf(" %.4f", dif);
}

printf("\n\nSerie Fibonaci RECUR:");

for(int i=1; i<=15; i++) {
printf("%ld ", fiborecur(i));
}

free(fibo);
return 0;
}

int fiborecur(int i)
{

if(i==1 || i==2)
{
return 1;
}
else

return fiborecur(i-1) + fiborecur(i-2);

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

void convertirABinarioRecursivo(int numero) {

if (numero == 0) {
return;
}

convertirABinarioRecursivo(numero / 2);
printf("%d", numero % 2);
}

int main() {
int n;
printf("digite la cantidad de numeros a convertir: ");
scanf("%d", &n);
int *num;
num = (int *)malloc(n*sizeof(int));
for(int i=0; i<n; i++)
{
printf("Digite num en pos [%d]: ", i);
scanf("%d", (num+i));
}
printf("\n\nConversion de cada numero a binario: \n");
for(int i=0; i<n; i++)
{
printf("Numero %d en binario: ", *(num+i));

// Caso especial para el 0

if(*(num+i) == 0) {
printf("0");
} else {
// Primero contar cuántos bits necesitamos
int temp = *(num+i);
int contador = 0;
while(temp > 0) {
temp = temp / 2;
contador++;
}

// Crear arreglo dinámico del tamaño exacto

int *binario = (int*)malloc(contador * sizeof(int));
int indice = 0;
temp = *(num+i); // Reiniciar temp

while(temp > 0) // Cambié la condición del while

{
 binario[indice] = temp % 2; // Guardar el bit
temp = temp / 2; // Dividir para la siguiente iteración
indice++;
}

// Imprimir los bits en orden correcto

for(int j = indice - 1; j >= 0; j--) {
printf("%d", binario[j]);
}

free(binario); // Liberar memoria del arreglo dinámico

}
printf("\n");
}

printf("\n\nRECURS Conversion de cada numero a binario:\n");

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

printf("Numero %d en binario: ", num[i]);

if (num[i] == 0) {
printf("0");
} else {
convertirABinarioRecursivo(num[i]);
}

printf("\n");
}

free(num);
system("PAUSE");
return 0;
}

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

int potencia(int b, int e);

int main()
{

int num;
int pot;

printf("Digite un num: ");

scanf("%d", &num);
 printf("Digite la potencia a elevar: ");
scanf("%d", &pot);

long long resultado = pow(num,pot);

printf("\n\nResultado con pow: %lld \n\n", resultado);

// 2^4 = 2x2x2x2;

int resul = 1;
for(int i=0; i<pot; i++)
{
resul = resul*num;
}

printf("\n\nResultado con for: %d \n\n", resul);

printf("\n\nResultado con Recursividad: %d \n\n", potencia(num,pot));

system("PAUSE");
return 0;
}

int potencia(int b, int e){

if(e==0){
return 1;
}
if(e==1){
return b;
}

return b * potencia(b, e-1);

#include <stdio.h>
#include <string.h>

// Función recursiva para imprimir texto sin espacios innecesarios

void imprime_texto(char *s) {
if (*s == '\0') return;

if (*s == ' ') {

 if (*(s+1) != ' ' && *(s+1) != '\0') {
printf("%c", *s);
}
} else {
printf("%c", *s);
}

imprime_texto(s + 1);
}

int main() {
char texto[100];
int i, espacio_anterior = 1;

printf("Ingrese el texto: ");

gets(texto);

printf("\nTexto original: \"%s\"\n", texto);

// Versión normal (iterativa)

printf("Version normal: \"");
for (i = 0; texto[i] != '\0'; i++) {
if (texto[i] == ' ') {
if (!espacio_anterior) {
printf("%c", texto[i]);
espacio_anterior = 1;
}
} else {
printf("%c", texto[i]);
espacio_anterior = 0;
}
}
printf("\"\n");

// Saltar espacios iniciales para la versión recursiva

i = 0;
while (texto[i] == ' ') i++;

// Versión recursiva
printf("Version recursiva: \"");
imprime_texto(&texto[i]);
printf("\"\n");

return 0;
}
#include <stdio.h>
#include <stdlib.h>

// Versión iterativa
int numbits_iter(int n) {
int count = 0;
while (n != 0) {
// Si el bit menos significativo es 1, incrementar contador
if (n & 1) {
count++;
}
// Desplazar bits hacia la derecha
n = n >> 1; // También se puede escribir como: n = n / 2;
}
return count;
}

// Versión recursiva
int numbits_rec(int n) {
if (n == 0) {
return 0;
}
// Si el bit menos significativo es 1, suma 1, sino suma 0
// Luego llama recursivamente con n desplazado hacia la derecha
return (n & 1) + numbits_rec(n >> 1);
}

int main() {
int n;

printf("Digite un numero entero positivo: ");

scanf("%d", &n);

if (n < 0) {
printf("El numero debe ser positivo.\n");
system("PAUSE");
return 1;
}

printf("\nCantidad de bits en 1 (iterativo): %d\n", numbits_iter(n));

printf("Cantidad de bits en 1 (recursivo): %d\n", numbits_rec(n));

system("PAUSE");
return 0;
}
#include <stdio.h>

// Prototipos
int multiplicacion_normal(int a, int b);
int multiplicacion_rec(int a, int b);

int main() {
int x, y;
printf("Digite el primer numero: ");
scanf("%d", &x);
printf("Digite el segundo numero: ");
scanf("%d", &y);

int normal = multiplicacion_normal(x, y);

int rec = multiplicacion_rec(x, y);

printf("Multiplicacion (funcion normal): %d\n", normal);

printf("Multiplicacion (funcion recursiva): %d\n", rec);

return 0;
}

// Funcion normal (NO recursiva)

int multiplicacion_normal(int a, int b) {
int resultado = 0;
int signo = 1;

if (b < 0) {
b = -b;
signo = -1;
}

for (int i = 0; i < b; i++) {

resultado += a;
}

return signo * resultado;

}

// Funcion recursiva
int multiplicacion_rec(int a, int b) {
if (b == 0)
return 0;
else if (b > 0)
return a + multiplicacion_rec(a, b - 1);
else
return -multiplicacion_rec(a, -b);
}

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

int mcd(int a, int b);

int main(){

int a;
int b;

printf("Digite a: ");
scanf("%d", &a);
printf("Digite b: ");
scanf("%d", &b);

int temp;
while(b != 0){
temp = b; // Guardar b
b = a % b; // Nuevo b = resto
a = temp; // Nuevo a = valor anterior de b
}

printf("\n\nEl MCD es %d\n", a);

int c;
int d;
 printf("\n\nDigite c: ");
scanf("%d", &c);
printf("Digite d: ");
scanf("%d", &d);

printf("\n\nRECUR El MCD entre %d y %d es: %d\n", c, d, mcd(c,d));

system("PAUSE");
return 0;
}

int mcd(int a, int b){

if(b==0){
return a;
}

return mcd(b, a%b);

}

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

int longcadenarecur(char *);

int main ()
{
char *cadena;
char c;
int i=0;
printf("Digite una cadena: ");

while((c=getchar())!='\n')
{
 if(i == 0)
{
cadena = (char *)malloc(sizeof(char));
}
else
{
cadena = (char *)realloc(cadena, i+1*sizeof(char));
}

*(cadena+i) = c;
i++;

}
*(cadena+i)='\0';

puts(cadena);

printf("\n\nstrlen, La longitud del string es: %d", strlen(cadena));

int cont = 0;
for(int i =0; i < *(cadena+i)!='\0'; i++)
{
cont++;
}

printf("\n\nFOR, La longitud del string es: %d", cont);

printf("\n\nrecur, La longitud del string es: %d", longcadenarecur(cadena));

free(cadena);
printf("\n");
system("PAUSE");
return 0;
}

int longcadenarecur(char *cadena){

if(*cadena == '\0') return 0;

return 1 + longcadenarecur(cadena+1);

}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Versión normal
void rev_normal(char *s) {
int len = strlen(s);
char temp;

for (int i = 0; i < len / 2; i++) {

temp = s[i];
s[i] = s[len - 1 - i];
s[len - 1 - i] = temp;
}
}

// Versión recursiva
void rev(char *s) {
int len = strlen(s);

if (len <= 1) {
return;
}

// Intercambiar primer y último carácter

char temp = s[0];
s[0] = s[len - 1];
s[len - 1] = temp;
 // Llamar recursivamente con la subcadena del medio
s[len - 1] = '\0'; // Terminar temporalmente la cadena
rev(s + 1); // Llamar con el resto de la cadena
s[len - 1] = temp; // Restaurar el carácter
}

int main() {
char str1[] = "ABRACADABRA";
char str2[] = "ABRACADABRA";

printf("Cadena original: %s\n", str1);

rev_normal(str1);
printf("Invertida (normal): %s\n", str1);

rev(str2);
printf("Invertida (recursivo): %s\n", str2);

system("PAUSE");
return 0;
}

#include <stdio.h>
#include <stdlib.h>
int fact(int n);

int main ()
{

int n;
printf("Digite un numero: ");
scanf("%d", &n);

if(n==1)
{
printf("\n\nEl factorial de %d!, es: 1", n);
}

if(n==0)
{
printf("\n\nEl factorial de %d!, es: 1", n);
}

int factorial = 1;
int i = n;
while(i > 1)
{

factorial = factorial * i;
i--;

printf("\n\nEl factorial de %d!, es: %d ", n, factorial);

int factfuncionrecur = fact(n);

printf("\n\nFR, El factorial de %d!, es: %d ", n, factfuncionrecur);

printf("\n");
system("PAUSE");
return 0;
}

int fact(int n)
{
if(n==1){
return 1;
}
if(n==0){
return 1;
}

return n * fact(n-1);

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

// Versión normal (iterativa)

void convertir_normal(int num, int base) {
if (num == 0) {
printf("0");
return;
}

int digitos[100];
int i = 0;

while (num > 0) {

int resto = num % base;
if (resto < 10) {
digitos[i] = resto + '0'; // Dígitos 0-9
} else {
digitos[i] = resto - 10 + 'A'; // Letras A-F para bases > 10
}
num = num / base;
i++;
}

// Imprimir en orden inverso

for (int j = i - 1; j >= 0; j--) {
printf("%c", digitos[j]);
}
}

// Versión recursiva
void convertir(int num, int base) {
// Caso base: si el número es 0, no hacer nada
if (num == 0) {
 return;
}

// Llamada recursiva con el cociente

convertir(num / base, base);

// Imprimir el resto después de la recursión

int resto = num % base;
if (resto < 10) {
printf("%d", resto);
} else {
printf("%c", resto - 10 + 'A'); // Para bases > 10 (hexadecimal)
}
}

// Función auxiliar para manejar el caso especial del 0

void convertir_completo(int num, int base) {
if (num == 0) {
printf("0");
} else {
convertir(num, base);
}
}

int main() {
int numero, base;

printf("Digite el numero a convertir: ");

scanf("%d", &numero);

do {
printf("Digite la base (2-16): ");
scanf("%d", &base);

if (base < 2 || base > 16) {

printf("Error: La base debe estar entre 2 y 16\n");
}
} while (base < 2 || base > 16);

printf("\nNumero %d en base %d:\n", numero, base);

printf("Conversion (normal): ");

convertir_normal(numero, base);
printf("\n");

printf("Conversion (recursivo): ");

convertir_completo(numero, base);
printf("\n");

// Ejemplo del ejercicio: 317 en base 3

printf("\nEjemplo del ejercicio (317 en base 3): ");
convertir_completo(317, 3);
printf("\n");

system("PAUSE");
return 0;
}
#include <stdio.h>

// Prototipos
int cont_pal_normal(char *s);
int cont_pal(char *s);

int main() {
char texto[100];
printf("Digite un texto: ");
gets(texto);

int normal = cont_pal_normal(texto);

int rec = cont_pal(texto);

printf("Cantidad de palabras (funcion normal): %d\n", normal);

printf("Cantidad de palabras (funcion recursiva): %d\n", rec);

return 0;
}

// Funcion normal (NO recursiva)

int cont_pal_normal(char *s) {
int palabras = 0;
int i = 0;
int en_palabra = 0;

while (s[i] != '\0') {

if (s[i] != ' ' && en_palabra == 0) {
en_palabra = 1;
palabras++;
} else if (s[i] == ' ') {
en_palabra = 0;
}
i++;
 }
return palabras;
}

// Funcion recursiva
int cont_pal(char *s) {
// Saltar espacios iniciales
while (*s == ' ')
s++;

if (*s == '\0')
return 0;

// Avanzar hasta el próximo espacio o final de cadena

while (*s != ' ' && *s != '\0')
s++;

return 1 + cont_pal(s);
}
#include <stdio.h>
#include <stdlib.h>

// Versión normal
int cdig_normal(int n)
{
if (n == 0)
{
return 1;
}

int contador = 0;
if (n < 0)
{
n = -n; // Hacer positivo
}

while (n > 0)
{
contador++;
n = n / 10;
}

return contador;
}

// Versión recursiva
int cdig(int n)
{
// Caso especial para 0
if (n == 0)
{
return 1;
}

// Hacer positivo si es negativo

if (n < 0)
{
n = -n;
}

// Caso base: si n < 10, tiene 1 dígito

if (n < 10)
{
return 1;
}

// Caso recursivo: 1 + dígitos del número sin el último dígito

return 1 + cdig(n / 10);
}

int main()
{
int numero;

printf("Digite un numero: ");

 scanf("%d", &numero);

printf("\nNumero: %d\n", numero);

printf("Digitos (normal): %d\n", cdig_normal(numero));
printf("Digitos (recursivo): %d\n", cdig(numero));

system("PAUSE");
return 0;
}

#include <stdio.h>

// Prototipos
int cantidad_caracter_normal(char *s);
int cantidad_caracter_rec(char *s);
int main() {
char texto[100];
printf("Digite un texto: ");
gets(texto);

int normal = cantidad_caracter_normal(texto);

int rec = cantidad_caracter_rec(texto);

printf("Cantidad de caracteres (funcion normal): %d\n", normal);

printf("Cantidad de caracteres (funcion recursiva): %d\n", rec);

return 0;
}

// Funcion normal (NO recursiva)

int cantidad_caracter_normal(char *s) {
int contador = 0;
while (s[contador] != '\0') {
contador++;
}
return contador;
}

// Funcion recursiva
int cantidad_caracter_rec(char *s) {
if (*s == '\0')
return 0;
else
return 1 + cantidad_caracter_rec(s + 1);
}

#include <stdio.h>

// Prototipos
int cant_digit_normal(int num);
int cant_digit_rec(int num);
int main() {
int n;
printf("Digite un numero: ");
scanf("%d", &n);

int normal = cant_digit_normal(n);

int rec = cant_digit_rec(n);

printf("Cantidad de digitos (funcion normal): %d\n", normal);

printf("Cantidad de digitos (funcion recursiva): %d\n", rec);

return 0;
}

// Funcion normal (NO recursiva)

int cant_digit_normal(int num) {
if (num < 0)
num = -num;

int contador = 0;
do {
contador++;
num = num / 10;
} while (num != 0);
return contador;
}

// Funcion recursiva
int cant_digit_rec(int num) {
if (num < 0)
num = -num;

if (num < 10)

return 1;
else
return 1 + cant_digit_rec(num / 10);
}