Python: Hallar el punto de intersección entre dos segmentos
Este segmento de código devuelve el punto de intersección entre dos rectas, no se consideran el caso de que no exista o exista más de uno (lineas paralelas). Depende del valor de la variable det, si es igual a cero, es necesario verificar que las lineas sean paralelas, si no lo son, entonces nunca se tocan.
#interseccion EN UN UNICO PUNTO entre segmentos
class punto:
def __init__(self,x,y):
self.x = x
self.y = y
def __str__(self):
return "("+str(self.x)+","+str(self.y)+")"
class linea:
def __init__(self, p0, p1):
self.p0 = p0
self.p1 = p1
self.A = p1.x - p0.x
self.B = p1.y - p0.y
self.C = p1.x*p0.y - p0.x*p1.y
def intersecta(self, otro):
det = self.A*otro.B - otro.A*self.B
x = otro.A*self.C-self.A*otro.C
y = otro.B*self.C-self.B*otro.C
return punto(x/det,y/det)
def __str__(self):
return str(self.p0) + "," + str(self.p1)
if __name__=="__main__":
l1 =linea(punto(0,0),punto(10,10))
l2 =linea(punto(10,0),punto(0,10))
print l1,l2
print l1.intersecta(l2)
Python: calcular los n primeros números primos
No conozco otro lenguaje más flexible y fácil que python. Este código te permite obtener los n primos menores que la variable MAX.
#calcula los primos menores que 100
MAX = 100
primos = [2]
for k in range(3, MAX):
for i in range(len(primos)):
if k%primos[i]==0: break
if i==len(primos)-1: #solo si no es multimplo de los actuales primos
primos.append(k)
print primos
Python: Recorridos en un árbol
Una manera muy fácil de representar un árbol binario es utilizando un vector. A partir de esta representación es fácil ejemplificar los recorridos en un árbol: pre-orden, in-orden y post-orden.
arbol = [5,3,7,2,4,6,9]
#como se representa un arbol binario casi-completo con una lista?
# 5 Nos enfocamos en el nodo 7, su indice en la lista es 2,
# / \ el hijo izquierdo esta en la posicion 2*indice + 1
# 3 7 y el hijo derecho esta en la posicion 2*indice + 2
# / \ / \
#2 4 6 9
def postorden(nodo): #id*
if nodo >= len(arbol): #nodo sin hijo
return
else:
postorden(2*nodo+1) #subarbol izquierdo
postorden(2*nodo+2) #subarbol derecho
print arbol[nodo],
def preorden(nodo): #*id
if nodo >= len(arbol): #nodo sin hijo
return
else:
print arbol[nodo],
preorden(2*nodo+1) #subarbol izquierdo
preorden(2*nodo+2) #subarbol derecho
def inorden(nodo): #i*d
if nodo >= len(arbol): #nodo sin hijo
return
else:
inorden(2*nodo+1) #subarbol izquierdo
print arbol[nodo],
inorden(2*nodo+2) #subarbol derecho
if __name__=="__main__":
print "pre-orden:"
preorden(0)
print "\nin-orden:"
inorden(0)
print "\npost-orden:"
postorden(0)
Salida desde la terminal
5 3 2 4 7 6 9
in-orden:
2 3 4 5 6 7 9
post-orden:
2 4 3 6 9 7 5
Cómo escribir programas para tu graficadora TI
En el sitio oficial de TIGCC puedes encontrar todo lo que necesitas para escribir un programa en lenguaje C y compilarlo para generar un ejecutable en ensamblador. Los modelos soportados son TI-89, TI-92 Plus y Voyage200.
¿Qué es lo que hay que hacer?
- Bajar el compilador TIGCC v0.96 Beta 8 que incluye un IDE.
- Bajar el emulador TIEmu que nos permitirá probar nuestros programas antes de descargalo.
- Instalar TI Connect, el software de enlance entre la PC y la graficadora TI, de la página de Texas Instruments.
- Descargar la imagen del ROM (Voyage200_OS209.img) del modelo de tu graficadora o simplemente crear una copia de tu propio ROM.
- Antes de lanzar el emulador, la ventana “Set ROM version” aparecerá y debes añadir la imagen del ROM para que luzca como en la siguiente imagen.
En la página oficial podrás encontrar manuales, tutoriales, ejemplos y demás…
Nota: ¡un conocimiento básico del lenguage C sería de gran ayuda!
Les dejo esta implementación del algoritmo de Floyd para hallar el camino mínimo entre todos los pares de vértices de un grafo ponderado.
#define USE_TI92PLUS // Compile for TI-92 Plus
#define USE_V200 // Compile for V200
#define OPTIMIZE_ROM_CALLS // Use ROM Call Optimization
#define MIN_AMS 100 // Compile for AMS 1.00 or higher
#define SAVE_SCREEN // Save/Restore LCD Contents
#include <tigcclib.h> // Include All Header Files
#define INF 1000
int N;
void print(int (*A)[N],int k){
clrscr();
printf("It: %d\n",k+1);
int i,j;
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
if (i==j)
printf(" -");
else if( A[i][j] > 500)
printf(" i");
else
printf ("%3d", A[i][j]); // print out the matrix
printf ("\n");
}
}
void _main (void)
{
clrscr ();
printf ("# de nodos: ");
scanf("%d",&N);
printf("\n");
int (*A)[N] = NULL;
int (*S)[N] = NULL;
int i,j,k;
A = calloc (N, sizeof (*A));
S = calloc (N, sizeof (*S));
//inicializacion
for (i = 0; i < N; i++){
for (j = 0; j < N; j++){
S[i][j] = j;
if (i==j)
A[i][j] = INF;
else{
printf("e[%d][%d]?",i,j);
scanf("%d",&A[i][j]);
printf("\n");
if (A[i][j] < 0)
A[i][j] = INF;
}
}
}
for (k=0; k<N; k++){
for(i=0; i<N; i++){
for(j=0; j<N; j++){
if(A[i][k] + A[k][j] < A[i][j]){
A[i][j]= A[i][k] + A[k][j];
S[i][j]= k;
}
}
}
print(A,k);
ngetchx();
}
free (A);
ngetchx();
clrscr();
print(S,-1);
free(S);
ngetchx();
}
Este es el grafo que representa un instancia del problema
D1 representa la matriz de adyacencia del grafo, dónde el símbolo de infinito y el guión indican que no existe una conexión entre el par de nodos Dij. La matriz D4 representa los pesos/distancias mínimas entre cualquier par de nodos.
Así es como se introduce la matriz de adyacencia, los infinitos se representan con -1 y la diagonal simplemente no se solicita.
El programa muestra cada una de las iteraciones del algoritmo, esta es la última de ellas.
Los ejecutables en ensamblador, que se generan en la misma carpeta del proyecto, son estos TI-89, TI-92 Plus y Voyage200.
Nota: Para realizar la sincronización y el lanzamiento del programa deberás consultar el manual de tu graficadora.