Reto_03: Caer y caminar

El gato cae desde arriba solo, y, cuando está sobre la línea negra, debe andar por ella, subiendo o bajando según sea la línea. Puede ir algo más rápido si se pulsa las teclas izquierda o derecha. Debe rebotar en las paredes.

Instrucciones:

• Entra en el proyecto https://scratch.mit.edu/projects/99461830/#editor
• IMPORTANTE: pulsa el botón de Reinventar (junto al de compartir) para que puedas trabajar en él.

• Programa el gato para que haga lo que se ve en el vídeo. Tienes pistas, pero a lo mejor necesitas más bloques.
• Complétalo y comparte con el profesor para que te corrija.

= = = 

Ampliación

El gato empieza desde el suelo. Debe elevarse sólo, y, cuando llegue a la línea negra, tendrá que atravesarla. Entonces, deberá seguir el programa anterior y seguir la línea. Si salta, deberá caer después, afectado por la gravedad.

Reto_02: Reconstruye el programa plataformas.

Debes reconstruir el programa para que haga lo que ves en el vídeo. El gato debe llegar a la puerta de salida, sin tocar las zonas rojas. Puede andar a izquierda y derecha, saltar un poco y bajar rápido. Puede ir montándose en las plataformas negras.

Instrucciones:

• Entra en el proyecto https://scratch.mit.edu/projects/99458377/#editor
• IMPORTANTE: pulsa el botón de Reinventar (junto al de compartir) para que puedas trabajar en él.

• Comparte el programa con tu profesor.

Reto _01: Trampa mortal

El bicho, una vez que entra en el recinto mortal, debe intentar salir de él rebotando en las paredes con ángulos entre 80 y 100.

Instrucciones:

• Entra en el proyecto https://scratch.mit.edu/projects/99358640/#editor
• IMPORTANTE: pulsa el botón de Reinventar (junto al de compartir) para que puedas trabajar en él.

• Programa "el bicho" para que haga lo que se especifica, como en el vídeo.
• Comparte el programa con tu profesor.

Bajantes y sistema de desagüe

Aprovecho la oportunidad de que me están arreglando el cuarto de baño y han partido el techo. Estoy viendo el sistema de desagüe del vecino de arriba perfectamente. Bote sifónico, cañerías, bovedillas, bajantes... 

Processing. Recta que pasa por dos puntos.

import javax.swing.JOptionPane; // Permite introducir números

float x1 = 30;
float y1 = 80;
float px1 = 0;
float py1 = 0;
float x2 = 30;
float y2 = 80;
float px2 = 0;
float py2 = 0;

float x3 = 0;
float x4 = 0;
float y3 = 0;
float y4 = 0;
float px3 = 0;
float py3 = 0;
float px4 = 0;
float py4 = 0;

float a = 0.0;
float b = 0.0;

void setup() {
  size(600,400);
  x1 = pedirNumero("Dame la x del primer punto","Punto 1");
  y1 = pedirNumero("Dame la y del primer punto","Punto 1");
  x2 = pedirNumero("Dame la x del segundo punto","Punto 2");
  y2 = pedirNumero("Dame la y del segundo punto","Punto 2");
  x3 = -width/2;
  x4 = width/2;
  a = (y2-y1)/(x2-x1);
  b = y1-a*x1;
  y3 = a*x3+b;
  y4 = a*x4+b;
  println(str(x1)+","+str(y1));
  println(str(x2)+","+str(y2));
  println("A: "+str(a)+" - B:"+str(b));
}

void draw() {
 background(254);
 stroke(0);
 line (0,height/2,width,height/2); // eje x
 line (width/2,0,width/2,height); // eje Y

 // Transformadas
 px1 = width/2+x1;
 py1 = height/2-y1;
 px2 = width/2+x2;
 py2 = height/2-y2;

 for (int xx=-width/2; xx<=width/2; xx=xx+3) {
    y3 = a*xx+b;
    if ((y3>-height/2) && (y3<height/2)) {
         px3 = width/2+xx;
         py3 = height/2-y3;
         noStroke();
         fill(0,255,0);
         ellipse(px3,py3,1,1);
    }
 }

 // Segmento
 stroke(0);
 line(px1,py1,px2,py2);

  // dibujar
 dibujarCruz(px1,py1);
 dibujarCruz(px2,py2);

}


// Input Box
float pedirNumero(String frase, String titulo) {
  float i = 0;
  String r = JOptionPane.showInputDialog(null,frase,titulo, JOptionPane.QUESTION_MESSAGE);
  try {
    i = Float.parseFloat(r);
  } catch(NumberFormatException e) {
    println("you did not enter a number!");
  }
  return i;
}

void dibujarCruz(float px, float py) {
    stroke(0,0,255);
    line (px-3,py-3,px+3,py+3);
    line (px-3,py+3,px+3,py-3);  
}

16.9 Ejercicios de Algoritmos

• En los algoritmos de búsqueda (inserción, burbuja y quicksort) realiza las modificaciones pertinentes para obtener un ordenamiento de MAYOR a MENOR.
• Para el método quicksort, escribe el algoritmo en pseudocódigo y el diagrama de flujo.

= = =

Funcion quicksort ( L, principio, final )
    i<-principio
    j<-final
    pivote<-(L[i]+L[j])/2
    
    Mientras i<j Hacer
        Mientras L[i]<pivote Hacer
            i<-i+1
        Fin Mientras
        Mientras L[j]>pivote Hacer
            j<-j-1
        Fin Mientras
        Si i<=j Entonces
            temporal<-L[i]
            L[i]<-L[j]
            L[j]<-temporal
            i<-i+1
            j<-j-1
        Fin Si
    Fin Mientras
    
    Si principio<j Entonces
        quicksort(L,principio,j)
    Fin Si
    
    Si final>i Entonces
        quicksort(L,i,final)
    Fin Si
    
Fin Funcion

Algoritmo ordenar
    Dimension numeros[10]
    // Genero un arreglo de 10 nmeros aleatorios
    Para i<-1 Hasta 10 Con Paso 1 Hacer
        numeros[i] <- azar(100)+1
    Fin Para
    
    Escribir "Desordenados..."
    Para i<-1 Hasta 10 Con Paso 1 Hacer
        Escribir numeros[i]
    Fin Para
    
    quicksort(numeros,1,10)
    // Como se pasa por REFERENCIA, numeros se modificara dentro de la funcion
    Escribir "Ordenados..."    
    Para i<-1 Hasta 10 Con Paso 1 Hacer
        Escribir numeros[i]
    Fin Para
FinAlgoritmo

= = =

16.8 Algoritmos de búsqueda e inserción de datos

Algoritmos de Búsqueda

Algoritmo secuencial

# ================== 
# Programa principal
# ==================
# Genero un vector con 20 elementos colocados en posiciones aleatorias, de números entre 1 y 100

numeroDeElementos = 20
maximoNumeroAparecido = 100
misNumeros = []
for i in range(1,maximoNumeroAparecido+1):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)
misNumeros = misNumeros[:20] # solo quiero 20 números

print "Mis números: ",misNumeros
print "= = = "

# ===========================================================================
# Búsqueda secuencial
# ¿En qué lugar encuentro uno de los números?
# Uso búsqueda secuencial cuando la lista no es ordenada o no puedo ordenarla
# Método más lento. No queda más remedio que recorrer uno a uno.
# Comprobar si tengo el elemento, y si no salir
# ===========================================================================

numeroAleatorio = misNumeros[random.randint(0,len(misNumeros)-1)]
print "El número elegido es el %d" % (numeroAleatorio)

indice = 0
while indice<(len(misNumeros)-1):
    if misNumeros[indice]==numeroAleatorio:
        print "Lo encuentro en el lugar %d del vector, contando desde 0" % (indice)
        indice = len(misNumeros)-1
    indice+=1

Búsqueda por dicotomía

La búsqueda por dicotomía (o binaria) se caracteriza por dividir el array en dos partes, si es que no encuentra el valor en el índice dado. Y va calculando índices, por divisiones sucesivas. Es mucho más rápido que el anterior.
En el siguiente ejemplo se encuentra implementado sin recursividad o con recursividad. Como el array debe estar ordenado, uso el método quicksort visto anteriormente.

# *-* coding: utf-8 *-*

import random

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last    
    pivote = (L[i] + L[j]) / 2
    # print "PIVOTE: ",str(pivote)

    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea menor que pivote
        while L[i] < pivote:
            # Incrementamos el índice
            i+=1
            # print "i: ",str(i)
        # iteramos mientras que el valor de L[j] sea mayor que pivote
        while L[j] > pivote:
            # decrementamos el índice
            j-=1
            # print "j: ",str(j)
        # si i es menor o igual que j significa que los índices se han cruzado
        # print "i: ",str(i), ", j: ",str(j), " --> números: ", L
        if i<=j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1
        # print "L cambiado: ",L,"añadidos i e j: ",str(i),",",str(j)
    
    # si first es menor que j mantenemos la recursividad
    if first < j:
        L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    if last > i:
        L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L
    

# Función de búsqueda dicotómica
""" def busquedaDicotomica (L,aguja,desde,hasta):    
    i = (desde+hasta)/2 # valor intermedio.
    while L[i]!=aguja:
        print "Voy buscando índices...: %d --> %d" % (i,L[i])
        if L[i]>aguja: # está en el lado de valores más pequeños
            hasta = i-1
        elif L[i]<aguja: # está en el lado de valores mayores
            desde = i+1
        i = (desde+hasta)/2 # valor intermedio. Recalculo.
    return i """

# Función de búsqueda dicotómica RECURSIVA
def busquedaDicotomica (L,aguja,desde,hasta):
    ans = -1 # En principio, la respuesta es -1
    if desde>=hasta:
        ans = -1 # Si los dos índices se encuentran, o el inferior supera al superior,  es que no ha encontrado nada 
    else:
        centro = (desde+((hasta-desde)//2)) # calculo el centro... // cociente de la división
        if   aguja < L[centro]: 
            ans = busquedaDicotomica(L,aguja,desde,centro) # Busco en la parte del array inferior. No poner centro-1 ??
        elif aguja > L[centro]: 
            ans = busquedaDicotomica(L,aguja,centro+1,hasta) # busco en la parte del array superior
        else:    
            ans = centro # Y si lo encuentra, es la respuesta
    return ans 

    
# ================== 
# Programa principal
# ==================
# Genero un vector con 20 elementos colocados en posiciones aleatorias, de números entre 1 y 100

numeroDeElementos = 70
maximoNumeroAparecido = 100
misNumeros = []
for i in range(1,maximoNumeroAparecido+1):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)
misNumeros = misNumeros[:numeroDeElementos] # solo quiero 20 números

print "Mis números: ",misNumeros
print "= = = "

print "Pero ahora los ordeno... "
misNumeros = quicksort(misNumeros,0,len(misNumeros)-1)
print "Ordenados: ",misNumeros

# ===========================================================================
# Búsqueda dicotómica
# ¿En qué lugar encuentro uno de los números?
# Uso búsqueda secuencial cuando la lista no es ordenada o no puedo ordenarla
# Método más lento. No queda más remedio que recorrer uno a uno.
# ===========================================================================

numeroAleatorio = misNumeros[random.randint(0,len(misNumeros)-1)]
# numeroAleatorio = 43
print "El número elegido es el %d" % (numeroAleatorio)

indiceEncontrado = busquedaDicotomica(misNumeros,numeroAleatorio,0,len(misNumeros)-1)

if indiceEncontrado!=-1:
    print "El valor buscado se encuentra en el lugar...: %d" % (indiceEncontrado)
    print "Compruebo... %d" % (misNumeros[indiceEncontrado])
else:
    print "No encontrado"

# print quicksort(misNumeros,0,len(misNumeros)-1)

= = = 

Algoritmo para insertar un dato en un array ordenado

Búsqueda por dicotomía: modificación para insertar un elemento.

Uso el programa anterior, modificado, para conseguir insertar un elemento en un array ordenado en su posición.

# *-* coding: utf-8 *-*

import random

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last  
    pivote = (L[i] + L[j]) / 2
    # print "PIVOTE: ",str(pivote)

    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea menor que pivote
        while L[i] < pivote:
            # Incrementamos el índice
            i+=1
            # print "i: ",str(i)
        # iteramos mientras que el valor de L[j] sea mayor que pivote
        while L[j] > pivote:
            # decrementamos el índice
            j-=1
            # print "j: ",str(j)
        # si i es menor o igual que j significa que los índices se han cruzado
        # print "i: ",str(i), ", j: ",str(j), " --> números: ", L
        if i<=j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1
        # print "L cambiado: ",L,"añadidos i e j: ",str(i),",",str(j)
  
    # si first es menor que j mantenemos la recursividad
    if first < j:
        L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    if last > i:
        L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L
  

# Función de búsqueda dicotómica RECURSIVA
# Modificación para que devuelva, de todas formas, aunque no lo encuentre, la posición.
def busquedaDicotomica (L,aguja,desde,hasta):
    if desde>=hasta:
        ans = hasta # Si los dos índices se encuentran, o el inferior supera al superior,  es que no ha encontrado nada
    else:
        centro = (desde+((hasta-desde)//2)) # calculo el centro... // cociente de la división
        if   aguja < L[centro]:
            ans = busquedaDicotomica(L,aguja,desde,centro) # Busco en la parte del array inferior. No poner centro-1 ??
        elif aguja > L[centro]:
            ans = busquedaDicotomica(L,aguja,centro+1,hasta) # busco en la parte del array superior
        else:  
            ans = centro # Y si lo encuentra, es la respuesta
    return ans

  
# ==================
# Programa principal
# ==================
# Genero un vector con 20 elementos colocados en posiciones aleatorias, de números entre 1 y 100

numeroDeElementos = 15
maximoNumeroAparecido = 100
misNumeros = []
for i in range(1,maximoNumeroAparecido+1):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)
numeroInsertar = misNumeros[numeroDeElementos]
misNumeros = misNumeros[:numeroDeElementos] # solo quiero 20 números

print "Mis números: ",misNumeros
print "Número a insertar... ",numeroInsertar
print "= = = "

print "Pero ahora los ordeno... "
misNumeros = quicksort(misNumeros,0,len(misNumeros)-1)
print "Ordenados: ",misNumeros

# ================================================================================================
# Búsqueda dicotómica e Inserción
# ¿En qué lugar encuentro uno de los números? ¿Dónde introduzco otro?
# Uso búsqueda secuencial c# *-* coding: utf-8 *-*

import random

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last  
    pivote = (L[i] + L[j]) / 2
    # print "PIVOTE: ",str(pivote)

    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea menor que pivote
        while L[i] < pivote:
            # Incrementamos el índice
            i+=1
            # print "i: ",str(i)
        # iteramos mientras que el valor de L[j] sea mayor que pivote
        while L[j] > pivote:
            # decrementamos el índice
            j-=1
            # print "j: ",str(j)
        # si i es menor o igual que j significa que los índices se han cruzado
        # print "i: ",str(i), ", j: ",str(j), " --> números: ", L
        if i<=j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1
        # print "L cambiado: ",L,"añadidos i e j: ",str(i),",",str(j)
  
    # si first es menor que j mantenemos la recursividad
    if first < j:
        L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    if last > i:
        L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L
  

# Función de búsqueda dicotómica RECURSIVA
# Modificación para que devuelva, de todas formas, aunque no lo encuentre, la posición.
def busquedaDicotomica (L,aguja,desde,hasta):
    if desde>=hasta:
        ans = hasta # Si los dos índices se encuentran, o el inferior supera al superior,  es que no ha encontrado nada
    else:
        centro = (desde+((hasta-desde)//2)) # calculo el centro... // cociente de la división
        if   aguja < L[centro]:
            ans = busquedaDicotomica(L,aguja,desde,centro) # Busco en la parte del array inferior. No poner centro-1 ??
        elif aguja > L[centro]:
            ans = busquedaDicotomica(L,aguja,centro+1,hasta) # busco en la parte del array superior
        else:  
            ans = centro # Y si lo encuentra, es la respuesta
    return ans

  
# ==================
# Programa principal
# ==================
# Genero un vector con 20 elementos colocados en posiciones aleatorias, de números entre 1 y 100

numeroDeElementos = 15
maximoNumeroAparecido = 100
misNumeros = []
for i in range(1,maximoNumeroAparecido+1):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)
numeroInsertar = misNumeros[numeroDeElementos]
misNumeros = misNumeros[:numeroDeElementos] # solo quiero 20 números

print "Mis números: ",misNumeros
print "Número a insertar... ",numeroInsertar
print "= = = "

print "Pero ahora los ordeno... "
misNumeros = quicksort(misNumeros,0,len(misNumeros)-1)
print "Ordenados: ",misNumeros

# ================================================================================================
# Búsqueda dicotómica e Inserción
# ¿En qué lugar encuentro uno de los números? ¿Dónde introduzco otro?
# Uso búsqueda secuencial cuando la lista no es ordenada o no puedo ordenarla
# Método más lento. No queda más remedio que recorrer uno a uno.
# EN ESTE CASO LA MODIFICO PARA ENCONTRAR EL INDICE SUPERIOR DEL ELEMENTO DONDE TENGO QUE INSERTAR
# ================================================================================================

# numeroAleatorio = misNumeros[random.randint(0,len(misN umeros)-1)]
print "El número elegido es el %d" % (numeroInsertar)

indiceEncontrado = busquedaDicotomica(misNumeros,numeroInsertar,0,len(misNumeros)-1)

if misNumeros[indiceEncontrado]==numeroInsertar:
    print "El valor buscado se encuentra en el lugar...: %d" % (indiceEncontrado)
    print "Compruebo... %d" % (misNumeros[indiceEncontrado])
    print "No necesito insertarlo..."
else:    print "El límite superior está en el índice... %d" % (indiceEncontrado)
    print "Antes del valor... %d" % (misNumeros[indiceEncontrado])
    misNumeros.insert(indiceEncontrado,numeroInsertar) # Al insertar en esa posición, se desplazan los demás a la derecha...
    print "Array con elemento insertado: %s" % (misNumeros)


uando la lista no es ordenada o no puedo ordenarla
# Método más lento. No queda más remedio que recorrer uno a uno.
# EN ESTE CASO LA MODIFICO PARA ENCONTRAR EL INDICE SUPERIOR DEL ELEMENTO DONDE TENGO QUE INSERTAR
# ================================================================================================

# numeroAleatorio = misNumeros[random.randint(0,len(misN umeros)-1)]
print "El número elegido es el %d" % (numeroInsertar)

indiceEncontrado = busquedaDicotomica(misNumeros,numeroInsertar,0,len(misNumeros)-1)

if misNumeros[indiceEncontrado]==numeroInsertar:
    print "El valor buscado se encuentra en el lugar...: %d" % (indiceEncontrado)
    print "Compruebo... %d" % (misNumeros[indiceEncontrado])
    print "No necesito insertarlo..."
else:    print "El límite superior está en el índice... %d" % (indiceEncontrado)
    print "Antes del valor... %d" % (misNumeros[indiceEncontrado])
    misNumeros.insert(indiceEncontrado,numeroInsertar) # Al insertar en esa posición, se desplazan los demás a la derecha...
    print "Array con elemento insertado: %s" % (misNumeros)

16.7 Algoritmo de ordenación quicksort

= = =

Primero, explicándolo paso a paso...

# *-* coding: utf-8 *-*

import random

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last    
    pivote = (L[i] + L[j]) / 2
    print "PIVOTE: ",str(pivote)

    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea menor que pivote
        while L[i] < pivote:
            # Incrementamos el índice
            i+=1
            print "i: ",str(i)
        # iteramos mientras que el valor de L[j] sea mayor que pivote
        while L[j] > pivote:
            # decrementamos el índice
            j-=1
            print "j: ",str(j)
        # si i es menor o igual que j significa que los índices se han cruzado
        print "i: ",str(i), ", j: ",str(j), " --> números: ", L
        if i<=j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1
        print "L cambiado: ",L,"añadidos i e j: ",str(i),",",str(j)

    # si first es menor que j mantenemos la recursividad
    # if first < j:
    #    L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    # if last > i:
    #    L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L
    

# Genero un vector con 100 elementos colocados en posiciones aleatorias
"""
misNumeros = []
for i in range(1,11):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)"""
    
misNumeros = [8,4,7,5,3,2,1,6]

print "Mis números: ",misNumeros
print "= = = "
print quicksort(misNumeros,0,len(misNumeros)-1)

El método quicksort completo

# *-* coding: utf-8 *-*

import random

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last    
    pivote = (L[i] + L[j]) / 2
    # print "PIVOTE: ",str(pivote)

    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea menor que pivote
        while L[i] < pivote:
            # Incrementamos el índice
            i+=1
            # print "i: ",str(i)
        # iteramos mientras que el valor de L[j] sea mayor que pivote
        while L[j] > pivote:
            # decrementamos el índice
            j-=1
            # print "j: ",str(j)
        # si i es menor o igual que j significa que los índices se han cruzado
        # print "i: ",str(i), ", j: ",str(j), " --> números: ", L
        if i<=j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1
        # print "L cambiado: ",L,"añadidos i e j: ",str(i),",",str(j)
    
    # si first es menor que j mantenemos la recursividad
    if first < j:
        L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    if last > i:
        L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L
    

# Genero un vector con 100 elementos colocados en posiciones aleatorias

misNumeros = []
for i in range(1,11):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)

# misNumeros = [8,4,7,5,3,2,1,6]

print "Mis números: ",misNumeros
print "= = = "
print quicksort(misNumeros,0,len(misNumeros)-1)

16.6 Algoritmo de ordenación por burbuja

 = = =

# *-* coding: utf-8 *-*

import random

# =============================================================
# ALGORITMO DE ORDENACION POR INSERCIÓN DIRECTA
# =============================================================

# Genero un vector con 100 elementos colocados en posiciones aleatorias
misNumeros = []
for i in range(1,101):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)

# print misNumeros

# ================================
# Ordenacion por insercion directa
# ================================

misNumerosID = misNumeros[:] #COPIO los valores del array
indice=len(misNumerosID)-1 # corresponde a la última posición del array
pivote = 0 # corresponde al pivote, que puede ser el último elemento del array

print "ANTES: ",misNumerosID
# print "Longitud del elemento: ",str(len(misNumerosID))
# print "Rango negativo: ",str(range(len(misNumerosID),0,-1))

for i in range(indice,-1,-1): # desde el último índice, al 0 (límite inferior -1), hacia atrás, de uno en uno
    for j in range(1,i+1): # desde la segunda posición [1] hasta el último índice. Límite superior i+1
        if misNumerosID[j]<misNumerosID[j-1]:
            pivote = misNumerosID[j]
            misNumerosID[j]=misNumerosID[j-1]
            misNumerosID[j-1]=pivote
            pivote=0

print " = = = "
print "DESPUÉS: ",misNumerosID

16.5 Algoritmo de inserción directa

 

= = =

# *-* coding: utf-8 *-*

import random

# =============================================================
# ALGORITMO DE ORDENACION POR INSERCIÓN DIRECTA
# =============================================================

# Genero un vector con 100 elementos colocados en posiciones aleatorias
misNumeros = []
for i in range(1,11):
    longitud = len(misNumeros)
    misNumeros.insert(random.randint(0,longitud),i)

# print misNumeros

# ================================
# Ordenacion por insercion directa
# ================================

misNumerosID = misNumeros[:] #COPIO los valores del array
indice=1 # corresponde a la SEGUNDA posicion del array, la posición cero es la primera
pivote = 0 # corresponde al pivote, que puede ser el último elemento del array

print "ANTES: ",misNumerosID
# print "Longitud del elemento: ",str(len(misNumerosID))
# print "Rango negativo: ",str(range(len(misNumerosID),0,-1))

while indice<len(misNumerosID): # mientras indice sea menor que la longitud. Acabará en el índice 9, el último, ya
    # que la longitud es 10. O en n, y el índice es n-1
    # print indice
    for i in range(indice,0,-1): #desde la posición indice hasta 1, 0 es el límite inferior. 
        # print " - ",str(misNumerosID[i])
        if misNumerosID[i]<misNumerosID[i-1]: # si el anterior es MAYOR que el que estoy evaluando...
            pivote = misNumerosID[i] # Asigno este al pivote
            misNumerosID[i]=misNumerosID[i-1] # al de la posición i le pongo el de la posición i-1
            misNumerosID[i-1]=pivote # a la posición i-1 pongo el pivote
            pivote=0
            # print misNumerosID
    indice+=1 #importante. Aumento el pivote en 1
print " = = = "
print "DESPUÉS: ",misNumerosID

16.4 Python: ejercicios de algoritmos

Programa online de dibujo de flowcharts: https://www.draw.io/

Programa descargado para Linux, dibujo de flowcharts y pseudocódigo (bueno): http://pseint.sourceforge.net/

• Describe en diagrama de flujo y pseudocódigo el programa de cálculo del índice de masa corporal.

• Describe en diagrama de flujo y pseudocódigo los siguientes programas. Usa PSEINT:

1. El programa pide un número entero. Comprobar que está entre 1 y 100. Si no lo está, el programa termina. Calcular, en otro caso, el factorial de dicho número.
2. El programa pide tres números enteros entre 1 y 100. Si cualquiera de ellos no está en ese intervalo, el programa acaba. El programa presenta el mayor de esos tres números en pantalla.
3. El programa pide 5 números enteros distintos mayores que cero. No se comprobará nada; el usuario debe introducirlos distintos. El programa presentará los números ordenados de mayor a menor.