Matriz de la relación predecesor inmediato en c++. – Email – Lawyers – Law Firm – Registros

Cuando aprendemos sobre reticulados nos enseñan un algoritmo para conseguir lamatriz de la relación de predecesores inmediatos de un CPO (Conjunto Parcialmente Ordenado) a partir de la matriz de la relación de orden [A,] donde A tiene n elementos.

El algoritmo sería el siguiente:

-Se calcula la matriz de la relación de orden M.

-Determinamos la matriz M = M- In . M es igual a la matriz de relación de orden menos la matriz identidad.

-Calculamos M^2 (M al cuadrado = MxM) haciendo una multiplicación binaria. Es decir, la matriz resultante solo contendrá unos y ceros como entradas.

-Hallamos M = M - M^2 (matriz de la relación predecesor inmediato). La matriz de la relación predecesor inmediato es igual a la matriz M menos la matriz M^2.

Ejercicio de ejemplo:

Dado el CPO [A, /] en dondeA = {200,60,30,10,5,1} y"/" es la relación binaria dedivisibilidad enA, (a/b si y sólo si "a" divide a "b") entonces: Hallar lamatriz de predecesores inmediatos.

Siguiendo el algoritmo calculamos la matriz M:

M=

1 divide a todo número real, por ello todas las entradas de esta fila de la matriz son 1.
5 divide a 5, 10, 30,60,200.
10 divide a 10,30,60,200.
30 divide a 30 y 60.
60 divide a 60.
200 divide a 200.

Siguiente paso, calculamos la matriz M que esta dada por M = M- In.

M=

In =

M = M- In

M =

Luego, calculamos M^2:

M^2 = M x M

X

M^2 =

Finalmente, hallamos la matriz de la relación predecesor inmediato.

M = M - M^2

M =

C++

Una buena opción es desarrollar este algoritmo en algún lenguaje de programación que conozcamos, con el fin de aprender un poco más y a su vez comprobar los ejercicios que realizamos en nuestras horas de estudio. Este algoritmo lo podemos desarrollar enc++ de la siguiente forma:

#include iostream

using namespace std;

int main(){
 int filas, colum;
 cout  "Ingrese la cantidad de filas de la matriz de la relación de orden: "  endl;
 cin  filas;
 cout  "Ingrese la cantidad de columnas de la matriz de la relación de orden: "  endl;
 cin  colum;
 int matrizRO[filas][colum]; //matriz de relación de orden
 int matrizRO2[filas][colum];
 int matrizm2[filas][colum];
 int matrizPI[filas][colum];
 // Ingresamos las entradas de la matriz de relación de orden
 cout  "Ingrese las entradas de la matriz de la relación de orden"  endl;
 for(int i = 0; i  filas; i++){
  for(int j = 0; j  colum; j++){
  cout  "Ingrese la entrada a"  i  j  endl;
  cin  matrizRO[i][j];
  }
 }
 // Restamos la matriz identidad a nuestra matriz
 for(int diagonal = 0; diagonal  colum; diagonal++)
 {
  matrizRO[diagonal][diagonal] = 0;
 }

 //Imprimimos el valor de M

 cout  "Matriz M: "  endl;
   for(int i = 0; i  filas; i++){
     for(int j = 0; j  colum; j++){
      cout  matrizRO[i][j]  " ";
     }
     cout  endl;
    }

 //segunda matriz

 for(int i = 0; i  filas; i++){
   for(int j = 0; j  colum; j++){
   matrizRO2[i][j] = matrizRO[i][j];
   }
  }

 //

 //Calculamos M^2 (Binarizada)
 for(int i=0;ifilas;i++){
        for(int j=0;jcolum;j++){
            matrizm2[i][j]=0;
          for(int k=0;kcolum;k++){
           if(matrizRO[i][k] == 1 and matrizRO2[k][j] == 1)
            matrizm2[i][j] = 1;
          }
        }
 }
 // Imprimimos M^2
 cout  "Matriz M^2: "  endl;
  for(int i = 0; i  filas; i++){
    for(int j = 0; j  colum; j++){
     cout  matrizm2[i][j]  " ";
    }
    cout  endl;
  }

 //Calculamos la matriz de la relación predecesor inmediato

  for(int i = 0; i  filas; i++){
    for(int j = 0; j  colum; j++){
     matrizPI[i][j] = matrizRO[i][j] - matrizm2[i][j];
    }
  }

 //Imprimimos la matriz de la relación predecesor inmediato

  cout  "Matriz de la relación predecesor inmediato: "  endl;
    for(int i = 0; i  filas; i++){
      for(int j = 0; j  colum; j++){
       cout  matrizPI[i][j]  " ";
      }
      cout  endl;
    }

 return 0;
}

int matrizRO[filas][colum]; //matriz de relación de orden
int matrizRO2[filas][colum];
int matrizm2[filas][colum];
int matrizPI[filas][colum];

La matrizRO representa la matriz de relación de orden, la matrizRO2 contiene las mismas entradas que la anterior, esta se usará solo para realizar la multiplicación para obtener M^2.

La matrizm2 representa la matriz M^2.

La matrizPI representa la matriz de la relación de predecesores inmediatos.

int filas, colum;
cout "Ingrese la cantidad de filas de la matriz de la relación de orden: " endl;
cin filas;
cout "Ingrese la cantidad de columnas de la matriz de la relación de orden: " endl;
cin colum;

Inicialmente ingresamos la cantidad de filas y columnas que tiene nuestra matriz. Dicha matriz es una matriz cuadrada de orden nxn.

// Restamos la matriz identidad a nuestra matriz
for(int diagonal = 0; diagonal colum; diagonal++)
{
matrizRO[diagonal][diagonal] = 0;
}

Para encontrar el valor de M solo debemos anular la diagonal principal de nuestra matriz.

//Calculamos M^2 (Binarizada)
for(int i=0;ifilas;i++){
for(int j=0;jcolum;j++){
matrizm2[i][j]=0;
for(int k=0;kcolum;k++){
if(matrizRO[i][k] == 1 and matrizRO2[k][j] == 1)
matrizm2[i][j] = 1;
}
}
}

Calculamos M^2 con el anterior algoritmo, tomar en cuenta que como es una matriz binarizada solo tendrá ceros y unos. Al conseguir una coincidencia de dos 1 almacenamos 1 en la matriz M^2.

//Calculamos la matriz de la relación predecesor inmediato

for(int i = 0; i filas; i++){
for(int j = 0; j colum; j++){
matrizPI[i][j] = matrizRO[i][j] - matrizm2[i][j];
}
}

Calculamos la matriz de la relación de predecesor inmediato con la diferencia entre la matriz M y M^2.

Resolviendo el ejercicio anterior con nuestro programa de consola hecho en c++, ésta sería su ejecución:

Ingrese la cantidad de filas de la matriz de la relación de orden:
6
Ingrese la cantidad de columnas de la matriz de la relación de orden:
6
Ingrese las entradas de la matriz de la relación de orden
Ingrese la entrada a00
1
Ingrese la entrada a01
1
Ingrese la entrada a02
1
Ingrese la entrada a03
1
Ingrese la entrada a04
1
Ingrese la entrada a05
1
Ingrese la entrada a10
0
Ingrese la entrada a11
1
Ingrese la entrada a12
1
Ingrese la entrada a13
1
Ingrese la entrada a14
1
Ingrese la entrada a15
1
Ingrese la entrada a20
0
Ingrese la entrada a21
0
Ingrese la entrada a22
1
Ingrese la entrada a23
1
Ingrese la entrada a24
1
Ingrese la entrada a25
1
Ingrese la entrada a30
0
Ingrese la entrada a31
0
Ingrese la entrada a32
0
Ingrese la entrada a33
1
Ingrese la entrada a34
1
Ingrese la entrada a35
0
Ingrese la entrada a40
0
Ingrese la entrada a41
0
Ingrese la entrada a42
0
Ingrese la entrada a43
0
Ingrese la entrada a44
1
Ingrese la entrada a45
0
Ingrese la entrada a50
0
Ingrese la entrada a51
0
Ingrese la entrada a52
0
Ingrese la entrada a53
0
Ingrese la entrada a54
0
Ingrese la entrada a55
1
Matriz M:
0 1 1 1 1 1
0 0 1 1 1 1
0 0 0 1 1 1
0 0 0 0 1 0
0 0 0 0 0 0
0 0 0 0 0 0
Matriz M^2:
0 0 1 1 1 1
0 0 0 1 1 1
0 0 0 0 1 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
Matriz de la relación predecesor inmediato:
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 1
0 0 0 0 1 0
0 0 0 0 0 0
0 0 0 0 0 0

Optimizando el algoritmo en c++:

El código fuente del algoritmo hecho en c++ está escrito con el mayor detalle posible con el fin de que pueda ser entendido fácilmente. Sin embargo, este puede ser optimizado evitando la creación de algunas matrices no tan necesarias y algunos ciclos repetitivos for. Esto con el fin de minimizar el tiempo de ejecución y reducir el espacio utilizado en la memoria.

#include iostream

using namespace std;

int main(){
 int n;
 char respuesta;
 do{
 cout  "Ingrese el valor de n para su matriz de orden nxn "  endl;
 cin  n;
 int matrizR[n][n]; //matriz de relación de orden y luego de la relación predecesor inmediato.
 int matrizm2[n][n];
 // Ingresamos las entradas de la matriz de relación de orden
 cout  "Ingrese las entradas de la matriz de la relación de orden"  endl;
 for(int i = 0; i  n; i++){
  for(int j = 0; j  n; j++){
  cout  "Ingrese la entrada a"  i  j  endl;
  cin  matrizR[i][j];
  //Anulando diagonal principal al momento de ingresar la matriz
  if(i == j)
   matrizR[i][j] = 0;
  }
 }

 //Calculamos M^2 (Binarizada)
 for(int i=0;in;i++){
        for(int j=0;jn;j++){
            matrizm2[i][j]=0;
          for(int k=0;kn;k++){
           if(matrizR[i][k] == 1 and matrizR[k][j] == 1){
            matrizm2[i][j] = 1;

            break;

            }
          }
        }
 }

 //Calculamos la matriz de la relación predecesor inmediato y la imprimimos al mismo tiempo
  cout  "Matriz de la relación predecesor inmediato:"  endl;
  for(int i = 0; i  n; i++){
    for(int j = 0; j  n; j++){
     matrizR[i][j] = matrizR[i][j] - matrizm2[i][j];
     cout  matrizR[i][j]  " ";
    }
    cout  endl;
  }
  cout  "Desea obtener una nueva matriz de la relación predecesor inmediato a partir de otra matriz de relación de orden? si = s no = n"  endl;
  cin  respuesta;
 }while(respuesta == 's');
 return 0;
}

Inicialmente ingresamos el valor de n, la matriz de la relación de orden es una matriz cuadrada de orden nxn.

Mientras ingresamos las entradas o componentes de la matriz podemos ir anulando automática la diagonal principal, esto lo hacemos cuando los índices i y j son iguales.

if(i == j)
matrizR[i][j] = 0;

Para obtener la matriz M^2 solo necesitaremos conseguir un 1, recordemos que esta matriz debe estar binarizada. Por ello le agregamos el break al ciclo de manera que cuando encuentre un 1 salga del ciclo y no ejecute instrucciones innecesarias.

if(matrizR[i][k] == 1 and matrizR[k][j] == 1){

matrizm2[i][j] = 1;

break;

}

Al momento de obtener la matriz de la relación predecesor inmediato podemos guardar el resultado en la misma matriz inicial, además podemos ir imprimiendo los resultados en paralelo se van obteniendo.

for(int i = 0; i n; i++){
for(int j = 0; j n; j++){
matrizR[i][j] = matrizR[i][j] - matrizm2[i][j];
cout matrizR[i][j] " ";
}
cout endl;
}

Descarga del código fuente del proyecto:
http://www.mediafire.com/download/urr...


También te podría interesar:
4 Ejercicios Básicos de Programación Orientada a Objetos en c++
De sistema decimal a sistema binario en c++ y Java
3 libros sobre programacion orientada a objetos
[Ejercicio resuelto c++ POO Herencia Vectores MVC] Una Asociación de Lancheros trasladan turistas

Matriz de accesibilidad de un Digrafo en c++ – Virginia – Platform – cancer

ParaDigrafos existe un procedimiento para encontrar lamatriz de accesibilidad, podemos determinar la matriz de accesibilidad a través de una serie de pasos. La matriz de accesibilidad nos brinda información sobre si el digrafo es F.C (fuertemente conexo) o no, es decir si para cada par de vértices u,v:u es accesible desdev yv es accesible desdeu.

Al observar la matriz sí notamos que hay al menos un elemento igual a cero diremos que el digrafo no es F.C conexo. De lo contrario, si es F.C.

La matriz de accesibilidad de un Digrafo es:

Acc(D) = bin[In+ M+ M^2+ M^3+ ...+ M^n-1]

M es la matriz de conexión del digrafo, determinaremos M^2, M^3 hasta M^n-1donde n es el número de vértices del digrafo.

Luego de determinar las matrices antes mencionadas las sumaremos junto a la matriz identidad y ese resultado procederemos a binarizarlo (Los elementos mayores que 1 los haremos igual a 1, los elementos que sean igual a 0 seguirán siendo igual a 0).

Ejercicio de ejemplo:

Dada la matriz de conexión del siguiente digrafo, determinar su matriz de accesibilidad.

M=

M^2 = MxM

M^3 = M^2 * M

M^4 = M^3 * M

I5 =

Acc(D) = bin[In+ M+ M^2+ M^3+ ...+ M^n-1]

Acc(D) =

De esta manera podemos obtener la matriz de accesibilidad del digrafo. Este digrafo no es fuertemente conexo, debido a que su matriz de accesibilidad posee componentes nulas.

EnC++ Estos pasos para determinar sí el digrafo es F.C o no, los podemos realizar de la siguiente manera:

#include iostream

using namespace std;

int main(){
 int vertices;
 cout  "Ingrese la cantidad de vertices del digrafo:"  endl;
 cin  vertices;
 int matrizC[vertices][vertices];
 int matrizaux[vertices][vertices];
 int matrizM[vertices][vertices];
 int matrizAcc[vertices][vertices];
 //Cargamos la matriz de conexion
 cout  "Ingrese los elementos de la matriz de conexion: "  endl;
 for(int i = 0; i  vertices; i++){
  for(int j = 0; j  vertices; j++){
  cout  "Ingrese la entrada a"  i  j  endl;
  cin  matrizC[i][j];
  }
 }

   for(int i = 0; i  vertices; i++){
    for(int j = 0; j  vertices; j++){
     matrizaux[i][j] = matrizC[i][j];
     matrizAcc[i][j] = matrizC[i][j];
    }
   }
  //ciclo
  int cont = vertices-2;
  while(cont){
  // Producto para M...
   for(int i=0;ivertices;i++){
         for(int j=0;jvertices;j++){
             matrizM[i][j]=0;
           for(int k=0;kvertices;k++){
             matrizM[i][j]=matrizM[i][j]+(matrizC[i][k]*matrizaux[k][j]);
           }
     }
      }
  //Sumamos para la matriz de accesibilidad
   for(int i = 0; i  vertices; i++){
     for(int j = 0; j  vertices; j++){
     matrizAcc[i][j] += matrizM[i][j];
     matrizaux[i][j] =  matrizM[i][j];
     }
    }
   cont--;
  }//Fin del ciclo

  //Sumar matriz de indentidad y binarizar
  for(int i = 0; i  vertices; i++){
    for(int j = 0; j  vertices; j++){
    if(i == j)
     matrizAcc[i][j] = 1;
    if(matrizAcc[i][j]  1)
     matrizAcc[i][j] = 1;
    }
   }

  //Imprimimos la matriz de accesibilidad
  cout  "Matriz de accesibilidad:"  endl;
    for(int i = 0; i  vertices; i++){
      for(int j = 0; j  vertices; j++){
       cout  matrizAcc[i][j]  " ";
      }
      cout  endl;
    }


 return 0;
}

Inicialmente ingresamos el numero de vértices del digrafo, las matrices con las que vamos a trabajar son de orden nxn donde n es el numero de vértices del digrafo.

El ciclo while se repetirá mientras la variable cont sea distinta de 0 (n - 2 veces debido a que M^2 se calcula fuera del ciclo while), esta variable irá decreciendo de uno en uno en cada repetición del ciclo.

Mientras vamos realizando la multiplicación de las matrices vamos sumando los resultados en la matriz de accesibilidad.

Al final, luego de salir del ciclo sumamos la matriz identidad y binarizamos la matriz de accesibilidad.

Ejecución:

Ingrese la cantidad de vertices del digrafo:
5
Ingrese los elementos de la matriz de conexion:
Ingrese la entrada a00
0
Ingrese la entrada a01
1
Ingrese la entrada a02
0
Ingrese la entrada a03
0
Ingrese la entrada a04
0
Ingrese la entrada a10
1
Ingrese la entrada a11
0
Ingrese la entrada a12
1
Ingrese la entrada a13
0
Ingrese la entrada a14
1
Ingrese la entrada a20
0
Ingrese la entrada a21
0
Ingrese la entrada a22
0
Ingrese la entrada a23
0
Ingrese la entrada a24
0
Ingrese la entrada a30
0
Ingrese la entrada a31
1
Ingrese la entrada a32
0
Ingrese la entrada a33
0
Ingrese la entrada a34
0
Ingrese la entrada a40
0
Ingrese la entrada a41
1
Ingrese la entrada a42
1
Ingrese la entrada a43
1
Ingrese la entrada a44
0
Matriz de accesibilidad:
1 1 1 1 1
1 1 1 1 1
0 0 1 0 0
1 1 1 1 1
1 1 1 1 1

Descarga del proyecto en C++:
https://mega.co.nz/#!ZBETVRqK!eVh_8o...


También te podría interesar:
Algoritmo para calcular la matriz de la relación predecesor inmediato a partir de la matriz de la relación de orden en c++.
4 Ejercicios Básicos de Programación Orientada a Objetos en c++
eBook - Como programar en c++ Deitel
De sistema decimal a sistema binario en c++ y Java
3 libros sobre programacion orientada a objetos

[Ejercicio resuelto Progranimate] Promedio de notas de una sección – Law Firm – Miami – Virtual

Planteamiento:
"Se conoce la cantidad de estudiantes de una sección y la nota de cada uno de ellos. Determinar el promedio de la sección."

Código fuente JavaScript:

script type="text/javascript"
   //Program:Untitled
   
            var cantidad = 0;
            var i = 0;
            var j = 0;
            var nota = 0;
            var AcumuladorNotas = 0;
            var promedio = 0;

            alert("Ingrese la cantidad de estudiantes de la sección");
            cantidad = pronpt("","");

            for ( i = 0 ; i  cantidad ; i = i + 1 )
            {
               j = i + 1;
               alert("Ingrese la nota numero " + j);
               nota = pronpt("","");
               AcumuladorNotas = AcumuladorNotas + nota ;
            }//End  For

            promedio = AcumuladorNotas / cantidad ;
            alert("El promedio de la sección es de: " + promedio);

   //End of Program
/script

Diagrama de flujo:

Ejecución:

Ingrese la cantidad de estudiantes de la sección
5
Ingrese la nota numero 1
20
Ingrese la nota numero 2
11
Ingrese la nota numero 3
14
Ingrese la nota numero 4
17
Ingrese la nota numero 5
16
El promedio de la sección es de: 15.6

[Ejercicio resuelto Progranimate] Determine sí la edad de una persona es mayor o igual a 18 – Forex – Promotional Code – Auto – Forex

Planteamiento:
"Se conoce la edad de una persona. Sí la edad es mayor o igual a 18 imprimir: "Mayor de edad", en caso contrario, imprimir: "Menor de edad"

Código fuente JavaScript:

script type="text/javascript"
   //Program:Untitled
   
            var edad = 0;

            alert("Ingrese la edad de la persona");
            edad = pronpt("","");

            if (edad = 18 )
            {
               alert("Mayor de edad");
            }//End  If
            else 
            {
               alert("Menor de edad");
            }//End  Else


   //End of Program
/script

Diagrama de flujo:

Ejecución:

Siendo la edad ingresada mayor o igual a 18:

Ingrese la edad de la persona
24
Mayor de edad

Siendo la edad ingresada menor a 18:

Ingrese la edad de la persona
15
Menor de edad

[Ejercicio resuelto Progranimate] Determinar Sueldo de un Empleado – Record – cancer – Motor

Planteamiento:

"Se tiene un empleado del que se conoce su nombre, cédula y cantidad de horas trabajadas. Determinar su sueldo sabiendo que cada hora trabajada tiene un valor de 14. Además imprimir su nombre, cédula y sueldo"

Código fuente JavaScript:

script type="text/javascript"
   //Program:Untitled
   
            var nombre;
            var cedula;
            var horas = 0;
            var sueldo = 0;

            alert("Ingrese el nombre del empleado");
            nombre = pronpt("","");
            alert("Ingrese la cedula del empleado");
            cedula = pronpt("","");
            alert("Ingrese la Cantidad de horar trabajadas");
            horas = pronpt("","");
            sueldo = horas * 14 ;
            alert("Nombre: " + nombre);
            alert("Cedula: " + cedula);
            alert("Sueldo: " + sueldo);

   //End of Program
/script

Diagrama de flujo:

Ejecución:
Ingrese el nombre del empleado
"Francves"
Ingrese la cedula del empleado
99.999.999
Ingrese la Cantidad de horar trabajadas
40
Nombre: "Francves"
Cedula: 99.999.999
Sueldo: 560

[Ejercicio resuelto Progranimate] Puntaje respuestas correctas e incorrectas – Accident – Credit – dinero

Planteamiento:
"Elaborar un algoritmo que solicite la cantidad de respuestas correctas, incorrectas y en blanco, correspondiente a postulantes, y muestre su puntaje final considerando, que por cada respuesta correcta tendrá 4 puntos, respuestas incorrectas tendrá -1 y respuestas en blanco tendrá 0."

Código fuente JavaScript:

script type="text/javascript"
   //Program:Untitled
   
            var cantRC = 0;
            var cantRB = 0;
            var cantRI = 0;
            var puntaje = 0;

            alert("Ingrese la cantidad de respuestas correctas: ");
            cantRC = pronpt("","");
            alert("Ingrese la cantidad de respuestas en blanco: ");
            cantRB = pronpt("","");
            alert("Ingrese la cantidad de respuestas incorrectas: ");
            cantRI = pronpt("","");
            puntaje = cantRC * 4 + cantRI * -1 ;
            alert("Puntaje final obtenido:" + puntaje);

   //End of Program
/script

Diagrama de flujo:

Ejecución:

Ingrese la cantidad de respuestas correctas:
3
Ingrese la cantidad de respuestas en blanco:
1
Ingrese la cantidad de respuestas incorrectas:
1
Puntaje final obtenido:11

[Ejercicio resuelto Progranimate] Promedio estudiante – Lawyers – php – World – dinero

Planteamiento:
"Se necesita obtener el promedio de un estudiante a partir de sus tres notas parciales."

Código fuente JavaScript:

script type="text/javascript"
   //Program:Untitled
   
            decimal nota1 = 0;
            decimal nota2 = 0;
            decimal nota3 = 0;
            decimal resultado = 0;

            alert("Ingrese las tres notas parciales del estudiante una por una");
            nota1 = pronpt("","");
            nota2 = pronpt("","");
            nota3 = pronpt("","");
            resultado = (nota1 + nota2 + nota3)/ 3 ;
            alert("El promedio del estudiante es: " + resultado);

   //End of Program
/script

Diagrama de flujo:

Curso online Pensamiento algorítmico en coursera gratis – programmers – Car

¿Qué es un algoritmo? ¿Cómo se hace un diagrama de flujo? ¿Qué es un pseudocódigo? ¿Cómo me pueden ayudar a resolver problemas cotidianos? Este curso básico de computación te ayudará a desarrollar el pensamiento algorítmico necesario para solucionar problemas en forma estructurada.

Acerca del curso

¿Has tenido que resolver un mismo problema varias veces?, por ejemplo, al salir de viaje o preparar una reunión con amigos. Y cada vez, ¿tuviste que volver a pensar en todo lo que hay que hacer, cuáles pasos y en qué orden?

Precisamente lo que busca este curso es proporcionarte las herramientas necesarias con las que identificarás, analizarás y plantearás soluciones efectivas para estas situaciones. Así, al encontrarte con el mismo problema, ya sabrás una manera de resolverlo.

En este curso introductorio a la computación, desarrollarás el razonamiento estructurado necesario para analizar problemas básicos y resolverlos utilizando la reflexión lógica y el pensamiento algorítmico. De igual manera, reconocerás los elementos que están a tu alcance y cómo los puedes utilizar efectivamente para lograr tus objetivos.

Al finalizar el curso, aprenderás a plasmar soluciones en términos computacionales a través de diagramas de flujo o pseudocódigo. Además, podrás trasladar estas soluciones a herramientas como hojas de cálculo que te serán útiles en tus actividades diarias, personales y profesionales.

Preguntas frecuentes

¿Recibiré una constancia al concluir el curso?

Sí. Todos los participantes que completen el curso satisfactoriamente recibirán una constancia.

¿Cuál será el mayor aprendizaje que me dejará esta materia?

Se ampliarán tus habilidades analíticas y de razonamiento para resolver problemas simples. También conocerás la simbología y correcta aplicación de los diagramas de flujo y te familiarizarás con el uso de una hoja de cálculo.

Enlace del curso:

https://www.coursera.org/course/pealgoritmico

Ordenar alfabéticamente vectores con Java – Free – programmers – Domains – Automovil

Para el ordenamiento de vectores existen varios algoritmos los cuales podemos usar, entre ellos el "Bubble Sort" oOrdenamiento de burbujadel cual hablaremos en ésta entrada.

wiki:

LaOrdenación de burbuja(Bubble Sorten inglés) es un sencilloalgoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Estealgoritmoobtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como elmétodo del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

Nos encontramos con el siguiente enunciado:

"Desarrolle un programa el cual cargue 5 marcas de automóviles y mediante el algoritmo deOrdenamiento de burbuja ordene e imprima de manera alfabética cada una de las marcas de automóviles."

Autos.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

import java.util.Scanner; public class Autos { private Scanner teclado; private String[] autos; public void leerDatos() { teclado=new Scanner(System.in); autos=new String[5]; for(int i=0;iautos.length;i++) { System.out.println("Ingrese la marca del auto:"); autos[i]=teclado.next(); } } public void ordenar() { for(int j=0;j4;j++) { for(int i=0;i4-j;i++) { if (autos[i].compareTo(autos[i+1])0) { String aux; aux=autos[i]; autos[i]=autos[i+1]; autos[i+1]=aux; } } } } public void imprimirInfo() { System.out.println("AUTOS:"); System.out.println("Modelo A - Z"); for(int i=0;iautos.length;i++) { System.out.println(autos[i]); } } public static void main(String[] ar) { Autos aut=new Autos(); aut.leerDatos(); aut.ordenar(); aut.imprimirInfo(); } }

Explicación:

Declaramos el vector autos "private String[] autos;" en el cual almacenaremos cada una de las marcas. 

Le damos tamaño a ese vector "autos=new String[5];".

Luego cargamos las 5 marcas de autos dado que ese es el tamaño de nuestro vector. Nótese que el ciclo for se repetirá tantas veces como el tamaño del vector  for(int i=0;iautos.length;i++) para ello usaremos la función ".length " la cual retorna el tamaño de nuestro vector. 

A su vez, después de cargar los datos (marcas de autos) se ejecutará el algoritmo de la burbuja ordenando alfabéticamente los datos ingresados, la comparación no la podemos realizar con operadores relacionales (,,=,=) Por ello utilizamos la función ".compareTo".

Finalmente se realiza la salida la cual sería: