INTRODUCCIÓN
Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas. Algunos de ellos podemos solucionarlos fácilmente, mientras que otros se complican de tal forma que nos afectan de una manera muy profunda.
Algunos problemas, por su naturaleza, pueden ser resueltos utilizando una computadora. Estos problemas generalmente son de tipo estructurado, es decir, tienen una solución determinada y pueden ser desde muy sencillos hasta muy complejos.
Para resolver problemas estructurados utilizando la computadora es importante utilizar un método. Este método debe ser fácil de comprender y nos debe guiar paso a paso hasta la solución del problema.
El método propuesto y utilizado en el presente texto es el Método de las 6’D, que está compuesto de seis etapas, cada una de las cuales consta de una serie de pasos, los cuales se van modificando (ajustando) dependiendo del grado de complejidad del problema y las herramientas que se utilicen para su solución.
Con la finalidad de recordar el método, se ha definido que el nombre de cada una de las etapas del método comience con la misma letra, la letra “D”. Es decir, el método tiene seis etapas y el nombre de cada una de las etapas comienza con la letra “D”, de modo que este se pueda recordar como el Método de las 6’D.
MÉTODO DE LAS 6’D
En la siguiente figura se muestra el Método de las 6’D con sus respectivas etapas:
ETAPAS Y PASOS
El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para solucionar el problema.
El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican cómo se debe hacer para solucionar el problema.
El resultado obtenido en esta etapa son los programas y/o clases, codificados en un lenguaje de programación, que permiten solucionar el problema.
El resultado obtenido en esta etapa son las pruebas que registran el adecuado funcionamiento de la solución del problema.
El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de la solución desarrollada.
RESUMEN DEL MÉTODO
2 comentarios:
Hola, queria ver si me podria ayudar en la solucion de un programa con la estructura de datos:
Planteamiento:
En un restaurante se desea tener un registro del momento en el que cada mesero inicia su jornada laboral, de manera que una vez que realice su registro se contabilicen 8 horas a partir de ese momento y pueda entonces registrar su salida al finalizar su jornada. Así mismo se desea ver quien llego más tarde en dicho registro.
1. Registre en orden de entrada el nombre de 5 meseros y los muestre con la directriz FIFO. El tipo de dato será cadena (String)
2. De manera paralela, se guarde y muestre en un arreglo el índice del nodo del registro del nombre junto a la hora de entrada del mismo. Utiliza el tipo de dato que más convenga para esta estructura.
3. Se muestre la hora en la que cada mesero podrá registrar su salida. Sumar 8 horas a la hora de entrada.
4. Se muestre mediante una pila el orden de los nombres de los meseros, de manera que se vea quién llego más tarde (directriz LIFO).
5. Genera un método recursivo que funcione para vaciar los datos expuestos de los meseros al final de toda la información mostrada.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Restaurante
{
class Program
{
static void Main(string[] args)
{
// 1. Registre en orden de entrada el nombre de 5 meseros y los muestre con la directriz FIFO. El tipo de dato será cadena (String)
Queue colaMeseros = new Queue();
colaMeseros.Enqueue("Juan");
colaMeseros.Enqueue("Pedro");
colaMeseros.Enqueue("María");
colaMeseros.Enqueue("José");
colaMeseros.Enqueue("Luis");
Console.WriteLine("Lista de meseros registrados en orden FIFO:");
foreach (string mesero in colaMeseros)
{
Console.WriteLine(mesero);
}
// 2. De manera paralela, se guarde y muestre en un arreglo el índice del nodo del registro del nombre junto a la hora de entrada del mismo. Utiliza el tipo de dato que más convenga para esta estructura.
List arregloHoras = new List();
var horaActual = DateTime.Now;
for (int i = 0; i < 5; i++)
{
// Obtenemos el índice del nodo del registro del nombre
int indiceNodo = colaMeseros.Count - i - 1;
// Guardamos la hora de entrada
arregloHoras.Add(new int[] { indiceNodo, horaActual.Hour });
}
Console.WriteLine("Horas de entrada de los meseros registradas en el arreglo:");
foreach (int[] hora in arregloHoras)
{
Console.WriteLine($"Mesero {colaMeseros[hora[0]]}: {hora[1]}");
}
// 3. Se muestre la hora en la que cada mesero podrá registrar su salida. Sumar 8 horas a la hora de entrada.
Console.WriteLine("Hora de salida de los meseros:");
foreach (int[] hora in arregloHoras)
{
// Sumamos 8 horas a la hora de entrada
int horaSalida = hora[1] + 8;
Console.WriteLine($"Mesero {colaMeseros[hora[0]]}: {horaSalida}");
}
// 4. Se muestre mediante una pila el orden de los nombres de los meseros, de manera que se vea quién llego más tarde (directriz LIFO).
Stack pilaMeseros = new Stack();
pilaMeseros.Push("Juan");
pilaMeseros.Push("Pedro");
pilaMeseros.Push("María");
pilaMeseros.Push("José");
pilaMeseros.Push("Luis");
Console.WriteLine("Lista de meseros registrados en orden LIFO:");
while (!pilaMeseros.IsEmpty)
{
Console.WriteLine(pilaMeseros.Pop());
}
// 5. Genera un método recursivo que funcione para vaciar los datos expuestos de los meseros al final de toda la información mostrada.
// Vaciar la cola de meseros
VaciarCola(colaMeseros);
// Vaciar el arreglo de horas
VaciarArreglo(arregloHoras);
// Vaciar la pila de meseros
VaciarPila(pilaMeseros);
Console.WriteLine("Datos de los meseros vaciados.");
}
private static void VaciarCola(Queue cola)
{
while (!cola.IsEmpty)
{
cola.Dequeue();
}
}
private static void VaciarArreglo(List arreglo)
{
arreglo.Clear();
}
private static void VaciarPila(Stack pila)
{
while (!pila.IsEmpty)
{
pila.Pop();
}
}
}
}
Es lo que quieres?
Publicar un comentario