Equipo Tarea 1

Equipo de laboratorio Jueves M5

Juan Carlos Guzman Pinales

Oscar Missael Ramirez Reyes

Eduardo Alberto Briones Hdz

Victor Emanuel Rios Martinez

Tarea 1

Big data

Big data es la próxima frontera de la innovación, la competencia y la productividad. La cantidad de datos en nuestro mundo ha sido una explosión, y el análisis de grandes conjuntos de datos los llamados grandes de datos se convertirá en un elemento esencial de la competencia, que sustenta las nuevas olas de crecimiento de la productividad, la innovación y el excedente del consumidor, según una investigación de MGI y Oficina de Negocios de Tecnología de McKinsey.Hay cinco formas generales en que el uso de grandes volúmenes de datos puede crear valor. Primero, los grandes volúmenes de datos pueden desbloquear un valor significativo al hacer una información transparente y útil en una frecuencia mucho más alta. En segundo lugar, como a las organizaciones crear y almacenar más datos transaccionales en formato digital, pueden recoger información más precisa y detallada sobre el desempeño de todo, desde los inventarios de productos para los días de enfermedad, y por lo tanto exponer la variabilidad y mejorar el rendimiento. En tercer lugar, permite a los grandes volúmenes de datos cada vez más estrecha de la clientela y de los productos o servicios por lo tanto, a medida mucho más precisa. En cuarto lugar, el análisis sofisticados pueden mejorar sustancialmente la toma de decisiones. Por último, grandes de datos se pueden usar para mejorar el desarrollo de la próxima generación de productos y servicios. El uso de grandes volúmenes de datos se convertirá en un elemento esencial de la competencia y el crecimiento de las empresas individuales. Desde el punto de vista de la competitividad y la captura potencial de valor, todas las empresas deben tener grandes volúmenes de datos en serio. En la mayoría de las industrias, los competidores establecidos y los nuevos operadores por igual impulsará estrategias para innovar, competir y capturar el valor de la información profunda y actualizada en tiempo real basada en datos.

1. El uso de grandes volúmenes de datos será la base de las nuevas olas de crecimiento de la productividad y el excedente del consumidor.

2. Aunque el uso de grandes volúmenes de datos importa en todos los sectores, algunos sectores se establecen para mayores ganancias. Se comparó la productividad histórica de los sectores en los Estados Unidos con el potencial de estos sectores para capturar valor a partir de grandes volúmenes de datos (utilizando un índice que combina varias métricas cuantitativas), y encontramos que las oportunidades y los desafíos varían de un sector a otro.

3. Habrá una escasez de talento necesario para las organizaciones que se aprovechan de grandes volúmenes de datos. En 2018, los Estados Unidos podrían enfrentar una escasez de 140.000 a 190.000 personas con capacidad de análisis profundos, así como 1,5 millones de gestores y analistas con el know-how para utilizar el análisis de grandes volúmenes de datos para tomar decisiones eficaces.

4. Varias cuestiones tendrán que ser abordados para capturar todo el potencial de grandes volúmenes de datos. Las políticas relacionadas con la privacidad, la seguridad, la propiedad intelectual, e incluso la responsabilidad tendrán que ser abordados en un mundo de grandes datos 

Map-Reduce

Map-Reduce  es un paradigma de procesamiento de datos para la condensación de grandes volúmenes de datos útiles en agregados resultados. Para mapas reducir operaciones, MongoDB provee la MapReduce comandos de base de datos.

En esta operación de mapas reducir, MongoDB aplica el mapa de fase para cada documento de entrada (es decir, los documentos de la colección que coinciden con la condición de consulta). La función de mapa emite pares clave-valor. Para aquellas teclas que tienen varios valores, MongoDB aplica la reduzca fase, que recoge y condensa los datos agregados. MongoDB a continuación, almacena los resultados en una colección. Opcionalmente, la salida de la función reduzca puede pasar a través de una finalizar la función de más condensan o procesar los resultados de la agregación.Todas las funciones de mapas reducir en MongoDB es JavaScript y se ejecutan dentro de la mongod proceso. Mapa-reducen las operaciones toman los documentos de una sola colección como la de entrada y pueden realizar cualquier clasificación arbitraria y la limitación antes de comenzar la etapa de mapa. MapReduce puede devolver los resultados de una operación de mapa-reducir en un documento, o puede escribir los resultados en colecciones . La entrada y las colecciones de salida pueden estar fragmentadas.

En MongoDB, la operación de mapas puede reducir escribir los resultados a una colección o devolver la línea resultados. Si escribes map-reduce la producción de una colección, se pueden realizar las operaciones siguientes mapas reducir en la misma colección de entrada que fusionar sustituir, fusionar o reducir los nuevos resultados con los resultados anteriores. Al devolver los resultados de un mapa de reducir la operación en línea , los documentos de resultados deben estar dentro del BDON documento tamaño límite, que es actualmente de 16 megabytes.

Tag cloud wordle

Wordle es un juguete para generar "nubes de palabras" del texto que nosotros proporcionamos. Las nubes dan mayor importancia a las palabras que aparecen con mayor frecuencia en el texto de origen. Puede ajustar sus nubes con diferentes fuentes, diseños y combinaciones de colores. Las imágenes que se crean con Wordle son tuyas para utilizar como usted quiera. Usted puede imprimirlos o guardarlos en la galería Wordle para compartir con tus amigos.

Programas

Colas

Una cola (también llamada fila) es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción pushse realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Codigo

#include<stdio.h>
#include<stdlib.h>
/* Colas */
/* Guarda matr�culas de alumnos y su nombre */

typedef struct nodos{
 int numero;
 char nombre[10];
 struct nodos *sige;
} typenodo;

typedef typenodo *cola;

void addmat(cola *pnod, cola *unod, int mat){
 cola nnod;
 nnod=(cola)malloc(sizeof(typenodo));
 nnod->numero=mat;
 printf("Nombre: ");scanf("%s",&nnod->nombre);
 nnod->sige=NULL;
 if (*unod) (*unod)->sige=nnod;
  *unod=nnod;
 if (!*pnod) *pnod=nnod;
}

int mosmats(cola *pnod, cola *unod) {
    cola nodo;
    nodo=*pnod;
    if(!nodo) return 0;
 *pnod=nodo->sige;
    printf("Matricula: %d\n",nodo->numero);
    printf("Nombre: %s\n",nodo->nombre);
 free(nodo);
  if (!*pnod) *unod=NULL;
}

int main (){
 cola pnod=NULL, unod=NULL;
 printf("Agregar matricula? 1-SI 2-NO -> ");
 int mat,r=0,i=0,j; scanf("%d",&r);
 while(r==1){
  i++;
  printf("Matricula: ");
  scanf("%d",&mat);
  addmat(&pnod,&unod,mat);
  printf("Agregar matricula? 1-SI 2-NO -> ");
  scanf("%d",&r);
 }
 for(j=0;j<i;j++) mosmats(&pnod,&unod);

 return 0;
}

Pilas

Una pila (stack en ingles ) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informatica debido a su simplicidad y ordenación implícita de la propia estructura.

Codigo

#include<stdio.h>
#include<stdlib.h>
/* Pilas */
/* Guarda matr�culas de alumnos y su nombre */

typedef struct nodos{
 int numero;
 char nombre[10];
 struct nodos *sige;
} typenodo;

typedef typenodo *pila;

void addmat(pila *pnod, int mat){
 pila nnod;
 nnod=(pila)malloc(sizeof(typenodo));
 nnod->numero=mat;
 printf("Nombre: ");scanf("%s",&nnod->nombre);
 nnod->sige=*pnod;
 *pnod=nnod;
}

int mosmats(pila *pnod) {
    pila nodo;
    nodo=*pnod;
    if(!nodo) return 0;
 *pnod=nodo->sige;
    printf("Matricula: %d\n",nodo->numero);
    printf("Nombre: %s\n",nodo->nombre);
 free(nodo);
}

int main (){
 pila pnod=NULL, unod=NULL;
 printf("Agregar matricula? 1-SI 2-NO -> ");
 int mat,r=0,i=0,j; scanf("%d",&r);
 while(r==1){
  i++;
  printf("Matricula: ");
  scanf("%d",&mat);
  addmat(&pnod, mat);
  printf("Agregar matricula? 1-SI 2-NO -> ");
  scanf("%d",&r);
 }
 for(j=0;j<i;j++) mosmats(&pnod);

 return 0;
}

Lista y cadenas

En programación, una cadena de caracteres, palabra, ristra de caracteres o frase (string en inglés) es una secuencia ordenada de longitud arbitraria (aunque finita) de elementos que pertenecen a un cierto lenguaje formal o alfabeto análogas a una fórmula o a una oración. En general, una cadena de caracteres es una sucesión de caracteres (letras, números u otros signos o símbolos).

Codigo

#include<stdio.h>
#include<stdlib.h>
/* Listas y cadenas */
/* Guarda matr�culas de alumnos y su nombre */

typedef struct nodos{
 int numero;
 char nombre[10];
 struct nodos *siguiente;
} typenodo;

typedef typenodo *nod;
typedef typenodo *lista;

void addmat(lista *lis, int mat){
 nod nnod;
 nnod=(nod)malloc(sizeof(typenodo));
 nnod->numero=mat;
 printf("Nombre: ");scanf("%s",&nnod->nombre);
 nnod->siguiente=*lis;
 *lis=nnod;
}

void mosmats(lista lis) {
   nod nodo=lis;
   while(nodo) {
      printf("Matricula: %d\n",nodo->numero);
      printf("Nombre: %s\n",nodo->nombre);
      nodo=nodo->siguiente;
   }
}

void eramats(lista *lis) {
   nod nodo;

   while(*lis) {
      nodo = *lis;
      *lis = nodo->siguiente;
      free(nodo);
   }
}

int main (){
 lista lis = NULL;
 nod ap;
 printf("Agregar matricula? 1-SI 2-NO -> ");
 int mat,r=0; scanf("%d",&r);
 while(r==1){
  printf("Matricula: ");
  scanf("%d",&mat);
  addmat(&lis,mat);
  printf("Agregar matricula? 1-SI 2-NO -> ");
  scanf("%d",&r);
 }
 mosmats(lis);
 eramats(&lis);

 return 0;
}

Arbol

En ciencias de la computación, un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno. Usos comunes de los árboles binarios son los árboles binarios de búsqueda, los montículos binarios y Codificación de Huffman.

Codigo
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct arbol{
int info;
struct arbol *left;
struct arbol *right;
};
typedef struct arbol nodetree;
typedef nodetree *arbolptr;
void insertar(arbolptr*L, int b);
void imprimir(arbolptr L);
void preorden(arbolptr L);
void entreorden(arbolptr L);
void posorden(arbolptr L);
void instrucciones();
main()
{
arbolptr L=NULL;
int inf, opcion;
instrucciones(),
(" \n Seleciona la opcion: \n");
scanf("%d",&opcion);
while(opcion!=5){
switch(opcion)
{
case 1:{
printf("\n Introduzca el elemento:");
scanf("%d",&inf);
insertar(&L,inf);
imprimir(L);
instrucciones();
break;
}
case 2: {
printf("Pre-orden");
preorden(L);
break;
}
case 3: {
printf("Entre-orden");
entreorden(L);
break;
}
case 4: {
printf("Pos-orden");
posorden(L);
break;
}
case 5: {
printf("Fin del programa");
break;
}
default:
printf("Operacion invalida");
instrucciones();
break;
}
printf("\n SELECCIONA UNA OPCION: ");
scanf("%d",&opcion);
}// Fin del While
printf("Fin del proyecto");
return 0;
}
void instrucciones()
{

printf("\n 1- INTRODUZCA UN ELEMENTO AL ARBOL");
printf("\n 2- RECORRIDO EN PRE-ORDEN");
printf("\n 3- RECORRIDO EN ENTRE-ORDEN");
printf("\n 4- RECORRIDO EN POS-ORDEN");
printf("\n 5-SALIR\n");
}
void insertar(arbolptr*r,int x)
{
arbolptr pnuevo,panterior,pactual;
pnuevo=(arbol*)malloc(sizeof(arbol));
if(pnuevo!=NULL)
{
pnuevo->info=x;
pnuevo->right=NULL;
pnuevo->left=NULL;
panterior=NULL;
pactual=*r;
printf("%d",pnuevo->info);
while(pactual!=NULL && x>pactual->info)
{
panterior=pactual;
pactual=pactual->left;
}
if(panterior==NULL)
{
pnuevo->left=*r;
*r=pnuevo;
}
else
{
panterior->left=pnuevo;
pnuevo->left=pactual;
}
}
}
void imprimir(arbolptr pactual)
{
if(pactual==NULL)
printf("\n La lista esta vacia\n");
else
{
printf("\n La cadena de elementos del Arbol es:\n");
while(pactual!=NULL)
{
printf("%d->",pactual->info);
pactual=pactual->left;
}
printf("NULL\n\n");
}
}
void preorden(arbolptr pactual)
{
if(pactual!=NULL)
{
printf("%d",pactual->info);
preorden(pactual->left);
}
}
void entreorden(arbolptr pactual)
{
if(pactual!=NULL)
{
entreorden(pactual->left);
printf("%d",pactual->info);
entreorden(pactual->right);
}
}
void posorden(arbolptr pactual)
{
if(pactual!=NULL)
{
posorden(pactual->left);
posorden(pactual->right);
printf("%d",pactual->info);
}
}