Instrucciones Taller “PARCIAL2B_15” (15% de la nota)

 Se debe entregar un informe “Word”, al finalizar la hora asignada por el profesor.

 Deben formar grupos de a dos o tres personas, pero se permiten grupos individuales
 Deben enviar un informe en “Word” vía correo electrónico al profesor y en el informe debe
estar incluido el programa “PseInt” elaborado durante el tiempo asignado por el profesor.

Correo electrónico: fsalazard@unal.edu.co

Nombre del informe (archivo “WORD”) adjunto al correo:
Prog_I_2020_PARCIAL2B_15@prefijo_correo_quien_envia (Ojo: una sola persona)
Asunto del correo:
PARCIAL2B_15@pref_correo_1er_estud@pref_correo_2do_estud@pref_correo_3er_estud
(Ojo: de todas las personas que participan en el grupo)
Cuerpo del mensaje: Programa “PseInt” elaborado durante la prueba
Contenido del informe (archivo “WORD”) adjunto al correo:
1) Portada (hoja por separado) de presentación: nombre de la universidad, nombre, el correo y
la identificación de los integrantes del grupo, fecha del informe.
2) Este documento (obligatorio) “Word” (Taller PARCIAL2B_15)
3) Programa “PseInt” (especificando al comienzo del programa en una sección de comentarios
los nombres de las personas del grupo) y aclarando cuál informe valdrá como
Taller 2do 15% (ojo: aplica solo para aquellos que presentaron el taller
el 30 de abril el Taller)
NOTAS:
1) En el cuerpo del mensaje electrónico deberá ir solamente el código fuente del algoritmo
“PseInt” elaborado por el grupo de los dos estudiantes. No se tendrá en cuenta cualquier
otro archivo adjunto (.pdf, .psc, etc.) enviado en el correo (Advertencia: sino aparece archivo
“Word” la nota del trabajo será de cero y no se valdrá, así haya un programa “PseInt”,
enviado en el cuerpo del mensaje).
2) Programa que no desarrolle el tema obligatorio con las restricciones que adelante se darán,
o taller que no venga con el documento “Word” Taller PARCIAL2B_15, tendrá como nota
cero (0).
3) Se penalizará la nota del taller, si tanto el nombre del archivo “Word” adjunto en al correo,
como el asunto del mensaje, no vienen claramente descritos de acuerdo a las normas
explicadas al comienzo de estas instrucciones.
Gráfica tema del taller, con “marco” de ancho y de alto 6.4a, con un cuadrado girado,
de lado 4.5a, cuyo primer vértice está rotado alfa grados y con un círculo de radio “a”
(tener presente que fuera del marco es región 6)

Actividad: desarrolle un programa en “PseInt”, tal que ejecute las siguientes acciones:

1) Leer el valor de “a” en el rango [+0.55 .. +23.75] y múltiplo de 0.125

2) Leer el número de coordenadas a procesar en el rango de [ 33 .. 48]
3) Leer el valor de ángulo “alfa” (tipo de dato entero y unidades en grados) en el rango [+1 .. +44],
es decir sin decimales
4) Leer el número de coordenadas y almacenarlas en un par de vectores. Rango de lectura para las
coordenadas a leer, tanto para la “x” como para las “y”: [ -6.6*a .. +6.6*a];
5) Usar los vectores obtenidos en el paso 4) para determinar cuántos puntos caen en cada una de
las regiones de acuerdo a la gráfica ilustrada. Dichos resultados deben quedar almacenados en un
arreglo lineal
6) Presentar los resultados usando una función creada por el usuario

Notas:
1) Tener presente el concepto "frontera" (región 0) y fuera del “marco” (región 6)
2) Obligatorio realizar las operaciones de lectura (“leer”) utilizando la función azar
3) Seguir la restricción según se indica más adelante

Para la escritura del programa “PseInt” (código fuente) hay restricciones de codificación en la
formación de nombres de variables y nombres de funciones

Restricción: no se pueden utilizar para la formación de nombres de variables y nombres de

funciones, que comiencen y contengan los siguientes caracteres: b, i, j, k, N, x, y, r
Notas obligatorias:
1) Obligatorio usar variables lógicas (siguiendo la metodología “divide y reinaras” – “DyR”)
2) Se repite: Obligatorio usar para las operaciones de lectura (Leer), la función azar
3) Obligatorio tener presente la región 0 (cero) como la región frontera, según lo explicado en
clase
4) Obligatorio usar arreglos de tipo lógico y arreglos de tipo numérico, donde se puedan usar
5) Obligatorio aplicar la restricción de codificación descrita

Ayuda1: Del Principio de Perpendicularidad: Si dos rectas se cortan perpendicularmente entonces

(m1=-1/m2), donde m1 es la pendiente de la recta 1 y m2 es la pendiente de la recta 2

Ayuda2: Conocido el valor de la hipotenusa y su respectivo ángulo, la abscisa o componente en “x”

está dada por el valor de la hipotenusa*coseno de su ángulo, y la ordenada o componente en “y”
está dada por el valor de la hipotenusa*seno de su ángulo

Ayuda3: En el caso de un cuadrado, si se conoce la coordenada de uno de sus vértices, se puede

determinar las coordenadas del resto de sus vértices

Solución (parte A)

Funcion EscC(Cot)
Definir c,tot como entero
tot=0
Para c=0 hasta 6 hacer
Escribir sinsaltar" cot[",c,"]:",Cot[c];tot=tot+Cot[c]
FinPara
Escribir"";Escribir " .. sumatoria contadores:",tot
FinFuncion
Funcion L=fup(up,vp,m,t)
Definir L como logico
L=vp>m*up+t
FinFuncion
Funcion L=fdd(up,vp,m,p)
Definir L como logico
L=vp<m*up+p
FinFuncion
Algoritmo Rescate2do15Mayo2020R
///1) Leer el valor de "a" en el rango [+0.55 .. +23.75] y múltiplo de 0.125
///2) Leer el número de coordenadas a procesar en el rango de [ 33 .. 48]
 ///3) Leer el valor de ángulo "alfa" (entero y unidades en grados) en el rango [+1 .. +44], sin
decimales
///4) Leer el número de coordenadas y almacenarlas en un par de vectores.
/// Rango de lectura para las coordenadas a leer, tanto para la "x" como para las "y":
/// [ -6.69*a .. +6.69*a];
///5) Usar los vectores obtenidos en el paso 4) para determinar cuántos puntos caen en cada
una de las regiones
/// de acuerdo a la gráfica ilustrada. Dichos resultados deben quedar almacenados en un
arreglo lineal
///6) Presentar los resultados usando una función creada por el usuario
/// "marco" de ancho y de alto 6.4a; cuadrado girado, de lado 4.5a; círculo de radio "a"
Definir alfaG,c,d,k,MM,Cot Como Entero
Definir a,alfaP,h,u,v,m,Uc,Vc,ua,up,vp,L,aa Como Real
Definir peg,L31,L51,L22,L42,L33,L53,L44,L24 como logico
Definir Cu,DentC,FueC,DentM,FueM,AuuU,AbaU Como logico
Dimension u[99],v[99],Uc[5],Vc[5],Cot[7],peg[7],m[5],ua[5],Cu[5],AuuU[5],AbaU[5]
a=azar(2321)+55;mientras a%125!=0 hacer a=azar(2321)+55;FinMientras
a=a/100
//a=10 para probar inicialmente
aa=a; ///
MM=azar(16)+33;
//MM=99 para probar inicialmente
alfaG=azar(44)+1
//alfaG=30 para probar inicialmente
para c=0 hasta MM-1 Hacer
u[c]=a*((azar(1339)-669)/1000);v[c]=a*((azar(1339)-669)/1000);
FinPara
alfaP=(alfaG*pi/180.0);Escribir".. alfaG:",alfaG," grados .. alfaP:",alfaP," radianes"
L=4.5*a;h=(L/2)/rc(2);Uc[1]=h*cos(alfaP);Vc[1]=h*sen(alfaP)
Uc[2]=-Vc[1];Vc[2]=Uc[1];Uc[3]=-Uc[1];Vc[3]=-Vc[1];Uc[4]=-Uc[2];Vc[4]=-Vc[2];
m[1]=(Vc[2]-Vc[1])/(Uc[2]-Uc[1]);m[4]=-1/m[1];m[3]=m[1];m[2]=m[4];
Para c=1 hasta 4 hacer ua[c]=Vc[c]-m[c]*Vc[c];FinPara ///b[i]=Yc[i]-m[i]*Yc[i]
Para c=0 hasta 6 hacer Cot[c]=0; FinPara
para c=0 hasta MM-1 Hacer
up=u[c];vp=v[c]
Cu[1]=up>0&vp>0;Cu[2]=up<0&vp>0;Cu[3]=up<0&vp<0;Cu[4]=up>0&vp<0;
DentC=(up)^2+(vp)^2<aa^2;FueC=(up)^2+(vp)^2>aa^2;
Para d=1 hasta 4 hacer AuuU[d]=fup(up,vp,m[d],ua[d]); finpara
Para d=1 hasta 4 hacer AbaU[d]=fdd(up,vp,m[d],ua[d]); finpara
FueM=up>(6.3*a/2)|up<-(6.3*a/2)|vp>(6.3*a/2)|up<-(6.3*a/2)
DentM=up<(6.3*a/2)&up>-(6.3*a/2)&vp<(6.3*a/2)&up>-(6.3*a/2)
///
L31=Cu[1]&FueC&AbaU[1]&AuuU[4]
 L51=Cu[1]&DentM&(AuuU[1]|AbaU[4])
L22=Cu[2]&FueC&AbaU[1]&AbaU[2]
L42=Cu[2]&DentM&(AuuU[1]|AuuU[2])
L33=Cu[3]&FueC&AbaU[2]&AuuU[3]
L53=Cu[3]&DentM&(AuuU[2]|AbaU[3])
L44=Cu[4]&FueC&AuuU[3]&AuuU[4]
L24=Cu[4]&DentM&(AbaU[3]|AbaU[4])
peg[1]=DentC
peg[2]=L22|L24
peg[3]=L31|L33
peg[4]=L42|L44
peg[5]=L51|L53
peg[6]=FueM
k=0
para d=1 hasta 6 Hacer
si peg[d] Entonces
k=d;
FinSi
FinPara
Cot[k]=Cot[k]+1;
FinPara
Escribir"";Escribir" ..a:",a," .. N:",MM
EscC(Cot)
FinAlgoritmo

Solución (parte B) con una función que genera puntos para probar la
solución

Funcion M=GeneraPtos(x,y,c)
Definir i,j,k,l,N,M Como Entero
Definir yi,yf,dy,xi,xf,dx Como Real
xi=-6*3.2*c/5;xf=+5*3.2*c/5;dx=3.2*c/5
yi=-6*3.2*c/5;yf=+5*3.2*c/5;dy=3.2*c/5;
N=trunc((xf-xi)/dx)+1
M=trunc((yf-yi)/dy)+1
Escribir" .. Usando la función GeneraPtos()"
Escribir" ..N:",N," ..M:",M," ..N*M:",N*M
/// Generando Puntos con ciclos "para"
k=0;//Escribir""
Para i=0 hasta N-1 hacer
Para j=0 hasta M-1 hacer
x[k]=xi;y[k]=yi;///Escribir".. k:",k," ..x:",x[k]," ..y:",y[k]
yi=yi+dy;k=k+1;
 FinPara
yi=-2.25*c;yf=+2.25*c
xi=xi+dx
FinPara
///Escribir""
M=k; /// Valor que regresa la función
Escribir" ..M:",M
FinFuncion
Funcion EscribaCont(Cont)
Definir i,tot como entero
tot=0
Para i=0 hasta 6 hacer
Escribir sinsaltar" cont[",i,"]:",cont[i];tot=tot+cont[i]
FinPara
Escribir"";Escribir " .. sumatoria contadores:",tot
FinFuncion
Funcion L=farriba(xp,yp,m,b)
Definir L como logico
L=yp>m*xp+b
FinFuncion
Funcion L=fabajo(xp,yp,m,b)
Definir L como logico
L=yp<m*xp+b
FinFuncion
Algoritmo PruebaRescate2do7Mayo2020B
///1) Leer el valor de "a" en el rango [+0.55 .. +23.75] y múltiplo de 0.125
///2) Leer el número de coordenadas a procesar en el rango de [ 33 .. 48]
///3) Leer el valor de ángulo "alfa" (entero y unidades en grados) en el rango [+1 .. +44], sin decimales
///4) Leer el número de coordenadas y almacenarlas en un par de vectores.
/// Rango de lectura para las coordenadas a leer, tanto para la "x" como para las "y":
/// [ -6.69*a .. +6.69*a]
///5) Usar los vectores obtenidos en el paso 4) para determinar cuántos puntos caen en cada una de las
regiones
/// de acuerdo a la gráfica ilustrada. Dichos resultados deben quedar almacenados en un arreglo lineal
///6) Presentar los resultados usando una función creada por el usuario
/// "marco" de ancho y de alto 6.4a; cuadrado girado, de lado 4.5a; círculo de radio "a"
Definir alfaG,i,j,k,N,Cont Como Entero
Definir a,alfaR,h,x,y,Xc,Yc,xp,yp,L,r,m,b Como Real
Definir reg,L31,L51,L22,L42,L33,L53,L44,L24 como logico
Definir Cu,DentroC,FueraC,DentroM,FueraM,ArrR,AbaR Como logico
Dimension x[299],y[299],Xc[5],Yc[5],Cont[7],reg[7],m[5],b[5],Cu[5],ArrR[5],AbaR[5]
a=azar(2321)+55;mientras a%125!=0 hacer a=azar(2321)+55;FinMientras
a=a/100
//a=10. /// Para pruebas
r=a; ///
N=azar(16)+33;
N=99 /// Para pruebas
alfaG=azar(44)+1
//alfaG=30 /// Para pruebas
para i=0 hasta N-1 Hacer
 x[i]=a*((azar(1339)-669)/100);y[i]=a*((azar(1339)-669)/100);
FinPara
N=GeneraPtos(x,y,a)
alfaR=(alfaG*pi/180.0); Escribir".. alfaG:",alfaG," .. alfaR:",alfaR
L=4.5*a;h=(L/2)/rc(2);Xc[1]=h*cos(alfaR);Yc[1]=h*sen(alfaR)
Escribir"..Xc[1] ; Yc[1]..:",Xc[1]," ",Yc[1]
Escribir" ..r:",r," ..h:",h," ..L/2:",L/2," ..Lado del Marco:",6.3*a
Xc[2]=-Yc[1];Yc[2]=Xc[1];Xc[3]=-Xc[1];Yc[3]=-Yc[1];Xc[4]=-Xc[2];Yc[4]=-Yc[2];
m[1]=(Yc[2]-Yc[1])/(Xc[2]-Xc[1]);m[4]=-1/m[1];m[3]=m[1];m[2]=m[4];
Para i=1 hasta 4 hacer b[i]=Yc[i]-m[i]*Xc[i];
Escribir"..i,x[i],y[i],m[i],b[i]: ",i,": ",xc[i]," ",yc[i]," ",m[i]," ",b[i]
FinPara ///b[i]=Yc[i]-m[i]*Yc[i]
Para i=0 hasta 6 hacer Cont[i]=0; FinPara
para i=0 hasta N-1 Hacer
xp=x[i];yp=y[i]
Cu[1]=xp>0&yp>0;Cu[2]=xp<0&yp>0;Cu[3]=xp<0&yp<0;Cu[4]=xp>0&yp<0;
DentroC=xp^2+yp^2<r^2;FueraC=xp^2+yp^2>r^2;
Para j=1 hasta 4 hacer ArrR[j]=farriba(xp,yp,m[j],b[j]); finpara
Para j=1 hasta 4 hacer AbaR[j]=fabajo(xp,yp,m[j],b[j]); finpara
FueraM=xp>(6.3*a/2)|xp<-(6.3*a/2)|yp>(6.3*a/2)|xp<-(6.3*a/2)
DentroM=xp<(6.3*a/2)&xp>-(6.3*a/2)&yp<(6.3*a/2)&yp>-(6.3*a/2)
///
L31=Cu[1]&FueraC&AbaR[1]&ArrR[4]
L51=Cu[1]&DentroM&(ArrR[1]|AbaR[4])
L22=Cu[2]&FueraC&AbaR[1]&AbaR[2]
L42=Cu[2]&DentroM&(ArrR[1]|ArrR[2])
L33=Cu[3]&FueraC&AbaR[2]&ArrR[3]
L53=Cu[3]&DentroM&(ArrR[2]|AbaR[3])
L44=Cu[4]&FueraC&ArrR[3]&ArrR[4]
L24=Cu[4]&DentroM&(AbaR[3]|AbaR[4])
reg[1]=DentroC
reg[2]=L22|L24
reg[3]=L31|L33
reg[4]=L42|L44
reg[5]=L51|L53
reg[6]=FueraM
k=0
para j=1 hasta 6 Hacer
//Escribir sin saltar" ",reg[j]
si reg[j] Entonces
k=j;
FinSi
FinPara
cont[k]=cont[k]+1;//Escribir""
Escribir" el punto x[",i,"],y[",i,"]:(",x[i],",",y[i],") ..está en:",k
FinPara
Escribir"";Escribir" ..a:",a, " .. N:",N
EscribaCont(Cont)
FinAlgoritmo
Paseo del caballo: para acabar de entender la construcción de los cuadrados mágicos,
a continuación aparecen dos matrices no cuadradas de orden (N=7, M=6). Una de las
matrices está parcialmente ocupada por una serie de números en forma consecutiva.
Al recorrer consecutivamente la serie verán que esos “movimientos” semejan el
movimiento de la pieza de ajedrez “Caballo”. La otra matriz está vacía. Con dicha
matriz, cada uno de ustedes, realice otro “Paseo del Caballo”.
Deduzca intuitivamente el “Paseo del Caballo”, antes de pasar al siguiente párrafo de
instrucciones
Instrucciones: coloque el número uno (1) donde quiera hacerlo dentro del tablero y
empiece a desplazarse (hacer “movimientos”) en forma de ele (“L”) a través del
tablero. Durante el recorrido no se puede “ocupar” una posición “ya ocupada”,
tampoco puede hacerlo fuera del tablero. Hágalo hasta que se le agoten las ocho (8)
posibilidades que tienen para cada movimiento (en cuyo caso el “Caballo” se
“ahoga”).

Para la matriz parcialmente ocupada el último movimiento se realizó con el número 34 en la posición (2, 5)
Note que las denominaciones de las filas (primer subíndice, i) crecen en forma vertical
de arriba hacia abajo y que las denominaciones de las columnas (segundo subíndice, j)
crecen en forma horizontal de izquierda a derecha

Matrices en el juego del Ajedrez

Desplazamientos de la pieza de ajedrez caballo, desde la posición (i 0, j0)

Aquí la posición (i0, j0) = (2, 2)

Las filas van en sentido horizontal y aumentan de arriba hacia abajo

Las columnas van en sentido vertical y aumentan de izquierda a derecha

Algoritmo caballo_I_2020
Definir T,ii,jj,i,j,k,n,m,i0,j0,ix,jy Como Entero
Dimension T(8,8),ii(8),jj(8)
 ii(0)=2;ii(1)=2;ii(2)=1;ii(3)=1;ii(4)=-1;ii(5)=-1;ii(6)=-2;ii(7)=-2;
jj(0)=-1;jj(1)=1;jj(2)=-2;jj(3)=2;jj(4)=2;jj(5)=-2;jj(6)=-1;jj(7)=1;
n=8; ///orden del Tablero
/// Inicializando tablero: colocar cero (0) en cada posición para indicar tablero vacío
Para i=0 Hasta n-1 Con Paso 1 Hacer
Para j=0 Hasta n-1 Con Paso 1 Hacer
T[i,j]=0
FinPara
FinPara
i0=Azar(n)
j0= Azar(n)
///i0=3;j0=4; /// para probar inicialmente
k=1;T[i0,j0]=k;
Escribir"";Escribir" .. posición inicial:","(",i0,",",j0,")= ", T[i0,j0];Escribir"";
ix=i0;jy=j0;m=8*8;
/// Efecuando "Paeo" sin repetir posición "ocupada"
Para j=2 Hasta m Con Paso 1 Hacer
Para i=0 Hasta 7 Con Paso 1 Hacer
ix=i0+ii(i);jy=j0+jj(i);
Si ix>-1 & ix<8 & jy>-1 & jy<8 Entonces
Si T[ix,jy]=0 Entonces
k=k+1;T[ix,jy]=k;
i0=ix;j0=jy;
FinSi
FinSi
FinPara
FinPara
Para i=0 Hasta n-1 Con Paso 1 Hacer
Para j=0 Hasta n-1 Con Paso 1 Hacer
si T[i,j]<10 entonces escribir sin saltar"0";finsi
Escribir sin saltar T[i,j]," "
FinPara
Escribir" "
FinPara
Escribir " "
Escribir" k:",k
FinAlgoritmo