Practica 5 ASPP

.386
.MODEL flat
OPTION CASEMAP:N
.CODE
PUBLIC _int2fp
_int2fp PROC
; Cuerpo del pro
push ebp
mov ebp,esp
push eax
push ebx
push ecx
push edx

xor eax,eax
xor ebx,ebx
xor ecx,ecx
xor edx,edx

mov ecx, [ ebp
mov eax, [ ebp

cmp eax,0
je Cero

cmp eax,0
jge Bucle
mov dh,1
neg eax

Bucle: cmp eax
je Fb
shrd ebx,eax,1
shr eax,1
add dl,1
jmp Bucle

Cero: mov eax,
jmp Fin

Fb:add dl,127
xor eax,eax
mov ax,dx
shld eax,ebx,

Fin:mov [ ecx]

pop edx
pop ecx
pop ebx
pop eax
pop ebp

ret



_int2fp ENDP
END

Problema 6 Practica 2

public class Practi02E6 {
public static void main(String[ ] args) {
int [ ] size = {10000, 100000, 1000000, 10000000};
long [ ] tiempos= new long [ 3*size.length];
Temporizador t = new Temporizador(5);
CronometraMetodoBinarySearch CMBN = new CronometraMetodoBinarySearch(1,1);

for(int i=0;i < size.length;i++){
CMBN.setTamaño(size[ i]);
for(int j=0;j<3;j++){
CMBN.setCaso(j);
t.cronometra(CMBN);
tiempos[ 3*i+j]=t.getTiempoMinimo();
}
}
for(int i=0;i < size.length;i++){
System.out.println("Caso: EP, Tamaño: "+size[ i]+" \tTiempo: "+tiempos[ 3*i]+" ns");
System.out.println("Caso: EM, Tamaño: "+size[ i]+" \tTiempo: "+tiempos[ 3*i+1]+" ns");
System.out.println("Caso: EF, Tamaño: "+size[ i]+" \tTiempo: "+tiempos[ 3*i+2]+" ns");
}
}
}


public class CronometraMetodoBinarySearch implements EstrategiaSolucion{

public static final int EXITO_PRINCIPIO = 0;
public static final int EXITO_MITAD = 1;
public static final int EXITO_FINAL = 2;
public static final int SIN_EXITO_PRINCIPIO = 3;
public static final int SIN_EXITO_MITAD = 4;
public static final int SIN_EXITO_FINAL = 5;

private int numElem;
private int casoDeBusqueda;
private int [] datos;
private int numBuscado;

public CronometraMetodoBinarySearch(int numElem, int casoDeBusqueda) {

// TODO
this.numElem=numElem;
this.casoDeBusqueda=casoDeBusqueda;
this.datos= new int[this.numElem];
this.inicializaDatos();
this.generaNumBuscado();

}

public void setTamaño(int tam){
this.numElem=tam;
this.datos= new int[this.numElem];
this.inicializaDatos();
}

public void setCaso(int casoBusqueda) {

// TODO
this.casoDeBusqueda=casoBusqueda;
this.generaNumBuscado();
}

private void generaNumBuscado() {
switch(casoDeBusqueda) {
case EXITO_PRINCIPIO:
numBuscado = datos[0];
break;
case EXITO_MITAD:
numBuscado = datos[(numElem - 1) / 2];
break;
case EXITO_FINAL:
numBuscado = datos[numElem - 1];
break;
case SIN_EXITO_PRINCIPIO:
numBuscado = datos[0] - 1;
break;
case SIN_EXITO_MITAD:
numBuscado = datos[numElem / 2] - 1;
break;
case SIN_EXITO_FINAL:
numBuscado = datos[numElem - 1] + 1;
break;
default:
// no puede darse ningún otro caso
}
}

private void inicializaDatos() {
for(int i = 0; i < numElem; i++) {
// tomando pares dejamos sitio para las búsquedas fallidas
datos[i] = 2 * (i + 1);
}
}

public void procesamientoFinal() {

}

public void procesamientoInicial() {

}

public void solucion() {
Arrays.binarySearch(this.datos, this.numBuscado);

}

}

Problema 5 Practica 2

public class Practi02E5 {
public static void main(String[ ] args) {
int [ ] size = {1000, 10000, 100000};
long [ ] tiempos= new long [ 2*size.length];
Temporizador t = new Temporizador(1);
CronometraObjetosString COS=new CronometraObjetosString(1);
CronometraObjetosStringBuilder COSB=new CronometraObjetosStringBuilder(1);

for(int i=0;i < size.length;i++){
COS.setRepeticiones(size[ i]);
COSB.setRepeticiones(size[ i]);
t.cronometra(COS);
tiempos[ 2*i]=t.getTiempoMinimo();
t.cronometra(COSB);
tiempos[ 2*i+1]=t.getTiempoMinimo();
}
for(int i=0;i < size.length;i++){
System.out.println("Tiempo de String para "+size[ i]+" elementos: "+tiempos[ 2*i]+" ns");
System.out.println("Tiempo de StringBuilder para "+size[ i]+" elementos: "+tiempos[ 2*i]+" ns");
}


}

}

public class CronometraObjetosString implements EstrategiaSolucion{
private int n;

public CronometraObjetosString(int n){
this.n=n;
}

public void setRepeticiones(int n){
this.n=n;
}

public void procesamientoFinal() {
}

public void procesamientoInicial() {
}

public void solucion() {
String s="";
for (int c = 0; c < n; c++)
s +="A";
}

}


public class CronometraObjetosStringBuilder implements EstrategiaSolucion{

private int n;

public CronometraObjetosStringBuilder(int n){
this.n=n;
}

public void setRepeticiones(int n){
this.n=n;
}

public void procesamientoFinal() {

}

public void procesamientoInicial() {

}

public void solucion() {
StringBuilder sb = new StringBuilder("");
for (int c = 0; c < n; c++)
sb.append("A");
}

}

Problema 4 Practica 2

public class Practi02E4 {
public static void main(String[ ] args) {
int [ ] size = {100, 1000, 10000};
long [ ] tiempos= new long [4*size.length];
CronometraAccesoArray CAA= new CronometraAccesoArray(1);
CronometraAccesoLista CAL= new CronometraAccesoLista(1);
CronometraCreacionArray CCA= new CronometraCreacionArray(1);
CronometraCreacionLista CCL= new CronometraCreacionLista(1);
Temporizador t = new Temporizador(5);

for(int i=0;i < size.length;i++){
CCA.setTamañoArray(size[ i]);
CCL.setTamañoLista(size[ i]);
CAA.setArray(size[ i]);
CAL.setLista(size[ i]);
t.cronometra(CCA);
tiempos[ 4*i]=t.getTiempoMinimo();
t.cronometra(CCL);
tiempos[ 4*i+1]=t.getTiempoMinimo();
t.cronometra(CAA);
tiempos[ 4*i+2]=t.getTiempoMinimo();
t.cronometra(CAL);
tiempos[ 4*i+3]=t.getTiempoMinimo();
}
for(int i=0;i < size.length;i++){
System.out.println("Tiempo de creacion array de "+size[ i]+" elementos, es: "+tiempos[ 4*i]+" ns");
System.out.println("Tiempo de creacion lista de "+size[ i]+" elementos, es: "+tiempos[ 4*i+1]+" ns");
System.out.println("Tiempo de acceso array de "+size[ i]+" elementos, es: "+tiempos[ 4*i+2]+" ns");
System.out.println("Tiempo de acceso lista de "+size[ i]+" elementos, es: "+tiempos[ 4*i+3]+" ns");
}

}
}

public class CronometraAccesoArray implements EstrategiaSolucion {

private int n;
private int[ ] array;
private int aux;

public CronometraAccesoArray(int n){
this.n=n;
this.array=new int[ this.n];
this.aux=(int)this.n/2;
if(this.n%2 == 0)
this.aux++;
for(int i=0;i < n;i++)
this.array[ i]=i;
}

public void setArray(int n){
this.n=n;
this.array=new int[ this.n];
this.aux=(int)this.n/2;
if(this.n%2 == 0)
this.aux++;
for(int i=0;i < n;i++)
this.array[ i]=i;
}

@Override
public void procesamientoFinal() {
// TODO Auto-generated method stub

}

@Override
public void procesamientoInicial() {
// TODO Auto-generated method stub

}

@Override
public void solucion() {
// TODO Auto-generated method stub
System.out.print(this.array[ 0]+", ");
for(int i=1;i < this.aux;i++){
System.out.print(this.array[ this.n-i]+", ");
if(!((this.n-i)==i))
System.out.print(this.array[ i]+", ");
}
System.out.println("]");
}


}

public class CronometraAccesoLista implements EstrategiaSolucion{

private int n;
private LinkedList lista;
private int aux;

public CronometraAccesoLista(int n){
this.n=n;
this.lista=new LinkedList();
this.aux=(int)this.n/2;
if(this.n%2 == 0)
this.aux++;
for(int i=0;i < n;i++)
this.lista.add(i);
}

public void setLista(int n){
this.n=n;
this.lista = new LinkedList();
this.aux=(int)this.n/2;
if(this.n%2 == 0)
this.aux++;
for(int i=0;i < n;i++)
this.lista.add(i);
}

@Override
public void procesamientoFinal() {
// TODO Auto-generated method stub

}

@Override
public void procesamientoInicial() {
// TODO Auto-generated method stub

}

@Override
public void solucion() {
// TODO Auto-generated method stub
System.out.print("["+this.lista.get(0)+", ");
for(int i=1;i < this.aux;i++){
System.out.print(this.lista.get(n-i)+", ");
if(!((this.n-i)==i))
System.out.print(this.lista.get(i)+", ");
}
System.out.println("]");
}

}

public class CronometraCreacionArray implements EstrategiaSolucion {

private int n;

public CronometraCreacionArray(int n){
this.n=n;
}

public int getTamañoArray(){
return this.n;
}

public void setTamañoArray(int n){
this.n=n;
}

@Override
public void procesamientoFinal() {
// TODO Auto-generated method stub

}

@Override
public void procesamientoInicial() {
// TODO Auto-generated method stub

}

@Override
public void solucion() {
// TODO Auto-generated method stub
int [ ] array= new int[ this.n];
for(int i=0;i < n;i++)
array[ i]=i;
}

}


public class CronometraCreacionLista implements EstrategiaSolucion{

private int n;

public CronometraCreacionLista(int n){
this.n=n;
}

public int getTamañoLista(){
return this.n;
}

public void setTamañoLista(int n){
this.n=n;
}

@Override
public void procesamientoFinal() {
// TODO Auto-generated method stub

}

@Override
public void procesamientoInicial() {
// TODO Auto-generated method stub
}

@Override
public void solucion() {
// TODO Auto-generated method stub
LinkedList< Integer> l=new LinkedList< Integer>();
for(int i=0;i < n;i++)
l.add(i);
}

}

Problema 1 Practica 2

public static void main(String[ ] args) {
int [ ] size = {10000, 100000, 1000000, 10000000};
ProblemaBusqueda busquedaProblema;
BusquedaLineal bl;
BusquedaBinaria bb;
Temporizador t;
// TODO Crear un objeto temporizador; el argumento del
// constructor es numPruebas
t = new Temporizador(5);

for (int i = 0; i < 4; i++) {
// TODO Generar un problema para el tamaño dado
busquedaProblema = new ProblemaBusqueda(size[ i],1);

for (int j = 0; j < 3; j++) {
// TODO Establecer un caso para el tamaño de problema generado
busquedaProblema.setCaso(j);

// TODO Crea un objeto solución siguiendo la estrategia de la
// búsqueda lineal. Este objeto implementa la interfaz
// Temporizable
bl = new BusquedaLineal(busquedaProblema);

// TODO Crea un objeto solución siguiendo la estrategia de la
// búsqueda dicotómica. Este objeto implementa la interfaz
// Temporizable
bb = new BusquedaBinaria(busquedaProblema);

// TODO Imprimir el problema
System.out.print("Tamaño: "+size[ i]+" Problema:"+j+" NumBus: "+busquedaProblema.getNumBuscado());

// TODO Ejecutar la busqueda lineal, midiendo su tiempo de
// ejecución
t.cronometra(bl);

// TODO Imprimir la solución encontrada
// y el tiempo de ejecución
System.out.print(" Tiempo mínimo Lineal: "+t.getTiempoMinimo());

// TODO Ejecutar la busqueda dicotómica, midiendo su tiempo de
// ejecución
t.cronometra(bb);

// TODO Imprimir la solución encontrada
// y el tiempo de ejecución
System.out.println(" Tiempo mínimo Dicotomico: "+t.getTiempoMinimo());
}
}
}


public ProblemaBusqueda(int numElem, int casoDeBusqueda) {

// TODO
this.numElem=numElem;
this.casoDeBusqueda=casoDeBusqueda;
this.datos= new int[ this.numElem];
this.inicializaDatos();
this.generaNumBuscado();

}

public void setCaso(int casoBusqueda) {

// TODO
this.casoDeBusqueda=casoBusqueda;
this.generaNumBuscado();
}

Función Buscar

func buscar(a:array [ 1...n] de Entero, c: Entero) dev (r: Entero){
var
j:Entero
alg
j:=1 //1 OE
mientras a[ j]Y j < style="font-weight: bold;">fmientras
si a[ j]=c //2 Oe
r:=j //1 OE
| otras
r:=0 //1 OE
fsi
falg

Caso Mejor:
T(n) = 1+2+2+1 = 6 OE

Caso peor:
T(n) = 1 + 6(n-1) +4+2+1 = 6n+2

Caso medio:
T(n) = 3n +6 Ya que todos los casos son equiprobables.

Practica3

.386
.model flat,stdcall
option casemap:none
.data
Tabla db 41h, 5h, 69h, 0FEh, 0Fh, 28h, 0EFh, 011h
db 22h, 3h, 25h, 0E4h, 77h, 0Ah, 78h, 015h
Mayor db ?
Menor db ?
.code
start:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Ej1: Mayor y Menor de Tabla.-
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
xor eax, eax
xor edx, edx; indice i
mov al, Tabla[ eax]
mov Mayor, al
mov Menor, al
Bucle: cmp edx, 10h
je Fin
mov al,Tabla[ edx]
add edx, 1
cmp al,Mayor
ja Max
Mex: cmp al,Menor
jae Bucle
mov Menor,al
jmp Bucle
Max: mov Mayor,al
jmp Mex
Fin:mov al, Tabla[ 10h]
mov ah, Menor
xor eax,eax
xor edx,edx
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Ej2: Tabla[ i] <- Tabla [i ] AND 0x0F.-
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Bucle2: cmp edx, 10h
je Fin2
mov eax, dword ptr Tabla[ edx]
and eax, 0F0F0F0Fh
mov dword ptr Tabla[ edx], eax
add edx, 4h
jmp Bucle2
Fin2: xor eax,eax
xor edx,edx
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Ej3: Burbuja.-
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
xor ecx,ecx
mov dl, 10h
Bucle3: cmp al,0Eh
ja Fin3
mov ch,dl
sub ch,2h
sub ch,al
Bucle31: cmp dh,ch
ja Fin31
mov cl, byte ptr Tabla[ edx];indices con registro entero
cmp cl,Tabla[ dh+1h]
jb FSI
mov ah,Tabla[ dh+1h]
mov Tabla[ dh+1h],cl
mov Tabla[ dh],ah
FSI: add dh,1h
jmp Bucle31
Fin31: add al,1h
jmp Bucle3
Fin3: xor eax,eax
xor edx,edx
xor ecx,ecx
end start
end