Algoritmos y Estructuras de Datos I. - ALIPSO.COM: Monografías, resúmenes, biografias y tesis gratis.
Aprende sobre marketing online, desarrollo de sitios web gratis en Youtube
Suscribite para recibir notificaciones de nuevos videos:
Jueves 28 de Marzo de 2024 |
 

Algoritmos y Estructuras de Datos I.

Imprimir Recomendar a un amigo Recordarme el recurso

Algoritmos y Estructuras de Datos I Facultad de Ciencias Exactas y Naturales. Universidad de Buenos Aires Primer Cuatrimestre de 2000. Resolución de la Práctica 5. La longitud de L es Par. Programación. Algoritmos.

Agregado: 17 de JULIO de 2003 (Por Michel Mosse) | Palabras: 3118 | Votar | Sin Votos | Sin comentarios | Agregar Comentario
Categoría: Apuntes y Monografías > Computación > Programación >
Material educativo de Alipso relacionado con Algoritmos Estructuras Datos
  • Estructuras de datos: Tipos abstractos de datos. Un concepto importante en ingeniería: el de Caja Negra. El rol de las Estructuras de Datos en un programa. Definición y propiedades de los TADs. Bases de datos.
  • Mandatos: renuncia.:
  • Mandatos: oficio al registro de procesos universales.haciendo saber renuncia de mandato en una sucesion.:

  • Enlaces externos relacionados con Algoritmos Estructuras Datos

    Algoritmos y Estructuras de Datos I

    Facultad de Ciencias Exactas y Naturales

    Universidad de Buenos Aires

    Primer Cuatrimestre de 2000

    Resolución de la Práctica 5

    Ejercicio 2

    La longitud de L es Par

    Para todas las posiciones pares de L, sucede que hay un elemento en L0 que es igual a cada elemento de L y para todos los elementos de L0, sucede que hay un elemento en las posiciones Pares de L, que es igual a cada elemento de L0.

    Todas las posiciones pares de L son diferentes entre si.

    Para todas las posiciones pares de L sucede que en la sig. posicion aparece la cantidad de apariciones de L0.

    2-a) El procedimiento pone en las posiciones pares los elementos de L0 y en las impares la cantidad de veces que aparece cada elemento en L0.

    2-b-i) Podria pasar que no estén todos los elementos de L0 puestos en L.

    2-b-ii) Podria pasar que estén todos los elementos pero que haya repetidos.

    2-b-iii) Podria pasar que la lista quede impar, con lo cual quedaria un elemento en la ultima posicion y no estaria la cantidad de veces que aparece en la lista original (y se seguria cumpliendo Q)

    Ejercicio 3

    3-i)

    P {n=N0}

    Q {n=N0+1}

    Procedure Incrementar(in-out:n:integer)

    n:=n+1;

    endprocedure

    3-ii)

    P {n=N0 M=M0}

    Q {(N0M0 n=N0 m=M0) ú (N0<M0 n=M0 m=N0)}

    Procedure Ordint (in-out:n:integer,in-out:m:integer)

    if (nm) then skip;

    else Swap(n,m);

    fi;

    endprocedure

    //PROCEDIMIENTO AUXILIAR Swap

    P {n=N0 m=M0}

    Q {n=M0 m=N0}

    Procedure Swap(in-out:n:integer,in-out:m:integer)

    var

    tmp:integer:=n;

    n:=m;

    m:=tmp;

    endprocedure


    3-iii)

    P {n=N0}

    Q {(Par(N0)(n=N0/2)) ú (⌐Par(N0) n=N0)}

    Procedure Divpar(in-out:n:integer)

    if (Resto(n,2)=0) then

    n:=Division_entera(n,2);

    else

    skip;

    fi;

    endfunction

    3-iv)

    P {p=P0 q=Q0 r=R0}

    Q {p=(P0+Q0+R0)*P0 q=Q0 r=R0}

    procedure ej3iv (in-out:p:integer,in-out:q:integer,in-out:r:integer)

    p:=(p+q+r)*p;

    endprocedure

    3-v) VERSION 1

    P {A=A0}

    Q {A^dim(A)=f_incrementa A0^dim(A)}

    Pc {i=0}

    Qc {i=dim(A) A^dim(A)=f_incrementa_hasta (A0^dim(A)) dim(A)}

    B {i<dim(A)}

    I {A^dim(A)=f_incrementa_hasta (A0^dim(A)) i (0idim(A))}

    Fv = dim(A)-i

    //incrementa::[Int]->[Int]

    //incrementa [] = []

    //incrementa (x:xs) = (x+1):incrementa xs

    //incrementa_hasta::[Int]->Int->[Int]

    //incrementa_hasta [] _ = []

    //incrementa_hasta (x:xs) n | (n==0) = x:xs

    // | otherwise = (x+1):(incrementa_hasta xs (n-1))

    procedure Incrementa(in-out:A:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)) do

    incrementar(A[i]);

    incrementar(i);

    od;

    endprocedure


    3-v) VERSION 2

    P {A=A0}

    Q {("i)(0i<dim(A) => A[i]=A0[i]+1)}

    Pc {i=0}

    Qc {i=dim(A)} Q

    B {i<dim(A)}

    I {0idim(A) ("j)(0j<i => A[j]=A0[j]+1) ("j)(ij<dim(A) => A[j]=A0[j])}

    Fv = dim(A)-i

    procedure Incrementa(in-out:A:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)) do

    incrementar(A[i]);

    incrementar(i);

    od;

    endprocedure

    Demostraciones

    1)     Pc =>? I

    {i=0} =>? {0idim(A) ("j)(0j<i => A[j]=A0[j]+1)

    ("j)(ij<dim(A) => A[j]=A0[j])}

    {00dim(A) ("j)(0j<0 => ...) ("j)(0j<dim(A) => A[j]=A0[j]}

    T ( F => ¿) A=A0

    T T T

    2)IB en c/iteración

    IB {i<dim(A) 0idim(A) ("j)(0j<i => A[j]=A0[j]+1)

    ("j)(ij<dim(A) => A[j]=A0[j]) }

    E1 {i=i1 A=A1 i1<dim(A) 0i1dim(A) ("j)(0j<i1 => A1[j]=A0[j]+1)

    ("j)(i1j<dim(A) => A1[j]=A0[j])}

    E2 {i2=i1 A2[i2]=A1[i2]+1 ("j)(ji2 0j<dim(A) => A2[j]=A1[j])}

    E3 {i3=i2+1 A3=A2}

    QPQ E3 => I

    I {0idim(A) ("j)(0j<i => A[j]=A0[j]+1) ("j)(ij<dim(A) => A[j]=A0[j])}

    {i3=i1+1 0i1<dim(A)} => {0i3dim(A)} 1

    {A2[i1]=A1[i1]+1 ("j)(ji1 0j<dim(A) => A2[j]=A1[j])

    ("j)(0j<i1 => A1[j]=A0[j]+1) ("j)(i1j<dim(A) => A1[j]=A0[j])}

    =>

    {("j)(0j<i3 => A3[j]=A0[j]+1) ("j)(i3j<dim(A) => A3[j]=A0[j])} 2

    De 1 y 2 (E3 => I)

    3)FV decreciente y acotada

    FV1=dim(A)-i0

    FV3=dim(A)-i0-1

    Y está acotada en 0 pues 0idim(A)


    4) I ⌐B =>? Qc

    {0idim(A) ("j)(0j<i => A[j]=A0[j]+1) ("j)(ij<dim(A) => A[j]=A0[j])}

    {idim(A)} =>? Qc

    {i=dim(A) ("j)(0j<i => A[j]=A0[j]+1)} Qc

    5) Qc => Q Es trivial

    Ejercicio 4

    4-i)

    P {A=A0 B=B0 C=C0 dim(A)=dim(B)=dim(C)}

    Q {A=A0 B=B0 ("j)(0j<dim(A) => C[j]=A[j]+B[j])}

    Pc {i=0} P

    Qc {i=dim(A)} Q

    B {i<dim(A)}

    I {0idim(A) ("j)(0j<i => C[j]=A[j]+B[j])

    ("j)(ij<dim(A) => C[j]=C0[j]}

    FV = dim(A)-i

    procedure sumpoli

    (in:A:arreglo de integer,in:B:arreglo de integer,out:C:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)) do

    C[i]:=A[i]+B[i];

    i:=i+1;

    od;

    endfunction


    4-ii)

    P {A=A0 B=B0 C=C0 dim(A)=dim(B)=((dim(C)-1)/2)}

    Q {A=A0 B=B0

    ("j)(0j<2*dim(A)-1 => C[j]=f_coef_j_mult (A^dim(A)) (B^dim(B)) j)}

    Pc {i=0} P

    Qc {i=dim(A)*2-1} Q

    B {i<dim(A)*2-1}

    I {0idim(A)*2-1 ("j)(0j<i => C[j]=f_coef_j_mult (A^dim(A)) (B^dim(B)) j)

    ("j)(ij<dim(A)*2-1 => C[j]=C0[j]}

    FV = dim(A)-i

    type Polinomio = [Int]

    coef:: Polinomio -> Int -> Int

    coef pol i = i_esimo pol ((longitud pol-1)-i)

    coef_j_mult:: Polinomio -> Polinomio -> Int -> Int

    coef_j_mult p1 p2 j = sumar p1 p2 j 0

    -- sumar es "sumar coeficientes de grado j cuando multiplico p1 por p2"

    sumar:: Polinomio -> Polinomio -> Int -> Int -> Int

    sumar p1 p2 j cont

    | (j==cont) = (coef p1 j)*(coef p2 0)

    | otherwise = (coef p1 cont)*(coef p2 (j-cont)) +

    sumar p1 p2 j (cont+1)

    procedure multpoli

    (in:A:arreglo de integer,in:B:arreglo de integer,out:C:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)*2-1) do

    C[i]:=Coef_j_mult(A,B,i);

    i:=i+1;

    od;

    endfunction

    //FUNCION AUXILIAR Coef_j_mult

    P {A=A0 B=B0 dim(A)=dim(B) j=J0}

    Q {ret_value=f_coef_j_mult (A^dim(A)) (B^dim(B)) J0 A=A0 B=B0}

    Pc {cont=0 ret_value=0} P

    B {contj}

    Qc {cont=j+1 ret_value=f_sumar_n_veces A^dim(A) B^dim(B) j cont}

    I {0contj+1 ret_value=f_sumar_n_veces A^dim(A) B^dim(B) j cont

    FV = j+1-cont

    sumar_n_veces:: Polinomio -> Polinomio -> Int -> Int -> Int

    sumar_n_veces p1 p2 j 0 = 0

    sumar_n_veces p1 p2 j n = sumar p1 p2 j (j-n+1)

    function Coef_j_mult (A:arreglo de integer,B:arreglo de integer,j:integer):integer

    var

    cont:integer:=0;

    ret_value:=0;

    while (contj) do

    ret_value:=ret_value+A[j-cont]*B[cont];

    cont:=cont+1;

    od;

    endfunction


    4-iii)

    P {A=A0 ⌐("j)(0j<dim(A) => A[j]=0) x=X0 res=res0}

    Q {res=f_evaluar A0^dim(A) X0}

    Pc {i=0 res=0}

    Qc {i=dim(A) res=f_evaluar (f_drop (A0^dim(A)) (dim(A)-i)) X0}

    B {i<dim(A)}

    I {0idim(A) res=f_evaluar (f_drop (A0^dim(A)) (dim(A)-i)) X0 A=A0 x=X0}

    FV = dim(A)-i

    grado pol = vergrado pol 0

    vergrado:: Polinomio -> Int -> Int

    vergrado pol i | (i_esimo pol i) == 0 = vergrado pol (i+1)

    | otherwise = (longitud pol)-1-i

    -- El polinomio nulo NO tiene grado

    evaluar:: Polinomio -> Int -> Int

    evaluar [] _ = 0

    evaluar p x = ev_sumandos p x 0 (grado p)

    ev_sumandos:: Polinomio -> Int -> Int -> Int -> Int

    ev_sumandos p x i g

    | (i==g) = (coef p i)*(x^i)

    | otherwise = (coef p i)*(x^i) + ev_sumandos p x (i+1) g

    procedure Evaluar(in:A:arreglo de integer,in:x:integer,out:res:integer)

    var

    i:integer:=0;

    res:=0;

    while (i<dim(A)) do

    res:=res+A[i]*(x^i);

    i:=i+1;

    od;

    endfunction

    4-iv)

    P {A=A0 B=B0 C=C0 dim(A)=dim(B)=dim(C) x=X0 res=res0

    ⌐("j)(0j<dim(A) => A0[j]+ B0[j]=0)}

    Q {A=A0 B=B0 ("j)(0j<dim(A) => C[j]=A[j]+B[j])

    res=f_evaluar C^dim(A) X0}

    procedure evsuma(in:A:arreglo de integer,in:B:arreglo de integer,in:C:arreglo de integer,in:x:integer,out:res:integer)

    Sumpoli(A,B,C);

    Evaluar(C,x,res);

    endprocedure


    Ejercicio 6

    INTERPRETO QUE HAY QUE ORDENAR EL ARREGLO DE MENOR A MAYOR

    6-i)

    P {A=A0}

    Q {A^dim(A)=f_ordenar_crec A0^dim(A)}

    procedure Ordenar_Arreglo (in-out:A:arreglo de integer)

    var

    L:lista de integer;

    L:=Ordenar(A);

    List2Array(L,A);

    Reverse(A);

    endprocedure

    //Procedimiento auxiliar List2Array

    P {L=L0 A=A0 dim(A)=f_long L0}

    Q {L=L0 A^dim(A)=L0}

    Pc {i=0 L=L0 A=A0}

    Qc {i=f_long L0 A^dim(A)=L0}

    B {i<f_long L}

    I {0if_long L0 L=L0 A^i=f_take L i}

    FV = f_long L - i

    Procedure List2Array (in:L:lista de integer,in-out:A:Arreglo de integer)

    var

    i:integer:=0;

    while (i<Long(L)) do

    A[i]:=Iesimo(L,i);

    i:=i+1;

    od;

    endprocedure

    // PROCEDIMIENTO AUXILIAR Reverse

    P {A=A0}

    Q {("j)(0j<dim(A) => A[j]=A0[dim(A0)-j-1])}

    Pc {i=0 L=A0^dim(A) L=L0}

    Qc {i=dim(A) ("j)(0j<i => A[j]=A0[dim(A0)-j-1])}

    B {i<dim(A)}

    I {(0idim(A)) ("j)(0j<i => A[j]=A0[dim(A0)-j-1])

    ("j)(ij<dim(A) => A[j]=A0[j]) L=L0}

    Fv = dim(A)-i

    procedure Reverse(in-out:A:arreglo de integer):arreglo de integer

    var

    i:integer:=0;

    L:lista de integer;

    L:=Array2List(A);

    while (i<dim(A)) do

    A[i]:=Iesimo(L,dim(A)-i-1);

    i:=i+1;

    od;

    endfunction


    6-ii)

    P {A=A0}

    Q {A^dim(A)=f_burb_n_veces A0^dim(A) (dim(A)-1)}

    Pc {i=0}

    Qc {i=dim(A)-1 A^dim(A)=f_burb_n_veces A0^dim(A) i}

    B {i<dim(A)-1}

    I {0idim(A)-1 A^dim(A)=f_burb_n_veces A0^dim(A) i)

    FV = dim(A)-1-i

    procedure Ordenar_Arreglo(in-out:A:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)-1) do

    Burbujear(A);

    i:=i+1;

    od;

    endprocedure

    //PROCEDIMIENTO AUXILIAR BURBUJEAR

    P {A=A0}

    Q {A^dim(A)=f_burbujear A0^dim(A)}

    Pc {i=0}

    I {0idim(A)-1 A^dim(A)=f_burb_hta A0^dim(A) i}

    Qc {i=dim(A)-1 A^dim(A)=f_burb_hta A0^dim(A) i}

    B {i<dim(A)-1}

    FV = dim(A)-1-i

    procedure Burbujear (in-out:A:arreglo de integer)

    var

    i:integer:=0;

    while (i<dim(A)-1) do

    Ordint(A[i+1],A[i]);

    i:=i+1;

    od;

    endprocedure

    Ejercicios 2-99

    3i)

    Ei {tab=tab0}

    Ef {ret_value=f_cant_casillas_negras tab0}

    Eic {i=0 ret_value=0}

    Efc {i=f_cant_filas tab0

    ret_value=f_cant_casillas_negras_hasta_f tab0 (f_cant_filas tab0)}

    B {i<Cant_filas tab}

    I {ret_value=f_cant_casillas_negras_hasta_f tab0 i (0if_cant_filas tab0)}

    Fv = Cant_filas tab - i

    //cant_casillas_negras::Tab -> Int

    //cant_casillas_negras tab = cant_casillas_negras_hasta_f tab (cant_filas tab)

    //cant_casillas_negras_hasta_f::Tab -> Fila -> Int

    //cant_casillas_negras_hasta_f _ 0 = 0

    //cant_casillas_negras_hasta_f tab f

    //| (f==1) = cant_casillas_negras_fila tab 1 1

    //| ow = cant_casillas_negras_fila tab f 1 + cant_casillas_negras_hasta tab (f-1)

    //cant_casillas_negras_fila::Tab -> Fila -> Columna -> Int

    //cant_casillas_negras_fila tab f c

    //| (c==cant_columnas tab) = cheq_negra tab f c

    //| otherwise = cheq_negra tab f c + cant_casillas_negras_fila tab f (c+1)

    //cheq_negra:: Tab -> Fila -> Columna -> Int

    //cheq_negra tab f c | (color_casilla tab f c == Negro) = 1

    // | otherwise = 0

    function Cant_cas_negras(tab:Tablero):integer

    var

    i:integer:=0;

    ret_value:=0;

    while (i<Cant_filas tab) do

    ret_value:=ret_value+ContarNegras (Fila(tab,i+1))

    incrementar(i);

    od;

    endfunction

    // Funcion auxiliar ContarNegras

    Ei {A=A0}

    Ef {ret_value=f_contarnegras A0^dim(A)}

    Eic {ret_value=0 i=0}

    Efc {ret_value=f_contarnegras A0^dim(A) i=dim(A)}

    B {i<dim(A)}

    I {ret_value=f_contarnegras A0^i (0idim(A))}

    Fv = dim(A)-i

    //contarnegras:: [Color] -> Int

    //contarnegras [] = 0

    //contarnegras (x:xs) | (color_casilla x == negro) = 1 + contarnegras xs

    // | otherwise = contarnegras xs

    function ContarNegras(A:arreglo de colores):integer

    var

    i:integer:=0;

    ret_value:=0;

    while (i<dim(A)) do

    if (A[i]==negro) then

    ret_value:=ret_value+1;

    else

    skip;

    fi;

    i:=i+1;

    od;

    endfunction

    3ii)

    Ei {tab=tab0}

    Ef {ret_value=f_cant_casillas_negras2 tab0}

    Eic {i=0 ret_value=0}

    Efc {i=f_cant_columnas tab0

    ret_value=f_cant_casillas_negras_hta_c tab0 (f_cant_columnas tab0)}

    B {i<Cant_columnas tab}

    I {ret_value=f_cant_casillas_negras_hta_c tab0 i (0if_cant_columnas tab0)}

    Fv = Cant_columnas tab - i

    //cant_casillas_negras2::Tab -> Int

    //cant_casillas_negras2 tab = cant_casillas_negras_hta_c tab (cant_columnas tab)

    //cant_casillas_negras_hta_c::Tab -> Columna -> Int

    //cant_casillas_negras_hta_c _ 0 = 0

    //cant_casillas_negras_hta_c tab c

    //| (c==1) = cant_casillas_negras_col tab 1 1

    //| ow = cant_casillas_negras_col tab 1 c + cant_casillas_negras_hta_c tab (c-1)

    //cant_casillas_negras_col::Tab -> Fila -> Columna -> Int

    //cant_casillas_negras_col tab f c

    //| (f==cant_filas tab) = cheq_negra tab f c

    //| otherwise = cheq_negra tab f c + cant_casillas_negras_col tab (f-1) c

    function Cant_cas_negras2(tab:Tablero):integer

    var

    i:integer:=0;

    ret_value:=0;

    while (i<Cant_Columnas tab) do

    ret_value:=ret_value+ContarNegras (Columna(tab,i+1))

    incrementar(i);

    od;

    endfunction


    3iii)

    Ei {tab=tab0}

    Ef {ret_value=f_cant_casillas_negras3 tab0}

    Eic {f=0 c=0 ret_value=0}

    Efc {f=f_cant_filas tab0 c=f_cant_columnas tab0

    ret_value=f_rec_hta_fc tab0 f c}

    B {not(f==Cant_filas tab and c==Cant_columnas tab)}

    I {ret_value=f_rec_hta_fc tab0 f c (0ff_cant_filas tab0)

    (0cf_cant_columnas tab0)}

    Fv = ((Cant_filas tab)*(Cant_columnas tab))-(c+(f-1)*(Cant_columnas tab))

    //Nota:(c+(f-1)*((Cant_columnas tab)-1)) convierte fila y columna en una posicion

    //cant_casillas_negras3::Tab -> Int

    //cant_casillas_negras3 tab = rec_hta_fc tab (cant_filas tab) (cant_columnas tab)

    //rec_hta_fc::Tab -> Fila -> Columna -> Int

    //rec_hta_fc _ 0 0 = 0

    //rec_hta_fc tab f c

    //| ((f==1)&&(c==1)) = cheq_negra tab f c

    //| ow = cheq_negra tab f c + rec_hta_fc (antFil f) (antCol c)

    //antFil:: Tablero -> Fila -> Columna -> Fila

    //antFil tab f c | (c==1) = f-1

    // | othwerwise = f

    //antCol:: Tablero -> Columna -> Columna

    //antCol tab c | (c==1) = cant_columnas tab

    // | otherwise = c-1

    function Cant_cas_negras3(tab:Tablero):integer

    var

    f:integer:=0;

    c:integer:=0;

    ret_value:=0;

    while (not (f==Cant_filas tab and c==Cant_columnas tab)) do

    if (Color tab (sigFil tab f) (sigCol tab c) == Negro) then

    ret_value:=ret_value+1;

    else

    skip;

    fi;

    f:=sigFil tab f c;

    c:=sigCol tab c;

    od;

    endfunction

    //Funcion auxiliar sigFil

    Ei {tab=tab0 f=f0 c=c0}

    Ef {(c0=f_cant_columnas tab)(f=f0+1) ú (c0<f_cant_columnas tab)(f=f0)}

    function sigFil(tab:tablero,f:integer,c:integer):integer

    if (c==Cant_columnas tab) then

    f:=f+1;

    else

    skip;

    fi;

    endfunction
    //Funcion auxiliar sigCol

    Ei {tab=tab0 c=c0}

    Ef {(c0=f_cant_columnas tab)(c=1) ú (c0<f_cant_columnas tab)(c=c0+1}

    function sigCol(tab:tablero,c:integer):integer

    if (c==Cant_columnas tab) then

    c:=1;

    else

    c:=c+1;

    fi;

    endfunction

    3iv)

    Ei {tab=tab0 Cant_filas tab03 Cant_columnas tab03}

    Ef {ret_value=f_cantidad_cruces_negras tab0}

    Eic {f=1 c=1 ret_value=0}

    Efc {f=(f_cant_filas tab0)-1 c=(f_cant_columnas tab0)-1

    ret_value=f_cant_cruces_hta tab0 f c}

    B {not(f==(Cant_filas tab)-1 and c==(Cant_columnas tab)-1)}

    I {ret_value=f_cant_cruces_hta tab0 f c (0f≤(f_cant_filas tab0)-1)

    (0c≤(f_cant_columnas tab0)-1)}

    Fv=(((Cant_filas tab)-1)*((Cant_columnas tab)-1))-(c+(f-1)*((Cant_columnas tab)-1))

    //Nota:(c+(f-1)*((Cant_columnas tab)-1)) convierte fila y columna en una posicion

    //cantidad_cruces_negras:: Tablero -> Nat

    //cantidad_cruces_negras tab

    // | (cant_filas tab) < 2 || (cant_columnas tab) < 2 = 0

    // | otherwise = cant_cruces_hta tab (cant_filas tab)-1 (cant_columnas tab)-1

    //cant_cruces_hta::Tab -> Fila -> Columna -> Int

    //cant_cruces_hta _ 1 1 = 0

    //cant_cruces_hta tab f c

    //| ((f==2)&&(c==2)) = cheq_cruz tab f c

    //| ow = cheq_cruz tab f c + cant_cruces_hta (antFil4 f) (antCol4 c)

    //antFil4:: Tablero -> Fila -> Columna -> Fila

    //antFil4 tab f c | (c==2) = f-1

    // | othwerwise = f

    //antCol4:: Tablero -> Columna -> Columna

    //antCol4 tab c | (c==2) = cant_columnas tab

    // | otherwise = c-1

    //cheqcruz:: Tablero -> Fila -> Columna -> Nat

    //cheqcruz tab f c | es_cruz tab f c = 1

    | otherwise = 0

    //es_cruz:: Tablero -> Fila -> Columna -> Bool

    //es_cruz tab f c =

    //(color_casilla tab f c == negro) && (color_casilla tab (f-1) c == negro) &&

    //&& (color_casilla tab f (c-1) == negro) && (color_casilla tab f (c+1) == negro) &&

    //&& (color_casilla tab (f+1) c == negro)

    function Cant_cruces_negras(tab:tablero):integer

    var

    f:integer:=1;

    c:integer:=1;

    ret_value:=0;

    while (not(f==(Cant_filas tab)-1 and c==(Cant_columnas tab)-1)) do

    if (Es_centro_cruz tab (f+1) (c+1)) then

    ret_value:=ret_value+1;

    else

    skip;

    fi;

    f:=sigFil tab f c;

    c:=sigCol tab c;

    od;

    endfunction


    //Funcion auxiliar Es_centro_cruz

    Ei {tab=tab0 f=f0 c=c0 Cant_filas tab03 Cant_columnas tab03

    2f0≤((f_cant_filas tab0)-1) 2c0((f_cant_columnas tab0)-1)}

    Ef {(f_Color tab0 f0 c0 == Negro) (f_Color tab0 f0-1 c0 == Negro)

    (f_Color tab0 f0 c0-1 == Negro) (f_Color tab0 f0 c0+1 == Negro)

    (f_Color tab0 f0+1 c0 == Negro)}

    function Es_centro_cruz(tab:tablero,f:integer,c:integer):bool

    if ((Color tab f c == Negro) (Color tab f-1 c == Negro)

    (Color tab f c-1 == Negro) (Color tab f c+1 == Negro)

    (Color tab f+1 c == Negro)) then

    ret_value:=True;

    else

    ret_value:=False;

    fi;

    endfunction

    Ejercicio práctica)

    Tengo dos arreglos de enteros A y B, con dim(A)>dim(B), y quiero devolver un arreglo con la dimensión de A y que cumpla que:

    1)hasta la posicion (dim(B)-1) sumar los elementos de A con los de B

    2)El resto del arreglo dejarlo igual

    Ei {dim(A)>dim(B)}

    Eic1 {i=0}

    Efc1 {i=dim(B) ("j)((0j<dim(B)) => (ret_value[i]=A[j]+B[j]))}

    B1 {i<dim(B)}

    I1 {(0idim(B)) ("j)((0j<i) => (ret_value[i]=A[j]+B[j]))}

    Fv1 = dim(B)-i

    Eic2 Efc1

    Efc2 {i=dim(A) ("j)((dim(B)j<dim(A)) => (ret_value[j]=A[j]))

    ("k)((0k<dim(B)) => (ret_value[k]=A[k]+B[k]))}

    B2 {i<dim(A)}

    I2 {(dim(B)idim(A)) ("j)((dim(B)j<i) => (ret_value[j]=A[j]))

    ("k)((0k<dim(B)) => (ret_value[k]=A[k]+B[k]))}

    Fv2 = dim(A)-i

    Ef Efc2

    function Sumarreglos(A:arreglo de int,B:arreglo de int):arreglo[0..dim(A)-1] de int

    var

    i:integer:=0;

    while (i<dim(B)) do

    ret_value[i]:=A[i]+B[i];

    i:=i+1;

    od;

    while (i<dim(A)) do

    ret_value[i]:=A[i];

    i:=i+1;

    od;

    endfunction


    //Otra forma (con un solo ciclo en vez de dos)

    Ei {dim(A)>dim(B)}

    Eic {i=0}

    Efc {i=dim(A) ("j)((dim(B)j<dim(A)) => (ret_value[j]=A[j]))

    ("k)((0k<dim(B)) => (ret_value[k]=A[k]+B[k]))}

    B {i<dim(A)}

    I {(0idim(A)) ("j)((dim(B)j<i) => (ret_value[j]=A[j]))

    ("k)((0k<min(i,dim(B))) => (ret_value[k]=A[k]+B[k]))}

    Fv = dim(A)-i

    Ef Efc

    function Sumarreglos1(A:arreglo de int,B:arreglo de int):arreglo[0..dim(A)-1] de int

    var

    i:integer:=0;

    while (i<dim(A)) do

    if (i<dim(B)) then

    ret_value[i]:=A[i]+B[i];

    else

    ret_value[i]:=A[i];

    fi;

    i:=i+1;

    od;

    endfunction

    Ejercicio práctica)

    Recibo un arreglo y tengo que devolver el mismo arreglo con los elementos multiplicados por 2

    Ei {A=A0}

    Ef Efc

    Eic {i=0}

    Efc {i=dim(A) ("j)((0j<dim(A)) => (ret_value[j]:=2*A[j]))}

    B {i<dim(A)}

    I {(0idim(A)) ("j)((0j<i) => (ret_value[j]:=2*A[j])

    ("k)((ik<dim(A)) => (A[k]=B[k]))}

    Fv = dim(A)-i

    function Multpor2(A:arreglo de integer):arreglo[0..dim(A)-1] de integer

    var

    i:integer:=0;

    while (i<dim(A)) do

    ret_value[i]:=2*A[i];

    i:=i+1;

    od;

    endfunction

    Ejercicio de la Practica)

    Procedure Swap: le paso un arreglo y dos enteros menores que la dimension y devuelve el arreglo con las posiciones intercambiadas

    Ei {A=A0 (0n<dim(A)) (0m<dim(A))}

    Ef {A[n]=A0[m] A[m]=A0[n] ("i)(((0i<dim(A)) in im) => (A[i]=A0[i])}

    Procedure Swap(inout:A:arreglo de integer,in:n:integer,in:m:integer)

    var

    aux:integer:=A[n];

    A[n]:=A[m];

    A[m]:=aux;

    endprocedure


    Votar

    Ingresar una calificación para del 1 al 10, siendo 10 el máximo puntaje.

    Para que la votación no tenga fraude, solo se podrá votar una vez este recurso.

    Comentarios de los usuarios


    Agregar un comentario:


    Nombre y apellido:

    E-Mail:

    Asunto:

    Opinión:



    Aún no hay comentarios para este recurso.
     
    Sobre ALIPSO.COM

    Monografias, Exámenes, Universidades, Terciarios, Carreras, Cursos, Donde Estudiar, Que Estudiar y más: Desde 1999 brindamos a los estudiantes y docentes un lugar para publicar contenido educativo y nutrirse del conocimiento.

    Contacto »
    Contacto

    Teléfono: +54 (011) 3535-7242
    Email:

    Formulario de Contacto Online »