// 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";

finsi FinSi finsi finmientras // mostrar resultado escribir "".cant_discos[t1]]. torres[t2. cant_discos[t1]<-cant_discos[t1]-1. . FinSi FinSi si puede_mover Entonces // si paso todos los controles. escribir "". leer t2. 5: escribir " XXXXXXXXXXXXXXXXXX". cant_discos[t2]<-cant_discos[t2]+1. si cant_discos[t2]<>0 entonces // controlar que la torre dos no tenga discos o tenga discos mas grandes si torres[t2.4: escribir " XXXXXXXXXXXXXX". 8: escribir " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX". escribir "". // obtener tamanio del disco que se quiere mover puede_mover<-verdadero.torres[t1. finsegun FinPara finsi Escribir " ----------------------------------". Sino disco_a_mover <.cant_discos[t2]] <disco_a_mover. 7: escribir " XXXXXXXXXXXXXXXXXXXXXXXXXX".cant_movs+1. si t1<0 | t1>3 | t2<0 | t2>3 Entonces // controlar que el nro de torre sea valido escribir "Movimiento invalido". 6: escribir " XXXXXXXXXXXXXXXXXXXXXX". leer t1.cant_discos[t2]]<disco_a_mover Entonces puede_mover<-Falso. FinPara // solicitar movimiento Escribir "Mover desde la torre: ". sino si cant_discos[t1]=0 Entonces // controlar que la torre 1 tengo al menos un disco escribir "Movimiento invalido". Sino escribir "Movimiento invalido". mover cant_movs <. Escribir "hacia la torre: ".

Escribir 'Presione Enter para continuar'. Escribir 'Ingresar Numero:'.Atan(N). Escribir 'ArcTangente:'. Escribir '0 . FinProceso // Este ejemplo muestra el uso de expresiones. Redondear'.Cos(N).Lograritmo Natural. Sino Escribir 'Log Nat.trunc(N).ln(N).n-Trunc(n). f<-1.Hallar Factorial'.Truncar. Escribir '4 .:'. Escribir '8 . Escribir ' '.:'.Ingresar Otro Numero'. Escribir 'Coseno:'. Sino Si abs(N)>50 Entonces Escribir 'Resultado muy grande!'. Escribir '5 . Leer x.exp(N). Funcion Exponencial'. Leer Opcion. 7: Si N<>Trunc(N) Entonces Escribir 'El numero debe ser entero!'. 5: Escribir 'Valor Abs. operadores y funciones matematicas Proceso Matematicas Salir<-0.Averiguar si es primo'.Raiz Cuadrada'.Sen(N).:'.:'.Seno. Sino r<-1.escribir "Juego finalizado en ".Trunc(n). Escribir '3 . FinSi 3: Escribir 'Turncar:'.rc(N). ArcoTangente'." movimientos!". Leer N. Escribir '2 .redon(N). Coseno. Escribir ' '. 2: Si N<=0 Entonces Escribir 'El numero debe ser mayor a cero!'. 6: Escribir 'Parte Entera:'.Valor Absoluto'. Escribir 'Func Expon.Separar parte entera y decimal'.para Salir'. . escribir "". Escribir '6 .abs(N). Segun Opcion Hacer 1: Escribir 'Seno:'. Escribir '1 . 4: Escribir 'Raiz Cuad. Escribir '7 . Escribir 'Redondear:'.cant_movs. Escribir 'Parte Decimal:'. Repetir Escribir ' '. Escribir '9 .

De Otro Modo: Escribir 'Opcion No Valida!'. Sino r<-f*r.'x'. 0: Salir<-1.f-2. Si N/2=trunc(N/2) Entonces Primo<-'No'. Mientras f<=Nu & Primo='Si' Hacer Si N/F=trunc(N/F) Entonces Primo<-'No'. FinSi FinSi 9: Escribir 'Ingrese Numero:'.N/(f-2). sino Nu<-N. FinSegun Hasta que Salir=1 FinProceso . FinSi Si N<0 entonces Nu<-N*-1. Si f=3 Entonces F<-4. Leer N.r.Primo. FinSi Nu<-RC(Nu). FinSi f<-f+2.'='. FinMientras Escribir 'Factorial:'. f<-3. Sino Primo<-'Si'. FinSi FinSi 8: Si N<>Trunc(N) Entonces Escribir 'El numero debe ser entero!'. FinSi f<-f+1. FinSi Si Primo='No' Entonces Escribir N. FinMientras Escribir 'Numero Primo:'.Mientras f<=abs(N) Hacer Si N<0 Entonces r<-(-f)*r.

Para j<-i+1 Hasta cant Hacer Si lista[j]<lista[pos_menor] Entonces pos_menor<-j. se_repite<-Falso. FinSi FinPara // intercambia el que estaba en i con el menor que encontro aux<-lista[i]. Escribir "Ingrese los nombres (enter en blanco para terminar):". FinPara FinProceso . Mientras nombre<>"" Hacer cant<-cant+1. 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 i<-1 Hasta cant Hacer Si nombre=lista[i] Entonces se_repite<-Verdadero.// 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]. FinPara // mostrar como queda la lista Escribir "La lista ordenada es:". Para i<-1 Hasta cant Hacer Escribir " ". lista[i]<-lista[pos_menor]. Leer nombre. // leer la lista cant<-0. lista[pos_menor]<-aux. Repetir // leer un nombre y ver que no este ya en la lista Leer nombre. lista[cant]<-nombre.lista[i].

((-b)+rc(disc))/(2*a).(-b)/(2*a). pimag<. Leer n. Sino r1 <. Escribir "Raiz 1 = Raiz 2: ". Escribir "Raiz 2: "."-".preal. FinSi FinSi FinProceso .prom. Escribir "Raiz 1: ". Para i<-1 Hasta n Hacer Escribir "Ingrese el dato ". Escribir "El promedio es: "."i". Escribir "Raiz 2: ".// Calcula el promedio de una lista de N datos Proceso Promedio Escribir "Ingrese la cantidad de datos:". Escribir "Ingrese el coeficiente C:". Escribir "Ingrese el coeficiente B:".pimag. r2 <. Si disc<0 Entonces // si son imaginarias preal<.r1. acum<-0. Leer b. Leer c. FinProceso // calcula las raices de una ecuacion de segundo grado Proceso Resolvente // cargar datos Escribir "Ingrese el coeficiente A:".r2.rc(-disc)/(2*a). Sino Si disc=0 Entonces // ver si son iguales o distintas r <. FinPara prom<-acum/n. Leer a.":". // determinar si son reales o imaginarias disc <.r."i".i.pimag.b^2-4*a*c.(-b)/(2*a). Escribir "Raiz 1: ". Leer dato.((-b)-rc(disc))/(2*a). acum<-acum+dato.preal."+".

// * La sucursal de mayor recaudacion.I. Proceso Sucursales // Inicializar Prec=Arreglo de precios y Cant=Arreglo para cantidades Dimension Prec[5].Suc2.I]. de Articulo '. Leer Prec[I]. // Informar Sucursal 1.I. // * La cantidad del articulo 3 en la sucursal 1. NumMayor<-0.5]. // Leer Precios Para I<-1 Hasta 5 Hacer Escribir 'Ingrese Precio Articulo '. Articulo 3: Escribir 'Sucursal 1. // * La recaudacion total de cada sucursal.I]*Prec[i]).I]+Cant[2. Escribir 'Total articulo '. . Para I<-1 Hasta 5 Hacer TotSuc<-TotSuc+(Cant[J. Leer Cant[J. // * La recaudacion total de la empresa.Suma. Articulo 3:'.':'.I]+Cant[3.'. Cant[4. FinPara // Leer Cantidades Para J<-1 Hasta 4 Hacer Para I<-1 Hasta 5 Hacer Escribir 'Ingrese Cant. FinPara Escribir 'Total Sucursal 2:'. Para J<-1 Hasta 4 Hacer TotSuc<-0.J. // Acumular total de cada sucursal (TotSuc) y // total de la empresa (TotEmp) MayorRec<-0.I].':'.// Problema Ejemplo: // Se ingresan los precios de 5 articulos y las cantidades vendidas // por una empresa en sus 4 sucursales. // * La cantidad de articulos en la sucursal 2.Cant[1. Para I<-1 Hasta 5 Hacer Suc2<-Suc2+Cant[2.I. Para I<-1 Hasta 5 Hacer Suma<-Cant[1.I].I]+Cant[4. TotEmp<-0. Informar: // * Las cantidades totales de cada articulo. FinPara // Informar Total de Articulos Sucursal 2 Suc2<-0.':'. en Sucursal '.3]. FinPara FinPara // Sumar cantidades por articulos Escribir 'Cantidades por articulos:'.

Si l2>l3 Entonces hip<-l2.':'. Leer l1. determina // si corresponden (por Pitargoras) y en caso afirmativo // calcula el area Proceso TrianguloRectangulo // cargar datos Escribir "Ingrese el lado 1:".TotEmp. cat2<-l1. Escribir "Ingrese el lado 2:". Si TotSuc>MayorRec entonces MayorRec<-TotSuc. FinSi . Escribir 'Sucursal de Mayor Recaudacion:'. cat2<-l2. FinPara Escribir 'Recaudacion total de la empresa:'. FinProceso // Lee los tres lados de un triangulo rectangulo. // encontrar la hipotenusa (mayor lado) Si l1>l2 Entonces cat1<-l2. FinSi FinSi // ver si cumple con Pitagoras Si hip^2 = cat1^2 + cat2^2 Entonces // calcualar area area<-(cat1*cat2)/2. cat2<-l3.J. Sino hip<-l3.area.". Escribir "El area es: ". Sino hip<-l3. Escribir "Ingrese el lado 3:". NumMayor<-J. Leer l3. Sino Escribir "No es un triangulo rectangulo. FinSi TotEmp<-TotEmp+TotSuc. FinSi Sino cat1<-l1. cat2<-l3.FinPara Escribir 'Recaudaciones Sucursal '.TotSuc. Si l1>l3 Entonces hip<-l1. Leer l2.NumMayor.

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. Leer kilometros_por_hora.i)=0 entonces primo<-f finsi finpara fin c) Funcion mcd(a.0/60. metros_por_segundo<-kilometros_por_hora*1000. Escribir "Valor de metros por segundo: ".FinProceso Para visualizar el diagrama de flujo copie este código en PSeInt y presione F7.0.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 . Proceso Programa Escribir "Ingrese el valor de kilometros por hora:".b) : entero [entero: a.0/60.a) Funcion resto(a.b) : entero [entero: a. metros_por_segundo. FinProceso 1.

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) .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.

b) finsi fin 2.variable cadena: nombre inicio escribir 'Ingrese su nombre' leer nombre escribir '¡¡Bienvenid@ '. fact inicio fact<-1 para i<-1 hasta A hacer fact<-fact*i .b parametro por referencia] variables entero : aux inicio aux<-a a<-b b<-a fin j) procedimiento menormayor(a.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.nombre.b) [entero a.b parametro por referencia] inicio si b<a entonces intercambio(a.'!!' fin h) procedimiento intercambio(a.b) [cadena: a.

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°' .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.finpara escribir 'Factorial de '.B) : logico [entero: A.': '.fact fin funcion divisible(A.

stok '5' : escribir 'HASTA MAÑANA' finsegun fin Inicio repetir stock<-0 menu(op) hasta que op=1 o op=5 segmenu(op.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.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: '. 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.stock) si op<>5 entonces repetir menu(op) si op=1 entonces .

pos fin procedimiento cargar(v.stock) finsi finsi hasta que op=5 finsi Fin.n) [vector: v parametro por valor] [entero: n parametro por valor] variables logico: bmin entero: i.n) [vector: v parametro por referencia] ..min escribir 'posicion: '. num funcion ordenado(v.arreglo [1. 4.escribir 'Opcion deshabilitada' sino si op>=2 y op<=4 entonces segmenu(op. 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: '.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.100] de real : vector variables vector: vec entero: op.

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.[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 real: pro inicio .

num) 2 : mostrar(vec.1000] de entero: vector constantes: MAX: 1000 variables vector: vec entero: op. Algoritmo TP7.num) 6 : escribir 'Hasta mañana!' finsegun Fin.i finsi finpara fin Inicio procedimiento menu() leer op segun op 1 : cargar(vec.pro<-promedio(v.num) entonces escribir 'Quedate trankilo q esta ordenado' sino escribir 'Todo mal. var1.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 .num) 4 : si ordenado(vec.n) para i<-1 hasta n hacer si v(i)>pro entonces escribir v(i) escribir 'posicion: '. esta re desordenado' finsi 5 : minimo(vec.EJ5 tipo arreglo [1. ter. var2.num) 3 : mayorprom(vec.

v2) [vector: v parametro por referencia] [entero: n.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.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.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 .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.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. v1.

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.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.procedimiento cambiar(v.ter) 2: listar(vec.n.ter) 5: escribir 'Ingrese termino a ser reemplazado por otro valor' leer var1 escribir 'Ingrese valor a reemplazar' .ter. pos parametro por valor] inicio escribir 'Ingrese el valor' leer v(pos) fin procedimiento elimpos(v.n.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.ter) 3: leerpos() insertar(vec.pos) [vector: v parametro por referencia] [entero: n.leerpos) 4: agregar(vec.

leer var2 intercambio(vec.EJ5 arreglo [1.ter.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.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.leerpos) 7: leerpos() elimpos(vec.pos) 8: escribir 'Ingrese elemento a eliminar' leer elem elimelem(vec.elem) 0: escribir 'Hasta mañana' de otro modo escribir 'Eleji una opcion de las que te di.ter..n.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.(entre 0 y 8)' finsegun hasta que op=0 fin iAlgoritmo TP7.var1.100] de caracter : vector variables vector: vec entero: num procedimiento cargar(v..var2) 6: leerpos() cambiar(vec.n) [vector: v parametro por valor] [entero: n parametro por valor] variables .ter.ter.

n. vent.entero: i.num) escribir "VECTOR SIN ERRORES:" mostrar(vec..m parametro por valor] variables entero: i inicio para i<1 hasta m hacer escribir v(i) finpara fin .i) finsi finpara finpara fin Inicio cargar(vec.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. tipo arreglo[1.num) Fin.num) elimrepet(vec.n.num) escribir "VECTOR ORIGINAL:" mostrar(vec.j inicio para i<-1 hasta n-1 hacer para j<-1 hasta n hacer si v(i)=v(j) entonces eliminar(v.m) [vector:v parametro por valor] [entero:n.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.100] de caracter: vector variables vector: vec entero: ter. repet procedimiento cargar(v.

INICIO cargar(vec. opc.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.100] de entero: vector variables vector: vec entero: ter.vent) cambiar (vec. 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 .n) [vector: v parametro por referencia] [entero: n parametro por valor] variables entero: i. lim. 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.ter) finpara FIN Algoritmo TP8_EJ5 tipo arreglo[1.

k inicio para i<-2 hasta n con paso 2 hacer repetir escribir 'ingrese un n° impar y no primo para la pos'.i) finsi finpara fin procedimiento insertar(v.n) [vector: v parametro por referencia] [entero: n parametro por referencia] variables entero: i.i leer k .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.k) [vector: v parametro por referencia] [entero: n parametro por referencia] [entero: pos.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.finpara lim<-lim-1 finmientras fin procedimiento elimpos(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.n.

ter) 4: elimprimo(vec.1000.ter) 3: ordenar(vec.1] de caracter: condicion tipo arreglo[1.ter) 6: ordenado(vec.ter) 0: escribir 'Hasta mañana' finsegun hasta que opc=0 FIN.ter) 2: mostrar(vec.1000...hasta que primo(k) y k mod 2 <> 0 insertar (v..k) finpara fin procedimiento ordenado(v. tipo arreglo[1.n.1000] de caracter: merito variables nombre: nomb condicion: cond nota: nota .1000.1] de cadena: nombre tipo arreglo[1.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.1] de real: nota tipo arreglo[1..ter) 5: insertenpospar(vec.i.

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.not(i.1) con(i.n) [nombre: nom parametro por referencia] [condicion: con parametro por referencia] [nota: not parametro por referencia] [entero: n parametro por referencia] variables entero: i.not.1).1) nom(i. lim real: auxnot cadena: auxnom caracter: auxcon logico: band inicio .not.2)<-con(i.2)<-not(i.not(i.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.con.con(i.2) finpara fin procedimiento mostrar(nom.con.not(i.1).con(i.not.not.1).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) finpara fin procedimiento ordenpornota(nom.1) not(i.1) finpara fin procedimiento mostraroriginal(nom.1).con(i.2).merito: meri entero: ter procedimiento cargar(nom.con.2).con.2)<-nom(i.

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 con(i+1. lim real: auxnot cadena: auxnom caracter: auxcon logico: band inicio band<-v lim<-n-1 mientras band y 1 <= limite hacer .1) not(i+1.1) con(i.1)<-con(i+1.1)<-nom(i+1.1) not(i.1)<-auxnot nom(i+1.1) auxcon<-con(i.not.mer.1)<-not(i+1.1) auxnom<-nom(i.1)<-auxcon band<-v finsi finpara lim<-lim-1 finmientras fin procedimiento addmerito(not.con.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.n) [nombre: nom parametro por referencia] [condicion: con parametro por referencia] [nota: not parametro por referencia] [entero: n parametro por referencia] variables entero: i.1) nom(i.

1)<-nom(i+1.1) not(i.1)<-auxnot nom(i+1.1) nom(i.1)<-con(i+1.1) auxnom<-nom(i.1) not(i+1.1)<-not(i+1.1) con(i.band<-f para i<-1 hasta lim hacer si nom(i+1)<nom(i) entonces auxnot<-not(i.1)<-auxnom con(i+1.1)<-auxcon band<-v finsi finpara lim<-lim-1 finmientras fin .1) auxcon<-con(i.

Sign up to vote on this title
UsefulNot useful