Dicho de otro modo; los tubos de Unix son comandos anidados.

Se emplean con el caracter | de acuerdo con la siguiente sintaxis:

orden1 | orden2 | orden3 | ... | ordenN

Ejemplo: Mostrar el contenido de un directorio página por página

Veamos un ejemple simple: Es necesario visualizar completamente la carpeta sbin, para esto debemos ejecutar el comando ls -l, pero este comando muestra la lista completa sin dejar visualizar los primeros directorios o archivos ya que su contenido es bastante para visualizarlo en una sola pantalla.

$ ls -l /sbin/
total 15824
-rwxr-x--- 1 root root     22324 2009-10-23 19:33 acpid
-rwxr-xr-x 1 root root      1754 2010-02-23 18:46 activate_dm_linear
-rwxr-xr-x 1 root root     39048 2009-10-21 15:04 adjtimex
-rwxr-xr-x 1 root root     18540 2009-10-21 15:04 agetty
-rwxr-xr-x 1 root root    754308 2009-10-24 08:05 apparmor_parser
-rwxr-xr-x 1 root root     48864 2009-10-19 10:36 arp
-rwxr-xr-x 1 root root     18100 2009-10-23 19:37 arping
-rwxr-x--- 1 root root     96152 2009-10-23 19:22 audispd
-rwxr-x--- 1 root root    116576 2009-10-23 19:22 auditctl
-rwxr-x--- 1 root root    174284 2009-10-23 19:22 auditd
.
.
.
$

Este problema se puede resolver con tuberías y el comando more de la siguiente manera:

$ ls -l /sbin/ | more
total 15824
-rwxr-x--- 1 root root     22324 2009-10-23 19:33 acpid
-rwxr-xr-x 1 root root      1754 2010-02-23 18:46 activate_dm_linear
-rwxr-xr-x 1 root root     39048 2009-10-21 15:04 adjtimex
-rwxr-xr-x 1 root root     18540 2009-10-21 15:04 agetty
-rwxr-xr-x 1 root root    754308 2009-10-24 08:05 apparmor_parser
-rwxr-xr-x 1 root root     48864 2009-10-19 10:36 arp
-rwxr-xr-x 1 root root     18100 2009-10-23 19:37 arping
-rwxr-x--- 1 root root     96152 2009-10-23 19:22 audispd
-rwxr-x--- 1 root root    116576 2009-10-23 19:22 auditctl
-rwxr-x--- 1 root root    174284 2009-10-23 19:22 auditd
.
.
.
--More--
.
.
.
-rwxr-xr-x 1 root root     82600 2009-10-19 10:47 debugfs
-rwxr-xr-x 1 root root    227384 2009-10-19 10:59 debugreiserfs
-rwxr-xr-x 1 root root     67976 2009-10-23 19:32 depmod
-rwxr-xr-x 1 root root     13912 2009-10-23 19:24 detectups
-rwxr-xr-x 1 root root    453124 2009-12-17 18:45 dhclient
-rwx------ 1 root root     12564 2009-12-17 18:45 dhclient-script
-rwxr-xr-x 1 root root     72248 2010-01-24 18:05 dhcpcd
-rwxr-xr-x 1 root root     14040 2009-10-21 15:01 dm_dso_reg_tool
-r-xr-xr-x 1 root root     26636 2009-10-23 19:25 dmeventd
-rwxr-xr-x 1 root root    235320 2009-10-21 15:01 dmraid
--More--
.
.
.
$

Su funcionamiento es simple: la salida del comando ls -l es enviada al comando more que se encarga de mostrar el contenido página por página.

Ejemplo: man 2 PDF

Con el comando man visualizamos la documentación de los comandos que especifiquemos, por ejemplo:

$ man tar
.
.
.
NAME
       tar - The GNU version of the tar archiving utility

SYNOPSIS
       tar [OPTION...] [FILE]...
.
.
.

Pero… tal vez no sea muy cómodo leerlo en el Shell, entonces lo enviamos a un archivo PDF:

man -t tar | ps2pdfwr -> tar.pdf

También lo podemos enviar a la impresora:

man -t tar | lpr

Simple, ¿No?…

Las clases pueden implementar mas de una interfaz. Y debemos seguir una sola regla: Todos los métodos declarados en la interfaz deben estar implementados en las clases que implementan la interfaz.

Es recomendable crear una interfaz en un archivo distinto. Y al igual que las clases, el nombre del archivo debe ser el mismo que el de la interfaz; en este caso el archivo se llama Geometria.java.

La interfaz Geometria será implementada por las clases Circulo y Cuadrado.

Como mencioné al inicio; una interfaz nos indica lo que deben hacer las clases pero no como hacerlo. En esta caso la interfaz Geometria nos indica que las clases Circulo y Cuadrado realizarán los cálculos para obtener el área, perímetro y el nombre de las figuras; pero no nos especifica como hacerlo ya que los calculos para ambas figuras son distintos, al igual que el nombre.

El código completo queda de la siguiente forma con los cuatro archivos respectivamente: Geometria.java, Circulo.java, Cuadrado.java y Test.java.
Código para el archivo Geometria.java

package org.snippetstricks.oop;

public interface Geometria {

	public static final double PI = 3.14159265;
	public double area();
	public double perimetro();
	public String nombre();

}

Código para el archivo Circulo.java

package org.snippetstricks.oop;

public class Circulo implements Geometria {

	private double radio = 0;

	public Circulo(double r) {
		this.radio = r;
	}

	public double area() {
		return PI * radio * radio;
	}

	public double perimetro() {
		return 2.0 * PI * radio;
	}

	public String nombre() {
		return "Circulo";
	}

}

Código para el archivo Cuadrado.java

package org.snippetstricks.oop;

public class Cuadrado implements Geometria {

	private double lado = 0;

	public Cuadrado(double l) {
		this.lado = l;
	}

	public double area() {
		return lado * lado;
	}

	public double perimetro() {
		return 4.0 * lado;
	}

	public String nombre() {
		return "Cuadrado";
	}

}

Código para el archivo Test.java

package org.snippetstricks.oop;

public class Test {

	static void resultados(Geometria figura) {
		System.out.printf("Los datos de la figura %s son:%n", figura.nombre());
		System.out.printf("El perimetro es: %f%n", figura.area());
		System.out.printf("El area es: %f%n", figura.perimetro());
	}

	public static void main(String[] args) {

		Circulo circulo = new Circulo(10);
		Cuadrado cuadrado = new Cuadrado(20);

		resultados(circulo);
		resultados(cuadrado);
	}

}

Para probar el ejemplo creamos el archivo Test.java donde declaramos el método resultados que tiene como argumento la interfaz Geometria con el nombre figura. Este argumento utiliza los métodos perimetro(), area() y nombre() de las clases Circulo y Cuadrado.

Ahora compilemos y ejecutemos el ejemplo.

> javac -d . *.java
> java org.snippetstricks.oop.Test
Los datos de la figura Circulo son:
El perimetro es: 314.159265
El area es: 62.831853
Los datos de la figura Cuadrado son:
El perimetro es: 400.000000
El area es: 80.000000

Para crear dicho control debemos crear GtkTreeView y asignarle el modelo de lista. Para crear nuestra lista necesitaremos declarar los siguientes Widgets, variables y un evento.

/* Declaraciones */
GtkWidget *treeview, *scroll;
GtkListStore *store;
GtkTreeIter iter;
guint i = 0;

/* Declaramos el método para crear las columnas */
static void setup_tree_view (GtkWidget*);

Puesto que el Widget GtkListStore se basa en un TreeView debemos crear dicho control especificando las columnas que utilizaremos.

/* Creamos el Widget */
treeview = gtk_tree_view_new();
setup_tree_view(treeview);

Para crear una nueva lista utilizamos la función gtk_list_store_new() en donde especificamos la cantidad de columnas y los tipos de datos que almacenarán dichas columnas. En este caso utilizaremos dos columnas del tipo GString.

/* Especificamos que tipos de datos almacenará el Widget */
store = gtk_list_store_new (COLUMNAS, G_TYPE_STRING, G_TYPE_STRING);

La variable COLUMNAS la podemos sustituir por el número 2, en este ejemplo utilizamos la siguiente enumeración:

enum {
	SOFTWARE = 0,
	LICENCIAS,
	COLUMNAS
};

Puesto que el control que hemos creado en un GtkTreeView, debemos especificar que el control es un GtkListStore. Una vez que especificamos el modelo del Widget podemos agregar los datos con un ciclo. Los datos los tomaremos del arreglo ListaItem lista[].

/* Especificamos que el Widget es un GtkListStore */
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
g_object_unref (store);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

/* Agregamos los datos */
while (i != 6) {
	gtk_list_store_append (store, &iter);
	gtk_list_store_set (store, &iter, SOFTWARE, lista[i].software, LICENCIAS, lista[i].licencias, -1);
	i++;
}

Nuestro código completo queda de la siguiente manera:

#include <gtk/gtk.h>

enum {
	SOFTWARE = 0,
	LICENCIAS,
	COLUMNAS
};

typedef struct {
	gchar *software;
	gchar *licencias;
} ListaItem;

const ListaItem lista[] = {
	{ "openSUSE", "Software libre" },
	{ "OpenOffice.org", "Software libre" },
	{ "RHLE 5", "Software libre" },
	{ "Microsoft Windows", "Privada" },
	{ "MacOS X", "Privada" },
	{ "Debian", "Software libre" }
};

/* Declaramos el método para crear las columnas */
static void setup_tree_view (GtkWidget*);

static void destroy (GtkWidget*, gpointer);
static gboolean destroy_event (GtkWidget*, GdkEvent*, gpointer);

int main (int argc, char *argv[]) {
	GtkWidget *ventana;

	/* Declaraciones */
	GtkWidget *treeview, *scroll;
	GtkListStore *store;
	GtkTreeIter iter;
	guint i = 0;

	gtk_init (&argc, &argv);

	ventana = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_widget_set_size_request (ventana, 400, 200);
	gtk_window_set_title (GTK_WINDOW (ventana), "GtkListStore");

	/* Creamos el Widget */
	treeview = gtk_tree_view_new();
	setup_tree_view(treeview);

	/* Especificamos que tipos de datos almacenará el Widget */
	store = gtk_list_store_new (COLUMNAS, G_TYPE_STRING, G_TYPE_STRING);

	/* Especificamos que el Widget es un GtkListStore */
	gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
	g_object_unref (store);
	scroll = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

	/* Agregamos los datos */
	while (i != 6) {
		gtk_list_store_append (store, &iter);
		gtk_list_store_set (store, &iter, SOFTWARE, lista[i].software, LICENCIAS, lista[i].licencias, -1);
		i++;
	}

	gtk_container_add (GTK_CONTAINER (scroll), treeview);
	gtk_container_add (GTK_CONTAINER (ventana), scroll);

	g_signal_connect (G_OBJECT (ventana), "destroy", G_CALLBACK (destroy), NULL);
	g_signal_connect (G_OBJECT (ventana), "destroy_event", G_CALLBACK (destroy_event), NULL);

	gtk_widget_show_all (ventana);
	gtk_main ();

	return 0;
}

/* Agregamos dos columnas: Software y Licencia */
static void setup_tree_view (GtkWidget *treeview) {
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *columna;

	/* Columna 1 */
	renderer = gtk_cell_renderer_text_new();
	columna = gtk_tree_view_column_new_with_attributes("Software", renderer, "text", SOFTWARE, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), columna);

	/* Columna 2 */
	renderer = gtk_cell_renderer_text_new();
	columna = gtk_tree_view_column_new_with_attributes("Licencia", renderer, "text", LICENCIAS, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), columna);
}

static void destroy (GtkWidget *window, gpointer data) {
	gtk_main_quit ();
}

static gboolean destroy_event (GtkWidget *window, GdkEvent *event, gpointer data) {
	return FALSE;
}

$ gcc -Wall -g Lista.c -o Lista `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0`
$ ./Lista

Puedes encontrar más interfaces para utilizar este Widget en GtkListStore – GTK+ Reference Manual.

Un merge es una operación que combina dos arreglos ordenados en un tercer arreglo ordenado. Por ejemplo, teniendo dos arreglos ordenados 1, 4, 6, 10 y 2, 3, 5, 9 los combinamos y obtenemos el tercer arreglo ordenado 1, 2, 3, 4, 5, 6, 9, 10.

Esta combinación o mezcla es la clave del algoritmo Mergesort.

Análisis

Veamos como se combinan dos secuencias ordenadas utilizando el siguiente arreglo.

Comencemos dividiendo el arreglo a ordenar en dos arreglos ordenados como se muestra a continuación.

Vemos como los dos arreglos están ordenados, por lo que ahora los podemos combinar o mezclar.

Tomamos el primer elemento de los dos arreglos y los comparamos (10 y 5). Al ser menor 5 que 10 lo copiamos en el tercer arreglo.

Recorremos el segundo arreglo y ahora comparamos los valores 10 y 15. Copiamos el 10 por ser el menor.

Recorremos el primer arreglo y ahora comparamos los valores 23 y 15. Copiamos el 15 por ser menor.

Nuevamente recorremos el segundo arreglo y comparamos los valores 23 y 55. Copiamos el 23 por ser el menor.

Una vez más recorremos el primer arreglo y comparamos los valores 30 y 55. Nuevamente copiamos el menor.

Nuevamente recorremos el primer arreglo y comparamos 50 y 55. Bajamos el 50 por ser el menor.

Ya hemos copiado todos los elementos del primer arreglo, por lo que solo queda copiar los elementos restantes del segundo arreglo.

Esta combinación o mezcla es la clave de este algoritmo. No obstante, las mitades deben ordenarse primero. Para lograr esto, el algoritmo se basa en la estrategia divide y vencerás, por lo que implementa una función recursiva hasta dividir todo el arreglo en un solo elemento.

Antes de LINQ era necesario conocer tres herramientas: C#, SQL y el API de ADO .NET lo cual suele ser molesto. Con LINQ esta tarea se hace más sencilla.

Al programar con un lenguaje orientado a objetos es interesante hacer una consulta en la base de datos y cargar los resultados en objetos. LINQ soluciona el problema de mapeo relacional de objetos y simplifica la interacción entre objetos y las fuentes de datos.

Hola LINQ

Veamos dos ejemplos básicos en C# con Mono-Project. En el primer ejemplo consultamos una lista de palabras en un objeto llamado saludo que muestra el tradicional mensaje Hola Mundo!. El segundo ejemplo mostramos como crear una consulta que selecciona las palabras con un máximo de cinco caracteres, las ordena de forma ascendente y las enlista en la consola.

Primeramente debemos importar la librería Ling de la siguiente manera:

using System.Linq;

Ejemplo 1

using System;
using System.Linq;

namespace EjemploLinq
{
	class HolaLinq
	{
		[STAThread]
		public static void Main()
		{
			string[] palabras = {"Hola", "mundo", "!"};

			var saludo = from palabra in palabras select palabra;

			foreach (var palabra in saludo)
				Console.Write(palabra + " ");

			Console.WriteLine();
		}
	}
}

$ smcs HelloLinq.cs
$ mono HelloLinq.exe
Hola mundo !

Ejemplo 2

using System;
using System.Linq;

namespace EjemploLinq
{
	class HolaLinq2
	{
		[STAThread]
		public static void Main()
		{
			string[] palabras = {"programación", "linux", "unix", "mac os x",
						"concurrencia", "abstracción", "mono", "blog",
						"polmorfismo", "herencia", "código", "gnu"};

			var lista = from palabra in palabras
			where palabra.Length <= 5
			orderby palabra ascending
			select palabra;

			foreach (var palabra in lista)
				Console.WriteLine(palabra);
		}
	}
}

$ smcs HelloLinq2.cs
$ mono HelloLinq2.exe
blog
gnu
linux
mono
unix

Recomiendo dominar el método de Ordenación por Inserción.

Análisis

Ordenemos el siguiente grupo de 16 elementos que se muestran a continuación.

Los elementos de cada subconjunto se determinan poniendo un valor de intervalo entre los subíndices de cada grupo.

En este ejemplo utilizaremos un intervalo de 7 elementos.

Nuestro primer subconjunto cuenta con tres elementos (95, 20 y 16) que se ordenan con el método de inserción.

Ahora obtenemos los siguientes tres elementos del segundo subconjunto (25, 54 y 80). Nota que los tres elementos del primer subconjunto ya están ordenados.

El segundo subconjunto esta ordenado por lo que no hay intercambio.

Ahora obtenemos el tercer subconjunto; a partir de el tercer subconjunto todos los subconjuntos tendrán dos elementos.

Nuevamente los elementos del tercer subconjunto se ordenan con el método de inserción. Estas acciones se repiten con todos los subconjuntos y al final el conjunto queda de la siguiente manera:

Ahora vamos a recorrer de nuevo todo el conjunto, pero usaremos un intervalo de 3. Solo habrá tres subconjuntos, el primero con seis valores (16, 60, 68, 83, 63 y 80), el segundo subconjunto tiene los valores () y el tercer subconjunto tiene ().

Al final obtenemos el siguiente conjunto semiordenado.

Finalmente utilizamos un intervalos de 1; en otras palabras, utilizamos el ordenamiento por inserción en todo el conjunto.

Código de la función

Nuestra función queda de la siguiente manera.

void shell(int array[], int size)
{
	int i, j, intervalo, temp;

	intervalo = size/2;

	while (intervalo > 0) {
		for (i=intervalo; i < size; i++) {
			j = i;
			temp = array[i];
			while ((j >= intervalo) && (array[j - intervalo] > temp)) {
				array[j] = array[j - intervalo];
				j = j - intervalo;
			}
			array[j] = temp;
		}

	intervalo /= 2;
	}
}

Código completo

Ahora probemos la función con un arreglo.

#include <iostream>

using namespace std;

void shell(int array[], int size)
{
	int i, j, intervalo, temp;

	intervalo = size/2;

	while (intervalo > 0) {
		for (i=intervalo; i < size; i++) {
			j = i;
			temp = array[i];
			while ((j >= intervalo) && (array[j - intervalo] > temp)) {
				array[j] = array[j - intervalo];
				j = j - intervalo;
			}
			array[j] = temp;
		}

	intervalo /= 2;
	}
}

int main (int argc, char *argv[])
{
	int numeros[] = {95, 25, 83, 97, 71, 18, 68, 20, 54, 40, 60, 27, 63, 96, 16, 80};

	/* Imprimimos el arreglo original */
	for (int i = 0; i < 16; ++i) {
		cout << numeros[i] << " ";
	}

	cout << endl;

	shell(numeros, 16);

	/* Imprimimos el arreglo ordenado */
	for (int i = 0; i < 16; ++i){
		cout << numeros[i] << " ";
	}

	cout << endl;
}

$ g++ -o ShellSort ShellSort.cpp
$ ./ShellSort
95 25 83 97 71 18 68 20 54 40 60 27 63 96 16 80
16 18 20 25 27 40 54 60 63 68 71 80 83 95 96 97

Para evitar esto, es necesario hacer diferentes pruebas, pero no creo que importe cuantas de ellas se hagan, en algún momento el sistema necesitará revisiones.

Entre los errores de programación encontraremos: Errores de sintaxis, Errores de ejecución y Errores lógicos.

Errores de sintaxis

Los errores de sintaxis son los primeros errores con los que nos encontraremos, ya que se presentan cuando no se usa correctamente la gramática del lenguaje de programación.

Un ejemplo claro es el omitir el cierre del bloque de código con ‘}’ en el caso de los lenguajes de programación que ocupan las laves.

Pero existe la ventaja de que todos los compiladores actuales dan un aviso de error en el momento de invocarlos y no permitirán la compilación hasta que se corrijan todos los errores de sintaxis.

Entre los errores más comunes encontramos:

• No declarar e iniciar una variable.
• Repetir la declaración de alguna variable.
• Omitir las llaves que engloban los bloques de código.
• No devolver algún valor a las funciones (NO procedimientos).
• Escribir mal el nombre de alguna variable, función o procedimientos.

Errores en tiempo de ejecución

Los errores en tiempo de ejecución se presentan cuando el programa esta en marcha. Estos errores provocan que el sistema operativo o la biblioteca que se utilizo para su desarrollo envíe un mensaje de error y detenga su ejecución.

Para evitar estos errores se deben programar excepciones. Las excepciones capturan el error y permiten ejecutar otras instrucciones alternas para que el programa siga su ejecución.

Los errores más comunes son:

• División entre cero.
• Índice de arreglos fuera de los límites.

Errores lógicos

Los errores lógicos se presentan cuando el analista ha cometido un error en el diseño de alguna función o cuando ejecuta un algoritmo de forma incorrecta.

Estos errores se hacen visibles al finalizar la ejecución del programa puesto que los resultados son incorrectos. Por lo tanto, si el programador no conoce el resultado correcto será difícil de encontrar.

Para encontrarlos y corregirlos es necesario tener casos de prueba para comparar los resultados.

En otras palabras, la minería de datos busca el conocimiento en las bases de datos.

Aplicaciones de la minería de datos

La información encontrada tiene muchas aplicaciones. Un ejemplo claro es el PageRank de Google. Podemos encontrar algunas aplicaciones en Wikipedia.

Google PageRank

¿Recuerdas como eran los buscadores antes de Google?. Para encontrar la información que requeríamos era necesario navegar entre las páginas de un directorio; si no sabíamos como buscar un libro en la biblioteca entonces no sabíamos buscar en Internet.

Página principal de Yahoo! en 1995, ¿La recuerdas?

Los chicos de Google (Larry Page y Sergey Brin), en la Universidad de Stanford se dedicaron a descargar páginas web y almacenarlas en una base de datos. En poco tiempo se dieron cuenta de que necesitaban una gran computadora ya que la cantidad de paginas almacenadas era enorme.

Una vez que tuvieron esa gran base de datos pusieron en práctica la minería de datos y encontraron un patrón. Con dicho patrón de datos se dieron cuenta de que hay cierto numero de sitios web que enlazan a un sitio web.

En la siguiente figura podemos ver como existen muchos sitios web que enlazan al sitio web B.

Imagen obtenida en {link:http://es.wikipedia.org/wiki/PageRank}Wikipedia{/link}

Ellos analizaron esa información y esas páginas que recibían muchos enlaces y se dieron cuenta de que dichas páginas contenían la información que el usuario buscaba. Y en base a esto diseñaron el algoritmo para generar el valor que actualmente se le conoce como PageRank.

Una vez programado el algoritmo lo pusieron a prueba y se dieron cuenta de que mostraba resultados relevantes.

Y esto fue gracias a la minería de datos.

Teniendo un conjunto de números ordenados, sabemos que la media es el valor que deja el mismo número de datos antes y después que él.

Análisis

Considerando el siguiente conjunto de números enteros y positivos:

Determinamos que el valor máximo es 703; el valor mínimo es 2 y la media es 10.

Solución

Máximo

Para obtener el valor máximo del conjunto, es necesario recorrer todo el arreglo y comparar sus elementos y asignar el valor más grande a la variable m.

int maximo (int conjunto[], int size) {
	int m = 0;

	for (int i = 1; i < size; i++) {
		if (conjunto[i] > conjunto[m]) {
			m = i;
		}
	}

	return conjunto[m];
}

Mínimo

Para determinar el valor mínimo solo tenemos que cambiar el signo > por <.

int minimo(int conjunto[], int size) {
	int m = 0;

	for (int i = 1; i < size; i++) {
		if (conjunto[i] < conjunto[m])
			m = i;
	}

	return conjunto[m];
}

Media

La mediana es el valor de la variable que deja el mismo número de datos antes y después que él estando los datos ordenados.

int media (int conjunto[], int size) {
	int i = 0;
	int j = 0;
	int m = 0;
	int count = 0;

	for (; (j < size) && (count != size/2); j++) {
		count = 0;
		m = j;

		for (i = 0; i < size; i++) {
			if (conjunto[i] > conjunto[m])
				count++;
		}
	}

	return conjunto[m];
}

Código completo

#include <iostream>

using namespace std;

int minimo(int conjunto[], int size) {
	int m = 0;

	for (int i = 1; i < size; i++) {
		if (conjunto[i] < conjunto[m])
			m = i;
	}

	return conjunto[m];
}

int maximo (int conjunto[], int size) {
	int m = 0;

	for (int i = 1; i < size; i++) {
		if (conjunto[i] > conjunto[m]) {
			m = i;
		}
	}

	return conjunto[m];
}

int media (int conjunto[], int size) {
	int i = 0;
	int j = 0;
	int m = 0;
	int count = 0;

	for (; (j < size) && (count != size/2); j++) {
		count = 0;
		m = j;

		for (i = 0; i < size; i++) {
			if (conjunto[i] > conjunto[m])
				count++;
		}
	}

	return conjunto[m];
}

int main (int argc, char *argv[])
{
	int conjunto[] = {33,703,4,11,2,8,20,10};

	cout << minimo(conjunto, 8) << endl;
	cout << maximo(conjunto, 8) << endl;
	cout << media(conjunto, 8) << endl;
}

$ g++ -o Conjunto Conjunto.cpp
$ ./Conjunto
2
703
10