Ir al contenido principal

Algoritmo de Busqueda de Cuadrados en Matriz aleatoria de unos

Descargar Codigo Fuente
Hoy les traigo un pequeño ejercicio, el cual consiste en hallar cuadrados en una matriz aleatoria de unos y ceros, en dicha matriz existen dos tipos de cuadrados los de ángulo 0° y ángulo 45°, siendo breves les traigo un ejemplo:

Matriz de 6 X 6
    0   1   2   3   4   5
0  0   0   1   0   1   1
1  0   1   0   1   1   1
1   0   1   0     0
3  0   1   0   1   0   0
4  0   0   1   0   0   0
5  1   0   0   1   0   0

En este caso las coordenadas estan determinadas en filas y columnas, en el ejercicio piden encontrar los puntos que forman los cuadrados, citemos un ejemplo:

El cuadrado de color verde esta formado por los siguientes puntos
(4,0);(4,1);(5,0);(5,1)  si esto lo comparamos con un plano cartesiano la variable "X" o abcisa seria el valor de la columna y la variable "Y" o Ordenada sería el valor de fila.

IDE Usado Netbeans.
Lenguaje de Programación: JAVA
IN/OUTPUT DATA : Consola

Estructura del Proyecto:

Beans:
package com.square.bean;

import java.util.ArrayList;

/**
 *
 * @author Administrador
 */
public class Cuadrado {
    ArrayList<Punto> puntos=new ArrayList();
    int angulo;
    public int getAngulo() {
        return angulo;
    }
    public ArrayList<Punto> getPuntos() {
        return puntos;
    }
    public void setAngulo(int angulo) {
        this.angulo = angulo;
    }
    public void setPuntos(ArrayList<Punto> puntos) {
        this.puntos = puntos;
    }
}
***********************************************************************************

package com.square.bean;

/**
 *
 * @author Administrador
 */
public class Matriz {
    private int filas;
    private int columnas;
    private Value[][] arreglo;   
    public Matriz(int row,int column,Value[][]matrix){
        filas=row;
        columnas=column;
        arreglo=matrix;
    }
    public Value[][] getArreglo() {
        return arreglo;
    }
    public void setArreglo(Value[][] arreglo) {
        this.arreglo = arreglo;
    }
    public int getColumnas() {
        return columnas;
    }
    public void setColumnas(int columnas) {
        this.columnas = columnas;
    }
    public int getFilas() {
        return filas;
    }
    public void setFilas(int filas) {
        this.filas = filas;
    }   
}

***********************************************************************************

package com.square.bean;
/**
 *
 * @author Administrador
 */
public class Punto {
    int fila;
    int columna;
    public Punto(int x,int y){
        fila=x;
        columna=y;
    }
    public int getColumna() {
        return columna;
    }
    public void setColumna(int columna) {
        this.columna = columna;
    }
    public int getFila() {
        return fila;
    }
    public void setFila(int fila) {
        this.fila = fila;
    }               
}

***********************************************************************************

package com.square.bean;
/**
 *
 * @author Administrador
 */
public class Value {
    private String valor;
    private Punto point;   
    public Value(String val,Punto p){
        valor=val;
        point=p;
    }   
    public Punto getPoint() {
        return point;
    }
    public void setPoint(Punto point) {
        this.point = point;
    }
    public String getValor() {
        return valor;
    }
    public void setValor(String valor) {
        this.valor = valor;
    }   
}

***********************************************************************************
Dao:

package com.square.dao;

import com.square.bean.Matriz;
import com.square.bean.Punto;
import com.square.bean.Value;
import java.util.ArrayList;
import java.util.Random;
/**
 *
 * @author Administrador
 */
public class DaoMatriz {   
    public static Matriz generarMatriz(int filas,int columnas){
        Value[][] matriz=new Value[filas][columnas];
        double aux;
        int valor;
        Random rnd = new Random();;
        for(int i=0;i<filas;i++){
            for(int j=0;j<columnas;j++){               
                aux=rnd.nextDouble();               
                valor=(int)Math.round(aux);
                Punto p=new Punto(i,j);
                Value val=new Value(String.valueOf(valor),p);
                matriz[i][j]=val;
            }
        }
        Matriz matrix=new Matriz(filas,columnas,matriz);
        return matrix;
    }   
    public static void paintMatriz(Matriz matrix){          
        for(int i=0;i<matrix.getFilas();i++){                                                 
            for(int j=0;j<matrix.getColumnas();j++){                               
                System.out.print(" "+matrix.getArreglo()[i][j].getValor()+" ");               
            }
            System.out.print("\n");
        }
    }   
    public static ArrayList<Value> paintMatrizUnos(Matriz matrix){  
        ArrayList<Value> listOne=new ArrayList<Value>();
        for(int i=0;i<matrix.getFilas();i++){                                                 
            for(int j=0;j<matrix.getColumnas();j++){                               
                if(matrix.getArreglo()[i][j].getValor().equals("0")){
                    matrix.getArreglo()[i][j].setValor(".");
                }else if(matrix.getArreglo()[i][j].getValor().equals("1")){
                    listOne.add(matrix.getArreglo()[i][j]);               
                }
                   
                System.out.print(" "+matrix.getArreglo()[i][j].getValor()+" ");               
            }
            System.out.print("\n");
        }
        return listOne;
    }                       
}

***********************************************************************************

Logic:

package com.square.Logic;

import com.square.bean.Cuadrado;
import com.square.bean.Matriz;
import com.square.bean.Punto;
import com.square.bean.Value;
import java.util.ArrayList;
import java.util.Iterator;

/**
 *
 * @author Administrador
 */
public class AlgoBusca {
    //ALGORTIMO 1
    public static ArrayList<Cuadrado> buscarCuadradosAngulo0(Matriz matrix, ArrayList<Value> unos) {
        ArrayList<Cuadrado> cuadrados=new ArrayList<Cuadrado>();
        Iterator i = unos.iterator();
        Value val;
        int maxlado = 0;
        int contador;       
        if (matrix.getColumnas() > matrix.getFilas()) {
            maxlado = matrix.getColumnas();
        } else {
            maxlado = matrix.getFilas();
        }
        boolean valpunto=false;
        while (i.hasNext()) {
            val=(Value)i.next();
            //Moviendose a la Derecha   
            contador = 2;
            valpunto=false;
            int fila;
            int columna;
            while (contador <= maxlado-val.getPoint().getColumna()) {
                try{
                fila=val.getPoint().getFila();
                columna=val.getPoint().getColumna();
                Cuadrado cua=new Cuadrado();
                //derecha               
                for(int j=1;j<contador;j++){                   
                    if(!matrix.getArreglo()[fila][columna+j].getValor().equals("1")){                       
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila][columna+j].getPoint());
                        valpunto=true;
                    }
                }
                if(valpunto){
                    //abajo
for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila+j][columna+contador-1].getValor().equals("1")){                   
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila+j][columna+contador-1].getPoint());
                        valpunto=true;
                    }
                }   
                }else{
                    break;
                }
               
                if(valpunto){
                    //izquierda
                for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila+contador-1][columna+contador-1-j].getValor().equals("1")){
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila+contador-1][columna+contador-1-j].getPoint());
                        valpunto=true;
                    }
                }   
                }else{
                    break;
                }
               
                if(valpunto){
                    //arriba
                for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila+contador-1-j][columna].getValor().equals("1")){
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila+contador-1-j][columna].getPoint());
                        valpunto=true;
                    }
                }   
                }else{
                    break;
                }
                if(valpunto){
                 cua.setAngulo(0);
                cuadrados.add(cua);  
                }               
                contador=contador+1;
                }catch(Exception ex){
                contador=contador+1;
                }
            }
        }
        return cuadrados;
    }
    //ALGORTIMO 2
    public static ArrayList<Cuadrado> buscarCuadradosAngulo45(Matriz matrix, ArrayList<Value> unos) {
        ArrayList<Cuadrado> cuadrados=new ArrayList<Cuadrado>();
        Iterator i = unos.iterator();
        Value val;
        int maxlado = 0;
        int contador;       
        if (matrix.getColumnas() > matrix.getFilas()) {
            maxlado = matrix.getColumnas();
        } else {
            maxlado = matrix.getFilas();
        }
        boolean valpunto=false;
        while (i.hasNext()) {
            val=(Value)i.next();
            //Moviendose a la Derecha   
            contador = 2;
            valpunto=false;
            int fila;
            int columna;
            int auxfila=0;
            int auxcolum=0;
            while (contador <= maxlado-val.getPoint().getColumna()) {
                try{
                fila=val.getPoint().getFila();
                columna=val.getPoint().getColumna();
                Cuadrado cua=new Cuadrado();
               
                //NE              
                for(int j=1;j<contador;j++){                   
                    if(!matrix.getArreglo()[fila-j][columna+j].getValor().equals("1")){                       
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila-j][columna+j].getPoint());
                        valpunto=true;
                        auxfila=fila-j;
                        auxcolum=columna+j;
                    }
                }
                if(valpunto){
                    //SE
                    fila=auxfila;
                    columna=auxcolum;
                for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila+j][columna+j].getValor().equals("1")){                   
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila+j][columna+j].getPoint());
                        valpunto=true;
                        auxfila=fila+j;
                        auxcolum=columna+j;
                    }
                }   
                }else{
                    break;
                }
               
                if(valpunto){
                    //SO
                    fila=auxfila;
                    columna=auxcolum;
                for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila+j][columna-j].getValor().equals("1")){
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila+j][columna-j].getPoint());
                        valpunto=true;
                        auxfila=fila+j;
                        auxcolum=columna-j;
                    }
                }   
                }else{
                    break;
                }
               
                if(valpunto){
                    //NO
                    fila=auxfila;
                    columna=auxcolum;
                for(int j=1;j<contador;j++){
                    if(!matrix.getArreglo()[fila-j][columna-j].getValor().equals("1")){
                        valpunto=false;
                        break;
                    }else{
                        cua.getPuntos().add(matrix.getArreglo()[fila-j][columna-j].getPoint());
                        valpunto=true;
                        auxfila=fila-j;
                        auxcolum=columna-j;
                    }
                }   
                }else{
                    break;
                }
                if(valpunto){
                 cua.setAngulo(45);
                cuadrados.add(cua);  
                }               
                contador=contador+1;
                }catch(Exception ex){
                contador=contador+1;
                }
            }
        }
        return cuadrados;
    }
   
    public static void imprimirCuadrados(ArrayList<Cuadrado> param){
        Iterator i=param.iterator();
        Iterator j;
        System.out.println("Imprimiendo Cuadrados");
        Cuadrado c;
        Punto p;
        int contador=1;
        while(i.hasNext()){
            c=(Cuadrado)i.next();
            System.out.println("Cuadrado N° "+contador);
            System.out.println("Angulo "+c.getAngulo());
            j=c.getPuntos().iterator();
            System.out.println("Puntos que forman el cuadrado ");
            while(j.hasNext()){               
                p=(Punto)j.next();
                System.out.println("Punto("+p.getColumna()+","+p.getFila()+")");
            }
            contador=contador+1;
        }
    }
   
}
***********************************************************************************
Clase principal del proyecto main:

package com.square.main;

import com.square.Logic.AlgoBusca;
import com.square.bean.Matriz;
import com.square.dao.DaoMatriz;
import java.util.Random;
import java.util.Scanner;

/**
 *
 * @author Administrador
 */
public class main {   
    public static void main(String arg[]){       
        System.out.println("Bienvenido al Sistema de reconocimiento de cuadrados");
        System.out.println("Crear Matriz:");
        Scanner teclado=new Scanner(System.in);
        System.out.print("Ingrese Numero de Filas:");
        int filas=teclado.nextInt();
        System.out.print("Ingrese Numero de Columnas:");
        int columnas=teclado.nextInt();
        Matriz m=DaoMatriz.generarMatriz(filas,columnas);
        DaoMatriz.paintMatriz(m);
        System.out.println("");
        System.out.println("Matriz de Unos");
        DaoMatriz.paintMatrizUnos(m);   
        System.out.println("Busqueda");
        System.out.println("CUADRADOS ANGULO 0:");
        AlgoBusca.imprimirCuadrados(AlgoBusca.buscarCuadradosAngulo0(m, DaoMatriz.paintMatrizUnos(m)));
        System.out.println("===============================================================");
        System.out.println("CUADRADOS ANGULO 45:");
        AlgoBusca.imprimirCuadrados(AlgoBusca.buscarCuadradosAngulo45(m, DaoMatriz.paintMatrizUnos(m)));
        System.out.println("===============================================================");
    }
}


Espero les haya gustado y servido. XD


Entradas más populares de este blog

Conexion JDBC - JAVA a travès de un archivo Properties

Para conectar a bases de datos con el archivo properties necesitas definir la siguiente estructura:

Rutas de los Archivos Properties, es esas rutas tienes que haber creado tus archivos properties:

package com.develtrex.util;
import java.net.URL;
/**
 *
 * @author 007M
 */
public class Ruta {
    private final String dbOracle="/com/develtrex/propiedad/dboracle.properties";
    private final String dbMysql="/com/develtrex/propiedad/dbmysql.properties";
    private final String dbPostgres="/com/develtrex/propiedad/dbpostgres.properties";
    private final String dbSqlServer="/com/develtrex/propiedad/dbsqlserver.properties";

    public URL getFileDbOracle(){
        return getClass().getResource(dbOracle);
    }

    public URL getFileDbMysql(){
        return getClass().getResource(dbMysql);
    }

    public URL getFileDbPostgres(){
        return getClass().getResource(dbPostgres);
    }

    public URL getFileDbSqlServer(){
        return getClass…

Registrar driver oracle en iReport 3.7.1

Esta entrada la estoy escribiendo porque en algún momento necesite conectar ireport con mi base de oracle, para asi poder crear reportes, además aquí tambien se registran los archivos Jar para ordenar las columnas de un crosstab, pero esto lo explicare en otra entrada.
Bueno comenzemos, primero que nada abra su ireport la versión que tuviese. Luego de esto solo seguir todos los pantallazos que colocaré.
fig 1: Drivers para conexión a bases de datos.
En la fig1 se muestran todos lo drivers con los cuales se establece la conexión a base de datos a través de ireport, como se puede observar hay drivers de color rojo y negro, los negros están activos y los rojos son los drivers que aún no han sido registrados, en esta ocasión vamos a registrar el driver para conectarnos a una base de datos oracle.
Registrando el driver de oracle:
fig 2: Pestaña herramientas, subitem opciones
Una vez que hacemos click en el item Opciones nos saldra una ventana como la imagen de la fig 3.
fig 3: Ventana …

Instalando Open Broadcaster Software en CentOS 7

Saludos. Soy @jofrantoba. En este post te enseñare a instalar el OBS Studio el cual te permitira hacer grabaciones de audio y video, asi como también realizar Streaming a través de facebook, youtube y otros.

Paso 1: Instalar repositorio EPEL
En este enlace podrás encontrar el post de como hacerlo http://kiongotechnology.com/i-d/vblogdev/4-instalar-repo-epel-release-en-centos-7
Paso 2: Instalar repositorio RPM Fusion
En este enlace podrás encontrar el post de como hacerlo http://kiongotechnology.com/i-d/vblogdev/5-instalar-repo-rpmfusion-en-centos-7
Paso 3: Instalar repositorio Nux Desktop x86_64
En este enlace podrás encontrar el post de como hacerlo http://kiongotechnology.com/i-d/vblogdev/8-instalando-nux-desktop-x86-64-en-centos7
Paso 4: Instalar las siguientes librerias con el siguiente comando ejecutado en tu terminal
sudo yum install gcc gcc-c++ gcc-objc cmake git

Paso 5: Instalar las siguiente dependencias de OBS Studio ejecutando el siguiente comando en tu terminal

sudo yum install lib…