En la programación, el algoritmo es una gran cantidad de direcciones caracterizadas en su totalidad en disposición de abordar el tema.

Características de un algoritmo decente

La información y el rendimiento deben caracterizarse de manera inequívoca.

Toda progresión en el cálculo debe ser clara e inequívoca.

El algoritmo debería ser el mejor entre una amplia gama de enfoques para resolver un problema.

Un algoritmo no debería tener código de PC. Más bien, el cálculo debe ser escrito de manera que, tienda a ser utilizado en dialectos de programación comparables.

Ejemplos de algoritmos en la programación

Escriba un algoritmo para sumar dos números introducidos por el usuario.

Paso 1: Comenzar

Paso 2: Declarar las variables num1, num2 y suma.

Paso 3: Leer los valores num1 y num2.

Paso 4: Sume los números 1 y 2 y asigne el resultado a la suma.

        sum←num1+num2

Paso 5: Mostrar la suma

Paso 6: Detenerse

Escriba un algoritmo para encontrar el más grande entre tres números diferentes introducidos por el usuario.

Paso 1: Comenzar

Paso 2: Declarar las variables a, b y c.

Paso 3: Leer las variables a, b y c.

Paso 4: Si a>b

           Si a>c

              La pantalla a es el número más grande.

           Else

              La pantalla c es el número más grande.

        Else

           Si b>c

              La pantalla b es el número más grande.

           Else

              La pantalla c es el número más grande. 

Paso 5: Detenerse

Escribe un algoritmo para encontrar todas las raíces de una ecuación cuadrática ax2+bx+c=0.

Paso 1: Comenzar

Paso 2: Declarar las variables a, b, c, D, x1, x2, rp e ip;

Paso 3: Calcular el discriminante

         D←b2-4ac

Paso 4: Si D≥0

              r1←(-b+√D)/2a

              r2←(-b-√D)/2a

              Mostrar r1 y r2 como raíces.

        Else   

              Calcular la parte real y la parte imaginaria

              rp←b/2a

              ip←√(-D)/2a

              Mostrar rp+j(ip) y rp-j(ip) como raíces

Escribir un algoritmo para encontrar el factorial de un número introducido por el usuario.

Paso 1: Comenzar

Paso 2: Declarar las variables n, factorial e i.

Paso 3: Iniciar las variables

          factorial←1

          i←1

Paso 4: Leer el valor de n

Paso 5: Repita los pasos hasta que i=n

     5.1: factorial←factorial*i

     5.2: i←i+1

Paso 6: Mostrar el factorial

Paso 7: Detenerse

Escribir un algoritmo para comprobar si un número introducido por el usuario es primo o no.

Paso 1: Comenzar

Paso 2: Declarar las variables n,i,flag.

Paso 3: Iniciar las variables

        flag←1

        i←2 

Paso 4: Leer n del usuario.

Paso 5: Repita los pasos hasta que i<(n/2)

     5.1 Si el resto de n÷i es igual a 0

            flag←0

            Ir al paso 6

     5.2 i←i+1

Paso 6: Si la bandera = 0

           La pantalla n no es la primera

        más

           La pantalla n es la primera

Paso 7: Detenerse

Escriba un algoritmo para encontrar la serie de Fibonacci hasta term≤1000.

Paso 1: Comenzar

Paso 2: Declarar las variables first_term, second_term y temp.

Paso 3: Inicializar las variables primero_term←0 segundo_term←1

Paso 4: Mostrar primer_término y segundo_término

Paso 5: Repita los pasos hasta el segundo_term≤1000

     5.1: temp←second_term

     5.2: segundo_term←second_término+primer término

     5.3: primero_term←temp

     5.4: Mostrar segundo_término

Paso 6: Detenerse

Por qué cada programador debería aprender a optimizar los algoritmos

¿Qué son los algoritmos?

Casualmente, un cálculo es sólo un aviso de los pasos a seguir para resolver un problema. Son básicamente una respuesta.

Por ejemplo, un cálculo para atender el tema de los factoriales puede parecerse a esto:

Problema: Encuentra el factorial de n

Iniciar el hecho = 1

Para cada valor v en el rango de 1 a n:

    Multiplica el hecho por v

contiene el factorial de n

Aquí, el algoritmo está escrito en inglés. Si estuviera escrito en un lenguaje de programación, lo llamaríamos código en su lugar. Aquí hay un código para encontrar el factorial de un número en C++.

int factorial(int n) {

    int hecho = 1;

    para (int v = 1; v <= n; v++) {

        hecho = hecho * n;

    }

    hecho de retorno;

}

La programación es sobre estructuras de información y cálculos. Las estructuras de información se utilizan para guardar la información mientras que los cálculos se utilizan para abordar la cuestión utilizando esa información.

Las estructuras de información y los cálculos (DSA) experimentan en detalle las respuestas a las cuestiones estándar y dan a conocer el hecho de que es tan productivo utilizar cada una de ellas. También te muestra el estudio de la evaluación de la productividad de un cálculo. Esto te permite elegir la mejor de las diferentes decisiones.

La utilización de estructuras de datos y algoritmos hacen que su código sea escalable

El tiempo es valioso.

Supongamos que Alice y Bob intentan ocuparse de una cuestión básica de encontrar el total de los 1011 números normales iniciales. Mientras Bob componía el cálculo, Alice lo actualizó demostrando que es tan básico como condenar a Donald Trump.

Algoritmo (por Bob)

Inicializar la suma = 0

para cada número natural n en el rango de 1 a 1011 (inclusive):

    sumar n a la suma

la suma es tu respuesta

Código (por Alice)

int findSum() {

int sum = 0;

para (int v = 1; <= 100000000000; v++) {

suma += v;

}

…devuelve la suma;

}

Alice y Bob están eufóricos de sí mismos por haber podido fabricar algo propio en cuestión de segundos. ¿Qué tal si nos colamos en su espacio de trabajo y sintonizamos su discusión.

Alice: Vamos a ejecutar este código y descubrir el conjunto.

Muévete: Corrí este código hace unos momentos y aún no indica el rendimiento. ¿Qué pasa con él?

¡Oh no, algo salió mal! Un PC es la máquina más determinante. Volver e intentar ejecutarlo de nuevo no ayudará. Así que deberíamos diseccionar lo que pasa con este código sencillo.

Dos de los activos más importantes para un programa de PC son el tiempo y la memoria.

El tiempo que tarda el PC en ejecutar un código es:

Código de tiempo de ejecución = número de instrucciones * tiempo de ejecución de cada instrucción

La cantidad de direcciones depende del código que utilizó, y el tiempo de ejecución de cada código depende de su máquina y su compilador.

Para esta situación, el número completo de pautas ejecutadas (suponga x) será x = 1 + (1011 + 1) + (1011) + 1, que es x = 2 * 1011 + 3

Danos la oportunidad de aceptar que un PC puede ejecutar y = 108 directrices en un solo segundo (puede fluctuar expuesto a la disposición de la máquina). El tiempo que se tarda en ejecutar el código anterior es

El tiempo que se tarda en ejecutar el código = x/y (más notable que 16 minutos)

¿Es concebible mejorar el cálculo con el objetivo de que Alice y Bob no tengan que esperar 16 minutos cada vez que ejecuten este código?

Estoy seguro de que previamente especuló con la técnica correcta. El conjunto de los primeros números característicos de N está dado por la receta:

Total = N * (N + 1)/2

Cambiar el código se verá algo así:

int sum(int N) {

retorno N * (N + 1)/2;

}

Este código se ejecuta en una sola dirección, y completa la tarea independientemente de lo que valga. Dale la oportunidad de ser más notable que el número total de partículas conocidas por la humanidad. Descubrirá el resultado en un parpadeo.

En este caso, el número total de instrucciones ejecutadas (digamos x) son x = 1 + (1011 + 1) + (1011) + 1, que es x = 2 * 1011 + 3

Asumamos que un ordenador puede ejecutar y = 108

Danos la oportunidad de aceptar que un PC puede ejecutar y = 108 directrices en un solo segundo (puede fluctuar expuesto a la configuración de la máquina). El tiempo que se tarda en ejecutar el código anterior es:

Tiempo de ejecución del código = x/y (más notable que 16 minutos)

¿Es concebible mejorar el cálculo con el objetivo de que Alice y Bob no tengan que esperar 16 minutos cada vez que ejecuten este código?

Estoy seguro de que previamente especuló con la técnica correcta. La totalidad de los primeros números normales de N está dada por la ecuación:

Entero = N * (N + 1)/2

Cambiar el código se verá algo así:

int sum(int N) {

retorno N * (N + 1)/2;

}

Este código se ejecuta en una sola dirección, y completa la tarea independientemente de lo que valga. Dale la oportunidad de ser más prominente que el número total de moléculas conocidas por la humanidad. Descubrirá el resultado en cuestión de momentos.

El tiempo que se tarda en abordar la cuestión para esta situación es de 1/y (que es de 10 nanosegundos). Casualmente, la respuesta combinada de una bomba nuclear toma 40-50 ns, lo que implica que su programa terminará efectivamente sin importar si alguien arroja una bomba nuclear en su PC simultáneamente usted ejecutó su código. 🙂

Nota: Las computadoras toman un par de pautas (no 1) para calcular el aumento y la división. He dicho 1 sólo para la franqueza.