Parcial estructura de datos!

public class Matriz {

public String[25][25] letra;
public String[5] filas;
public String[5] columnas;
public String[][] resultado;

public void arreglo() {
Boolean x = true;

if (x=true) {
resultado = filas x columnas;
}
for (i=0; i<0; i++) {
System.out.println(“el resultado de la matriz es” + resultado);
}
Return i;
}

public String letricas() {

lestras = (1 1 1 1 1 (1 1 1 1 1 (1 1 ( 1
1 1 1 1 1 1 1
1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1
1 ); 1 1 1 1 1); 1 1); 1 1);

for (i=0; i<25; i++) {
for (i=0; i<25; i++) {
return m.arreglo(resultado);
}
}
}

public void Romano() {

String[5] Rom;
String[5] Roma;
Matriz m = new Matriz;
String[25] posicion;
int =1; int v=5; int x=10; int xx=20; int xxx=30; int l=50;

if (i+v+x+xx = 25 v+xx = 25 posicion = (filas x Rom) + (columnas x Roma)) {

System.out.println(“\n El resultado en Romanos es” + z.arreglo(resultado));
}
else
return 0;
}

public void Hexadecimal() {

String[5] Hex;
String[5] Hexa;
Matriz y = new Matriz;
String[25] resultante;
int a=10, int b=11, int c=12, int d=13; int e=14; int f=15 ….;

if (a + b + n = 25 c+d = 25 resultado = (filas x Hex) + (columnas x Hexa)) {

System.out.println(“\n El resultado en Hexadecimal es” + y.arreglo(resultado));
}

else
Return 0;
}

public static void main ( String arg[] ) {
Matriz p = new Matriz;
p.Arreglo(); //Imprime la letra TINA y su posición
p.Romano(); // Imprime la letra TINA y su posición en Rom.
p.Hexadecimal(); // Imprime la letra TINA y su posición en Hex.

}
}

Tarea de Ejercicio 2.5

public class Arreglo {
public Arreglo() {;} // Constructor de la clase
public void merge(int[] a, int[] b) {
int longitud = (a.length + b.length); //Longitud de los dos arreglos
int[] w = new int[longitud]; //Creacion del arreglo del tamano de la suma de los dos arreglos
for(int i=0; i < a.length; i++) //se llena el valor de a
w[i] = a[i];
for(int i=0; i < b.length; i++) //se llena el valor de b
w[i + a.length] = b[i];
int temp = 0; //Metodo de ordenacion burbuja. Se ordenan los numeros rangos de mayor a menor
for(int j = 0; j <= (w.length -2); j++)
for(int k = 0; k <= ((w.length - j) - 2); k++)
if(w[k] < w[k+1]) {
temp = w[k];
w[k] = w[k + 1];
w[k+1] = temp;
}
System.out.println("\n");
System.out.print("Arreglo final: ");
for(int i=0; i < w.length; i++)
System.out.print(w[i] + " ");
}
public static void main(String[] args) {
int[] x = new int[5]; //declaracion de arreglo x
int[] y = new int[5]; //declaracion de arreglo y
Arreglo z = new Arreglo(); //declaracion del objeto z que llena ambos arreglos
for(int i=0; i < x.length; i++) { //llenar arreglo x
x[i] = (int)(Math.random() * 100);
}
for(int i=0; i < y.length; i++) { //llenar arreglo y
y[i] = (int)(Math.random() * 100);
}
System.out.print("Valores del arreglo X: "); //imprime el contenido del arreglo x
for(int i=0; i < x.length; i++) {
System.out.print(x[i] + " ");
}
System.out.println("\n");
System.out.print("Valores del arreglo Y: "); //imprime el contenido del arreglo y
for(int i=0; i < y.length; i++) {
System.out.print(y[i] + " ");
}
z.merge(x,y);
}
}

Torre de Hanoi

#include
/* Delcaracion de funciones */
void mover_torre (int n,
char pinicial,
char pfinal,
char paux,
int dsup,
int *movs);
void mover_disco (int n,
char pinicial,
char pfinal,
int *movs);
/* Flujo de ejecucion */
int main()
{
int numero_discos, movs=0;
char poste_inicial='A', poste_final='C', poste_aux='B';
printf("\nEste algoritmo resuelve el problema de\n"
"las torres de Hanoi.\n\n");
printf("Introduzca el numero de discos: ");
scanf("%d", &numero_discos);
printf("\n");
mover_torre(numero_discos, poste_inicial, poste_final,
poste_aux, 1, &movs);
printf("\n\nFueron necesarios %d movimientos.\n", movs);
return (1);
}
/* Definicion de funciones */
/* Funcion: mover_torre (
* n - numero de discos
* pinicial - poste inicial
* pfinal - poste final
* paux - poste auxiliar
* dsup - numero de disco superior de la subtorre
* movs - puntero a contador de movimientos )
*/
void mover_torre(int n, char pinicial, char pfinal,
char paux, int dsup, int *movs)
{
/* Caso general */
if ( n != dsup ) {
mover_torre(n-1, pinicial, paux, pfinal, 1, movs);
mover_torre(n, pinicial, pfinal, paux, n, movs);
mover_torre(n-1, paux, pfinal, pinicial, 1, movs);
/* Caso base ( numero de discos == disco superior subtorre ) */
} else {
mover_disco(dsup, pinicial, pfinal, movs);
}
}
/* Funcion: mover_disco (
* n - numero de disco
* pinicial - poste inicial
* pfinal - poste final
* movs - puntero a contador de movimientos )
*/
void mover_disco(int n, char pinicial, char pfinal, int *movs)
{
printf("Muevo disco %d desde poste %c a poste %c\n",
n, pinicial, pfinal);
(*movs)++;
}

Tema IV

Tema IV .- Desarrolle los algoritmos correspondientes a:

a) Multiplicación de los 100 primeros números primos.
class numerosprimos{
public static void main(String [] args){
boolean bool = false;
double multiplicacion = 2.0d;
for(int z=3; z < '100 ; z + = 2)
{
bool = true;
for(int j=3; j < 'z ; j + = 2)
{
if(z%j == 0){bool = false;
break;
}
}
if(bool){mult *= z;}
}

b) La raíz cuadrada de un número.
{
float igual = 0;
for (int i = 1; i <>
{
if (i * i == dado)
{
igual = i;
}
}
return igual;
}

c) El mayor de 3 números.
public class mayor {
xvalores[0] = numero1 ;xvalores[1] = numero2 ;xvalores[2] = numero3 ;for(int z = 0 ; z < 'xvalores.length ; z ++)
{
for(int j=0; j < 'xvalores.length - 1 ; j ++)
{
if(xvalores[j] > xnumero[j+1])
{int temporal = xnumero[j];xvalores[j] = xnumero[j+1];xvalores[j+1] = temporal ;}}}System.out.println("El numero mayor es: " + xvalores[2]);}

d) La calificación de 5 estudiantes para 4 asignaturas de 3 puntuaciones.

Tema III

Tema III .- Declare los tipos de datos para las siguientes estructuras:

a) Días de la semana.
Int
b) Los valores comprendidos para almacenar la edad de una persona.
double
c) Una lista de un supermercado.
String[][]
d) Un archivo de texto.
File

Tema II

Tema II .- Realice los siguientes ejercicios:

Polindromo:

bool state = false;
int long = word.Length;
string[] left = new string[long];
string[] right = new string[long];
int f = 0;

for (int i = 0; i <> {
left[i] = word.Substring(i, 1);
}
for (int j = long-1; j >= 0; j--)
{
right[f] = word.Substring(j, 1);
f++;
}
if (left[k] == right[k])
{
state = true;
}
else
{
state = false;
break;
}
}
return state;
}

Factorial:
{
int rest = 1;
for (int i = num; i > 0; i--)
{
rest *= i;
}
return rest;
}

Tema I

Tema I .- Definiciones:

a) Variables: Las variables son estructuras de datos que, como su nombre indica, cambian a lo largo de la ejecución de un programa.
Más concretamente, una variable corresponde a un área reservada en la memoria principal del ordenador, longitud fija o variable, en donde el programa puede almacenar valores.
Cada variable tiene un tipo de dato asociado, que determina el espacio ocupado, los valores que puede almacenar y las operaciones que se pueden realizar con ellos.
Las variables pueden ser intercambiadas entre rutinas por valor y por referencia.
b) Constantes: Una constante es un valor fijo, aunque a veces no determinado. Una función constante es una función matemática que para cada conjunto de variables en la misma, devuelve el mismo valor.

c) Tipos de Datos: Podemos definir un tipo de dato a partir de los valores permitidos y las operaciones que se puedan llevar a cabo sobre estos valores.
A menudo, un mismo tipo de dato se implementará de formas diversas.
d) Algoritmo: Un algoritmo es un conjunto finito de instrucciones o pasos que sirven para ejecutar una tarea o resolver un problema.

e) OOP: La Programación Orientada a Objetos (POO ú OOP según siglas en inglés) es una metodología de diseño de software y un paradigma de programación que define los programas en términos de "clases de objetos", objetos que son entidades que combinan estado (es decir, datos) y comportamiento (esto es, procedimientos o métodos).
f) Clase: Una clase es un tipo especial de datos, y esta orientada a la creación de objetos y que consta de unos miembros que pueden ser datos o funciones privadas o públicas.g) Polimorfismo: Se denomina polimorfismo a la capacidad del código de un programa para ser utilizado con diferentes tipos de datos u objetos. También se puede aplicar a la propiedad que poseen algunas operaciones de tener un comportamiento diferente dependiendo del objeto (o tipo de dato) sobre el que se aplican.