Algoritmia-Ejercicios introductorios.

[h0oke]

Muchas gracias por su cooperación ahora pasamos al siguiente tema.

VARIABLES INDIZADAS UNIDIMENSIONALES

Problema1: Un vector está compuesto por una cantidad N de números distintos. Se deberá mostrar los dos más próximos.

Problema2: Inserta un elemento X dentro de un vector ordenado de N elementos. *En caso de que exista dar su posición.
a) Dar una solución implementando búsqueda secuencial.
b) Dar una solución implementando búsqueda binaria.

Problema3: Diseñar un algoritmo que permita ordenar una lista de alumnos con sus correspondientes calificaciones obtenidas en un parcial.

Se destaca que el elemento de nombre(X) tiene su correspondiente nota(X).

Problema 4: Diseñar un algoritmo que ordene números distintos de 0 mientras se vayan ingresando.

Problema 5: Dado un número en base B, donde 1<B<10, generar todos los enteros entre 0 y el número dado en base B.
Tener en cuenta el problema nº7 de variables simples.

[h0oke]

Lenguaje C:

Código (c) [Seleccionar] Expandir


/*Problema1: Un vector está compuesto por
una cantidad N de números distintos. Se deberá mostrar los dos más próximos.*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char *argv[])
{
   int x[100];
   int i,j,n,p1,p2,d,men;
   printf("Ingrese cantidad:");
   scanf("%d",&n);
   for(i=0;i<n;i++)
   {
                 printf("Ingrese numero\n");
                 scanf("%d",&x[i]);
   }
   men=abs(x[0]-x[1]);
   p1=1;
   p2=2;
   for(i=0;i<n;i++)
   {
                   for(j=0;j<n;j++)
                   {
                                   if(i!=j)
                                   {
                                           d=abs(x[i]-x[j]);
                                           if(d<men)
                                           {
                                                    men=d;
                                                    p1=i;
                                                    p2=j;
                                           }
                                   }
                   }
   }
   printf("%d,%d",p1,p2);
   getch();
 return 0;
}

Código (c) [Seleccionar] Expandir


/*Problema2: Inserta un elemento X dentro de un vector ordenado de N elementos. *En caso de que exista dar su posición.
a) Dar una solución implementando búsqueda secuencial.*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int vector[]={1,1,3,5,4,5,6,3,9,10};
    int i,j,k;
    int n=9;
    for(i=1;i<=10;i++)
    {
        j=1;
        while(vector[i]!=vector[j])
        {
            j++;
        }
        if(j==i)
        {
            printf("Numero: %d, ",vector[i]);
            for(k=i;k<=n;k++)
            {
                if(vector[i]==vector[k])
                    printf("%d\n",k);
            }
        }
    }
    return 0;
}

[j retirado]

Edito: le agregue la opcion GeSHi, jeje. Ahora aprendi y queda mas lindo el código.

Problema 8: Desarrollar un algoritmo para generar los primeros K primeros números primos de la serie Fibonacci.
Ejemplo:
K=6
1 2 3 5 13 89

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define FALSE 0
#define TRUE !FALSE
typedef int Bool;

int fib(double n);
Bool es_primo(int num);

int main()
{
int n; printf("Cantidad de primos a obtener:  "); scanf("%d", &n);

int i=0, j;
for(j=0; j<n;)
{
if( es_primo(fib(i)) )
{
printf("%d  ", fib(i));
j++;
}
i++;
}

printf("\n\n");
system("pause");
return 0;
}

int fib(double n)
{
double a = 1/sqrt(5);
double b = (1+sqrt(5))/2;
double c = (1-sqrt(5))/2;
double fib_n = a*pow(b, n) - a*pow(c, n);

return fib_n;
}

Bool es_primo(int num)
{
       Bool b = TRUE;
       int i, divisores=0;

       if(num == 0)
               return b=FALSE;

       for(i=1; i<=num; i++)
       {
               if((num%i) == 0)
                       divisores++;
               if(divisores > 2)
               {
                       return b=FALSE;
               }
}

return b;
}


[ny0x]

el 2 en asm (el mas facil) conforme vaya mejorando mi uso de arrays pongo los otros (claro si no me da weba  )

Código (asm) [Seleccionar] Expandir


format pe console
include 'c:\fasm\include\win32ax.inc'
entry main
.data
       number  dd      ?
.code
main:
       invoke printf,"Escribe un numero, 0 para salir: "
       add esp,4
       invoke scanf,"%d",number
       add esp,8
       cmp [number],0
       jle salir
       push [number]
       call factorial
       invoke printf,"El factorial es %d",eax
       add esp,8
       push 10
       call [putchar]
       jmp main
       salir:
ret

factorial:
       push ebp
       mov ebp,esp
       mov ecx,[ebp + 8]
       mov eax,1
       fact@L1:
               cdq
               mul ecx
               dec ecx
               cmp ecx,0
               jg fact@L1
       pop ebp
retn 4
section '.idata' import data readable
library msvc,'msvcrt.dll'
import msvc,printf,'printf',scanf,'scanf',putchar,'putchar'


[h0oke]

x0ʎu
Muchas gracias, a esto quería llegar...
Diferentes soluciones, en diferentes lenguajes.

[ghastlyX]

Para el 3, pongo varios algoritmos de ordenación en C++ que permiten ordenar un vector de reales:

Ordenación por inserción (O(n²)):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
using namespace std;

void ordena_por_insercion(vector<double>& v) {
    for (int i = 1; i < v.size(); ++i) {
        double x = v[i];
        int j = i;
        while (j > 0 and v[j-1]>x) {
            v[j] = v[j-1];
            --j;
        }
        v[j] = x;
    }
}


Ordenación por selección (O(n²)):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
using namespace std;

int posicion_maximo(const vector<double>& v, int n) {
    int pos = 0;
    for (int i = 1; i <= n; ++i)
        if (v[i] > v[pos]) pos = i;
    return pos;
}

void ordena_por_seleccion(vector<double>& v, int n) {
    if (n > 0) {
        swap(v[posicion_maximo(v,n)],v[n]);
        ordena_por_seleccion(v,n-1);
    }
}

Ordenación por burbuja (O(n²)):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
using namespace std;

void ordena_por_burbuja(vector<double>& v) {
    for (int i = 0; i < v.size(); ++i) {
        for (int j = v.size()-1; j >= i + 1; --j) {
            if (v[j] < v[j - 1] ) swap(v[j], v[j - 1]);
        }
    }
}

Y un par de algoritmos Divide&Conquer, primero Merge Sort (Ordenación por fusión, O(n log n)):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
using namespace std;

void fusiona(vector<double>& v, int e, int m, int d) {
    int n = d-e+1;
    vector<double> aux (n);
   
    int i = e;
    int j = m + 1;
    int k = 0;
    while (i <= m and j <= d) {
        if (v[i] <= v[j]) {
            aux[k] = v[i];
            ++i;
            ++k;
        }
        else {
            aux[k] = v[j];
            ++j;
            ++k;
        }
    }
    while (i <= m) {
        aux[k] = v[i];
        ++k;
        ++i;
    }
   
    while (j <= d) {
        aux[k] = v[j];
        ++j;
        ++k;
    }
    for (k = 0; k < n; ++k) v[k+e] = aux[k];
}

void ordena_rec(vector<double>& v, int e, int d) {
    if (e < d) {
        int m = (e+d)/2;
       
        ordena_rec(v,e,m);
        ordena_rec(v,m+1,d);
        fusiona(v,e,m,d);
    }
}

void ordena_por_fusion(vector<double>& v) {
    ordena_rec(v, 0, v.size()-1);
}

Otro Divide&Conquer, Quicksort (O(n log n) en caso promedio, O(n²) en el peor caso, aunque en general es más rápido que el Merge Sort):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
using namespace std;

int pivota(vector<double>& v, int ini, int fin) {
    double valor_pivote = v[ini];
    int p1 = ini + 1, p2 = fin - 1;
    while (p1 <= p2) {
        if (v[p1] < valor_pivote) ++p1;
else if (v[p2] >= valor_pivote) --p2;
else {
    swap(v[p1], v[p2]);
    ++p1;
    --p2;
}
    }
    swap(v[ini], v[p1 - 1]);
    return p1 - 1;
}

void quicksort_rec(vector<double>& v, int ini, int fin) {
    if (ini >= fin - 1) return;
    int pivote = pivota(v, ini, fin);
    quicksort_rec(v, ini, pivote);
    quicksort_rec(v, pivote + 1, fin);
}

void quicksort(vector<double>& v, int r) {
    quicksort_rec(v, 0, r);
}

Un saludo de ghastlyX

[h0oke]

ESRUCTURAS ESTATICAS BIDIMENSIONALES

1-Mostrar una matriz por filas.
2-Mostrar una mtriz por columnas.
3-Mostrar una matriz por recorrido en caracol.
4-Mostrar los elementos que se encuentran en el triangular inferior.
  ------------------------------------------------------------------------------, junto a su diagonal.
5-Sea una tabla NxM ordenada por filas ascendentemente y dada una lista tamaño M² insertar en la fila correspondiente utilizando el método de Búsqueda Binaria.
             
6- Se posee una tabla de A de M filas y N columnas, conformada por números naturales. Se deberá mostrar la posición del menor número repetido junto con su frecuencia de aparición.

7- De una tabla NxM informar la posición del primer elemento primo de cada fila y la posición del primer elemento primo de la tabla.

[h0oke]

1-2

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

int main()
{
   int N,M,i,j;
   int a[100][100];
   printf("Ingrese cantidad filas(M)\n");
   scanf("%d",&M);
   printf("Ingrese cantidad columnas(N)\n");
   scanf("%d",&N);
   for(i=0;i<M;i++)
   {
       for(j=0;j<N;j++)
       {
           printf("Elemento\n");
           scanf("%d",&a[i][j]);
       }
   }
   for(i=0;i<M;i++)
   {
       for(j=0;j<N;j++)
       {
           printf("%d",a[i][j]);
       }
   }
   return 0;
}

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

int main()
{
   int N,M,i,j;
   int a[100][100];
   printf("Ingrese cantidad filas(M)\n");
   scanf("%d",&M);
   printf("Ingrese cantidad columnas(N)\n");
   scanf("%d",&N);
   for(j=0;j<N;j++)
   {
       for(i=0;i<M;i++)
       {
           printf("Elemento\n");
           scanf("%d",&a[i][j]);
       }
   }
   for(j=0;j<N;j++)
   {
       for(i=0;i<M;i++)
       {
           printf("%d",a[i][j]);
       }
   }
   return 0;
}

[VonN]

El algoritmo para recorrer y mostrar el triangulo superior:

Código (cpp) [Seleccionar] Expandir

for(int i=0,i<n-1;i++)
{
     for(int j=i+1;j<n;j++)
     {
          std::cout<<vec[i][j]<<std::endl;
     }
}

Triangulo superior y diagonal:

Código (cpp) [Seleccionar] Expandir

for(int i=0,i<n;i++)
{
     for(int j=i;j<n;j++)
     {
          std::cout<<vec[i][j]<<std::endl;
     }
}

[leogtz]

El 2 en Perl:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl
use strict;
use warnings;
print "Numero : ";
my $numero = <stdin>;
my $factorial = 1;
for(my $i = 1; $i <= $numero; $i++)
{
$factorial *= $i;
}
print $factorial;
exit;