// Juego simple que pide al usuario que adivine un numero en 10 intentos

Proceso Adivina Numero

intentos<-9;
num_secreto <- azar(100)+1;

Escribir "Adivine el numero (de 1 a 100):";

Leer num_ingresado;
Mientras num_secreto<>num_ingresado & intentos>0 Hacer
Si num_secreto>num_ingresado Entonces
Escribir "Muy bajo";
Sino
Escribir "Muy alto";
FinSi
Escribir "Le quedan ",intentos," intentos:";
Leer num_ingresado;
intentos <- intentos-1;
FinMientras

Si intentos=0 Entonces
Escribir "El numero era: ",num_secreto;
Sino
Escribir "Exacto! Usted adivino en ",11-intentos," intentos.";
FinSi

FinProceso

Proceso Factorización

Escribir "Ingrese el numero: ";

Leer num;

Escribir "Factorizacion: ";

factorizar<-verdadero;

Mientras factorizar & num>1 hacer

div<-0;
Si num/2 = trunc(num/2) Entonces
Escribir 2;
num<-num/2;
Sino
div<-1; factor_primo<-Verdadero;
Mientras div<=rc(num) & factor_primo Hacer
div <- div+2;
Si num/div = trunc(num/div) Entonces
factor_primo <- Falso;
FinSi
FinMientras
Si factor_primo Entonces
escribir num;
factorizar<-falso;
sino
escribir div;
num<-num/div;
factor_primo<-verdadero;
 FinSi
FinSi
FinMientras

FinProceso

// El objetivo del juego es mover los discos de la torre 1 a la 3 en la

// menor cantidad de movimientos posible. No se puede colocar un disco de
// un tamanio sobre otro mas chico

// Hay una matriz que representa las torres, cada columna contiene
// nros que representan los tamanios de los discos en esas torres (solo
// interesan los valores hasta la cantidad de discos de esa torre).
// Cuantos discos tiene cada torre lo dice el vector cant_discos.

Proceso Hanoi

Dimension torres[3,10], cant_discos[3];

// pedir y validar cuantos discos colocar en la primer torre

Escribir "Ingrese el nro de discos (1-5):";
leer discos;
mientras discos<1 | discos>8 Hacer
Escribir "El numero de discos debe ser mayor a 0 y menor a 5:";
leer discos;
finmientras

// inicializar los datos

cant_discos[1]<-discos;
cant_discos[2]<-0;
cant_discos[3]<-0;
para i<-1 hasta discos hacer
torres[1,i]<-discos-i+1;
finpara

cant_movs<-0;

// jugar!
mientras (cant_discos[3]<>discos) Hacer // mientras no esten todos los discos
en la tercer torre, el juego sigue

para i<-1 hasta 3 Hacer // dibujar las tres torres

escribir "";
escribir "Torre ",i;
si cant_discos[i]=0 Entonces
Escribir "";
sino
para j<-cant_discos[i] hasta 1 con paso -1
Hacer // recorrer los discos de la torre, de arriba hacia abajo
segun torres[i,j] Hacer // dibujar
cada disco
1: escribir
" XX";
2: escribir
" XXXXXX";
3: escribir "
XXXXXXXXXX";
 4: escribir "
XXXXXXXXXXXXXX";
5: escribir "
XXXXXXXXXXXXXXXXXX";
6: escribir "
XXXXXXXXXXXXXXXXXXXXXX";
7: escribir "
XXXXXXXXXXXXXXXXXXXXXXXXXX";
8: escribir "
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
finsegun
FinPara
finsi
Escribir " ----------------------------------";
escribir "";
FinPara

// solicitar movimiento
Escribir "Mover desde la torre: ";
leer t1;
Escribir "hacia la torre: ";
leer t2;

si t1<0 | t1>3 | t2<0 | t2>3 Entonces // controlar que el nro de

torre sea valido
escribir "Movimiento invalido";
sino
si cant_discos[t1]=0 Entonces // controlar que la torre 1
tengo al menos un disco
escribir "Movimiento invalido";
Sino
disco_a_mover <- torres[t1,cant_discos[t1]]; //
obtener tamanio del disco que se quiere mover
puede_mover<-verdadero;
si cant_discos[t2]<>0 entonces // controlar que
la torre dos no tenga discos o tenga discos mas grandes
si
torres[t2,cant_discos[t2]]<disco_a_mover Entonces
puede_mover<-Falso;
FinSi
FinSi
si puede_mover Entonces // si paso todos los
controles, mover
cant_movs <- cant_movs+1;
cant_discos[t2]<-cant_discos[t2]+1;
torres[t2,cant_discos[t2]] <-
disco_a_mover;
cant_discos[t1]<-cant_discos[t1]-1;
Sino
escribir "Movimiento invalido";
finsi
FinSi
finsi

finmientras

// mostrar resultado
escribir "";
escribir "";
 escribir "Juego finalizado en ",cant_movs," movimientos!";
escribir "";

FinProceso

// Este ejemplo muestra el uso de expresiones, operadores y funciones matematicas

Proceso Matematicas
Salir<-0;
Escribir 'Ingresar Numero:';
Leer N;
Repetir
Escribir ' ';
Escribir 'Presione Enter para continuar';
Leer x;
Escribir '1 - Seno, Coseno, ArcoTangente';
Escribir '2 - Lograritmo Natural, Funcion Exponencial';
Escribir '3 - Truncar, Redondear';
Escribir '4 - Raiz Cuadrada';
Escribir '5 - Valor Absoluto';
Escribir '6 - Separar parte entera y decimal';
Escribir '7 - Hallar Factorial';
Escribir '8 - Averiguar si es primo';
Escribir '9 - Ingresar Otro Numero';
Escribir ' ';
Escribir '0 - para Salir';
Escribir ' ';
Leer Opcion;
Segun Opcion Hacer
1:
Escribir 'Seno:',Sen(N);
Escribir 'Coseno:',Cos(N);
Escribir 'ArcTangente:',Atan(N);
2:
Si N<=0
Entonces Escribir 'El numero debe ser mayor a cero!';
Sino
Escribir 'Log Nat.:',ln(N);
Escribir 'Func Expon.:',exp(N);
FinSi
3:
Escribir 'Turncar:',trunc(N);
Escribir 'Redondear:',redon(N);
4: Escribir 'Raiz Cuad.:',rc(N);
5: Escribir 'Valor Abs.:',abs(N);
6:
Escribir 'Parte Entera:',Trunc(n);
Escribir 'Parte Decimal:',n-Trunc(n);
7:
Si N<>Trunc(N)
Entonces
Escribir 'El numero debe ser entero!';
Sino
Si abs(N)>50
Entonces Escribir 'Resultado muy grande!';
Sino
r<-1; f<-1;
 Mientras f<=abs(N) Hacer
Si N<0
Entonces r<-(-f)*r;
Sino r<-f*r;
FinSi
f<-f+1;
FinMientras
Escribir 'Factorial:',r;
FinSi
FinSi
8:
Si N<>Trunc(N)
Entonces
Escribir 'El numero debe ser entero!';
Sino
Primo<-'Si';
Si N/2=trunc(N/2)
Entonces
Primo<-'No';
FinSi
Si N<0
entonces Nu<-N*-1;
sino Nu<-N;
FinSi
Nu<-RC(Nu);
f<-3;
Mientras f<=Nu & Primo='Si' Hacer
Si N/F=trunc(N/F)
Entonces Primo<-'No';
FinSi
f<-f+2;
FinMientras
Escribir 'Numero Primo:',Primo;
Si f=3
Entonces F<-4;
FinSi
Si Primo='No'
Entonces
Escribir N,'=',f-2,'x',N/(f-2);
FinSi
FinSi
9:
Escribir 'Ingrese Numero:';
Leer N;
0: Salir<-1;
De Otro Modo:
Escribir 'Opcion No Valida!';
FinSegun
Hasta que Salir=1
FinProceso
// Se ingresa una lista de nombres (la lista termina
// cuando se ingresa un nombre en blanco) no permitiendo
// ingresar repetidos y luego se ordena y muestra

Proceso OrdenaLista

Dimension lista[200];

Escribir "Ingrese los nombres (enter en blanco para terminar):";

// leer la lista
cant<-0;
Leer nombre;
Mientras nombre<>"" Hacer
cant<-cant+1;
lista[cant]<-nombre;
Repetir // leer un nombre y ver que no este ya en la lista
Leer nombre;
se_repite<-Falso;
Para i<-1 Hasta cant Hacer
Si nombre=lista[i] Entonces
se_repite<-Verdadero;
FinSi
FinPara
Hasta Que ~se_repite
FinMientras

// ordenar
Para i<-1 Hasta cant-1 Hacer
// busca el menor entre i y cant
pos_menor<-i;
Para j<-i+1 Hasta cant Hacer
Si lista[j]<lista[pos_menor] Entonces
pos_menor<-j;
FinSi
FinPara
// intercambia el que estaba en i con el menor que encontro
aux<-lista[i];
lista[i]<-lista[pos_menor];
lista[pos_menor]<-aux;
FinPara

// mostrar como queda la lista

Escribir "La lista ordenada es:";
Para i<-1 Hasta cant Hacer
Escribir " ",lista[i];
FinPara

FinProceso
// Calcula el promedio de una lista de N datos

Proceso Promedio

Escribir "Ingrese la cantidad de datos:";

Leer n;

acum<-0;

Para i<-1 Hasta n Hacer

Escribir "Ingrese el dato ",i,":";
Leer dato;
acum<-acum+dato;
FinPara

prom<-acum/n;

Escribir "El promedio es: ",prom;

FinProceso

// calcula las raices de una ecuacion de segundo grado

Proceso Resolvente

// cargar datos
Escribir "Ingrese el coeficiente A:";
Leer a;
Escribir "Ingrese el coeficiente B:";
Leer b;
Escribir "Ingrese el coeficiente C:";
Leer c;

// determinar si son reales o imaginarias

disc <- b^2-4*a*c;
Si disc<0 Entonces
// si son imaginarias
preal<- (-b)/(2*a);
pimag<- rc(-disc)/(2*a);
Escribir "Raiz 1: ",preal,"+",pimag,"i";
Escribir "Raiz 2: ",preal,"-",pimag,"i";
Sino
Si disc=0 Entonces // ver si son iguales o distintas
r <- (-b)/(2*a);
Escribir "Raiz 1 = Raiz 2: ",r;
Sino
r1 <- ((-b)+rc(disc))/(2*a);
r2 <- ((-b)-rc(disc))/(2*a);
Escribir "Raiz 1: ",r1;
Escribir "Raiz 2: ",r2;
FinSi
FinSi

FinProceso
// Problema Ejemplo:

// Se ingresan los precios de 5 articulos y las cantidades vendidas

// por una empresa en sus 4 sucursales. Informar:
// * Las cantidades totales de cada articulo.
// * La cantidad de articulos en la sucursal 2.
// * La cantidad del articulo 3 en la sucursal 1.
// * La recaudacion total de cada sucursal.
// * La recaudacion total de la empresa.
// * La sucursal de mayor recaudacion.

Proceso Sucursales

// Inicializar Prec=Arreglo de precios y Cant=Arreglo para cantidades

Dimension Prec[5], Cant[4,5];

// Leer Precios
Para I<-1 Hasta 5 Hacer
Escribir 'Ingrese Precio Articulo ',I,':';
Leer Prec[I];
FinPara

// Leer Cantidades
Para J<-1 Hasta 4 Hacer
Para I<-1 Hasta 5 Hacer
Escribir 'Ingrese Cant. de Articulo ',I,', en Sucursal ',J,':';
Leer Cant[J,I];
FinPara
FinPara

// Sumar cantidades por articulos

Escribir 'Cantidades por articulos:';
Para I<-1 Hasta 5 Hacer
Suma<-Cant[1,I]+Cant[2,I]+Cant[3,I]+Cant[4,I];
Escribir 'Total articulo ',I,':',Suma;
FinPara

// Informar Total de Articulos Sucursal 2

Suc2<-0;
Para I<-1 Hasta 5 Hacer
Suc2<-Suc2+Cant[2,I];
FinPara
Escribir 'Total Sucursal 2:',Suc2;

// Informar Sucursal 1, Articulo 3:

Escribir 'Sucursal 1, Articulo 3:',Cant[1,3];

// Acumular total de cada sucursal (TotSuc) y

// total de la empresa (TotEmp)
MayorRec<-0; NumMayor<-0; TotEmp<-0;
Para J<-1 Hasta 4 Hacer
TotSuc<-0;
Para I<-1 Hasta 5 Hacer
TotSuc<-TotSuc+(Cant[J,I]*Prec[i]);
 FinPara
Escribir 'Recaudaciones Sucursal ',J,':',TotSuc;
Si TotSuc>MayorRec
entonces MayorRec<-TotSuc; NumMayor<-J;
FinSi
TotEmp<-TotEmp+TotSuc;
FinPara
Escribir 'Recaudacion total de la empresa:',TotEmp;
Escribir 'Sucursal de Mayor Recaudacion:',NumMayor;

FinProceso

// Lee los tres lados de un triangulo rectangulo, determina

// si corresponden (por Pitargoras) y en caso afirmativo
// calcula el area

Proceso TrianguloRectangulo

// cargar datos
Escribir "Ingrese el lado 1:";
Leer l1;
Escribir "Ingrese el lado 2:";
Leer l2;
Escribir "Ingrese el lado 3:";
Leer l3;

// encontrar la hipotenusa (mayor lado)

Si l1>l2 Entonces
cat1<-l2;
Si l1>l3 Entonces
hip<-l1;
cat2<-l3;
Sino
hip<-l3;
cat2<-l1;
FinSi
Sino
cat1<-l1;
Si l2>l3 Entonces
hip<-l2;
cat2<-l3;
Sino
hip<-l3;
cat2<-l2;
FinSi
FinSi

// ver si cumple con Pitagoras

Si hip^2 = cat1^2 + cat2^2 Entonces
// calcualar area
area<-(cat1*cat2)/2;
Escribir "El area es: ",area;
Sino
Escribir "No es un triangulo rectangulo.";
FinSi
FinProceso

Para visualizar el diagrama de flujo copie este código en PSeInt y presione F7.

Proceso Programa
Escribir "Ingrese el valor de kilometros por hora:";
Leer kilometros_por_hora;
metros_por_segundo<-kilometros_por_hora*1000.0/60.0/60.0;
Escribir "Valor de metros por segundo: ", metros_por_segundo;
FinProceso

1.-
a)
Funcion resto(a,b) : entero
[entero: a,b parametro por valor]
inicio
resto<-a-a/b*b
fin

b)
Funcion primo(a) : logico
[entero: a parametro por valor]
variables:
entero: i
inicio
primo<-v
para i<-2 hasta a/2 hacer
si resto(a,i)=0 entonces
primo<-f
finsi
finpara
fin

c)
Funcion mcd(a,b) : entero
[entero: a,b parametro por valor]
inicio
mientras a<>b
si a>b
a<-a-b
sino
b<-b-a
finsi
finmientras
mcd<-a
fin

d)
funcion fact(a) : entero
[entero: a parametro por valor]
variables
entero: i
inicio
fact<-1
para i<-1 hasta a hacer
fact<-fact*i
finpara
fin

e)
funcion fibo(a) : entero
[entero: a parametro por valor]
variables
entero: f,i
inicio
f<-1
fibo<-0
para i<-1 hasta a hacer
fibo<-f+fibo
f<-fibo-f
finpara
fin

f)
funcion nac(a) : cadena
[entero: a parametro por valor]
inicio
segun a hacer
0 : nac<-'cero'
1 : nac<-'uno'
2 : nac<-'dos'
3 : nac<-'tres'
4 : nac<-'cuatro'
5 : nac<-'cinco'
6 : nac<-'seis'
7 : nac<-'siete'
8 : nac<-'hocho'
9 : nac<-'nuebe'
10 : nac<-'dies'
11 : nac<-'onse'
12 : nac<-'dose'
13 : nac<-'trese'
14 : nac<-'catorse'
15 : nac<-'quinse'
16 : nac<-'dihesiseis'
17 : nac<-'diesiete'
18 : nac<-'diezyocho'
19 : nac<-'diezynueve'
20 : nac<-'beinte'
de otro modo
nac<-'n° fuera de rango'
finsegun
fin

g)
procedimiento bienvenida(a)
variable
cadena: nombre
inicio
escribir 'Ingrese su nombre'
leer nombre
escribir '¡¡Bienvenid@ ',nombre,'!!'
fin

h)
procedimiento intercambio(a,b)
[entero a,b parametro por referencia]
variables
entero : aux
inicio
aux<-a
a<-b
b<-a
fin

j)
procedimiento menormayor(a,b)
[cadena: a,b parametro por referencia]
inicio
si b<a entonces
intercambio(a,b)
finsi
fin

2.-
Algoritmo TP7_EJ2
Variables
entero: N
caracter: resp
funcion primo(A) : logico
[entero: A parametro por valor]
variables
entero: i
inicio
primo<-v
para i<-2 hasta A/2 hacer
si A MOD i = 0 entonces
primo<-f
finsi
finpara
fin
procedimiento mostrarfact(A)
[entero: A parametro por valor]}
variables
entero: i, fact
inicio
fact<-1
para i<-1 hasta A hacer
fact<-fact*i
 finpara
escribir 'Factorial de ',A,': ',fact
fin
funcion divisible(A,B) : logico
[entero: A,B]
inicio
divisible<-f
si A MOD B = 0 entonces
divisible<-v
finsi
fin
funcion fibo(A): entero
[entero: A parametro por valor]
variables
entero: f, i
inicio
f<-1
fibo<-0
para i<-1 hasta A hacer
fibo<-f+fibo
f<-fibo-f
finpara
fin
procedimiento letras(A)
[entero: A parametro por valor]
inicio
Segun A hacer
0 : escribir 'cero'
1 : escribir 'uno'
2 : escribir 'dos'
3 : escribir 'tres'
4 : escribir 'cuatro'
5 : escribir 'cinco'
6 : escribir 'seis'
7 : escribir 'siete'
8 : escribir 'ocho'
9 : escribir 'nueve'
10 : escribir 'diez'
11 : escribir 'once'
12 : escribir 'doce'
13 : escribir 'trece'
14 : escribir 'catorce'
15 : escribir 'quince'
16 : escribir 'dieciseis'
17 : escribir 'diecisiete'
18 : escribir 'dieciocho'
19 : escribir 'diecinueve'
20 : escribir 'veinte'
de otro modo
escribir 'n° fuera de rango'
finsegun
fin
Inicio
Repetir
escribir 'Ingrese un N°'
 Leer N
si primo(N) entonces
mostrarfact(N)
finsi
letras(N)
escribir 'continuar ? (S/N)'
leer resp
hasta que resp='n' o resp'N'
fin.

3.-
Algoritmo TP7_EJ3
variables
entero: stock
caracter: op
procedimiento menu(opc)
[caracter: opc parametro por referencia]
inicio
escribir '***************************'
escribir '* MENU *'
escribir '***************************'
escribir '* 1 : VALOR INICIAL STOCK *'
escribir '* 2 : RETIRAR CANTIDAD *'
escribir '* 3 : AUMENTAR STOCK *'
escribir '* 4 : MOSTRAR STOCK *'
escribir '* 5 : SALIR *'
escribir '***************************'
escribir '* ELIJA SU OPCION *'
escribir '***************************'
leer opc
fin
procedimiento segmenu(opp,stok)
[caracter: opp parametro por valor]
[entero: stok parametro por referencia]
variebles
entero: cant
inicio
segun opp
'1': escribir 'INGRESE STOCK INICIAL'
leer stok
'2' : escribir 'INGRESE CANTIDAD A RETIRAR'
leer cant
stok<-stok-cant
'3' : escribir 'INGRESE CANTIDAD A AUMENTAR'
leer cant
stok<-stok+cant
'4' : escribir 'STOCK ACTUAL: ',stok
'5' : escribir 'HASTA MAÑANA'
finsegun
fin
Inicio
repetir
stock<-0
menu(op)
hasta que op=1 o op=5
segmenu(op,stock)
si op<>5 entonces
repetir
menu(op)
si op=1 entonces
 escribir 'Opcion deshabilitada'
sino
si op>=2 y op<=4 entonces
segmenu(op,stock)
finsi
finsi
hasta que op=5
finsi
Fin.

4.-
arreglo [1..100] de real : vector
variables
vector: vec
entero: op, num
funcion ordenado(v,n) : logico
[vector: parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
ordenado<-v
para i<-1 hasta n-1 hacer
si v(i)<v(i+1) entonces
ordenado<-f
finsi
finpara
fin
procedimiento minimo(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
logico: bmin
entero: i, por
real: min
inicio
bmin<-v
pos<-0
para i<-1 hasta n hacer
si bmin entonces
bmin<-f
min<-v(i)
pos<-i
sino
si v(i)<min entonces
min<-v(i)
pos<-i
finsi
finsi
finpara
escribir 'minimo: ',min
escribir 'posicion: ',pos
fin
procedimiento cargar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variables
entero i
inicio
escribir 'Ingrese cantidad de elementos'
leer n
para i<-1 hasta n hacer
leer v(i)
finpara
fin
procedimiento mostrar(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
escribir v(i)
finpara
fin
procedimiento menu()
inicio
escribir '***************************'
escribir '* MENU *'
escribir '***************************'
escribir '* 1 : CARGAR VECTOR *'
escribir '* 2 : MOSTRAR VECTOR *'
escribir '* 3 : SUPERAN AL PROMEDIO *'
escribir '* 4 : ORDENADO *'
escribir '* 5 : MINIMO *'
escribir '* 6 : SALIR *'
escribir '***************************'
escribir '* ELIJA SU OPCION *'
escribir '***************************'
fin
funcion promedio(v,n) : real
[vector: v parametro por valor]
[entero: n parametro por valor]
variable
real: s
entero: i
inicio
s<-0
para i<-1 hasta n hacer
s<-s+v(i)
finpara
promedio<-s/n
fin
procedimiento mayorprom(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
entero: i
real: pro
inicio
 pro<-promedio(v,n)
para i<-1 hasta n hacer
si v(i)>pro entonces
escribir v(i)
escribir 'posicion: ',i
finsi
finpara
fin
Inicio
procedimiento menu()
leer op
segun op
1 : cargar(vec,num)
2 : mostrar(vec,num)
3 : mayorprom(vec,num)
4 : si ordenado(vec,num) entonces
escribir 'Quedate trankilo q esta ordenado'
sino
escribir 'Todo mal, esta re desordenado'
finsi
5 : minimo(vec,num)
6 : escribir 'Hasta mañana!'
finsegun
Fin.

Algoritmo TP7.EJ5
tipo
arreglo [1..1000] de entero: vector
constantes:
MAX: 1000
variables
vector: vec
entero: op, ter, var1, var2,elem
procedimiento menu(opc)
[entero: opc parametro por referencia]
inicio
escribir '**MENU**'
escribir '1: Cargar Vector'
escribir '2: Listar'
escribir '3: Insertar valor en posicion'
escribir '4: Agregar Valor'
escribir '5: Intercambias elementos iguales por otro'
escribir '6: Cambiar elemento unico'
escribir '7: Eliminar un elemento'
escribir '8: Eliminar elementos que coincidan con un valor'
escribir '0: Salir'
escribir 'Elija su opcion:'
leer opc
fin
procedimiento cargar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variable
caracter: op
inicio
n<-0
repetir
n<-n+1
escribir 'Ingrese el valor numero: ',n
leer v(n)
escribir 'mas datos? (s/n)'
leer op
hasta que op='n' o op='N'
fin
procedimiento listar(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variable
enteor: i
inicio
para i<-1 hasta n hacer
escribir v(i)
finpara
fin
procedimiento insertar(v,n,pos)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: pos parametro por valor]
variables
entero: i
inicio
para i<-n hasta pos con paso -1 hacer
v(i+1)<-v(i)
finpara
escribir 'Inserte valor'
leer v(pos)
n<-n+1
fin
procedimiento agregar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
inicio
n<-n+1
escribir 'Ingrese el valor a agregar'
leer v(n)
fin
procedimiento intercambiar(v,n,v1,v2)
[vector: v parametro por referencia]
[entero: n, v1, v2 parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
si v(i)=v1 entonces
v(i)<-v2
finsi
finpara
fin
procedimiento cambiar(v,n,pos)
[vector: v parametro por referencia]
[entero: n, pos parametro por valor]
inicio
escribir 'Ingrese el valor'
leer v(pos)
fin
procedimiento elimpos(v,n,pos)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: s parametro por valor]
variables
entero: i
inicio
para i<-pos hasta n-1 hacer
v(i)<-v(i+1)
finpara
n<-n-1
fin
procedimiento elimelem(v,n,k)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: k parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
si v(i)=k entonces
elimpos(v,n,i)
i<-i-1
finsi
finpara
fin
funcion leerpos() : entero
inicio
repetir
escribir 'Ingrese posicion'
leer leerpos
si MAX<leerpos entonces
escribir 'El limite del vector es 1000'
finsi
hasta que leerpos<MAX
fin
INICIO
repetir
menu(op)
segun op hacer
1: cargarvector(vec,ter)
2: listar(vec,ter)
3: leerpos()
insertar(vec,ter,leerpos)
4: agregar(vec,ter)
5: escribir 'Ingrese termino a ser reemplazado por otro valor'
leer var1
escribir 'Ingrese valor a reemplazar'
 leer var2
intercambio(vec,ter,var1,var2)
6: leerpos()
cambiar(vec,ter,leerpos)
7: leerpos()
elimpos(vec,ter,pos)
8: escribir 'Ingrese elemento a eliminar'
leer elem
elimelem(vec,ter,elem)
0: escribir 'Hasta mañana'
de otro modo
escribir 'Eleji una opcion de las que te di..(entre 0 y 8)'
finsegun
hasta que op=0
fin

iAlgoritmo TP7.EJ5
arreglo [1..100] de caracter : vector
variables
vector: vec
entero: num
procedimiento cargar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variables
entero i
inicio
escribir 'Ingrese cantidad de elementos'
leer n
para i<-1 hasta n hacer
leer v(i)
finpara
fin
procedimiento mostrar(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
escribir v(i)
finpara
fin
procedimiento eliminar(v,n,pos)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: pos parametro por valor]
variables
entero: i
inicio
para i<-pos hasta n-1 hacer
v(i)<-v(i+1)
finpara
n<-n-1
fin
procedimiento elimrepet(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
 entero: i,j
inicio
para i<-1 hasta n-1 hacer
para j<-1 hasta n hacer
si v(i)=v(j) entonces
eliminar(v,n,i)
finsi
finpara
finpara
fin
Inicio
cargar(vec,num)
escribir "VECTOR ORIGINAL:"
mostrar(vec,num)
elimrepet(vec,num)
escribir "VECTOR SIN ERRORES:"
mostrar(vec,num)
Fin.

tipo
arreglo[1..100] de caracter: vector
variables
vector: vec
entero: ter, vent, repet
procedimiento cargar(v,n)
[vector:v parametro por referencia]
[entero:n parametro por referencia]
variables
entero: i
Inicio
escribir 'Ingrese cantidad de terminos'
leer n
para i<1 hasta n hacer
leer v(i)
finpara
fin
procedimiento cambiar(v,n)
[vector:v parametro por referencia]
[entero:n parametro por valor]
variables
entero: i
caracter: aux
Inicio
aux<-v(1)
para i<-1 hasta n hacer
v(i)<-v(i+1)
finpara
v(n)<-aux
fin
procedimiento mostrar(v,n,m)
[vector:v parametro por valor]
[entero:n,m parametro por valor]
variables
entero: i
inicio
para i<1 hasta m hacer
escribir v(i)
finpara
fin
INICIO
cargar(vec,ter)
escribir 'Ingrese cantidad de elementos q desea ver en la ventana'
leer vent
escribir 'Ingrese cantidad de repeticiones'
leer repet
para i<1 hasta repet hacer
mostrar (vec,ter,vent)
cambiar (vec,ter)
finpara
FIN

Algoritmo TP8_EJ5
tipo
arreglo[1..100] de entero: vector
variables
vector: vec
entero: ter, opc, i
procedimiento cargar (v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variables
caracter: resp
Inicio
n<-0
repetir
n<-n+1
leer v(n)
escribir 'continua?'
leer resp
hasta que resp='n' o resp='N'
fin
procedimiento mostrar(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
escribir v(i)
finpara
fin
procedimiento ordenar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por valor]
variables
entero: i, lim, aux
logico: band
inicio
band<-v
lim<-n-1
mientras band y limite >= 1 hacer
band<-f
para i<-1 hasta lim hacer
si v(i) > v(i+1) entonces
aux<-v(i)
v(i)<-v(i+1)
v(i+1)<-aux
band<-v
finsi
finpara
lim<-lim-1
finmientras
fin
procedimiento elimpos(v,n,pos)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: pos parametro por valor]
variable
entero: i
inicio
para i<-pos hasta n-1 hacer
v(i)<-v(i+1)
finpara
n<-n-1
fin
funcion primo(n): logico
[entero: n parametro por valor]
variable
entero: i
inicio
primo<-f
para i<-2 hasta n/2
si n mod i = 0 entonces
primo<-v
finsi
finpara
fin
procedimiento elimprimo(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variables
entero: i
inicio
para i<-1 hasta n hacer
si primo(v(i)) entonces
elimpos(v,n,i)
finsi
finpara
fin
procedimiento insertar(v,n,pos,k)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
[entero: pos,k parametro por valor]
variable
entero: i
inicio
para i<-n hasta pos con paso -1 hacer
v(i+1)<-v(i)
finpara
v(pos)<-k
n<-n+1
fin
procedimiento insertenpospar(v,n)
[vector: v parametro por referencia]
[entero: n parametro por referencia]
variables
entero: i,k
inicio
para i<-2 hasta n con paso 2 hacer
repetir
escribir 'ingrese un n° impar y no primo para la pos',i
leer k
hasta que primo(k) y k mod 2 <> 0
insertar (v,n,i,k)
finpara
fin
procedimiento ordenado(v,n)
[vector: v parametro por valor]
[entero: n parametro por valor]
variable
entero: i
inicio
i<-1
mientras v(i)>=v(i+1) y i<n hacer
i<-i+1
finmientras
si v(i)<v(i+1)
escribir 'esta desordenado'
sino
escribir 'esta ordenado'
finsi
fin
procedimiento menu(op)
[entero: op parametro por referencia]
Inicio
escribir '1: cargar vector'
escribir '2: mostrar vector'
escribir '3: ordenar datos del vector de menor a mayor'
escribir '4: eliminar los valores primos'
escribir '5: insertar datos en posiciones pares'
escribir '6: mostrar si estar ordenado en forma ascendente'
escribir '0: salir'
fin
INICIO
repetir
menu(opc)
segun opc hacer
1: cargar(vec,ter)
2: mostrar(vec,ter)
3: ordenar(vec,ter)
4: elimprimo(vec,ter)
5: insertenpospar(vec,ter)
6: ordenado(vec,ter)
0: escribir 'Hasta mañana'
finsegun
hasta que opc=0
FIN.

tipo
arreglo[1..1000,1] de cadena: nombre
tipo
arreglo[1..1000,1] de caracter: condicion
tipo
arreglo[1..1000,1] de real: nota
tipo
arreglo[1..1000] de caracter: merito
variables
nombre: nomb
condicion: cond
nota: nota
merito: meri
entero: ter
procedimiento cargar(nom,con,not,n)
[nombre: nom parametro por referencia]
[condicion: con parametro por referencia]
[nota: not parametro por referencia]
[entero: n parametro por referencia]
variables
entero: i
inicio
escribir 'ingrese numero de datos'
leer n
para i<1 hasta n hacer
leer nom(i,1),con(i,1),not(i,1)
nom(i,2)<-nom(i,1)
con(i,2)<-con(i,1)
not(i,2)<-not(i,1)
finpara
fin
procedimiento mostraroriginal(nom,con,not,n)
[nombre: nom parametro por valor]
[condicion: con parametro por valor]
[nota: not parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
escribir nom(i,2),con(i,2),not(i,2)
finpara
fin
procedimiento mostrar(nom,con,not,n)
[nombre: nom parametro por valor]
[condicion: con parametro por valor]
[nota: not parametro por valor]
[entero: n parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
escribir nom(i,1),con(i,1),not(i,1)
finpara
fin
procedimiento ordenpornota(nom,con,not,n)
[nombre: nom parametro por referencia]
[condicion: con parametro por referencia]
[nota: not parametro por referencia]
[entero: n parametro por referencia]
variables
entero: i, lim
real: auxnot
cadena: auxnom
caracter: auxcon
logico: band
inicio
band<-v
lim<-n-1
mientras band y 1 <= limite hacer
band<-f
para i<-1 hasta lim hacer
si not(i+1)<not(i) entonces
auxnot<-not(i,1)
auxnom<-nom(i,1)
auxcon<-con(i,1)
not(i,1)<-not(i+1,1)
nom(i,1)<-nom(i+1,1)
con(i,1)<-con(i+1,1)
not(i+1,1)<-auxnot
nom(i+1,1)<-auxnom
con(i+1,1)<-auxcon
band<-v
finsi
finpara
lim<-lim-1
finmientras
fin
procedimiento addmerito(not,mer,n)
[nota: not parametro por valor]
[merito: mer parametro por referencia]
[entero: parametro por valor]
variables
entero: i
inicio
para i<-1 hasta n hacer
si not(i)>=6 entonces
mer(i)<-'A'
sino
si not(i)>=4 entonces
mer(i)<-'B'
sino
mer(i)<-'C'
finsi
finsi
finpara
fin
procedimiento ordenpornombre(nom,con,not,n)
[nombre: nom parametro por referencia]
[condicion: con parametro por referencia]
[nota: not parametro por referencia]
[entero: n parametro por referencia]
variables
entero: i, lim
real: auxnot
cadena: auxnom
caracter: auxcon
logico: band
inicio
band<-v
lim<-n-1
mientras band y 1 <= limite hacer
band<-f
para i<-1 hasta lim hacer
si nom(i+1)<nom(i) entonces
auxnot<-not(i,1)
auxnom<-nom(i,1)
auxcon<-con(i,1)
not(i,1)<-not(i+1,1)
nom(i,1)<-nom(i+1,1)
con(i,1)<-con(i+1,1)
not(i+1,1)<-auxnot
nom(i+1,1)<-auxnom
con(i+1,1)<-auxcon
band<-v
finsi
finpara
lim<-lim-1
finmientras
fin