You are on page 1of 16

Sacar races cuadradas aproximadas

include <stdio.h>
int funcion(int a, int b,int contador){
//Funcion recursiva que busca raices aproximadas
//-------------Simbologia------------//a= Variable local representante del numero ingresado por el usuario
//b= Representante de b=1 en la funcion global. Este valor local Resta continuamente el numero...
//...hasta que sea menor o igual a cero. Es notable mencionarque b no es constante y aumenta en el numero
//...no es cero
//c= Representante de c=0 en la funcion global.El contador aumenta con cada resta realizada por "b"...
//...su valor es la "raiz cuadrada aproximada en este ejercicio"
if(a==0 || a<0)
//Si el numero ingresado por el usuario es menor o igual a cero. Se retorna el contador (la raiz cuadrada
aproximada)
return contador;
else
//De lo contrario:
contador++; //El contador aumenta
return funcion((a-b),(b+2),contador);
//Junto con llamar nuevamente a la funcion.
//Notese que en esta nueva funcion entra "El numero restado con la cifra b" y con b redefinido y aumentado en
dos
}
main(){
int a,b=1,c=0;
//a= El numero ingresado por el usuario
//b= Globalmente se declara como uno y no tiene un papel mas protagonico mas que entrar en una funcion...
//...localmente se utiliza para restar continuamente el valor ingresado por el usuario
//c= Globalmente se declara como cero y no tiene un papel mas protagonico mas que entrar en una funcion...
//...localmente es usado como un "contador" en la funcion en la cual aumenta cada vez que se le resta
//...el valor "b" al numero del usuario.
printf("Raices aproximadas");
printf("Ingrese un numero positivo: ");
scanf("%d",&a);
//Usuario ingresa el numero
if(a>=0){ //Caso correcto: El usuario ingreso un numero positivo
funcion(a,b,c);
//Los numeros ingresan a la duncion: el numero del usuario,la variable b y la variable c
printf("\nLa raiz aproximada de %d es %d... ",a,funcion(a,b,c));
}else{ //Caso incorrecto: Se ingreso un numero negativo
printf("Error: Se ingreso un numero negativo\n");
}
return 0; //Salida exitosa
}
Da vuelta una palabra
#include <stdio.h>
#include <string.h>
int funcion(char arreg[],int cont){
//Funcion recursiva usada para invertir la palabra
//--------Simbologia-------//arreg[]= Variable Local representante a la variable Global del mismo nombre. Es la palabra ingresada por el...
//... usuario (un arreglo de 20 elementos)
//cont= Variable local representante a la variable global del mismo nombre. Representa el numero de letras encontradas...

//...en el arreglo (arreg[]) y es usada para posicionar en la ultima letra de la palabra ingresada por el usuario...
//...al estar en la ultima letra es sinonimo de estar en el ultimo elemento valido (que no sea basura)...
//...por ende para invertir la palabra usamos una funcion recursiva que explore hasta el primer elemento...
//...Al partir desde el ultimo elemento valido imprimimos la palabra invertida
if(cont == 0){ //Si cont (el contador) esta en cero, retornara la primera posicion del arreglo
return arreg[0];
}else{
//De lo contrario imprimira un caracter desde la ultima letra de la palabra hasta llegar a la primera
printf("%c",arreg[cont-1]);
//Recordar por propiedad de arreglos posicion no es lo mismo que la cantidad de elementos. Aqui
cont nos da la
//cantidad de elementos (palabras en el arreglo), para adaptarlos a la posicion de un arreglo lo
disminuimos por 1
return funcion(arreg,cont-1);
//Se usara recursividad para imprimir el siguiente caracter de la posicion anterior
}
}
main(){
char arreg[10];
int cont;
//------------Simbologia-----------//arreg[10] = Un arreglo char de 10 elementos utilizado para guardar la palabra del usuario
//cont= usa la funcion Strlen para contar el numero de elementos
printf("Ingrese una palabra (no mas de 10 letras):\n");
scanf("%s",arreg); //El usuario ingresa una palabra en este arreglo
cont= strlen(arreg);
//Cont usa la funcion Strlen para contar el numero de palabras VALIDAS en el arreglo de caracteres
if(cont<=10){ //Caso correcto: Una palabra de 10 letras o menos
printf("Palabra invertida:\n");
funcion(arreg,cont);
//Entran a esta funcin: La palabra del usuario y su numero de letras que la componen
}else{ //Caso Incorrecto: Una palabra con mas de 10 letras
printf("Palabra muy larga\n");
}
return 0; //Salida exitosa
}
Factorial en c
#include<stdio.h>
Funcion(int a){
//Funcion recursiva en donde se hace el factorial
//a:representa al numero ingresado por el usuario (mult)
if (a==1){
//El caso base. Si "a" es igual a este numero, el valor retornado sera un 1
//este valor sera reemplazado en donde se llamo esta funcin
return 1;
}else{
//De lo contrario, a se multiplicara consigo mismo pero con una cifra menos
//esta operacion se hara hasta que sea 1
a=a*Funcion(a-1);
}
return a;
}

int main(){
int mult; //mult: el numero ingresado por el usuario, el cual calcular el factorial
printf("----Factoriales----\n");
printf("Ingrese un numero mayor a cero para sacar su factorial\n");
scanf("%d",&mult); //El usuario ingresa un numero
while(mult<0){ //Este while previene que el usuario ingrese numeros invalidos
printf("Numero invalido.Ingrese otro\n");
scanf("%d",&mult); //Se reasigna el numero a uno valido
}
if(mult>0){ //Caso normal. UN numero cualquiera
Funcion(mult); //El numero entra a la funcion
printf("El factorial de %d es %d\n",mult,Funcion(mult));
}else{ //Lo usamos para cero
printf("El factorial de %d es 1\n",mult);
}
return 0; //Salida exitosa
}
Nmero de dgitos de un nmero recursivo
#include <stdio.h>
int cuentaDigitos(int n){
//Funcion recursiva que cuenta digitos
//----Simbologia
//n= Variable local, es el numero ingresado por el usuario. Si su valor es mayor a 10 entonces se divide
//...por 10 disminuyendo dicho numero en una cifra
if(n < 10) //Si el numero es menor a 10, Se retorna la unidad del digito
return 1;
else //De lo contrario se cuenta un digito y se usa recursividad con la cifra recortada en un digito
return 1 + cuentaDigitos(n/10);
}
int main(){
//--------Simbologa-----------//n= El numero ingresado por el usuario
int n;
printf("Ingrese un numero Positivo para saber cuantos digitos tiene: ");
scanf("%d", &n); //El usuario ingresa el numero
if(n>=0){ //Caso correcto: El numero es positivo o cero
//El numero del usuario entra a la funcion, que es mostrado directamente en este printf
printf("El numero de digitos es: %d \n ", cuentaDigitos(n));
}else{ //Caso Incorrecto: El numero es negativo
printf("Error: Restriccion traspasada");
}
return 0; //Salida exitosa
}
return 0; //Salida exitosa
}
Suma de dgitos de un nmero recursivo
#include <stdio.h>
int suma(int num){ //La funcion suma es utiliza para extraer las cifras del numero de uno en uno para sumarlas

//----Simbologia---//num= Variable local, comparte el mismo nombre que su contraparte Global, es el numero ingresado por el usuario
//Si el numero ingresado es menor a 10 (solamente con una cifra) se retornara dicha cifra
if(num<10) return num;
else return num%10 + suma(num/10);
//De lo contrario se utilizara recursividad para tomar esa cifra y tomar la siguiente en la proxima llamada a la
funcion
}
int main(){
//-----------Simbologia---------------//num = Variable Global.El numero ingresado por el usuario
int num;
printf("Ingrese un numero Positivo:\n");
scanf("%d",&num); //El numero ingresado por el usuario
if(num>=0){ //Caso correcto: El numero es positivo
//El numero ingrea a la funcin y es mostrado en este printf
printf("Suma de sus digitos: %d \n",suma(num));
}else{ //Caso incorrecto: El numero es negativo y producir un error
printf("Error: Numero menor a cero\n");
}
return 0; //Salida Exitosa
}
Mximo comn divisor de 2 nmeros
#include <stdio.h>
int mcd(int a, int b){
//Funcion de Maximo comun multiplo.
//--------Simbologa:----------//a= Variable local. Representa a "num", una variable ingresada por el usuario. Inicialmente representa al primer numero
de la funcion...
//...pero en las siguientes llamadas a la funcion sera dividido modularmente con b y se usara para reasignar la variable
"b"
//...(el segundo numero)
//b= Variable local. Representa a "num1", una variable ingresada por el usuario. Inicialmente representa al segundo
numero de la
//funcion, pero en las siguientes llamadas a la funcion, sera asignado en donde deberia estar "a" (el primer numero) y
usado para dividir
//...modularmente a la variable "a", cuyo resultado se usara para reasignar el segundo numero
if(b==0) return a;
//Si el segundo numero es igual a cero, entonces se retorna el "primer numero" (de otro modo se dividiria
modularmente por cero)
//El objetivo es que el segundo numero llegue a cero, el primero nos dira el Maximo comun divisor
else return mcd(b,a%b);
//De lo contrario se hara lo siguiente: el valor actual de b se reasignara en "a" (primer numero) y luego...
//...se dividira modularmente el valor actual de "a" por "b" y este resultado se asignara al segundo numero
}
int main(){
int num,num1;

//--------Simbologa:----------//num y num1: Numeros ingresados por el usuario


printf("Ingrese un numero entero positivo:");
scanf("%d",&num); //El usuario ingresa el primer numero
printf("Ingrese otro numero entero positivo:");
scanf("%d",&num1); //El usuario ingresa un segundo numero
if(num>0&&num1>0){ //Caso correcto: El usuario ingresa un numero mayor que cero
//Los numeros entran en esta funcion y el dato saliente es mostrado en este printf
printf("MCD de %d y de %d es %d ",num,num1, mcd(num,num1));
}else{ //Caso incorrecto: El usuario ingresa un numero menor a cero
printf("Error: Los numeros menores o iguales a cero no trabajan en Max Comun Multiplo");
}
return 0; //Salida exitosa
}
Decimal a binario recursivo
#include <stdio.h>
void DecBin(int n){
//Funcion que transforma el numero a binario
//n=variable local que representa a la variable global del mismo nombre
if (n<=1) //(Caso base) Si el numero es menor o igual a 1 se imprime este valor (
//este valor se imprimira primero, se aclarar despues el motivo).
printf("%d",n);
else{ //De lo contrario...
DecBin(n/2); //...La funcion se llamara recursivamente hasta llegar al uno
//Es importante mencionar el papel de este printf, ya que luego de llegar al caso base y utilizar su correspondiente
printf
//...se imprimen los caracteres desde el penultimo caso (antes de llegar al caso base) hasta el primero
//los caracteres impresos son "el numero dividido modularmente por dos" (cuyos resultados son "1" si es impar
y "0" si es par)...
//Luego de imprimir todos estos caracteres ser nuestro "numero binario"
printf("%d", n%2);
}
}
int main(){
int n;
printf("Ingrese un nmero: ");
scanf("%d",&n); //El usuario ingresa un numero.
printf("El nmero en binario es: ");
if(n<0){ //Si el numero es negativo anteponemos un cero y volvemos el numero positivo para compatibilizarlo al
programa
printf("0");
n*=-1;
}
DecBin(n); //El numero ingresado entra en la funcion
printf("\n"); //Separador cosmetico
return 0; //Salida Exitosa
}
Divisin entera por restas sucesivas
#include <stdio.h>
int dividir(int x, int y){
//x= valor local representanete al numerador (num1) ingresado por el usuario
//y= valor local representante al divisor (num2) ingresado por el usuario

if (x<y)
//Si el numerador es menor que el denominador no retorna cifras, solo dependera de las cifras
contadas en...
//...las previas llamadas de la funcin. Esto se hace para evitar resultados ilogicos como " 2 / 3 = 1 "
return 0;
else{
//De lo contrario reasignar el numerador restandole el denominador, mientras que el denominador
entra intacto...
//...y se contara un numero
return 1 + dividir(x-y,y);
}
}
int main(){
int num1,num2;
printf("ingrese numero para dividir: ");
scanf("%d",&num1); //El usuario ingresa un numerador
printf("por cuanto lo quiere dividir?: ");
scanf("%d",&num2); //El usuario ingresa un denominador
if(num2!=0){ //Para evitar divisiones por cero
if(num1>0&&num2>0||num1<0&&num2<0){ //Caso1: Division entre positivos o negativos
//Notese que una division entre dos negativos o dos positivos SIEMPRE generara
positivos
//El numerador y el denominador entran a la funcion dividir, el resultado es mostrado en
este printf
if(num1<0) num1*=-1; //Si el primer numero era negativo, se multiplica por -1 para
cambiarlo de signo
if(num2<0) num2*=-1; //Si el segundo numero era negativo, se multiplica por -1 para
cambiarlo de signo
printf("el resultado de la division es: %d\n",dividir(num1,num2));
}else{ //Caso3: Divisiones con signos mixtos
//Notese que una division entre signos mixtos SIEMPRE generara negativos
if(num1<0) num1*=-1; //Si el primer numero era negativo, se multiplica por -1 para
cambiarlo de signo
if(num2<0) num2*=-1; //Si el segundo numero era negativo, se multiplica por -1 para
cambiarlo de signo
printf("el resultado de la division es: %d\n",-dividir(num1,num2));
}
}else{ //Casos de division por cero. Solo muestran mensajes
//El numerador y el divisor eran cero. Una division indeterminada
if(num1==0)
printf("Respuesta: Division Indeterminada\n");
//El divisor es cero.
else printf("Respuesta: Tendencia al infinito\n");
}
return 0; //Salida exitosa
}
Versiones alternativas

Variables: en todas las funciones: int divisor,dividendo;

Publicado Por: Bastian Carvajal

#include <stdio.h>
int DIV(int dividendo,int divisor){
if(divisor>dividendo) return 0;

else return 1 + DIV((dividendo-divisor),divisor);


}
int main(){
int dividendo,divisor;
printf("Ingrese dividendo: ");
scanf("%d",&dividendo);
printf("Ingrese divisor: ");
scanf("%d",&divisor);
printf("El cociente es: %d\n",DIV(dividendo,divisor));
/*Hecho por Bastian Carvajal*/
return 0;
}
Suma recursiva con elementos de un vector
// Se define el largo del vector.
#define LARGO_VECTOR 8
// Funcion recursiva que suma los elementos del arreglo
int sumaRecursiva(int vector[], int largoVector){
//------Simbologia-----//vector[] = Variable local, es el areglo llenado por el usuario, se necesita declarar como primer numero en la
funcion recursiva
//largoVector = Variable local. Inicialmente refleja la ultima posicion del arreglo,para luego disminuir
continuamente hasta llegar a la
//...posicion inicial del arreglo
if(largoVector==0) return vector[largoVector];
//Si la posicion esta en cero, entonces se entregara el elemento dentro de esa posicion
else return vector[largoVector]+sumaRecursiva(vector, largoVector-1);
//De lo contrario, se usara recursividad para entregar el elemento dentro de la posicion junto con
//la misma funcion (declarando respectivamente el arreglo junto con la posicion ANTERIOR)
}
int main(){
int i, vector[LARGO_VECTOR];
//----Simbologia---//i= Usado en un for para navegar en los elementos del arreglo
//vector[LARGO_VECTOR]= El arreglo de enteros, consiste de 8 elementos, los cuales son ingresados por el
usuario.
// Lectura de datos del vector
printf("Ingrese los datos del vector:\n");
for(i=0;i<LARGO_VECTOR; i++){ //Este for recorre las posiciones del arreglo del 0-7 (total:8 elementos)
printf("%d: ", i+1); //Este printf ajusta de posicion a alementos, para evitar que diga "Ingrese el
elemento 0"
scanf("%d", &vector[i]); //El usuario ingresa el elemento del vector
}
//A la funcion ingresa el arreglo vector junto con LARGO_VECTOR que al restar 1 refleja las posiciones del
arreglo (7)...
//...en vez de cantidad de elementos (8). Cuando haya terminado la funcin se mostrara el resultado en este
printf
printf("La suma es: %d\n", sumaRecursiva(vector, LARGO_VECTOR-1));
return 0; //Salida exitosa
}
Versiones alternativas

Descripcin: sumar los elementos de un vector

Variables: i(para control) , num(para tamao del arreglo)

Publicado Por: Cristhian Gonzlez , Programacion I

#include <stdio.h>
int suma(int arreglo1[], int tam){
if(tam==0) return arreglo1[tam]; // Caso base : Cuando llegue al comienzo finaliza el caso recursivo y retornar a
la primera posicin del arreglo
else return arreglo1[tam]+suma(arreglo1, tam-1); // Caso recursivo : realizar iteraciones hasta llegar al caso
recursivo
y al momento de finalizar le preguntar al caso anterior cuando vala lo anterior y asi sucesivamente hasta llegar al
resultado*/
}
int main(){
int i,num;
printf("Ingrese el tamao que desea para su arreglo\nPara as saber la cantidad de numeros que desea
sumar\n");
scanf("%d" , &num);
int arreglo[num];
printf("Ingrese los numeros que desea dentro del arreglo:\n");
for(i=0;i<num; i++){ // Ciclo para llenar el arreglo con los numeros deseados
printf("En la posicion %d del arreglo :\n", i+1);
scanf("%d", &arreglo[i]);
}
printf("La suma de los numeros ingresados es : %d\n", suma(arreglo, num-1));/*se le envian los parametros
<arreglo> : para enviar el vector deseado a la funcion y se le envia
<num-1> porque el arreglo comienza desde 0 en adelante y para la funcion iremos del final al comienzo por eso se le
envia con una posicion menos*/
return 0;
}
#include<stdio.h>
/*aqui cambian el tamao del arreglo*/
#define tam 5
int sumavector(int v[],int n){
/*caso base*/
if(n==0) return v[0];
/*caso recursivo*/
else return sumavector(v,n-1) + v[n];
}
int main(){
int v[tam],i;
printf("Ingrese los valores del vector\n");
for(i=0;i<tam;i++){
printf("Ingrese el vector %d\n",i+1);
scanf("%d",&v[i]);
}
printf("La suma del vector es: %d\n",sumavector(v,tam-1));
}
/*By Sebastian Gonzalez*/
Suma elementos de una matriz

#include <stdio.h>
int sumaR(int mat[][2], int fil, int col){
//Funcion que suma todos los elementos de la matriz
//-----Simbologia----//mat[][2]= Variable local, representante del arreglo A[2][2], el cual es la matriz llenada por el usuario
//fil= Variable local. Utilizado para posicionar en la matriz basandose en las filas
//col= Variable local. Utilizado para posicionar en la matriz basandose en las columnas
//Estos printf son usados como guia para ver la posicion actuald e fila y columna de la matriz
printf("En columna = %d\n",col);
printf("En fila = %d\n",fil);
if (col==0 && fil==0){
//Caso1: La fila y la columna estan en primera posicion. (ESTE ES EL CASO BASE)
return mat[0][0]; //Se retorna el elemento en la posicion (0,0) de la matriz. El primer elemento
}else if (col<0){
//Caso2: Si la columna es menor a cero. Bajamos una fila y reposicionamos en la columna final (la 1)
//Este caso es usado para decir que hemos explorado todas las comulas de una fila y necesitamos
ver la fila anterior
//(ya que empezamos desde el final)
return sumaR(mat, fil-1, 1);
}else{
//Caso3: Suma de elementos y exploracion normal de posiciones en la matriz. Este proceso se
realizara hasta
//que se presente uno de los dos casos anteriores (1.llegar al primer elemento o 2.exploracion
completa de una fila)
return mat[fil][col] + sumaR(mat, fil, col-1);
/*sumamos desde el ltimo elemento de la matriz, movindonos a travs de las columnas */
}
}
int main(){
//-----Simbologia----//A[2][2]= La matriz de 4 elementos (2 filas, 2 columnas), es llenada por el usuario
//i=Contador de filas, si todas las columnas de dicha fila estan llenadas, se pasa a la siguiente fila
//j= contador de columnas, llena todas las columnas de una final. Si esta al final se reinicia a la posicion inicial..
//..(0) para volver a llenar
int A[2][2];
int i=0,j;
//For utilizado en recorrer las filas
for(i=0;i<2;i++){
printf("----Ingrese numero entero en la fila %d----\n",i+1);
//Se pone "+1" para adptarlo al numero de elementos en vez de la posicion
j=0; //contador j se inicia en cero para posicionarse otra vez en la primera columna
//For utilizad en recorrer las columnas
for(j=0;j<2;j++){
printf("Ingrese numero entero en la columna %d\n",j+1);
//Se pone "+1" para adptarlo al numero de elementos en vez de la posicion
scanf("%d",&A[i][j]); //Se escanea el numero del usuario
}
}
//Ingresa a la funcion: La matriz, la posicion en la fila FINAL y la posicion en la columna FINAL. El resultado se
mostrara
//en este printf
printf("La suma recursiva de los elementos es: %d\n",sumaR(A,1,1));
return 0;

}
Encontrar el elemento mayor de un vector
#include<stdio.h>
int busmayarr(int A[],int x){
//busmayarr= abreviatura de buscar mayor arreglo. Funcion recursiva que nos entregara el valor...
//...del mayor elemento del arreglo tan solo llegando a ella el arreglo A y su respectivo largo x
//-----Simbologa----//A[]= Variable local, representa al arreglo del mismo nombre, el cual almacena los datos ingresados por
usuario
//x= Variable local, representa lo mismo que su contraparte global (la posicion final del arreglo),
//...se reducira continuamente para llegar a la posicion inicial del arreglo
//z= Variable local, inicialmente posee un valor basura, pero luego se le asigna una posicion, que fue un dato
//...saliente de la funcion bussmayar, se usa en un if para encontrar el dato mayor. Si un elemento de cierta
posicion
//...lo supera, "z" se reasignara como tal elemento. En caso contrario se retornara el valor de z intacto en
futuras..
//..llamadas a funcion
int z;
if(x==0){ //(CASO BASE) Si llegamos a la posicion final del arreglo se retornara este elemento
printf("Caso base = %d\n",A[x]); //Printf guia
return A[x]; //El orden de retorno de elementos sera de la posicion inicial a la posicion final
}else{ //Si estamos en otra posicin...
printf("Comparando elemento %d con %d\n",A[x],A[x-1]);
//Printf guia. Se usa para representar las comparaciones entre una posicion y la anterior
z=busmayarr(A,x-1); //usara esta funcin, la cual recursivamente llegara al Caso base
//Esta operacin se har DESPUES de haber encontrado el caso base de la funcin
recursiva
if(A[x]>z){
//Se analiza desde al caso base hasta la posicion final.
//Si un elemento de una cierta posicion supera a "z", "z" se reasignara al valor de este
elemento
return A[x];
}else{
//De lo contrario se retornara el valor inteacto de z para futuras comparaciones en nuevas
llamadas a funcion
return z;
}
}
}
int main(){
//-----Simbologa----//i= variable de control de ciclo
//x= variable que indica la posicion en el arreglo (principalmente utlizada en la funcion recursiva)...
//...ademas de indicar el largo del arreglo(partiendo desde 0)
//y= variable que recivira el valor retornado por la funcion
//w= variable utilizada para almacenar la posicion del mayor valor
//z= variable auxiliar utilizada en la funcion recursiva para almacenar el valor de la posicion...
//...de areglo en el llamado en cuestion de la funcion recursiva
//A[]= es el arreglo que almacenara los datos ingresados por usuario
int A[9];
int i,x=9,y,w;
printf("----A continuacion se le pediran 10 numeros----\n");

for(i=0;i<=9;i++){ //For encargado de llenar el arreglo de 10 elementos


printf("ingrese el numero entero para la posicion %d : ",i);
scanf("%d",&A[i]); //Usuario ingresa elemento
printf("\n"); //Espaciador cosmetico
}
//Entran a la funcin El arreglo y la posicion final del arreglo (9)
y=busmayarr(A,x);
//El dato saliente es el valor del numero mayor
for(i=0;i<=9;i++){
//For utilizado para buscar el "mayor valor" en la posicion del arreglo
if(y==A[i]) w=i;
}
printf("el mayor valor del arreglo es %d y se encontro primero en la posicion: %d \n",y,w);
return 0;
}
Versiones alternativas

Descripcion: el programa busca el mayor elemento de un vector usando recursividad.

Variables: int i,tam,vector[](main),vector[](mayornum),indices,mayor;

Publicado Por: Bastian Carvajal;

#include<stdio.h>
#include<limits.h>
int mayornum(int vector[], int indices){
static int mayor=INT_MIN;
if(indices>0){
if (vector[indices-1]>mayor) mayor=vector[indices-1];
return mayornum(vector,indices-1);
}else return mayor;
}
int main(){
int i,tam=10,vector[tam]; //tam corresponde al tamao del vector
for(i=0;(i<tam);i++){
printf("Ingrese valor %d del vector: ",i+1);
scanf("%d",&vector[i]);
}
printf("el mayor numero del vector es %d\n", mayornum(vector,tam));
/*Hecho por Bastian Carvajal*/
return 0;
}
Invertir un nmero
#include<stdio.h>
int rec( int num ,int aux){ /*Aqui esta la funcion donde se produce la recursividad*/
//----------Simbologia--------//num= El numero ingresado por el usuario, recursivamente se va dividiendo para llegar al caso base y salir de
la funcion
//aux= Variable local, se le asigna la ultima cifra del numero para luego imprimirla desde la ultima a la primera.
//...Como claramente este ejercicio se basa en printf's, el valor de aux no es importante en la recursividad,
excepto
//...su participacion en mostrar las cifras

if (num==0){
//Caso base: Si el numero ya no tiene cifras (ya que fue reducido a cero) retornara un cero para salir
de la funcion...
//...recursiva
return 0;
}else{ //Si el numero posee cifras, se har lo siguiente...
aux=num%10; /*Se toma el valor de la ultima cifra del numero*/
num=num/10; /*aca es para borrar el ultimo numero que tomamos*/
printf("%d",aux);
//Este printf mostrara el numero tomado, como se prioriza desde el ultimo al primero se mostrara
"invertido"
return rec(num,aux);
//Se usara recursividad con el nuevo numero (ya reucido en una cifra), el valor de aux no es
importante
}
}
int main(){
int aux, num;
//----------Simbologia--------//num: El numero ingresado pro el usuario
//aux: Variable usada especificamente en la funcion recursiva, su valor global no tiene importancia
printf("----Bienvenido----\n");
printf("Ingrese el numero positivo en cual desea invertir: ");
scanf("%d", &num); //El usuario ingresa un numero
printf("\nSu numero invertido es : ");
if(num<0){
//Si el numero es negativo, se volvera positivo el numero y se imprimira un signo negativo
num=num*-1;
printf("-");
}
rec(num,aux);
//Entran a la funcion recursiva el numero del usuario y la variable aux (su valor no es importante por ahora)
//Su dato saliente son una variedad de printf's que mostraran nuestro numero "invertido"
printf("\n"); //Espaciador cosmetico
return 0; //Salida exitosa
}
/* CRISTIAN VALLES P. PROGRAMACION I*/
Versiones Alternativas

Descripcin: invierte los digitos de un numero usando recursividad

Variables: en todas las funciones: int num;

Publicado Por: Bastin Carvajal, Programacion I

#include<stdio.h>
void invierte(int num){
if(num<10)printf("%d",num);
else{
printf("%d",num%10);
invierte(num/10);
}
}
int main(){
int num;
printf("Ingrese un numero: ");
scanf("%d", &num);
printf("su numero invertido es: ");

invierte(num);
printf("\n");
/*Hecho por Bastian Carvajal*/
return 0;
}
Potencia de varios nmeros usando recursividad (CMD)
#include<stdio.h>
#include<stdlib.h>
int potencia(int base, int exponente){
if(exponente==1) return base;
else return base*potencia(base,exponente-1);
}
int main( int argc, char *argv[]){
if(argc>1){
int i, resultado;
printf("parametros ingresados: ");
for(i=1;(i<argc);i++){
printf("%d ",atoi(argv[i]));
if(i==1)resultado=atoi(argv[1]);
else resultado=potencia(resultado,atoi(argv[i]));
}
printf("\nel resultado es: %d\n",resultado);
}else printf("Se deben ingresar las potencias por linea de comando!!\n");
/*Hecho por Bastian Carvajal*/
return 0;
}
Versiones Alternativas

Variables: int base, poten, i, p[2],b,p; ...... char argv[];

Publicado Por: Diego Reyes Delgado

#include<stdio.h>
#include<stdlib.h>
int potencia(int b, int p){
if(p==1){
return b;
}
else{
return b * potencia(b,p-1);
}
}
int main( int argc, char *argv[]){
int base, poten, i, p[2];
p[0]=atoi(argv[1]);
p[1]=atoi(argv[2]);
i=potencia(p[0], p[1]);
printf("la potencia es: %d\n", i);
return 0;
}
Producto de dos nmeros enteros
#include<stdio.h>
int multiplicacion(int a,int b){ //Funcion recursiva multiplicativa

//-----Simbologia----//a= Valor local. Representante del numero del usuario (n1), segun b determinara cuantas veces se
multiplicara.
//b= Valor local. Representante de cuantas veces sera multiplicado n1, este ira disminuyendo hasta cero
/*Caso Base: Si el "factor" (b) es cero, retornara este valor*/
if(b<=0) return 0;
/*Funcion Recursiva: De lo contrario, retornara al valor de "a" sumado con una nueva llamada a la funcion
(el cual entrara el mismo numero "a", pero esta vez tendra el factor reducido en una cifra) */
else return a + multiplicacion(a,b-1);
}
int main(){
int n1,n2;
//-----Simbologia----//n1: numero del usuario a cual multiplicar
//n2: determina cuantas veces se multiplicara n1
printf("Ingrese 2 numeros enteros que quiere multiplicar:\n");
scanf("%d %d",&n1,&n2); //El usuario ingresa los numeros a multiplicar
if(n1>0&&n2>0||n1<0&&n2<0){ //Caso1: Multiplicacin entre positivos o negativos
//Notese que una multiplicacin entre dos negativos o dos positivos SIEMPRE generara
positivos
//Ingresa a la funcin: los dos numeros ingresados por el usuario, el resultado es mostrado
en este printf
if(n1<0) n1*=-1; //Si el primer numero era negativo, se multiplica por -1 para cambiarlo de
signo
if(n2<0) n2*=-1; //Si el segundo numero era negativo, se multiplica por -1 para cambiarlo
de signo
printf("La multiplicacion es = %d\n",multiplicacion(n1,n2));
}else{ //Caso2: Multiplicacin con signos mixtos
//Notese que una multiplicacin entre signos mixtos SIEMPRE generara negativos
//Ingresa a la funcin: los dos numeros ingresados por el usuario, el resultado es mostrado
en este printf
if(n1<0) n1*=-1; //Si el primer numero era negativo, se multiplica por -1 para cambiarlo de
signo
if(n2<0) n2*=-1; //Si el segundo numero era negativo, se multiplica por -1 para cambiarlo
de signo
printf("La multiplicacion es = %d\n",-multiplicacion(n1,n2));
}
return 0;
}
/*By Sebastian Gonzalez*/
Versiones alternativas

Descripcin: multiplicacion de 2 numeros enteros positivos de forma recursiva

Variables: num1 , num2 (numeros a ingresar)

Publicado Por: Cristhian Gonzlez , Programacion I

#include <stdio.h>

int multiplicar(int n,int m){


if(m<=0) //Caso Base : Condicion de control para terminar caso recursivo
return 0;
else return n + multiplicar(n,m-1); //Caso Recursivo : La funcion se llama a si misma
}
int main(){
int num1;
int num2;
comienzo: //Etiqueta para volver para ingresar numeros si fuera necesario
printf("\nIngrese 2 numeros enteros positivos que quiera multiplicar\n");
scanf("%d", &num1);
printf("\n");
scanf("%d", &num2);
if(num1>0 && num2>0){ //Verifica que los numeros ingresados sean positivos
printf("\nLa multiplicacion de los numeros ingresados es : %d\n",multiplicar
(num1,num2));
}else{
printf("Error : Uno o ambos numeros de los ingresados no es positivo\nEl programa volver a
ejecutarse hasta que ingrese correctamente\n");
goto comienzo; //Hace que vuelva a la etiqueta comienzo para volver a ingresar
}
return 0;
}
Largo de una cadena de caracteres
#include <stdio.h>
int largocadena(char cadena[],int largo){
//Funcion para saber el largo de una cadena
/*cadena[]=Valor local. Arreglo representante a palabra (ingresado por el usuario). Su inclusion en las proximas llamadas
a...
*...funcion significa que le estamos diciendo al programa que seguimos trabajando en el arreglo*/
/*largo = representa la posicion actual del arreglo, se aumenta hasta encontrar un espaciador o numeoro basura*/
if(cadena[largo]=='\0'){
/*Si en la palabra se encontro un caracter vaco o un espaciador, se retornara un cero (para salir de la funcin
recursiva)
junto con la cantidad de letras contadas (determinada por la posicion del arreglo)*/
printf("El largo de la cadena es : %d\n" , largo);
return 0;
}else{
/*Si ocurre lo contario, se usara recursividad para avanzar a la siguiente posicion del arreglo*/
return largocadena(cadena,largo+1);
}
}
int main(){
char palabra[100];
//palabra[100]= Arreglo char utilizado para almacenar la palabra del usuario
printf("Introduce la palabra (Max 100):\n");
scanf("%s",palabra); //El usuario ingresa una palabra
largocadena(palabra,0);
//Entra a la funcin: La palabra del usuario y un cero (que es la posicion inicial del arreglo)
//El resultado saliente es printf dandonos la cantidad de letras de la palabra
}
Repeticin de un caracter en una cadena

#include <stdio.h>
#define N 40
int ocurrencias(char cadena[] , char letra , int cont , int i)
{
//Funcion que busca un caracter especifico en una palabra (tambien ingresada por el usuario)
//-----Simbologa----//cadena[]= Valor local, representante del arreglo palabra. Utilizado para ddecirle al programa que estamos ocupando
arreglos
//letra= Valor local, representante de la variable del mismo nombre. Es el caracter a buscar (tambien ingresada por el
usuario)
//cont= Valor local. Representa cuantas veces se ve el caracter en la palabra
//i= Valor local. Sirve para navegar entre las posiciones del arreglo hasta contar un espaciador
//Caso base: Al encontrar un espaciador o numero basura, se cuenta como el final de la palabra ingresada
(restriccion)
//De ser asi, se retorna a la funcion principal el numro de veces que se encontro el caracter
if(cadena[i]=='\0'){
return cont;
}
//En caso de que la letra se haya encontrado, se avanza a la siguiente posicion del arreglo junto con aumentar
el contador
//en la proxima llamada a la funcion
if(cadena[i]==letra){
return ocurrencias(cadena,letra,cont+1,i+1);
}else{
//De lo contrario, solamente se avanza el contador en la proxima llamada a la funcion
return ocurrencias(cadena,letra,cont,i+1);
}
}
int main(){
//-----Simbologa----//palabra[N]= Un arreglo char, usado para la palabra del usuario
//caracter= El caracter que el usuario desea buscar en la palabra
char palabra[N];
char caracter;
printf("-----Programa del caracter repetido-----\n");
printf("Ingrese un caracter para saber cuantas veces se repite:\n(NOTA: Es necesario que se repita por lo menos una
vez)\n");
scanf("%c",&caracter); //El usuario ingresa el caracter a buscar
printf("Ingrese la palabra que desea (Max 40 caracteres):\n");
scanf("%s",palabra); //El usuario ingresa la palabra
/*A esta funcion entran: la palabra ingresada, el caracter a buscar, un contador (iniciado en cero) y la posicion inicial del
arreglo (0)
el resultado saliente en este print ser el numero de veces que se conto la palabra buscada */
printf("La cantidad de veces que se repite el caracter es: %d\n",ocurrencias(palabra,caracter,0,0));
return 0;
}