Un ejemplo de una función que toma punteros como parámetros

void swap( int *px, int *py) {
	int temp;

	temp = *px;

	*px = *py;

	*py = temp;
}

	swap(&x, &y);

	printf("\n");
	printf("%d %d\n", x, y);
	//Imprime 1, 0

....
test1(&x, &y);
....

void test1( int *px, int *py) {
	//Imprime 1 0
	printf("%d %d\n", *px, *py);
	//Imprime la dirección de x y casteada a Int
	printf("%d %d\n", px, py);
}

Arreglos, Punteros y aritmética de punteros

#include 

int main() {
	int a[10], x;
	int *pa;
	//Relleno el array a con [0-9]
	for( x=0; x<10; x++ ) {
		a[x] = x;
		printf(”%d\n”, a[x]);
	}

	pa = &a[0];
	//pa es ahora un puntero que apunta a la primer dirección del arreglo

	printf(”%d %d\n”, a[7], *(pa+7) );
	//Imprime 7 7.. porque luego de pa= &a[0], a[i] es igual a *(pa + i)
}

Punteros y funciones

//Toma como parámetro 2 punteros a char
int strlen( char *s, char *t) {
	while((*s++ = *t++) != '\0');
}
....

//Función que devuelve un apuntador a int
int *f();

Referencias

Macros con Variables

#include <stdio.h>
#define max(A, B) ((A) > (B) ? (A):(B))
int main() {
	int x = 20;
	int y = 10;
	int z;

	//Gets transformed to z = ((x + y) > (y - 10) ? (x + y):(y - 10));
	z = max(x + y, x - 10);
	//prints 30
	printf("%d\n", z);

	//Gets transformed to z = ((++x) > (++y) ? (++x):(++y);
	z = max( ++x, ++y);
	// ++ is doubly evaluated
	//So x and y are doubly incremented
	//prints 22
	printf("%d\n", z);

}

Cuidado con comerse los parentesis y los efectos secundarios que se pueden causar

#include <stdio.h>
#define square(x) x * x
#define square_works(x) (x) * (x);

int main() {
	int x = 20;
	int y = 10;
	int z;

	//Gets transformed to z = x + y * x + y
	//And because of precedence order is z = x + (y * x) + y
	z = square(x + y);
	//prints 230
	printf("%d\n", z);

	//Gets transformed to z = (x + y) * (x + y)
	z = square_works(x + y);
	//prints 900
	printf("%d\n", z);

}

#if SYSTEM_BITS == 64
	#define MAX_SIZE = 2^63
#elif
	#define MAX_SIZE = 2^31
#endif

Referencias

Variables Automáticas

int main() {
	double i;
	.......
	my_function();
	....
}
int my_function() {
	int i = 15;
	......
}

Variables Globales

#include <stdio.h>
int i = 0;
int main() {
	printf("%d ", i);
	i++;
	my_function();
	printf("%d ", i);
}
int my_function() {
	printf("%d ", i);
	i = 15;
}

0 1 15

Variables Externas

Archivo vars-1.c

int i = 15;

Archivo vars-2.c

#include <stdio.h>
extern int i; 

int main() {
	printf("%d ", i);
	i++;
	printf("%d ", i);
	return 1;
}

Archivo vars.h

Archivo vars-1.c

int i = 15;
char ch = 'a';

Archivo vars-2.c

#include <stdio.h>
#include "vars.h"
extern int i; 

int main() {
	printf("%d ", i);
	i++;
	printf("%d ", i);
	my_function();
	return 1;
}
void my_function(){
	extern char ch;
	printf("%c ", ch);
}

Variables Estáticas

#include <stdio.h>
void my_function( int a );
int main() {
	my_function(0);
	printf("\n");
	my_function( 10 );
}
void my_function( int a ) {
	static int i;
	int b = 10;
	i += a;
	printf("| %d - %d |\t", i);
	i++;
	b++;
	if( i < 5 ) my_function( 0 );
}

| 0 - 10 |	| 1 - 10 |	| 2 - 10 |	| 3 - 10 |	| 4 - 10 |
| 15 - 10 |

Algunas conclusiones

Algunos agregados más

int primos[] = { 2 , 3 , 5 , 7, 11 , 13 }

Referencias

Operaciones & , | , ~ y ^

& ( conjunción Lógica o multiplicación Booleana a nivel del bit )

Sean a, b dos cadenas de bits del mismo tamaño ( por ejemplo integer ). La operación a & b realiza una operación de Conjunción Lógica sobre cada uno de los bits de ambas cadenas, devolviendo una nueva cadena de bits de tamaño equivalente a a,b con un 1 en la posición donde tanto a como b tenian un 1 y un 0 en cualquier otro caso. Ej:

a     = 10010101 
b     = 00110100
a & b = 00010100

| ( disyunción Lógica o suma Booleana a nivel del bit )

La operación a | b devuelve un 1 en la posición donde a o b ( o ambos ) tienen un 1 y un 0 cuando ambas tienen cero. Ej:

a     = 10010101 
b     = 00110100
a | b = 10110101

~ ( negación Lógica a nivel del bit )

Sea a una cadena de bits. La operación ~a invierte los 1s y 0s de a. Ej:

a  = 10010101 
~a = 01101010

^ ( Disyunción exclusiva Lógica a nivel del bit )

La operación a ^ b devuelve un 1 en la posición donde a o b ( pero no ambos ) tienen un 1 y un 0 cuando ambas tienen 0 o ambas tienen 1. Ej:

a     = 10010101 
b     = 00110100
a ^ b = 10100001

Operaciones << y >>

Operación <<

Sea a una cadena de bits, n un entero, a << n, devuelve la misma cádena movida n bits a la izquierda ( perdiendose los primeros n bits de la cadena ) y reemplazando las n posiciones a la derecha por 0. Ej:

a      = 10010101 
a << 2 = 01010100

Operación >>

Sea a una cadena de bits, n un entero, a >> n, devuelve la misma cadena movida n bits a la derecha ( perdiéndose los últimos n bits de la cadena ) y reemplazando las n posiciones a la izquierda por 0. Ej:

a      = 10010101 
a >> 3 = 00010010

Algunos Usos y Ejemplos

Multiplicación por 2ⁿ

Por propiedades de los números binarios, se cumple que agregando n 0s a la derecha es equivalente a multiplicar este mismo número por 2ⁿ. Ej:

int function multiplicar_por_exponente_de_2( int a, int power ) {
	return a << power;
}

Nota: Hay que cuidar el overflow de los datos considerando el tamaño de ints en nuestro sistema. Pero este no es un post sobre implementaciones de C.

Cociente de dividir por 2ⁿ

int function cociente_de_exponente_de_2( int a, int power ) {
	return a >> power;
}

Nota: Desde ya que esta función devuelve el cociente pero no el resto.

Cociente y resto de dividir por 2ⁿ

unsigned int a, cociente, resto;
a = 757;
cociente = a >> 3;
resto =  (~((~0) << 3)) & a

Nota: ~0 devuelve un int del tamaño del sistema con todos sus bits pasados a 1, al moverlo 3 posiciones a la izquierda se tiene todos 1s salvo los 3 últimos bits, al negar esto se obtiene todos 0s salvo los 3 últimos bits que nos sirven para obtener los valores que son el resto de la división.

Representación en cadena binaria de un número

void show_as_binary( int a, char str[]) {
	int x, size;
	size = (int)sizeof(b) * 8;
	for(x=0; x<size; x++) {

		//This is necesary for a%2 might return -1 if a < 0. 
		str[x] = ‘0′ + ((a%2) < 0 ? 1: (a%2) );
		a = a >> 1;
	}
	reverse(str);
}

Representación en Octal de un número

void show_as_octal( int a, char str[]) {
	int x, size;
	size = (int)sizeof(b) * 8;
	for(x=0; x<size && a!=0; x++) {
		str[ x ] = ‘0′ + (a%8);
		a = a >> 3;
	}
	str[ x ] = ‘0′;
	reverse(str, (x+1));	

} 

Uso de un int para múltiples flags

Es una práctica común en Unix usar ints para pasar múltiples flags a funciones. Supongamos que necesito 4 flags distintos para una función o para lo que sea. Lo que puedo hacer es lo siguiente:

#define FLAG_A 1;
#define FLAG_B 2;
#define FLAG_C 4;
#define FLAG_D 8;

//Llamar a la función con FLAG_A y FLAG_D
call_function( FLAG_A | FLAG_D );

//Comparar si una variable tiene FLAG_B seteado
if( ( a & FLAG_B ) == FLAG_B ) { ...

//Comparar si una variable no tiene FLAG_C seteado
if( ( ( a | FLAG_C ) != a ) { ... 

Lo interesante de esto es que al abstraernos de los ints y pensarlos como cadenas de bits, se pueden hacer operaciones de algebra de boole, donde cada bit toma un valor verdadero o falso, que nos sirve para evaluar colecciones de flags como colecciones de proposiciones booleanas. Ahorrándonos así de pasar un valor como argumento a la función para cada una. Ej:

//Comparar contra FLAG_A, FLAG_B y no FLAG_D
if ( ( ( a & (FLAG_A | FLAG_B) ) == ( FLAG_A | FLAG_B ) ) && ( ( a | FLAG_D ) != a ) ) { ...

Un ejemplo concreto es el uso de los permisos de archivos en linux.

chmod toma un valor en octal que puede representarse así:

0012 = 18 = x

0102 = 28 = w

1002 = 48 = r

De donde surgen sus relativas combinaciones, por ej:

0112 = 38 = wx

1102 = 68 = rw

1112 = 78 = rwx

Bonús. Ejercicios 2.6, 2.7 y 2.8 de K & R

Ej 2.6

Escriba una función setbits( x,p,n,y ) que regresa x con los n bits que principian en la posición p iguales a los n bits más a la derecha de y, dejando los otros bits sin cambio.

//Ej 2.6
unsigned setbits(unsigned x, int p, int n, int y) {
	unsigned t, z;
	if(y < n) { 
		perror("Error");
	} else {
		//All 0s except for the space that starts at y and has size n
		t = ~(~0<<n)<<(y-n);
		//Get the value of x in this position
		t = x & t;
		//move the distance that p has from y
		t = t << (p-y);
		//Set that same space to 0s in x, starting on p and with size n
		z = ~(~0<<n)<<(p-n);		
		x = x & (~ z);
		//merge them
		t = x | t;
	}
	return t;
}

Ej 2.7

Escriba una función invert( x,p,n ) que regresa x con los n bits que principian en la posición p invertidos, dejando los otros sin cambio.

//Ej 2.7
unsigned invert(unsigned x, int p, int n) {
	unsigned t, z;
	//All 0s except for the space that starts at p and has size n
	t = ~(~0<<n)<<(p-n);
	//Get the inverted value of x in this position
	z = (~x & t);
	//merge them (first clean up x in the space that starts at p and has size n then merge with z)
	t = (~t & x) | z;
	return t;
}

Ej 2.8

Escriba una función rightrot( x,n ) que regresa x rotado a la derecha n posiciones de bits.

//Ej 2.8
unsigned rightrot( unsigned a, int n) {
	unsigned t, mascara, x;
	t = 0;
	mascara = 1;
	for(x=0; x<n; x++) {
		t = t << 1;
		t = t | (mascara & a);
		a = a >> 1;
	}
	return t;
}

Demostración

Llamemos B al conjunto { x ∈ A | x ∉ x }. Supongamos que B ∈ A y consideremos a B con respecto a si mismo desde la relación ∈, o bien B ∈ B o bien B∉ B.

Supongamos que B ∈ B entonces por la propia definición de B, B ∉ B, lo cual es una contradicción. Ahora si B ∉ B también por la definición de B sigue que B ∈ B, lo cual también es una contradicción.

Dado que nuestra premisa original nos lleva siempre a una contradicción, debe ser falsa, por consiguiente B ∉ A.

Es interesante también como este ejercicio sirve de introducción a los tipos y clases de Haskell.

Conjunto: Colección de Objetos. A, B, C..
Elemento: Objeto dentro de un conjunto. a, b, c.
Representación por extensión.
A = {a, b, c, d}
Representación por comprensión.
A = {x | x < 10 ∧ x > -100}
A = {x | Φ(x) }
∈ pertenece a, es elemento de

∪ Union
A ∪ B = {x | x ∈ A ∨ x ∈ B}
∩ Intersección
A ∩ B = {x | x ∈ A ∧ x ∈ B}
A^c Complemento
A^c = {x | x ∉ A}

Equivalencias Basicas

Doble negación
A = (A^c)^c

Idempotencia
A ∪ A = A
A ∩ A = A

De morgan
(A ∪ B)^c = (A^c ∪ B^c)
(A ∩ B)^c = (A^c ∩ B^c)

Conmutativa
(A ∪ B) = (B ∪ A)
(A ∩ B) = (B ∩ A)

Asociativa
(A ∪ B) ∪ C = A ∪ (B ∪ C)
(A ∩ B) ∩ C = A ∩ (B ∩ C)

Distributiva
A ∩ (B ∪ C) = (A ∪ B) ∩ (A ∪ C)
A ∪ (B ∩ C) = (A ∩ B) ∪ (A ∩ C)

Absorción
A ∩ (A ∪ B) = A
A ∪ (A ∩ B) = A

Universo, Conjunto Vacio

U Universo
∅ Conjunto Vacio

∅^c = U
U^c = ∅

Dominancia
U ∪ A = U
∅ ∩ A = ∅

Identidad
U ∩ A = A
∅ ∪ A = A

Ley del medio excluido
A ∪ A^c = U

Contradicción
A ∩ A^c = ∅

Inclusión, Inclusión estricta, Equivalencia, Resta, Diferencia simetrica

Definiciones

⊆ Inclusión
A ⊆ B = {x | x ∈ A => x ∈ B}
⊂ Inclusión Estricta
A ⊂ B <=> ∀x (x ∈ A => x ∈ B) ∧ ∃y (y ∈ B ∧ y ∉ A)
= Equivalencia
A = B <=> A ⊆ B ∧ B ⊆ A
- Resta
A - B = {x | x ∈ A ∧ x ∉ B}
Δ Diferencia Simetrica
A Δ B = {x | x ∈ A ∨ x ∈ B ∧ ¬ (x ∈ A ∧ x ∈ B) } = A ∪ B -(A ∩ B)

A, B son Disjuntos <=> A ∩ B = ∅

A^c = U - A

Conjunto de Partes y Familias de Conjuntos

Definiciónes

P(A) Conjunto de Partes
X ∈ P(A) <=> X ⊆ A
P(A) = {X | X ⊆ A}

Nota: ∀A( {∅} ∈ P(A) )

F, G Se usan para representar Familias de Conjuntos o o Colecciones de Conjuntos
∪F = ∀x ( ∃y ( y ∈ F ∧ x ∈ y ) )
∩F = ∀x ( ∀y ( y ∈ F -> x ∈ y ) )

Referencias

The Haskell Road To Logic, Math and Programming; Doets, Van Eijck; King´s College London Publications; 2004

How to Prove It: A Structured Approach; Velleman, Daniel; Cambridge University Press; 2006

En uno de los ejercicios se nos pide hacer una función reverse que tome una cadena y la devuelva invertida. Mi solución rapida fue:

void reverse(char line[], int n) {
	int temp, i, j, t ;
	if( (n/2) == ((n+1)/2) ) {
		t = -1 ;
	} else {
		t = 0 ;
	} 

	j = (n/2) ;
	for(i=0 ; i < j ; i++) {
		temp = line[i] ;
		line[i] = line[ (j*2)-i+t ] ;
		line[ (j*2)-i+t ] = temp ;
	}
	line[ n ] = ‘\0′ ;
}

Pero en el cápitulo 3 dan la forma de codificarlo de los autores:

void reverse( char s[] ) {
	int c, i, j;
	for( i = 0, j = strlen(s)-1 ; i < j ; i++, j– ) {
		c = s[i] ;
		s[i] = s[j] ;
		s[j] = c ;
	}
}

Me encanto como esta estructurado el loop, por el simple hecho de que no tengo la costumbre de hacer una doble inicialización y mucho menos un incremento y un decremento simultáneos en la tercera expresión del for. El código es super elegante y ahorra el problema y el exceso de código que tuve que poner en mi versión por si el tamaño de la cadena era impar o par.

Por que no es buena práctica usar breaks en un loop.

Además me di cuenta de lo siguiente, es una frase hecha que no es buena práctica usar breaks en un loop, el tema es que en realidad generalmente no es necesario ( salvo en casos especiales donde se necesita ejecutar algunas lineas de código antes de evaluar la condición del break ). Supongamos el siguiente codigo:

for( x=0 ; x < n ; x++) {
	......
	.....
	if( condicion_de_break ) break ;
}

Se puede resolver más elegantemente de la siguiente forma:

for( x=0 ; x < n && !condicion_de_break ; x++) {
	......
	.....
}

Teorema: Existen 2 números Irracionales a,b tales que a^b es racional.

Demostración: O ${\left(\sqrt{2}\right)}^{\sqrt{2}}$es racional o es irracional.

Caso 1: Si es racional, ya se probo lo que queríamos probar porque $\sqrt{2}$es irracional y tomamos a=b=$\sqrt{2}$ .

Caso 2: Si es irracional entonces sea a = ${\left(\sqrt{2}\right)}^{\sqrt{2}}$y b = $\sqrt{2}$. Entonces podemos formar el numero ${\left({\left(\sqrt{2}\right)}^{\sqrt{2}}\right)}^{\sqrt{2}}$ = ${\left(\sqrt{2}\right)}^{\sqrt{2}.\sqrt{2}}$= ${\left(\sqrt{2}\right)}^2=2$. Como $\sqrt{2}$es irracional, ${\left(\sqrt{2}\right)}^{\sqrt{2}}$es irracional por asumción de caso y 2 es racional, el Teorema queda demostrado.

Lo maravilloso es que llegamos a una demostración rigurosa del teorema sin necesidad de saber si  ${\left(\sqrt{2}\right)}^{\sqrt{2}}$es irracional o no. Simplemente por exhaustación de casos el teorema queda demostrado.
Nota: es irracional, lo que igual no quita lo maravilloso de la demostración y lo impecable de su lógica.

Σ : alfabeto, Conjunto finito, no vacio de símbolos.

Cadena: sucesión de símbolos concatenados.

Σ¹ = Σ

Σⁿ⁺¹ = { xy / x ∈ Σ, y ∈ Σⁿ } ; donde x, y son cadenas formadas por símbolos de Σ.
Aclaración: en este caso x representa una cadena formada por un solo símbolo de Σ.

Ejs:
Σ = {a,b,c} => Σ² = {aa, ab, ac, ba, bb, bc, ca, cb, cc }
aab ∈ Σ³

Cardinalidad de un Alfabeto

| Σ | = 3  => | Σ²| = 3²

Generalizando:

| Σ | = t  => | Σⁿ| = tⁿ

Cadena Vacia

λ: Cadena o palabra vacia. Elemento neutro para la concatenación de cadenas.

Importante: ∀Σ:  Σ⁰= { λ }

Conjunto infinito de todas las cadenas que pueden formarse con un alfabeto

Σ^* = $\underset{n=0}{\bigcup ^{\infty }}\Sigma { }^n$  
| Σ | = ∞

Cadenas y Concatenación

Se puede definir una cadena W sobre el alfabeto Σ como: W = x₁x₂…..x_n ; x_i ∈ Σ

Longitud de una cadena

|| w || = n

Concatenación

Sean:
X = x₁x₂…..x_n ; x_i ∈ Σ
Y = y₁y₂…..y_m ; y_i ∈ Σ
=>
XY = x₁x₂…..x_ny₁y₂…..y_m; ∧ XY ∈ Σ^{n + m}

Propiedades de la Concatenación

1. Cerrada sobre si misma (Ley de Composición Interna)
Σ^* -> Σ^* : Σ^*

2. Asociativa
X(YZ) = (XY)Z

3. No Conmutativa
XY ≠ YX

Longitud de una Concatenación

|| XY || = || X || + || Y ||; ∀ X, Y ∈ Σ^*

Potencias de una cadena

∀ X ∈ Σ^*:
X⁰ = λ
X¹ = X
X² = XX
Xⁿ = XX^{n - 1}
|| Xⁿ|| = n . || X ||

Prefijos, Sufijos

sea W ∈ Σ^* ∧ W = XY entonces X es prefijo de W, Y es sufijo de W.
Si adémas:
Y ≠ λ => X es prefijo propio de W
X ≠ λ => Y es prefijo propio de W  

Subcadenas

sea W ∈ Σ^* ∧ W = XZY entonces Z es subcadena de W.

Lenguajes

Sea Σ ≠ φ, L ⊆ Σ^* es un lenguaje sobre Σ

Importante: φ ⊂ Σ . φ es un lenguaje, llamado lenguaje Vacio.

Gramática

G = (V, T, S, P) es una gramática donde:
V  es un Alfabeto
T ⊂ V, son los elementos terminales
S ⊂ V, es el Start Symbol. O Simbolo de Comienzo.
P, son las reglas de Producción.

Lenguaje generado por una gramática

Todas las cadenas de elementos pertenecientes a T, que pueden formarse a partir de las reglas de Producción P. Se lo suele representar com L_{( G )} .

Ejemplos

1) L = { 1111ⁿ0ⁿ / n ∈ N}. Lenguaje formado por todas las cadenas con prefijo 111 y luego una suseción de 10.

G = ( V,T,S₀,P )
V = {1,0,S}
T = {1,0}
S₀ = S
P:
S -> S10
S -> 111S

2) L = Lenguaje formado por todas las cadenas con prefijo 111 y luego  al menos un 1 o un 0 y luego una sucesión de 1s y 0s en cualquier orden. = {1110, 1111, 11101, 11100, 11110, 11111, …. }

G = ( V,T,S₀,P )
V = {1,0,S,A,B}
T = {1,0}
S₀ = S
P:
AB -> BA
BA -> AB
A -> 0
B -> 1
S -> SA
S -> SB
S -> 111S

3) L = Lenguaje que tiene la misma cantidad de 0s y 1s. = { λ, 01, 10, 0011, 0110, 1100, 0101, 1010, …. }

G = ( V,T,S₀,P )
V = {1,0,S, A, B}
T = {1,0}
S₀ = S
P:
AB -> BA
BA -> AB
A -> 0
B -> 1
S -> SAB
S -> λ

Referencias

Apuntes de Clase de Algebra y Matemática Discreta cursada en el segundo cuatrimestre de 2007 en la Universidad de Palermo dictada por Marcela Wilder.
Algebra Y Matenática Discreta, Gabriela Esperón, Marcela Wilder, UP, 2007.

Demostración

Sabemos que p es primo por lo tanto no es multiplo de 3, o sea que es o de la forma 3k + 1 o 3k + 2 con k ∈ Z. Supongamos que es de la forma 3k + 1, entonces p + 2 = 3k + 1 + 2 = 3 ( k + 1 ) entonces p + 2 es multiplo de 3 y no es primo. Ahora si es de la forma 3k + 2 entonces p + 4 = 3k + 2 + 4 = 3 ( k + 2) por lo que p + 4 es multiplo de 3 y no es primo. De lo que sigue que no existen triplos de primos de la forma ( p, p+2, p+4 ) salvo ( 3, 5, 7 ).

De manera similar puede resolverse el ejercicio 3.43, que es demostrar que siendo p primo, no existen primos de la forma ( p² + 2 ) ≠ 11 o lo que es lo mismo con p ≠ 3 .

Demostración

Si p es primo ≠ 3 , entonces necesariamente no es multiplo de 3, o sea que es de la forma 3k + 1 o 3k + 2 con k ∈ Z. Supongamos que es de la forma 3k + 1, entonces p² + 2 = ( 9k² + 6k + 1) + 2 = 3 ( 3k² + 2k + 1 ) , porque lo que es multiplo de 3 y no es primo. Supongamos entonces que es de la forma 3k + 2, entonces p² + 2 = ( 9k² + 12k + 4) + 2 = 3 ( 3k² + 4k + 2 ), multiplo de 3 y no primo. Por exhaustación de casos, la proposición queda demostarda.

Bueno termine con el cápitulo 3, si alguién tiene la solución del ejercicio 3.34 me haría un favor enorme si me lo mandan porque estuve un buen rato y no lo pude resolver. Mierda, me gustaría poder dedicarle más tiempo, pero si me cuelgo no avanzo más y quiero seguir aprendiendo Haskell.