Alguien puede ayudarme a cambiar estos codigos a C por favor

Problemas de Recursividad
Problema 1.
La factorial de un número entero n≥0 , denotado como n ! , se define como
∏
i=1
n
❑i=1∗2∗…∗n cuando n>0 , y 0 !=1 .
Por ejemplo 6!=1∗2∗3∗4∗5∗6=720
Diseñad un método recursivo que lo calcule e implementadlo en Java (junto con un programa que
lo utilice)
/*Resolución del problema*/
package operationsLogit;
import java.util.Scanner;
public class Numero_1 {
static Scanner Entrada = new Scanner(System.in);
public static void main(String[] args) {
Scanner Entrada = new Scanner(System.in);
String Valora;
String Titulo="Ingrese el numero que desea saber su
factoria:";
System.out.println(" BIENVENIDO AL PROGRAMA");
System.out.println(Titulo);
Valora=Entrada.nextLine();
String Hola= Validar(Valora);
if(Hola.equalsIgnoreCase("Si")==true)
{
System.out.println("A salido del programa.");
System.exit(0);
}
else
{
Valora=Hola;
System.out.println("El factorial de " + Valora + " es:
" + factorial(Integer.parseInt(Valora)));
}
}
public static String Validar(String Valora)
{
int Bandera=0;
int contador=0;
String Titulo;
do {
Bandera=0;
for(int i=0; i<Valora.length(); i++)
{
if(Character.isDigit(Valora.charAt(i))==false)
{
Bandera=1;
}
}
if(Bandera==1)
{
Titulo="Ingrese el valor de nuevo el valor del
factorial:\n Desea salir del programa Si.";
System.out.println(Titulo);
Valora=Entrada.nextLine();
}
}while(Bandera!=0 && Valora.equalsIgnoreCase("Si")!=true);
return Valora;
}
 public static int factorial(int num){
 if(num == 0){
 return 1;
 }
 else
 return num * factorial(num-1);
 }
}


Problema 2.
Para calcular el máximo común divisor de dos números enteros puedo aplicar el algoritmo de
Euclides, que consiste en ir restando el más pequeño del más grande hasta que queden dos
números iguales, que serán el máximo común divisor de los dos números.
Por ejemplo, si comenzamos con el par de números 412 y 184, tendríamos:
412 228 44 44 44 44 44 36 28 20 12 8 4
184 184 184 140 96 52 8 8 8 8 8 4 4
Es decir, m.c.d.(412, 184) = 4
/*Resolución del problema*/
import java.util.Scanner;
public class mcd {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int a,b;
a = Integer.parseInt(validacampo("Ingrese el Primer Numero:
"));
b = Integer.parseInt(validacampo("Ingrese el Segundo Numero:
"));
System.out.println("el maximo comun divisor entre "+a+" y
"+b+" = "+maxcd(a,b));
}
public static String validacampo(String titulo)
{
Scanner sc = new Scanner(System.in);
String v = "";
while(v.equals(""))
{
System.out.println(titulo);
v = sc.nextLine();
if(!v.matches("^[0-9 ]*$"))
{
v = "";
}
}
return v;
}
public static int maxcd(int a,int b)
{
if(b==0) return a;
else return maxcd(b,a%b);
}
}


Problema 3.
Diseñad un método recursivo tal que, dado un vector de números enteros, retorne la suma de sus
elementos.
Para poder hacer recursividad, usaremos un índice que indique el trozo de vector a sumar en cada
llamada.
Es decir, el método a diseñar tendrá la forma:
1 public int sum(int[] elems, int pos) {
2 ¿?
3 }
Diseñad este método así como el que lo utiliza para calcular la suma de todo el vector. Tened en
cuenta cómo hacemos para referirnos a un intervalo dentro de un vector. ¿Qué pasa si el vector
está vacío (es decir, cuando elems.length vale cero)?
Usando el método recursivo, implementad el método que lo usa para calcular la suma de todo el
vector, es decir:
4 public int sum(int[] elems) {
5 return sum(elems, ¿?);
6 }
Nota: Podéis considerar dos descomposiciones del vector, una en la que la zona que vais sumando
crece de derecha a izquierda y otra en la que lo hace en sentido contrario.
/*Resolución del problema*/
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
static Scanner entrada = new Scanner(System.in);
static int GetInt(String cadena) {
int numero;
do{
try {
System.out.printf(cadena + "\n");
 numero = entrada.nextInt();
 break;
} catch (InputMismatchException e){
System.out.println("¡Cuidado! Solo puedes
insertar números. \n");
entrada.next();
}
}while(true);
return numero;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n;
n = GetInt("Favor ingrese el tamano del arreglo:");
int [] vec = new int[n];
for (int i=0; i<n; i++) {
vec = GetInt("Favor ingrese el numero de la posicion
"+ i +"\n");
}
System.out.print("La suma de los datos del vector es: "+
sumaRecursivaDeArreglo(vec,n-1)+ "\n");
}
static int sumaRecursivaDeArreglo(int [] vector, int pos) {
if (pos == 0) return vector[pos];
else return vector[pos]+ sumaRecursivaDeArreglo(vector,pos1);
}
}


Problema 4.
Diseñad un método recursivo que escriba al revés la cadena que se le pasa como parámetro, más
un índice que se usará para indicar la cadena.
Dicho método será de la forma:
7 public void printReversed(String text, int index) {
8 ¿?
9 }
Haced dos versiones del mismo:
● una en la que la subcadena sobre la que trabaja la función sea el prefijo de la cadena
original
● otra en la que sea el sufijo.
En ambos casos implementad la función que llama a la función recursiva diseñada, es decir:
10 public void printReversed(String text) {
11 printReversed(text, ¿?);
12 }
Mostrad las secuencias de llamadas que se producen para la cadena “abcd” en ambos casos.
Nota: No se considera una solución válida invertir la cadena y luego escribirla.
/*Resolución del problema*/
package invertcadena;
import java.util.Scanner;
public class invertircadena {
public static void main(String args[]) {
Scanner f = new Scanner(System.in);
String cadena;
cadena = validacampo("Ingrese una Cadena: ");
System.out.println("Cadena Invertida: " +
invert(cadena,cadena.length() -1));
}
public static String validacampo(String titulo)
{
Scanner f = new Scanner(System.in);
String v= "";
while(v.equals(""))
{
System.out.println(titulo);
v = f.nextLine();
if(!v.matches("^[A-Za-z0-9 ]*$"))
{
v = "";
}
}
return v;
}
public static String invert(String cadena,int longitud) {
if(longitud == 0) return cadena.charAt(longitud)+"";
else return cadena.charAt(longitud)+ (invert(cadena, longitud
-1));
}
}


Problema 5.
El ejemplo de la exponenciación mostrado en los apuntes, permite la siguiente descomposición:
● Si b es par, a
b=a
2∗(b÷2)=( a
b÷2
)
2
● Si b es impar, a
b=a
2∗(b÷2)+ 1=a∗(a
b÷2
)
2
Acabad de diseñar la solución recursiva que la emplea, implementar la solución en Java y hacer el
mismo diagrama de llamadas para el caso de 7
13
.
Nota: Es muy interesante que intentéis resolver un mismo problema de varias maneras y
comparéis entre sí las diferentes soluciones.
/*Resolución del problema*/
package operationsLogit;
import java.util.Scanner;
public class Numero_5 {
public static void main(String [] args)
{
String Valora,Valorb;
int Bandera=0;
Scanner Entrada = new Scanner(System.in);
String Titulo="Ingrese el valor de la variable"+" A:";
System.out.println(Titulo);
Valora=Entrada.nextLine();
//Titulo.replace('B','I');
Titulo="Ingrese el valor de la variable"+" B:";
System.out.println(Titulo);
Valorb=Entrada.nextLine();
do {
Bandera=0;
for(int i=0; i<Valorb.length(); i++)
{
if(Character.isDigit(Valorb.charAt(i))==false)
{
Bandera=2;
}
}
for(int i=0; i<Valora.length(); i++)
{
if(Character.isDigit(Valora.charAt(i))==false)
{
Bandera=1;
}
}
if(Bandera==1)
{
Titulo="Ingrese el valor de nuevo el valor de la
variable A:\n Desea salir del programa Si.";
System.out.println(Titulo);
Valora=Entrada.nextLine();
}
else if(Bandera==2)
{
Titulo="Ingrese el valor de nuevo el valor de la
variable B:\n Desea salir del programa Si.";
System.out.println(Titulo);
Valorb=Entrada.nextLine();
}
else
{
Bandera=0;
}
}while(Bandera!=0 && Valora.equalsIgnoreCase("Si")!=true &&
Valorb.equalsIgnoreCase("Si")!=true);
if(Bandera==0)
{
Titulo="La exponencial en descomposicion es
igual:"+Exponencial(Integer.parseInt(Valora),Integer.parseInt(Valorb));
System.out.println(Titulo);
}
else if(Valora.equalsIgnoreCase("Si")==true ||
Valorb.equalsIgnoreCase("Si")==true)
{
System.out.println("A salido del programa.");
System.exit(0);
}
}
public static int Exponencial(int A,int B)
{
int Valor=0;
if(B>0)
{
if(B %2==0)
{
Valor=(int) Math.pow((Math.pow(A, B/2)),2);
return Valor;
}
else
{
Valor=(int) Math.pow(A*(Math.pow(A, B/2)),2);
return Valor;
}
}
else
{
return 1;
}
}
}


Problema 6.
Ya que estamos, diseñad un método tal que dada una cadena, retorne la cadena invertida (es decir,
el primer carácter del resultado será el último de la cadena dada, etc.). Dicho método tendrá la
forma:
13 public String invert(String text) {
14 ¿?
15 }
Para hacerlo, debéis diseñar otro tal que dado un vector de caracteres, lo invierta. Como los
parámetros que son vectores se pasan por referencia, el método invert sobre vectores puede ser
de la forma:
16 public void invert(char[] textChars) {
17 ¿?
18 }
Para encontrar recursividad deberéis hacer otro método que, además del char[], use uno o más
índices sobre el vector.
/*Resolución del problema*/
import java.util.Scanner;
public class Main {
static Scanner entrada = new Scanner(System.in);
public static void main(String[] args) {
// TODO Auto-generated method stub
String cadena;
System.out.print("Favor ingrese la cadena a invertir: \n");
cadena = entrada.nextLine();
System.out.print("Cadena invertidad: \n");
System.out.print(invertirCadena(cadena));
}
private static String invertirCadena(String cadena){
 if(cadena.length()==1){
 return cadena;
 } else {
 return invertirCadena(cadena.substring(1)) +
cadena.charAt(0);
 }
 }
}


Problema 7.
Diseñad un método tal que, dados dos vectores de enteros, retorne un booleano indicando si son
iguales, es decir, si tienen los mismos valores en las mismas posiciones.
Para poder hacerlo recursivamente deberéis, como ya es habitual, hacer otro método que incluya
índices para indicar los trozos de subvectores sobre los que se trabaja. Indicad qué llamada se hace
al método recursivo para resolver el problema inicial.
/*Resolución del problema*/
import java.util.InputMismatchException;
public class Main {
static Scanner entrada = new Scanner(System.in);
static int GetInt(String cadena) {
int numero;
do{
try {
System.out.printf(cadena + "\n");
 numero = entrada.nextInt();
 break;
} catch (InputMismatchException e){
System.out.println("¡Cuidado! Solo puedes
insertar números. \n");
entrada.next();
}
}while(true);
return numero;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n;
n = GetInt("Favor ingrese el tamano de los arreglos:");
int [] vec1 = new int[n];
int [] vec2 = new int[n];
for (int i=0; i<n; i++) {
vec1 = GetInt("Favor ingrese el numero de la
posicion "+i+" del primer arreglo:");
}
for (int i=0; i<n; i++) {
vec2 = GetInt("Favor ingrese el numero de la
posicion "+i+" del segundo arreglo:");
}
if (ComparacionArray(vec1,vec2,n-1,true))
System.out.print("Los arreglos son iguales");
else System.out.print("Los arreglos no son iguales");
}
static boolean ComparacionArray(int [] vec1,int [] vec2, int
pos,boolean boleano) {
if (pos==0) return boleano;
else {
if (vec1[pos] == vec2[pos])
ComparacionArray(vec1,vec2,pos-1,boleano);
else return false;
}
return boleano;
}
}


Problema 8.
Diseñad un método tal que calcule el máximo de un vector no vacío de números enteros. De forma
similar al problema 4, implementad el método que llama al que habéis definido recursivamente
para que se calcule el máximo de todo el vector.
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
static Scanner entrada = new Scanner(System.in);
static int GetInt(String cadena) {
int numero;
do{
try {
System.out.printf(cadena + "\n");
 numero = entrada.nextInt();
 break;
} catch (InputMismatchException e){
System.out.println("¡Cuidado! Solo puedes
insertar números. \n");
entrada.next();
}
}while(true);
return numero;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, n;
n= GetInt("por favor ingresar el tamano del vector:");
int [] myList= new int [n];
for(i=0; i<n;i++) {
myList = GetInt("Introduzca número "+i+":");
}
System.out.println("El máximo es: " + Maximo(myList,n-1,
myList[0]) );
}
static int Maximo(int [] vec1, int pos,int mayor) {
if (pos==0 && vec1[pos]>mayor) return vec1[pos];
else if (pos==0) return mayor;
else if (vec1[pos]>mayor)
mayor= vec1[pos];
return Maximo(vec1,pos-1,mayor);
}
}


Problema 9.
El algoritmo chino de multiplicación. Diseñad un método que multiplique dos números enteros
usando las siguientes equivalencias:
x∗y=(2∗x )∗(
y
2 )={(2∗x )∗( y÷2),si y es par(2∗x)∗( y÷2)+x ,si y esimpar
Una cuestión a considerar es la siguiente: la expresión (2*x) puede calcularse de manera no
recursiva. Una posibilidad es usar:
● 2 * x = x + x
● 2 * x también puede implementarse (y en realidad el código que genera el compilador es
lo que hace) desplazando un bit la representación binaria de x. En el tema de Archivos
veremos cómo usar los desplazamientos de bits en Java.
/*Resolución del problema*/
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
static Scanner entrada = new Scanner(System.in);
static int GetInt(String cadena) {
int numero;
do{
try {
System.out.printf(cadena + "\n");
 numero = entrada.nextInt();
 break;
} catch (InputMismatchException e){
System.out.println("¡Cuidado! Solo puedes
insertar números. \n");
entrada.next();
}
}while(true);
return numero;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int x = 0 ,y ,resultado;
x= GetInt("por favor ingresar el primer numero");
y= GetInt("ingresa el segundo numero");
resultado =(2*x)*(y/2);
if (y % 2 ==0) resultado =(2*x)*(y/2);
else resultado =(2*x)*(y/2)+x;
System.out.printf("resultado %d: ", resultado);
}
}


Problema 10.
Dado un vector de números enteros ordenado decrecientemente, diseñad un método tal que
compruebe si el valor de alguno de los elementos del vector coincide con su índice.
Podéis hacer dos versiones:
● una que vaya comprobando elemento a elemento si dicha propiedad se cumple (para esta
versión, el método recursivo usará, además del vector, un índice).
● otra que, usando dos índices, sea capaz de descartar a cada llamada la mitad del vector.
En ambos casos implementad los métodos que hacen la llamada inicial al que habéis diseñado
recursivamente dando valores iniciales a los índices.
Pista: podéis pensar qué relación tiene este problema con la búsqueda dicotómica y, si la
encontráis, obtendréis la solución.
/*Resolución del problema*/
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
static Scanner entrada = new Scanner(System.in);
static int GetInt(String cadena) {
int numero;
do{
try {
System.out.printf(cadena + "\n");
 numero = entrada.nextInt();
 break;
} catch (InputMismatchException e){
System.out.println("¡Cuidado! Solo puedes
insertar números. \n");
entrada.next();
}
}while(true);
return numero;
}
static int BusquedaRecursiva(int [] vec, int n, int dato) {
if (n ==0 && vec[n]== dato)
return n;
else if( n==0)
return -1;
else if (vec[n]==dato)
return n;
else
return BusquedaRecursiva(vec, n-1,dato);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n,dato,retorno;
n= GetInt("por favor ingresar el tamano del vector:");
int [] vec= new int [n];
for(int i=0; i<n; i++) {
vec = GetInt("Introduzca número " + i + ":");
}
dato= GetInt("Por favor ingresar el dato a buscar:");
retorno=BusquedaRecursiva(vec, n-1,dato);
if(retorno==dato)
System.out.println("El dato se encuentra en el vector y
en el indice concide");
else if (retorno>-1)
System.out.println("El dato se encuentra en el vector
pero el indice no concide");
else
System.out.println("El dato no se encuentra:");
}
}


Problema 11.
Un problema parecido al anterior se puede plantear cuando el vector de enteros está ordenado
crecientemente y no contiene valores repetidos.
El razonamiento en este caso es más complicado que en el caso anterior (obviamente cuando se
intenta hacer la versión que, a cada paso divide la longitud del intervalo donde buscar por la
mitad).
Pista: la idea de la solución consiste en darse cuenta de que los valores crecen como mínimo tanto
como los índices. Esto es cierto porque el vector no contiene elementos repetidos.
/*Resolución del problema*/
package operationsLogit;
import java.util.Scanner;
public class Numero_11 {
public static int Arreglo[];
static Scanner Entrada = new Scanner(System.in);
public static void main(String Args[])
{
String Valora;
String Titulo="Ingrese la dimension del arreglo:";
System.out.println(Titulo);
Valora=Entrada.nextLine();
Valora=Validadar(Valora, "Ingrese la dimension del
arreglo:","Ingrese el valor de nuevo de la dimension del arreglo:\n Desea
salir del programa Si.");
if(Valora.equalsIgnoreCase("Si")==true)
{
System.out.println("A salido del programa.");
System.exit(0);
}
else
{
Arreglo= new int [Integer.parseInt(Valora)];
int temporal=0;
int valor=0;
System.out.println("Cargue el arreglo de dimension
"+Valora);
System.out.println("Los datos a agregar deben ser
ordenado, distinto y positivo!");
for (int i=0; i<Arreglo.length;i++)
{
System.out.println("Valor en posicion :"+(i+1));
valor=Entrada.nextInt();
while(temporal>=valor)
{
if(temporal==valor)
{
System.out.println("Digite de nuevo el
valor. El valor anterior es igual a nuevo dato!");
}
else
{
System.out.println("Digite de nuevo
el valor. El valor anterior es mayor a nuevo dato!");
}
System.out.println("Valor en posicion :"+
(i+1));
valor=Entrada.nextInt();
}
temporal=valor;
Arreglo=temporal;
}
System.out.println("Ingrese el numero a buscar");
int Numero_Buscar=Entrada.nextInt();
if(Funcion_media(Numero_Buscar)==-1)
{
System.out.println("El numero a buscar no existe");
}
else
{
System.out.println("El valor esta en la posicion: "+
(Funcion_media(Numero_Buscar)));
}
}
}
public static String Validadar(String Valora,String Titulo1, String
Titulo2)
{
int Bandera=0;
String Titulo=Titulo1;
do {
Bandera=0;
for(int i=0; i<Valora.length(); i++)
{
if(Character.isDigit(Valora.charAt(i))==false )
{
Bandera=1;
}
}
if(Valora.equals("")==true){Bandera=1;}
if(Bandera==1)
{
Titulo=Titulo2;
System.out.println(Titulo);
Valora=Entrada.nextLine();
}
}while(Bandera!=0 && Valora.equalsIgnoreCase("Si")!=true);
return Valora;
}
public static int Funcion_media(int Numero)
{
int longitud= (Arreglo.length)/2;
if(Numero<=Arreglo[longitud])
{
for(int i=longitud; i>=0; i--)
{
if(Arreglo==Numero)
{
return i;
}
}
}
else if(Numero>=Arreglo[longitud])
{
for(int i=longitud-1; i<Arreglo.length; i++)
{
if(Arreglo==Numero)
{
return i;
}
}
}
return -1;
}
}


Problema 12.
La sucesión de Fibonacci viene definida por la siguiente recurrencia:
f
n+2=f
n+f
n+1
con valores iniciales f
0=0 y f
1=1.
Diseñad e implementad un método recursivo para calcular el enésimo término de la sucesión y
mostrad el árbol de llamadas que se produce al calcular f
4
 con vuestra solución.
/*Resolución del problema*/
import java.util.Scanner;
public class fibonacci {
 public static void main(String[] args) {
 Scanner b = new Scanner(System.in);
 int n, i;

 n = Integer.parseInt(validacampo("Ingrese un Numero: "));
 for(i=0;i<n;i++){
 System.out.print(fibonaci(i)+" ");
 }
 }
 public static String validacampo(String titulo) {
 Scanner b = new Scanner(System.in);
 String v = "";
 while(v.equals(""))
 {
 System.out.println(titulo);
 v = b.nextLine();
 if(!v.matches("^[0-9 ]*$"))
{
v = "";
}
 }
 return v;
 }

 public static int fibonaci(int numero){
 if(numero==0||numero==1) return numero;
 else return fibonaci(numero-1)+fibonaci(numero-2);

 }
}