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);
}
}
