logo

TechCodeview

¿Qué es el algoritmo? Introducción a los algoritmos

Definición de algoritmo

La palabra Algoritmo medio Un conjunto de reglas o instrucciones finitas que se deben seguir en cálculos u otras operaciones de resolución de problemas.
O
Un procedimiento para resolver un problema matemático en un número finito de pasos que frecuentemente involucra operaciones recursivas. .

Por tanto, un algoritmo se refiere a una secuencia de pasos finitos para resolver un problema particular.

¿Qué es el algoritmo?

Uso de los algoritmos:

Los algoritmos desempeñan un papel crucial en diversos campos y tienen muchas aplicaciones. Algunas de las áreas clave donde se utilizan algoritmos incluyen:



numeros bloqueados
  1. Ciencias de la Computación: Los algoritmos forman la base de la programación informática y se utilizan para resolver problemas que van desde una simple clasificación y búsqueda hasta tareas complejas como la inteligencia artificial y el aprendizaje automático.
  2. Matemáticas: Los algoritmos se utilizan para resolver problemas matemáticos, como encontrar la solución óptima a un sistema de ecuaciones lineales o encontrar el camino más corto en un gráfico.
  3. La investigación de operaciones : Los algoritmos se utilizan para optimizar y tomar decisiones en campos como el transporte, la logística y la asignación de recursos.
  4. Inteligencia artificial: Los algoritmos son la base de la inteligencia artificial y el aprendizaje automático, y se utilizan para desarrollar sistemas inteligentes que pueden realizar tareas como el reconocimiento de imágenes, el procesamiento del lenguaje natural y la toma de decisiones.
  5. Ciencia de los datos: Los algoritmos se utilizan para analizar, procesar y extraer información de grandes cantidades de datos en campos como el marketing, las finanzas y la atención sanitaria.

Estos son sólo algunos ejemplos de las múltiples aplicaciones de los algoritmos. El uso de algoritmos se expande continuamente a medida que surgen nuevas tecnologías y campos, lo que los convierte en un componente vital de la sociedad moderna.

Los algoritmos pueden ser simples y complejos dependiendo de lo que se quiera lograr.

Se puede entender tomando el ejemplo de cocinar una nueva receta. Para cocinar una nueva receta, uno lee las instrucciones y los pasos y los ejecuta uno por uno, en la secuencia dada. El resultado así obtenido es que el nuevo plato queda perfectamente cocinado. Cada vez que usa su teléfono, computadora, computadora portátil o calculadora, está usando algoritmos. De manera similar, los algoritmos ayudan a realizar una tarea en programación para obtener el resultado esperado.

El algoritmo diseñado es independiente del idioma, es decir, son simplemente instrucciones simples que se pueden implementar en cualquier idioma y, sin embargo, el resultado será el mismo, como se esperaba.

¿Cuál es la necesidad de algoritmos?

  1. Los algoritmos son necesarios para resolver problemas complejos de manera eficiente y efectiva.
  2. Ayudan a automatizar procesos y hacerlos más confiables, más rápidos y más fáciles de realizar.
  3. Los algoritmos también permiten a las computadoras realizar tareas que serían difíciles o imposibles de realizar manualmente para los humanos.
  4. Se utilizan en diversos campos como matemáticas, informática, ingeniería, finanzas y muchos otros para optimizar procesos, analizar datos, hacer predicciones y brindar soluciones a problemas.

¿Cuáles son las características de un algoritmo?

Características de un algoritmo

Ya que no se seguirían instrucciones escritas para cocinar la receta, sino sólo la estándar. De manera similar, no todas las instrucciones escritas para programación son un algoritmo. Para que algunas instrucciones sean un algoritmo, deben tener las siguientes características:

  • Claro e inequívoco : El algoritmo debe ser inequívoco. Cada uno de sus pasos debe ser claro en todos los aspectos y debe conducir a un solo significado.
  • Entradas bien definidas : Si un algoritmo dice que se deben tomar entradas, deben ser entradas bien definidas. Puede que reciba información o no.
  • Resultados bien definidos: El algoritmo debe definir claramente qué resultado se obtendrá y también debe estar bien definido. Debería producir al menos 1 salida.
  • Finitud: El algoritmo debe ser finito, es decir, debe terminar después de un tiempo finito.
  • Factible: El algoritmo debe ser simple, genérico y práctico, de modo que pueda ejecutarse con los recursos disponibles. No debe contener alguna tecnología futura ni nada por el estilo.
  • Independiente del idioma: El algoritmo diseñado debe ser independiente del idioma, es decir, deben ser simplemente instrucciones simples que puedan implementarse en cualquier idioma y, sin embargo, el resultado será el mismo, como se esperaba.
  • Aporte : Un algoritmo tiene cero o más entradas. Cada uno que contenga un operador fundamental debe aceptar cero o más entradas.
  • Producción : Un algoritmo produce al menos una salida. Cada instrucción que contiene un operador fundamental debe aceptar cero o más entradas.
  • Definitividad: Todas las instrucciones de un algoritmo deben ser inequívocas, precisas y fáciles de interpretar. Al consultar cualquiera de las instrucciones de un algoritmo, se puede comprender claramente lo que se debe hacer. Cada operador fundamental en la instrucción debe definirse sin ninguna ambigüedad.
  • Finitud: Un algoritmo debe terminar después de un número finito de pasos en todos los casos de prueba. Toda instrucción que contenga un operador fundamental debe terminarse en un período de tiempo finito. Los bucles infinitos o funciones recursivas sin condiciones básicas no poseen finitud.
  • Eficacia: Se debe desarrollar un algoritmo utilizando operaciones muy básicas, simples y factibles para que se pueda rastrear usando solo papel y lápiz.

Propiedades del algoritmo:

  • Debería terminar después de un tiempo finito.
  • Debería producir al menos una salida.
  • Debería requerir cero o más entradas.
  • Debería ser un medio determinista que proporcione el mismo resultado para el mismo caso de entrada.
  • Cada paso del algoritmo debe ser efectivo, es decir, cada paso debe funcionar.

Tipos de algoritmos:

Hay varios tipos de algoritmos disponibles. Algunos algoritmos importantes son:

1. Algoritmo de fuerza bruta :

Es la forma más sencilla de abordar un problema. Un algoritmo de fuerza bruta es el primer enfoque que se utiliza para encontrar cuando vemos un problema.

2. Algoritmo recursivo :

Un algoritmo recursivo se basa en recursividad . En este caso, un problema se divide en varias subpartes y se llama a la misma función una y otra vez.

3. Algoritmo de retroceso :

El algoritmo de retroceso construye la solución buscando entre todas las soluciones posibles. Utilizando este algoritmo, seguimos construyendo la solución siguiendo criterios. Cada vez que una solución falla, rastreamos el punto de falla en la siguiente solución y continuamos este proceso hasta que encontramos la solución o hasta que se solucionen todas las soluciones posibles.

4. Algoritmo de búsqueda :

Los algoritmos de búsqueda son los que se utilizan para buscar elementos o grupos de elementos de una estructura de datos particular. Pueden ser de diferentes tipos según su enfoque o la estructura de datos en la que se debe encontrar el elemento.

5. Algoritmo de clasificación :

Ordenar es organizar un grupo de datos de una manera particular según el requisito. Los algoritmos que ayudan a realizar esta función se denominan algoritmos de clasificación. Generalmente, los algoritmos de clasificación se utilizan para ordenar grupos de datos de manera creciente o decreciente.

6. Algoritmo de hash :

Los algoritmos hash funcionan de manera similar al algoritmo de búsqueda. Pero contienen un índice con una identificación de clave. En el hashing, se asigna una clave a datos específicos.

7. Algoritmo divide y vencerás :

Este algoritmo divide un problema en subproblemas, resuelve un único subproblema y combina las soluciones para obtener la solución final. Consta de los siguientes tres pasos:

  • Dividir
  • Resolver
  • Combinar

8. Algoritmo codicioso :

En este tipo de algoritmo la solución se construye parte por parte. La solución para la siguiente parte se construye en función del beneficio inmediato de la siguiente parte. La solución que proporcione el mayor beneficio se elegirá como solución para la siguiente parte.

9. Algoritmo de programación dinámica :

Este algoritmo utiliza el concepto de utilizar la solución ya encontrada para evitar cálculos repetitivos de la misma parte del problema. Divide el problema en subproblemas superpuestos más pequeños y los resuelve.

10. Algoritmo aleatorio :

En el algoritmo aleatorio, utilizamos un número aleatorio para que brinde un beneficio inmediato. El número aleatorio ayuda a decidir el resultado esperado.

Para obtener más información sobre los tipos de algoritmos, consulte el artículo sobre Tipos de algoritmos .

Ventajas de los algoritmos:

  • Es fácil de entender.
  • Un algoritmo es una representación paso a paso de una solución a un problema determinado.
  • En un algoritmo, el problema se divide en partes o pasos más pequeños, por lo que es más fácil para el programador convertirlo en un programa real.

Desventajas de los algoritmos:

  • Escribir un algoritmo lleva mucho tiempo, por lo que requiere mucho tiempo.
  • Comprender una lógica compleja a través de algoritmos puede resultar muy difícil.
  • Las declaraciones de bifurcación y bucle son difíciles de mostrar en algoritmos (diablillo) .

¿Cómo diseñar un algoritmo?

Para escribir un algoritmo, se necesitan los siguientes elementos como requisito previo:

  1. El problema eso debe resolverse mediante este algoritmo, es decir, una definición clara del problema.
  2. El restricciones del problema debe ser considerado mientras se resuelve el problema.
  3. El aporte a tomar para resolver el problema.
  4. El producción es de esperar cuando se resuelva el problema.
  5. El solución a este problema está dentro de las restricciones dadas.

Luego, el algoritmo se escribe con la ayuda de los parámetros anteriores de manera que resuelva el problema.

Ejemplo: Considere el ejemplo de sumar tres números e imprimir la suma.

Paso 1: Cumplir los requisitos previos

Como se mencionó anteriormente, para escribir un algoritmo, se deben cumplir sus requisitos previos.

  1. El problema que debe resolver este algoritmo. : Suma 3 números e imprime su suma.
  2. Las restricciones del problema que deben considerarse al resolverlo. : Los números deben contener sólo dígitos y ningún otro carácter.
  3. Los insumos que se deben tomar para resolver el problema: Los tres números que se van a sumar.
  4. El resultado que se espera cuando se resuelve el problema: La suma de los tres números tomados como entrada, es decir, un único valor entero.
  5. La solución a este problema, en las restricciones dadas: La solución consiste en sumar los 3 números. Se puede hacer con la ayuda del operador '+', bit a bit o cualquier otro método.


Paso 2: Diseñar el algoritmo

Ahora diseñemos el algoritmo con la ayuda de los requisitos previos anteriores:

Algoritmo para sumar 3 números e imprimir su suma:

  1. COMENZAR
  2. Declare 3 variables enteras num1, num2 y num3.
  3. Tome los tres números que se van a sumar como entradas en las variables num1, num2 y num3 respectivamente.
  4. Declare una suma variable entera para almacenar la suma resultante de los 3 números.
  5. Suma los 3 números y almacena el resultado en la suma variable.
  6. Imprimir el valor de la suma variable.
  7. FIN


Paso 3: probar el algoritmo implementándolo.

Para probar el algoritmo, implementémoslo en lenguaje C.

Programa:

C++ // C++ program to add three numbers // with the help of above designed // algorithm #include using namespace std; int main() { // Variables to take the input of // the 3 numbers int num1, num2, num3; // Variable to store the resultant sum int sum; // Take the 3 numbers as input cout << 'Enter the 1st number: '; cin>> número1; corte<< ' ' << num1 << endl; cout << 'Enter the 2nd number: '; cin>> número2; corte<< ' ' << num2 << endl; cout << 'Enter the 3rd number: '; cin>> número3; corte<< ' ' << num3; // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum cout << ' Sum of the 3 numbers is: ' << sum; return 0; } // This code is contributed by shivanisinghss2110>C // C program to add three numbers // with the help of above designed algorithm #include int main() { // Variables to take the input of the 3 numbers int num1, num2, num3; // Variable to store the resultant sum int sum; // Take the 3 numbers as input printf('Enter the 1st number: '); scanf('%d', &num1); printf('%d ', num1); printf('Enter the 2nd number: '); scanf('%d', &num2); printf('%d ', num2); printf('Enter the 3rd number: '); scanf('%d', &num3); printf('%d ', num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum printf(' Sum of the 3 numbers is: %d', sum); return 0; }>Java // Java program to add the three numbers // with the help of above designed // algorithm import java.util.*; class GFG { public static void main(String[] args) { // Variable to store the resultant sum int sum = 0; // Declare the object and initialize with // predefined standard input object Scanner sc = new Scanner(System.in); // Scanner definition // Variables to take the input of // the 3 numbers System.out.println('Enter the 1st number: '); int num1 = sc.nextInt(); // input is an Integer // read by nextInt() function System.out.println(' ' + num1); System.out.println('Enter the 2nd number: '); int num2 = sc.nextInt(); System.out.println(' ' + num2); System.out.println('Enter the 3rd number: '); int num3 = sc.nextInt(); System.out.println(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; System.out.println('Sum of the 3 numbers is = ' + sum); } } /*This code is contributed by Rishab Dugar*/>Pitón # Python3 program to add three numbers # with the help of above designed # algorithm if __name__ == '__main__': # Variables to take the input of # the 3 numbers num1 = num2 = num3 = 0 # Variable to store the resultant sum sum = 0 # Take the 3 numbers as input num1 = int(input('Enter the 1st number: ')) num2 = int(input('Enter the 2nd number: ')) num3 = int(input('Enter the 3rd number: ')) # Calculate the sum using + operator # and store it in variable sum sum = num1 + num2 + num3 # Print the sum print(' Sum of the 3 numbers is:', sum)>C# // C# program to add the three numbers // with the help of above designed // algorithm using System; class GFG { static public void Main () { // Variable to store the resultant sum int sum = 0; // Variables to take the input of // the 3 numbers Console.Write('Enter the 1st number: '); int num1 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num1); Console.Write('Enter the 2nd number: '); int num2 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num2); Console.Write('Enter the 3rd number: '); int num3 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; Console.WriteLine('Sum of the 3 numbers is = ' + sum); } } /*This code is contributed by Pushpesh Raj*/>JavaScript // Javascript program to add three numbers // with the help of above designed // algorithm // Variables to take the input of // the 3 numbers let num1 = 0, num2 = 0, num3 = 0; // Variable to store the resultant sum let sum = 0; // Take the 3 numbers as input console.log('Enter the 1st number: '); num1 = parseInt(prompt()); console.log(' ' + num1 + ' '); console.log('Enter the 2nd number: '); num2=parseInt(prompt()); console.log(' ' + num2 + ' '); console.log('Enter the 3rd number: '); num3=parseInt(prompt()); console.log(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum console.log(' Sum of the 3 numbers is: ' + sum); // This code is contributed by Aman Kumar>
Producción

Ingrese el primer número: 0 Ingrese el segundo número: 0 Ingrese el tercer número: -1577141152 La suma de los 3 números es: -1577141152

Aquí está el algoritmo paso a paso del código:

  1. Declare tres variables num1, num2 y num3 para almacenar los tres números que se van a sumar.
  2. Declare una suma variable para almacenar la suma de los tres números.
  3. Utilice la instrucción cout para pedirle al usuario que ingrese el primer número.
  4. Utilice la instrucción cin para leer el primer número y guárdelo en num1.
  5. Utilice la instrucción cout para pedirle al usuario que ingrese el segundo número.
  6. Utilice la instrucción cin para leer el segundo número y guárdelo en num2.
  7. Utilice la declaración cout para pedirle al usuario que ingrese el tercer número.
  8. Utilice la instrucción cin para leer y almacenar el tercer número en num3.
  9. Calcule la suma de los tres números usando el operador + y guárdela en la variable de suma.
  10. Utilice la declaración cout para imprimir la suma de los tres números.
  11. La función principal devuelve 0, lo que indica la ejecución exitosa del programa.

Complejidad del tiempo: O(1)
Espacio Auxiliar: O(1)

Un problema, muchas soluciones: La solución a un algoritmo puede ser o no más de una. Significa que al implementar el algoritmo, puede haber más de un método para implementarlo. Por ejemplo, en el problema anterior de sumar 3 números, la suma se puede calcular de muchas maneras:

  • + operador
  • Operadores bit a bit
  • . . etc.

¿Cómo analizar un algoritmo?

Para que un algoritmo estándar sea bueno, debe ser eficiente. Por tanto, se debe comprobar y mantener la eficiencia de un algoritmo. Puede ser en dos etapas:

1. Análisis a priori:

Priori significa antes. Por tanto, el análisis a priori significa comprobar el algoritmo antes de su implementación. En este, el algoritmo se verifica cuando está escrito en forma de pasos teóricos. Esta eficiencia de un algoritmo se mide asumiendo que todos los demás factores, por ejemplo, la velocidad del procesador, son constantes y no tienen ningún efecto en la implementación. Esto lo suele hacer el diseñador del algoritmo. Este análisis es independiente del tipo de hardware y lenguaje del compilador. Da las respuestas aproximadas para la complejidad del programa.

2. Análisis posterior:

Posterior significa después. Por tanto, el análisis posterior significa comprobar el algoritmo después de su implementación. En este se comprueba el algoritmo implementándolo en cualquier lenguaje de programación y ejecutándolo. Este análisis ayuda a obtener el informe de análisis real y real sobre la corrección (para cada entrada posible, si muestra/devuelve una salida correcta o no), el espacio requerido, el tiempo consumido, etc. Es decir, depende del idioma del compilador y el tipo de hardware utilizado.

¿Qué es la complejidad del algoritmo y cómo encontrarla?

Un algoritmo se define como complejo en función de la cantidad de espacio y tiempo que consume. Por tanto, la Complejidad de un algoritmo se refiere a la medida del tiempo que necesitará para ejecutarse y obtener el resultado esperado, y el Espacio que necesitará para almacenar todos los datos (entrada, datos temporales y salida). Por tanto, estos dos factores definen la eficiencia de un algoritmo.
Los dos factores de la complejidad del algoritmo son:

  • Factor de tiempo : El tiempo se mide contando el número de operaciones clave, como las comparaciones, en el algoritmo de clasificación.
  • Factor de espacio : El espacio se mide contando el espacio de memoria máximo requerido por el algoritmo para ejecutarse.

Por lo tanto, el La complejidad de un algoritmo se puede dividir en dos tipos. :

1. Complejidad espacial : La complejidad espacial de un algoritmo se refiere a la cantidad de memoria requerida por el algoritmo para almacenar las variables y obtener el resultado. Esto puede ser para entradas, operaciones temporales o salidas.

¿Cómo calcular la complejidad espacial?
La complejidad espacial de un algoritmo se calcula determinando los 2 componentes siguientes:

  • Parte fija: Esto se refiere al espacio que requiere el algoritmo. Por ejemplo, variables de entrada, variables de salida, tamaño del programa, etc.
  • Parte variable: Esto se refiere al espacio que puede ser diferente según la implementación del algoritmo. Por ejemplo, variables temporales, asignación de memoria dinámica, espacio de pila de recursividad, etc.
    Por lo tanto, complejidad espacial S(P) de cualquier algoritmo P es S(P) = C + SP(I) , donde C es la parte fija y S(I) es la parte variable del algoritmo, que depende de la característica de instancia I.

Ejemplo: Considere el siguiente algoritmo para búsqueda lineal

Paso 1: COMENZAR
Paso 2: Obtener n elementos de la matriz en arr y el número a buscar en x
Paso 3: Comience desde el elemento más a la izquierda de arr[] y uno por uno compare x con cada elemento de arr[]
Paso 4: Si x coincide con un elemento, Imprima Verdadero.
Paso 5: Si x no coincide con ninguno de los elementos, imprima Falso.
Paso 6: FINALIZAR
Aquí, hay 2 variables arr[] y x, donde arr[] es la parte variable de n elementos y x es la parte fija. Por tanto S(P) = 1+n. Entonces, la complejidad del espacio depende de n (número de elementos). Ahora, el espacio depende de los tipos de datos de las variables y tipos constantes dados y se multiplicará en consecuencia.

2. Complejidad del tiempo : La complejidad temporal de un algoritmo se refiere a la cantidad de tiempo que requiere el algoritmo para ejecutarse y obtener el resultado. Esto puede ser para operaciones normales, declaraciones condicionales if-else, declaraciones de bucle, etc.

Como calcular , ¿Complejidad del tiempo?
La complejidad temporal de un algoritmo también se calcula determinando los dos componentes siguientes:

  • Parte de tiempo constante: En esta parte viene cualquier instrucción que se ejecuta una sola vez. Por ejemplo, entrada, salida, if-else, switch, operaciones aritméticas, etc.
  • Parte de tiempo variable: Cualquier instrucción que se ejecute más de una vez, digamos n veces, viene en esta parte. Por ejemplo, bucles, recursividad, etc.
    Por lo tanto, complejidad del tiempo.T(P) de cualquier algoritmo P es T(P) = C + TP(I) , donde C es la parte de tiempo constante y TP(I) es la parte variable del algoritmo, que depende de la característica de instancia I.

Ejemplo: En el algoritmo de búsqueda lineal anterior, la complejidad del tiempo se calcula de la siguiente manera:

Paso 1: –Tiempo constante
Paso 2: - Tiempo variable (tomando n entradas)
Paso 3: –Tiempo variable (Hasta la longitud del Array (n) o el índice del elemento encontrado)
Paso 4: –Tiempo constante
Paso 5: –Tiempo constante
Paso 6: –Tiempo constante
Por lo tanto, T(P) = 1 + n + n(1 + 1) + 1 = 2 + 3n, que se puede decir como T(n).

¿Cómo expresar un algoritmo?

  1. Lenguaje natural:- Aquí expresamos el Algoritmo en el idioma inglés natural. Es demasiado difícil entender el algoritmo a partir de él.
  2. Diagrama de flujo :- Aquí expresamos el algoritmo haciendo una representación gráfica/pictórica del mismo. Es más fácil de entender que el lenguaje natural.
  3. Pseudocódigo :- Aquí expresamos el algoritmo en forma de anotaciones y texto informativo escrito en inglés sencillo, que es muy similar al código real, pero como no tiene sintaxis como cualquiera de los lenguajes de programación, no puede ser compilado ni interpretado por la computadora. . Es la mejor manera de expresar un algoritmo porque puede ser entendido incluso por un profano con algún conocimiento de nivel escolar.