#include <stdio.h>
#include <stdlib.h>
 
int main (void){
 
        char *s;
        s=(char *) malloc (3);
 
        s[0]='1';
        s[1]='2';
        s[2]='3';
 
 
        printf ("%s\n",s);
 
        return 0;
}
 

#include <stdio.h>
 
int main (void){
 
        char s[3];
 
        char s[0]='1';
        char s[1]='2';
        char s[2]='3';
 
        printf ("%s\n",s);
 
}
 

char *s="aloja"; char s[]="aloja"; 

fac 0 = 1
fac n = n * fac (n-1)
 
replicate' 0 n = [n]
replicate' x n = n:replicate (x-1) n
 
take' 0 xs = []
take' n [] = []
take' 1 xs = [head xs]
take' n xs = head xs:take (n-1) (tail xs)
 
reverse' [] = []
reverse' (x:xs)=last (x:xs):reverse'(init (x:xs))
 
haycero [] = False
haycero (x:xs) = (x==0) || haycero (xs)
 
todosceros [] = error "No está definido para una lista vacía"
todosceros [x] = (x==0)
todosceros (x':x:xs) = (x'==0) && todosceros(x:xs)
 
 
maximo n x = if (n>x) then n else x
minimo n x = if (n>x) then x else n
 
maximo' n x
  | n>=x = n
  | n<x = x
 
zip' xs []         = []
zip' [] ys         = []
zip' (x:xs) (y:ys) = [(x,y)]  ++  zip' xs ys
 
zip'' xs [] = []
zip'' [] ys = []
zip'' (x:xs) (y:ys) = (x,y) : zip'' xs ys
 
nth [] n = error "No está definida para lista vacía"
nth xs n = if (length xs > n) then xs !! n else error "No se puede acceder a esa posición ya que no existe"
 
 
 
{-
Comprueba si un elemento dado está en la lista
-}
 
elem' n []     = False
elem' n (x:xs) = (n==x) || elem' n xs
 
{-
ANALISIS POR CASOS
-}
 
elem'':: Eq a => a -> [a] -> Bool
elem'' n xs
  | length xs==0  = False
  | otherwise     = (n==head xs) || elem'' n (tail xs)
 
{-
quicksort [10,2,5,3,1,6,7,4,2,3,4,8,9] = [1,2,2,3,3,4,4,5,6,7,8,9,10]
-}
 
 
{-
zip [] []= []
zip [2] [5] = [(2,5)] ++ zip [] []
zip [1,2] [4,5] = [(1,4)] ++ zip[2][5]
-}
 
length' [] = 0
length' (x:xs) = 1 + length' xs
 
{-
repeat' 0
repeat'
-}
 
map' f [] = []
map' f (x:xs) = f x : map' f xs
 
tail' [] = []
tail' (x:xs) = xs
 
{-
filter (>3) [1,2,3,4,10,10,10,20,20,20] = [4,10,10,10,...]
-}
 
sumatoria [] = 0
sumatoria (x:xs) = x+sumatoria xs
 
multiplicar [] = 1
multiplicar (x:xs) = x*multiplicar xs
 
sumatoria' xs
  | length (xs) == 0 = 0
  | otherwise = head xs+sumatoria' (tail xs)
 
multidos [] = []
multidos (x:xs) = 2*x : multidos xs
 
multiPor n [] = []
multiPor n (x:xs) = n*x : multiPor n xs
 
h [] = [1]
h (x:xs) = (x+1) : h xs
 
test [] = []
test (5:[]) = error "Tu lista empieza por 5"
 
h' [] = [1]
h' (x:xs) = [(x+1)] ++ h xs
 
g 0 = error "El numero es cero"
g n = error "El numero no es cero"
 
multiplicar' xs
 | length xs == 0 = 1
 | length xs /= 0 = head xs*multiplicar'(tail xs)
 
 
filter' f [] = []
filter' f (x:xs)
      | f x =  x:filter' f xs
      | otherwise = filter' f xs

#include <stdio.h>
 
int main (void){
 
  int a,c;
  a=c=3;
 
  while ((a=c=getchar()) == '1');
 
  printf ("c:%c\n",c);
  printf ("a:%c\n",a);
 
  return 0;
}

[dresuer@emachine TRABAJILLO]$ echo '3' | ./TEST
c:3
a:3
[dresuer@emachine TRABAJILLO]$ echo '1' | ./TEST
c:

a:

[dresuer@emachine TRABAJILLO]$ 

/*
Escribir un programa que lea enteros y los almacene en un arreglo
sin conocer de antemano la cantidad de valores que se leerán. 
El programa deberá completar el arreglo hasta que se ingrese un número negativo, 
valor que no se agregará a la mencionada estructura de datos. Finalmente deberá imprimir 
el promedio de los elementos del arreglo.
*/
 
#include <stdio.h>
#include <stdlib.h>
 
 
int main (void){
	int a,promedio;
	int i;
	int *AR=malloc (1*sizeof(int));
	int *tmp_AR;
 
	i=promedio=0;
	printf ("Number no negative: \n");
	scanf ("%d",&AR[i]);
	while (AR[i]>=0) {
		promedio+=AR[i];
		scanf ("%d",&AR[i]);
 
		tmp_AR=realloc(AR,(1+i)*sizeof(int));
		if (tmp_AR == NULL){
			// Falló la asignación de memoria.
			exit (-1);
		}
		else {  
			// Asignar memoria a AR
			AR=tmp_AR; 
		}
		i++;
	}
 
	printf ("Average: %f\n",(double)promedio);
 
 
 
 
	return 0;
}

/*Escribir un programa que defina el tipo Persona, con nombre, edad y nacionalidad; solicite al 
usuario el ingreso de los datos de 8 personas y los guarde en un arreglo con elementos de tipo Persona,
 para finalmente extraer del arreglo los datos de la persona más joven e imprimirlos en pantalla. 
Sugerencia: para probar el programa rápidamente se pueden guardar datos de personas 
en un archivo de texto y redirigir el contenido del mismo, usando la consola de Linux, al binario del programa.*/

#include <stdio.h>
 
void imprimir_dir(int x) {
 
	printf("La direccion de memoria de a es: %p.\n", (void*) &x);
}
 
int main(void) {
	int n;
 
	printf("Introduzca un valor entero: ");
	scanf("%d", &n);
 
	printf("La direccion de memoria de a es: %p.\n", (void*) &n);
 
	imprimir_dir(n);
	return 0;
}
 

/*
Definir una simple función imprimir_dir(int x) cuyo único propósito sea imprimir la dirección del entero 
x que se le pasa. Crear una variable entera en main, imprimir su dirección ahí mismo y 
luego pasar la variable a imprimir_dir. Comparar los resultados. ¿Es el comportamiento esperado?
*/
 
#include <stdio.h>
 
void imprimir_dir(int x){
 
	printf ("%p\n",&x);
 
}
 
int main (void){
	int a;
	a=20;
	printf ("%p\n",&a);
 
	imprimir_dir(a);
 
	return 0;
}