Categoría: programacion

Cuenta Atras Java Script

Hoy te explicamos como crear una cuenta atras en Java Script utilizando PHP para que el usuario introduzca los segundos que va a durar la cuenta atras, primero realizamos el formulario HTML con los segundos que durara la cuenta atras

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
<div id="reloj">
    
<form action ="index.php" method="POST">
Segundos:<input type="number" name="tiempo"/><br><br/>
<input type="submit" value="Enviar"><br><br/>
</form>
</div>
<?php
if($_POST){
$segundos=$_POST["tiempo"];
        ?>
 

Luego creamos el script de manera que creamos una variable con la fecha actual y le sumamos los segundos que nos pasó el usuario para la cuenta atrás para calcular el final de la cuenta atras y luego restamos el final(end) del ahora(now) y nos da los milisegundos que quedan para la cuenta atras los descomponemos en dias, horas, minutos y segundos y obtenemos los datasw para mostrar

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
echo"<div id=\"countdown\"></div>";
echo "<script>
var end1 = new Date();
var seg =end1.getSeconds();
var end = end1.setSeconds(seg+".$segundos.");
    var _second = 1000;
    var _minute = _second * 60;
    var _hour = _minute * 60;
    var _day = _hour * 24;
    var timer;
 
    function showRemaining() {
        var now = new Date();
        var distance = end - now;
        console.log(distance);
        if (distance < 0) {
 
            clearInterval(timer);
            document.getElementById('countdown').innerHTML = 'EXPIRED!';
 
            return;
        }
        var days = Math.floor(distance / _day);
        var hours = Math.floor((distance % _day) / _hour);
        var minutes = Math.floor((distance % _hour) / _minute);
        var seconds = Math.floor((distance % _minute) / _second);
 
document.getElementById('countdown').innerHTML =  'Tiempo para que finalice la cuenta atras:   ';
        document.getElementById('countdown').innerHTML += days + ' dias, ';
        document.getElementById('countdown').innerHTML += hours + ' horas, ';
        document.getElementById('countdown').innerHTML += minutes + ' minutos y ';
        document.getElementById('countdown').innerHTML += seconds + ' segundos';
    }
 
    timer = setInterval(showRemaining, 1000);
</script>";
?>
 

Se puede probar en el siguiente enlace temporizador donde aparte del JavaScript hay algun otro cambio pero de poca importancia.
Espero que te haya gustado 😉

Relaciones UML

DEPENDENCIA: El elemento de origen depende del elemento destino y se puede ver afectado por cambios en este, es una relación mas débil que la asociación.

ASOCIACIÓN: Vinculos entre objetos. Aunque las asociaciones suelen ser bidireccionales (se pueden recorrer en ambos sentidos), en ocasiones es deseable hacerlas unidireccionales (restringir su navegación en un único sentido). Gráficamente, cuando la asociación es unidireccional, la línea termina en una punta de flecha que indica el sentido de la asociación

AGREGACIÓN: El elemento destino es una parte del elemento origen. La parte existe si se va el todo.

COMPOSICIÓN: Una forma de agregación mas fuerte, si desaparece el todo desaparecen las partes.

GENERALIZACIÓN: El elemento origen es una especialización del elemento destino, se utiliza en la herencia de clases.

REALIZACIÓN: El elemento origen garantiza llevar a cabo el contrato especificado, se utiliza para la implementación de las interfaces.

Ejemplo de Diagrama de clases:

Espero que te haya gustado

Juego de 3 en raya en consola en Java

Hoy te traemos una aplicación de consola en Java para jugar al tres en raya.
Consta de varias funciones:
-filas()
-columnas()
-diagonal()
-diagonalInversa()
Estas funciones estan destinadas a comprobar si hay 3 en raya.
Luego esta la función pintar() que comprueba si se puede escribir en la posicion que indica el usuario(comprueba si esta ya escrita, entonces sería movimiento incorrecto o si se sale de la pista) en estos dos casos el usuario tendría que volver a introducir fila y columna donde quiere escribir su jugada.
Tambien está la función mostrar() que escribe por pantalla la matriz de tres en raya como estaría despues de cada jugada.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package aplicacion1;
 
import java.util.Scanner;
 
/**
*
* @author Javi
*/
public class TresEnRaya {
 
    /**
     * @param args the command line arguments
     */
    public static boolean diagonalInversa(char mat[][],char jugador){
        boolean diagonalInvers=false;
         int k=0;
        for(int i=2, j=0;j<mat.length;i--,j++){
          
            if(mat[i][j]==jugador){
                k++;
            }
            if(k==3){
                diagonalInvers=true;
            }
        }
        return diagonalInvers;
    }
    
    
    public static boolean diagonal(char mat[][],char jugador){
        boolean diagonal=false;
        int k=0;
        for(int i=0, j=0;i<mat.length;i++,j++){
            
            if(mat[i][j]==jugador){
                k++;
            }
            if(k==3){
                diagonal=true;
            }
        }
        return diagonal;
    }
    
    
    public static boolean columnas(char mat[][],char jugador){
        boolean columna=false;
        for (int j=0;j<mat[0].length;j++){
            int k=0;
            
            for(int i=0;i<mat.length;i++){
                if(mat[i][j]==jugador){
                    k++;
                }
                if(k==3){
                    columna= true;
                }
                
            }
            
        }
        return columna;
    }
    
    public static boolean pintar(int fila,int columna,char mat[][],char jugador){
        
        try{
        if(mat[fila][columna]=='-'){
          
                mat[fila][columna]=jugador;
                return true;
            
            
        }else{
            System.out.println("Movimiento incorrecto");
            return false;
        }
        }catch(Exception e){
            System.out.println("Te has salido de la pista");
            return false;
        }
    }
    
    public static void mostrar(char mat[][]){
        for (int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                System.out.print(mat[i][j]+" ");
            }
            System.out.println(" ");
        }
    }
    
    public static boolean filas(char mat[][],char jugador){
        boolean linea=false;
        for (int i=0;i<mat.length;i++){
            int k=0;
            
            for(int j=0;j<mat[i].length;j++){
                if(mat[i][j]==jugador){
                    k++;
                }
                if(k==3){
                    linea= true;
                }
                
            }
            
        }
        return linea;
    }
    
    
    public static void main(String[] args) {
        // TODO code application logic here
        
        char mat[][]= new char[3][3];
        Scanner miteclado = new Scanner(System.in);
        for (int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
               mat[i][j]='-';
            }
        }
        char player='x';
        char ultimo='x';
        
        while(!filas(mat,ultimo)&&!columnas(mat, ultimo)&&!diagonal(mat, ultimo)&&!diagonalInversa(mat, ultimo)){
        
            int fila,columna;
        
            do{
                System.out.println("Jugador "+player+"\n Donde quieres poner la "+player+"?\n Indica la fila");
                fila=miteclado.nextInt();
                System.out.println(" Indica la columna");
                columna=miteclado.nextInt();
            }while(!pintar(fila, columna, mat, player));
            
            mostrar(mat);
            filas(mat,player);
            columnas(mat,player);
            diagonal(mat,player);
            diagonalInversa(mat,player);
 
            if (filas(mat,player)||columnas(mat, player)||diagonal(mat, player)||diagonalInversa(mat, player))
                    System.out.println("Ha ganado "+player);
 
            ultimo=player;
            switch(player){
                case 'x':{
                    player='o';
                    break;
                }
                case 'o':{
                    player='x';
                    break;
                }
            }
        }
    }
    
}
 

Espero que te guste ♥

Información sobre clases, atributos y métodos en Java

Modificadores de clase

class Indica que es una clase class ClaseEjempIo{..}
public class Indica que puede ser accesible desde clases que se encuentren en el mismo paquete que esta clase y también desde clases que se encuentren en paquetes distintos, realizando un import. Solo puede haber una clase publica en un fichero java. public class ClaseEJemplo{…}
abstract class Indica que no se pueden crear instancias de esta clase con el operador new, Puede contener métodos sin implementar de tipo abstract Otras clases pueden heredar de ella implementanda todos Ios metodos que no lo estén. En Caso de que la clase hija sea abstracta, puede implementar solo algunos métodos abstract class ClaseEjemplo{..}
final class Indica que no puede tener clases hijas o subclases. Es decir. ninguna clase puede heredar de ella final class ClaseEjemplo{…}
sin modificador class Indica que puede ser accesible solo desde clases que se encuentren en el mismo paguete que esta clase. class ClaseEjemplo

Modificadores de acceso de métodos y atributos

public Accesible desde cualquier lugar public int atributoEjempIo
sin_modificador Accesible solo desde cualquier clase que se encuentre en el mismo paquete int atributoEjernplo
protected Accesible desde Ias clases hijas que se encuentren en cualquier paquete. O accesible desde de cualquier clase que se encuentre dentro del mismo paquete, sea o no su hija. protected int atributoEjempIo
private Accesible solo dentro de la clase en la que fue declarado private int atributoEjemplo
static No se necesita una instancia de la clase para poder acceder/modifcar un atributo o ejecutar un método. Se accede al atributo o método a través del nombre de Ia clase. Un método static solo puede acceder a atributos y métodos static. en caso de que estos estén declarados en la misma clase. Se puede acceder a atributos y métodos no static a través de objetos. EI valor de un atributo static es compartido por todos Ios objetos, y si un objeto lo modifica, Ios demas objetos perciben la modificación. A estos atributos se Ies suele llamar atributos de Clase. public static atributoEjemplo
final No permiten reescrituras ni sobrecargas.Se suele utilizar si se desea declarar una constante. También en el caso de que se quiera evitar que modifiquen un método definido en Ia clase padre en una clase hija. (Evitar override) public static final CONSTANTE_EJEMPLO;
synchronized Evita que dos hilos puedan acceder al mismo metodo a la vez, para evitar problemas de acceso concurrente. Dejaria al segundo hilo en espera hasta que terminase el primero. (No se usa en atributos) public synchronized int metodo{…}
volatile Tiene el el mismo electo que synchronized, pero este se aplica solo a atributos. public volatile int atributoEjempIo
transient Evita que un atributo sea serializado, al serializar el objeto que lo contiene. private transient int AtributoEjempIo
native native es un modificador utilizado cuando un determinado método estå escrito en un lenguaje distinto a Java. normalmente C. C++ o ensamblador para mejorar el rendimiento. La forma más común de implementar estos métodos es utilizar JNI (Java Native Interface). (No aplicable a atributos) private native int metodo();

Tabla de accesiblidad


 La misma clase Otra clase del mismo paquete Subclase de Otro paquete Otra clase de Otro paquete
public X X X X
protected X X X
sin_modificador X X

private X


Crear objetos

Crear un Objeto de una clase

NombreCIase nombreObjeto = new NombreCIase();

Crear Objeto de clase interna estática

ClaseExterna.CIaseInterna nombreObjeto = new ClaseExterna.ClaseInterna()

Crear objetos de clase interna no estática

ClaseExterna nombreObjetoExterna = new ClaseExterna();

Claselnterna nombreObjetolnterno = nombreObjeto.new Claselnterna();

Crear objeto de clase anónima:

Clasepadre nombreObjeto = new ClasePadre {

métodoDeClasePadre(){

Cambios en el método

}

};

nombreObjeto.metodoDeCIasePadre() //Llamada al método de la clase anonima.

Métodos y atributos estáticos

Crear un método o atributo estático

public static int nombreAtributo;

public static void nombreMetodo();

Acceder a un método estático.

NombreCIase.nornbreMetodo(); //No se necesita crear un Objeto con new para poder usarlo.

Acceder a un atributo estätico.

NombreCIase.nornbreAtributo //NO se necesita crear un objeto new para poder usarlo.

Información sobre clases, atributos y métodos en Java

Con este PDF se intenta explicar los modificadores de clase, atributos y métodos en Java.

Publicado:19 noviembre, 2019
¡Descarga ahora!13 Descargas

Operaciones con matrices en Java (suma, resta, multiplicación, matriz identidad)

Hola, hoy os traemos un programa en java que realiza operaciones (suma, resta, multiplicación y matriz identidad) con matrices, en este ejemplo utilizamos matrices cuadradas aleatorias para que sea mas rapido pero podríamos utilizar matrices introducidas por el usuario( en la función rellenar dejo comentado como sería para introducir los datos por el usuario).

La suma y resta de matrices tiene la condición de que las matrices tienen que ser de la misma dimensión, tienen que tener el mismo número de filas y de columnas.
Para efectuar la suma sumamos elemento a elemento:
el elemento (0,0) de la matriz 1 lo sumamos con el elemento (0,0) de la matriz 2 y obtenemos el elemento (0,0) de la matriz suma,
el elemento (0,1) de la matriz 1 lo sumamos con el elemento (0,1) de la matriz 2 y obtenemos el elemento (0,1) de la matriz suma y así sucesivamente.
Para restar seguimos el procedimiento anterior pero cambiando suma por resta.

Para multiplicar matrices las matrices tienen que cumplir la condición de que:
las filas de la matriz 1 = las columnas de la matriz 2
las columnas de la matriz 1 = las filas matriz 2
La matriz resultante tendría la dimensión :
[filas matriz 1 , columnas matriz 2]
Para efectuar la multiplicación efectuamos la operacion:
matrizproducto(0,0) = matriz1(0,0) * matriz2(0,0) + matriz1(0,1) * matriz2(1,0)+matriz1(0,2)*matriz2(2,0)+matriz1(0,3)*matriz2(3,0)
Con esto obtendríamos el elemento (0,0) de la matriz producto.
matrizproducto(0,1) = matriz1(0,0) * matriz2(0,1) + matriz1(0,1) * matriz2(1,1)+matriz1(0,2)*matriz2(2,1)+matriz1(0,3)*matriz2(3,1)
Y asi sucesivamente hasta hayar todos los elementos de la matriz producto

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
package aplicacion1;
 
import java.util.InputMismatchException;
import java.util.Scanner;
 
/**
*
* @author javi
*/
public class operaciones {
 
  
    public static void identidad(int dimension){
        int ident[][]=new int[dimension][dimension];
         for(int i=0;i<ident.length;i++){
            for(int j=0;j<ident[i].length;j++){
                if(i==j){
                    ident[i][j]=1;
                }else{
                    ident[i][j]=0;
                }
                System.out.print(ident[i][j]+" ");
            }
            System.out.println(" ");
        }
        
    }
    
    public static int[][] multiplicar(int mat1[][],int mat2[][],int dimension){
        int multi[][]=new int[dimension][dimension];
        System.out.println("Se va a proceder a multiplicar las matrices");
        int suma=0;
        for(int i=0;i<mat1.length;i++){
            for(int j=0;j<mat1[i].length;j++){
                suma=0;
                for(int k=0;k<dimension;k++){
                    suma=suma+mat1[i][k]*mat2[k][j];
                }
                multi[i][j]=suma;
                System.out.print(multi[i][j]+" ");
                
            }
            
            System.out.println(" ");
        }
        return multi;
    }
    
    public static int [][]restar(int mat1[][],int mat2[][],int dimension){
        int resta[][]=new int[dimension][dimension];
        System.out.println("Se va a proceder a restar las matrices");
        for(int i=0;i<mat1.length;i++){
            for(int j=0;j<mat1[i].length;j++){
                resta[i][j]=mat1[i][j]-mat2[i][j];
                System.out.print(resta[i][j]+" ");
            }
            System.out.println(" ");
        }
        return resta;
    }
    
    public static int [][]sumar(int mat1[][],int mat2[][],int dimension){
        int suma[][]=new int[dimension][dimension];
        System.out.println("Se va a proceder a sumar las matrices");
        for(int i=0;i<mat1.length;i++){
            for(int j=0;j<mat1[i].length;j++){
                suma[i][j]=mat1[i][j]+mat2[i][j];
                System.out.print(suma[i][j]+" ");
            }
            System.out.println(" ");
        }
        return suma;
    }
    
    public static void mostrar(int mat[][],int matriz){
        System.out.println("Mostrando la matriz "+matriz);
        for(int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                System.out.print(mat[i][j]+" ");
            }
            System.out.println(" ");
        }
        
    }
    
    public static void rellenar(int mat[][],int matriz){
        for(int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                //System.out.println("Dime un valor para la matriz "+matriz+" en la posicion(i "+i+", j "+j+")");
//mat[i][j]=miteclado.nextInt();
                mat[i][j]=(int)(Math.random()*9);
            }
        }
    }
    
    
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner miteclado = new Scanner(System.in);
        boolean salir=false;
        int num=0;
        while(!salir){
            try{
                System.out.println("cuantas filas y columnas quieres que tenga la matriz");
                num=miteclado.nextInt();
                salir=true;
            }catch(InputMismatchException e){
                System.out.println("No puedes introducir otra cosa que no sea un numero");
                miteclado.nextLine();
            }
        }
        salir=false;
        int op=0;
        while(!salir){
            try{
                System.out.println("1-sumar matrices\n2-restar matrices\n3-multiplicar matrices\n4-matriz identidad\n5-salir");
                op=miteclado.nextInt();
                salir=true;
            }catch(InputMismatchException e){
                System.out.println("No puedes introducir otra cosa que no sea un numero");
                miteclado.nextLine();
            }
        }
        int matriz1[][]=new int[num][num];
        int matriz2[][]=new int[num][num];        
        switch(op){
            case 1:{
                rellenar(matriz1,1);
                rellenar(matriz2,2);
                mostrar(matriz1,1);
                mostrar(matriz2, 2);
                sumar(matriz1, matriz2, num);
                
                break;
            }
            case 2:{
                rellenar(matriz1,1);
                rellenar(matriz2,2);
                mostrar(matriz1,1);
                mostrar(matriz2, 2);
                restar(matriz1, matriz2, num);
                break;
            }
            case 3:{
                rellenar(matriz1,1);
                rellenar(matriz2,2);
                mostrar(matriz1,1);
                mostrar(matriz2, 2);
                multiplicar(matriz1, matriz2, num);
                
                break;
            }
            case 4:{
                identidad(num);
                break;
            }
            case 5:{
                break;
            }
                
        }
              
    }
    
}
 

El resultado seria algo como esto:

cuantas filas y columnas quieres que tenga la matriz
3
1-sumar matrices
2-restar matrices
3-multiplicar matrices
4-matriz identidad
5-salir
3
Mostrando la matriz 1
6 0 0
7 6 8
6 4 5
Mostrando la matriz 2
4 3 7
3 7 0
2 7 4
Se va a proceder a multiplicar las matrices
24 18 42
62 119 81
46 81 62

Espero que les haya gustado 😉

Sumar multiples ángulos con Java

Hola, hoy proponemos un ejercicio de suma de ángulos sexagesimales en java, para ello primero indicamos al usuario cuantos ángulos quiere sumar, después introducimos los grados minutos y segundos en una matriz.
En este caso el usuario introdujo dos ángulos a sumar:

35º43′50″
12º36′35″

Una vez hecho esto sumamos las columnas y obtenemos:
sumas=el sumatorio de la columna de los segundos(85″)
sumam=el sumatorio de la columna de los minutos(79′)
sumag=el sumatorio de la columna de los grados(47º)

Por último normalizamos los segundos y minutos si son mayores que 60.
Quedando como segundos resultantes el resto entre los segundos y 60 y añadimos a los minutos el cociente de dividir los segundos entre 60.
Lo mismo hacemos con los minutos, normalizando si estos pasan de 60 entonces añadimos a los grados el cociente entre minutos y 60, el nuevo valor de minutos será el resto entre los minutos y 60.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
package aplicacion1;
 
import java.util.Scanner;
 
/**
*
* @author Javi
*/
public class sumarAngulos {
 
    /**
     * @param args the command line arguments
     */
    
    
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner miteclado = new Scanner(System.in);
        System.out.println(" ");      
        System.out.println("Cuantos angulos quieres sumar?");
        int num=miteclado.nextInt();
        int matriz[][];
        matriz =new int[num][3];
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[i].length;j++){
                if(j==0){
                    System.out.println("Dime los grados para el angulo "+(i+1));
                    matriz[i][j]=miteclado.nextInt();
                }
                if(j==1){
                    System.out.println("Dime los minutos para el angulo "+(i+1));
                    matriz[i][j]=miteclado.nextInt();
                }
                if(j==2){
                    System.out.println("Dime los segundos para el angulo "+(i+1));
                    matriz[i][j]=miteclado.nextInt();
                }
            }
        }
        int sumag=0;
        int sumam=0;
        int sumas=0;
        for(int j=0;j<3;j++){
            for(int i=0;i<matriz.length;i++){
                if(j==0){
                   sumag=sumag+matriz[i][j];
                }
                if(j==1){
                    sumam=sumam+matriz[i][j];
                }
                if(j==2){
                    sumas=sumas+matriz[i][j];
                }
                      
            }
        }
        
        if(sumas>60){
            
            sumam=sumam+(sumas/60);
            sumas=sumas%60;
        }
        if(sumam>60){
            sumag=sumag+(sumam/60);
            sumam=sumam%60;
        }
        
        System.out.println("La suma es "+sumag+"º "+sumam+"' "+sumas+"\"");
    
    }
    
}
 

La salida sería la siguiente:

Cuantos angulos quieres sumar?
2
Dime los grados para el angulo 1
35
Dime los minutos para el angulo 1
43
Dime los segundos para el angulo 1
50
Dime los grados para el angulo 2
12
Dime los minutos para el angulo 2
36
Dime los segundos para el angulo 2
35
La suma es 48º 20′ 25″

Espero que les haya gustado 😉

Matriz con los mismos elementos en las diagonales en Java

En este ejercicio vamos a consegir una matriz de dimensiones n x n dadas por el usuario.
Los elementos de la matriz tendran valores del 0 al 9 , si la matriz fuera de 10 elementos(10 x 10), obtendriamos el siguiente resultado, con el mismo número en las diagonales

0123456789
1234567890
2345678901
3456789012
4567890123
5678901234
6789012345
7890123456
8901234567
9012345678

La función mostrar simplemente muestra la matriz recorriendola fila a fila.
La función diagolnal calcula la suma de filas + columnas y lo asigna a cada elemento de la matriz, si es mayor que 10 el sumatorio de filas y columnas hará el sumatorio de filas y columnas modulo de 10 para asignarle este valor al elemento de la matriz.
Tenemos en cuenta que en Java los arrays se pasan por referencia.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
package aplicacion1;
 
import java.util.Scanner;
 
/**
*
* @author Javi
*/
public class diagonales {
 
    
    public static void mostrar(int mat[][]){
         for (int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                System.out.print(mat[i][j]);
            }
         System.out.println(" ");
         }    
    }
    
    
    public static int[][] diagonal(int mat[][]){
        for (int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                
                if(i+j>=10){
                    int total=(i+j)%10;
                    mat[i][j]=total;
                }else{
                    mat[i][j]=i+j;  
                }
            }
        }
        return mat;
    }
    
    
    public static void main(String[] args) {
        
        Scanner miteclado = new Scanner(System.in);
        System.out.println("cuantos filas tiene la matriz?");
        int filas = miteclado.nextInt();
        int matriz[][];
        matriz = new int[filas][filas];
        diagonal(matriz);
        mostrar(matriz);
    }
    
}

Espero que les haya gustado queda muy bonita 😆

Calcular la matriz transpuesta con Java

En este ejercicio calcularemos la matriz transpuesta de una matriz 4×4 con respecto a su eje diagonal. Primero rellenaremos con numeros aleatorios del 0 al 9 la primera matriz y despues con la función simétrica calcularemos su transpuesta. conforme al siguiente gráfico. Los elementos de la diagonal marcados con una X permaneceran en el mismo lugar y los elementos que estan en el mismo color son los que se intercambiaran entre si.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package aplicacion1;
 
/**
*
* @author Javi
*/
public class simetrica {
 
    
    public static int[][] simetrica(int mat[][]){
        int simetric[][];
        simetric=new int[4][4];
        
        for (int i=0;i<simetric.length;i++){
            for(int j=0;j<simetric[i].length;j++){
               simetric[i][j]=mat[3-j][3-i];
               System.out.print(simetric[i][j]);
            }
            System.out.println(" ");
        }
        return simetric;
    }
    
    
    public static int[][] rellenar(int mat[][]){
        for (int i=0;i<mat.length;i++){
            for(int j=0;j<mat[i].length;j++){
                mat[i][j]=(int)(Math.random()*9);
                System.out.print(mat[i][j]);
            }
            System.out.println(" ");
        }
        return mat;
    }
    
    public static void main(String[] args) {
        // TODO code application logic here
        
        int matriz[][];
        matriz=new int[4][4];
        rellenar(matriz);
        System.out.println("matriz simetrica");
        simetrica(matriz);
    }
    
}

El resultado sería algo como esto:

0126
1775
2105
8666
matriz simetrica
6556
6072
6171
8210

Array de números aleatorios sin repetición en Java

Este ejercicio consiste en generar un array de 20 numeros enteros (del 1 al 49) que no se repitan despues el usuario ingresara un array de 6 números y le diremos cuantos numeros a acertado comprobando las coincidencias con el primer array de 20 enteros. La función que genera los números aleatorios sin repetición es la función loteriaSinRepeticion.

La función miApuesta crea un array de enteros con los números elegidos por el usuario

La función comprobacion cuenta las coincidencias que hay entre el array de los 20 números aleatorios sin repetición y la apuesta del usuario.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
package javi;
 
import java.util.Scanner;
 
/**
*
* @author Javi
*/
public class Actividad5_01b {
 
    /**
     * @param args the command line arguments
     */
    public static int comprobacion(int ganador[],int miComb[]){
        System.out.println("La combinacion ganadora es");
        for(int i=0;i<ganador.length;i++){
            System.out.print(ganador[i]+" ");
        }
        System.out.println(" ");
        System.out.println("Tus numeros son");
        for(int i=0;i<6;i++){
            System.out.print(miComb[i]+" ");
        }
        
        int k=0;
        for(int i=0;i<ganador.length;i++){
            for (int j=0;j<miComb.length;j++){
                if(ganador[i]==miComb[j]){
                    k++;
                }
            }
        }
        System.out.println(" ");
        System.out.println("Has acertado "+k+" numeros");
        return k;
    }
    
    
    
    
    public static int[] miApuesta(){
        Scanner miteclado = new Scanner(System.in);
        int primitiva[];
        primitiva=new int[6];
        for(int i=0;i<6;i++){
            System.out.println("Dime tus numeros");
            primitiva[i] = miteclado.nextInt();
        }
        return primitiva;
    }
    
    public static int[] loteriaSinRepeticion(int arr[]){
        
        for(int i=0;i<arr.length;i++){
            boolean encontrado = false;
            int ale=(int)(Math.random()*48)+1;
            for (int j=0;j<i ;j++){
                if(arr[j]==ale){
                    encontrado=true;
                }
            }
            if(!encontrado){
                arr[i]=ale;
            }else{
                i--;
            }
        }
        
        return arr;
    }
    
    public static void main(String[] args) {
        // TODO code application logic here
        int combinacion[];
        combinacion=new int[20];
        comprobacion(loteriaSinRepeticion(combinacion),miApuesta());
    }
    
}
 

Espero que les guste 😉

La salida sería algo como esta:

Dime tus numeros
1
Dime tus numeros
2
Dime tus numeros
3
Dime tus numeros
4
Dime tus numeros
5
Dime tus numeros
6
La combinacion ganadora es
32 38 8 17 48 34 15 11 3 33 10 24 27 41 36 35 25 14 23 42
Tus numeros son
1 2 3 4 5 6
Has acertado 1 numeros