FACULTAD REGIONAL UTN VILLA MARÍA

Trabajo
Prá ctico:Cadenas
Algoritmos y Estructuras de Datos
Pértile Franco Giuliano
1)------------------------------------------------

Algoritmo sin_titulo

//Ingresar una cadena de caracteres que termine en un punto e indicar la

//cantidad de caracteres que posee. Mostrando la misma en formato

//mayúscula a la salida del programa.

leer cad

Escribir "Tiene la siguiente cantidad de caracteres: ",Longitud(cad)

Escribir Mayusculas(cad)

FinAlgoritmo

2)---------------------------------------------

Algoritmo sin_titulo

//2. Ingresar dos cadenas y determinar si son iguales.

Definir cad1 como cadena

Definir cad2 como cadena

Escribir "ingrese dos cadenas"

leer cad1

leer cad2

si cad1=cad2

Escribir "son iguales"

SiNo

Escribir "no son iguales"

FinSi

FinAlgoritmo
3)------------------------------

Algoritmo sin_titulo

//3. Ingresar dos cadenas y mostrar primero la cadena mayor y luego la

//cadena menor.

Definir cad1 como cadena

Definir cad2 como cadena

leer cad1

leer cad2

Escribir "ingrese dos cadenas"

si Longitud(cad1)>Longitud(cad2)

Escribir cad1, " esa cadena es mayor que la segunda"

Escribir cad2

SiNo

Escribir cad2, " es mayor que la primera "

Escribir cad1

FinSi

FinAlgoritmo
4)----------------------------

Algoritmo sin_titulo

//4. Realizar un programa que permita localizar todas las apariciones de una

//subcadena dentro de otra.

Definir cad como cadena

definir subcad como cadena

Escribir "ingrese la cadena"

leer cad

Escribir "Ingrese la subcadena que desea buscar cuantas veces se repite"

leer subcad

contador=0

para i=1 hasta Longitud(cad)

si subcad= subcadena(cad,i,longitud(subcad)+i-1)

contador=contador+1

FinSi

FinPara

Escribir contador

FinAlgoritmo
5)------------------------

subproceso resultado=contar_vocales(caden)

caden=minusculas(caden)

para i=1 hasta Longitud(caden)

si subcadena(caden,i,i)= "a" o subcadena(caden,i,i)= "e" o subcadena(caden,i,i)=

"i" o subcadena(caden,i,i)= "o" o subcadena(caden,i,i)= "u"

contador=contador+1

FinSi

FinPara

resultado= contador

FinSubProceso

subproceso resultado=espacios(caden)

caden=minusculas(caden)

para i=1 hasta Longitud(caden)

si subcadena(caden,i,i)= " "

contador=contador+1

FinSi

FinPara

resultado= contador

FinSubProceso

subproceso resultado=letrasFM(caden)

caden=minusculas(caden)
 contador=0

para i=1 hasta Longitud(caden)

si i=1

si Subcadena(caden,i,i)="f" o Subcadena(caden,i,i)="m"

contador=contador+1

FinSi

FinSi

si subcadena(caden,i,i)= " "

si Subcadena(caden,i+1,i+1)="f" O Subcadena(caden,i+1,i+1)="m"

contador=contador+1

FinSi

FinSi

FinPara

resultado= contador

FinSubProceso

Algoritmo sin_titulo

//5. Ingresar una cadena de caracteres que termina en un punto y determinar

//una estadísticas de la misma:

//? Cantidad de caracteres que compone la cadena.

//? Cantidad de vocales que existen en la cadena ingresada

//? Cuantos espacios en blanco

//? Cuantas palabras comienzan con la letra F , f y M, m

Definir cad como cadena

 Escribir "ingrese una cadena"

leer cad

Escribir "tiene la siguiente cantidad de vocales", contar_vocales(cad)

escribir "tiene la siguiente cantidad de caracteres:",longitud(cad)

Escribir "la cantiad de espacios en blanco es:", espacios(cad)

Escribir "la cantiad de palabras con F,f y m, M, son:" letrasFM(cad)

FinAlgoritmo
6)---------------------------------

subproceso union(cade1,cade2)

Definir vector como cadena

Dimension vector(2000)

contador1=0

anterior1=1

//cortamos la primera cadena

para i=1 hasta Longitud(cade1)

letra=Subcadena(cade1,i,i)

si letra=" "

contador1=contador1+1

vector(contador1)=Subcadena(cade1,anterior1,i-1)

anterior1=i+1

FinSi

FinPara

contador1=contador1+1

vector(contador1)=Subcadena(cade1,anterior1,Longitud(cade1))

dimension vector2(2000)

contador2=0

anterior2=1

//cortamos la segunda cadena

para i=1 hasta Longitud(cade2)

 letra=Subcadena(cade2,i,i)

si letra=" "

contador2=contador2+1

vector2(contador2)=Subcadena(cade2,anterior2,i-1)

anterior2=i+1

FinSi

FinPara

contador2=contador2+1

vector2(contador2)=Subcadena(cade2,anterior2,Longitud(cade2))

/////////////ahora buscamos en el nuevo vector si estan esas palabras

Dimension vector_final(2000)

para i=1 hasta contador1

si i<=contador1

comprobacion=0

para j=1 hasta contador1 //busco si el los valores del vector estan en el
final

si vector(i)=vector_final(j)

comprobacion=1//si estan los chequeo con esto

FinSi

FinPara

si comprobacion=0 //si no estan los agrego al vector

vector_final(i)=vector(i)

contador_final=contador_final+1
 FinSi

FinSi

FinPara

//comprobe los de la primera cadena ahora la segunda

para i=1 hasta contador2

comprobacion=0

para j=1 hasta contador2 //busco si el los valores del vector estan en el final

si vector2(i)=vector_final(j)

comprobacion=1//si estan los chequeo con esto

FinSi

FinPara

si comprobacion=0 //si no estan los agrego al vector

contador_final=contador_final+1

vector_final(contador_final)=vector2(i)

FinSi

FinPara

Escribir "respuesta"

para i=1 hasta contador_final

Escribir vector_final(i), " " Sin Saltar

FinPara

FinSubProceso
Algoritmo sin_titulo

//6.Escribir un programa que lea dos cadenas de caracteres y forme un solo

//texto con los caracteres que pertenecen a dos cadenas, pero no repetir

//palabras. Visualizar el contenido por pantalla.

Definir cad1 como cadena

Definir cad2 como cadena

Escribir "Ingrese la primera cadena"

leer cad1

Escribir "ingrese la segunda cadena"

leer cad2

union(cad1,cad2)

FinAlgoritmo
7)------------------------------------------

SubProceso palabras_de_3_vocales(n)

Definir vector como cadena

Dimension vector(12345)

Dimension vector_letras(12345)

anterior=1

contador=0

para j=1 hasta n

leer vector(j) //carga en el vector la cantida de cadena que me piden

cargar_vector_final(contador,vector_letras,j,vector)//activo esta funion para

separar cada vector en palabras y cada palabra pasarlas a un nuevo vector

FinPara

//ahora tengo todas las palabras en el vector, tengo que ver cuantas tienen mas de 3
vocales distintas

Escribir "la siguientes palabras cuentan con 3 o mas vocales distintas"

para i =1 hasta contador //hasta la cantidad de elementos del vector_letras

contador_vocales=0

estadoa=0

estadoe=0 //estado para contar si encuentra o no una voal

estadoi=0

estadoo=0

estadou=0

para j=1 hasta Longitud(vector_letras(i))

 vocal=Subcadena(vector_letras(i),j,j) //mira cada letra

si vocal="a" y estadoa=0

estadoa=1 //si la letra coincide con una vocal cambio de estado y

sumo 1 al contador hasta 3 y me chifla si funka o no

contador_vocales=contador_vocales+1

FinSi

si vocal="e" y estadoe=0

estadoe=1

contador_vocales=contador_vocales+1

FinSi

si vocal="i" y estadoi=0

estadoi=1

contador_vocales=contador_vocales+1

FinSi

si vocal="o" y estadoo=0

estadoo=1

contador_vocales=contador_vocales+1

FinSi

si vocal="u" y estadou=0

estadou=1

contador_vocales=contador_vocales+1

FinSi

FinPara

si contador_vocales>=3 //va escribiendo cada letra

Escribir vector_letras(i) //,"<--"

FinSi
 FinPara

//para i=1 hasta contador

// Escribir vector_letras(i)," i:",i

//FinPara

FinSubProceso

SubProceso cargar_vector_final(contador Por Referencia,vector_letras Por Referencia,j,vector Por

Referencia)

anterior=1 //para guardar el ultimo lugar

para i=1 hasta longitud(vector(j)) //hasta la longitud de la primera cadena

cad=vector(j)//guarda el vector en la variable porque no me deja usar o no me

dejaba usar la subcadena con el vector(j)

letra=subcadena(cad,i,i)

si letra= " " //busco el espacio

contador=contador+1 //cuento las letras

vector_letras(contador)=subcadena(vector(j),anterior,i-1) //guarda la letra

en la posicion del contador

anterior=i+1

FinSi

FinPara

contador=contador+1 //guardo la ultima palabra porque no me deja con el metodo barato

de arriba

vector_letras(contador)=subcadena(vector(j),anterior,Longitud(vector(j)))

FinSubProceso
Algoritmo sin_titulo

//7. Escribir un programa que lea varias cadenas de caracteres y visualice

//todas las palabras que contengan al menos tres vocales distintas.

Escribir "cuantas cadenas va a ingresar"

leer n

Escribir "ingrese las cadenas"

palabras_de_3_vocales(n)

FinAlgoritmo
8)----------------------------------------------

SubProceso palindroma(cade)

dimension vector(10000)

para i=1 hasta longitud(cade)

vector(i)=Subcadena(cade,i,i)

FinPara

para i= 1 hasta Longitud(cade)

si vector(i) <> vector(Longitud(cade)+1-i)

palin=1

i=Longitud(cade)

FinSi

FinPara

si palin=1

Escribir "no es palindroma"

SiNo

Escribir "es palindroma"

FinSi

FinSubProceso

Algoritmo sin_titulo

//8. Realizar un programa que compruebe si una palabra es palíndroma, es

//decir, si se lee igual de izquierda a derecha que de derecha a izquierda.

//Por ejemplo: RADAR, ANILINA....

 Escribir "INGRESE una cadena para ver si es palindroma"

leer cad

palindroma(cad)

FinAlgoritmo
9)-----------------------------------------------

SubProceso invertir(cade)

dimension vector(10000)

para i=1 hasta longitud(cade)

vector(i)=Subcadena(cade,i,i)

FinPara

para i= Longitud(cade) hasta 1 con paso-1

Escribir vector(i) Sin Saltar

FinPara

FinSubProceso

Algoritmo sin_titulo

//9. Diseñar un programa que lea una cadena de caracteres y la invierta.

Escribir "INGRESE una cadena para invertirla"

leer cad

invertir(cad)

FinAlgoritmo
10)------------------------------------------

SubProceso ordenar(nombres por referencia,n)

para i=1 Hasta n //ordeno como burbuja

para j=1 hasta n-1

si nombres(j)>nombres(j+1)

aux=nombres(j+1)

nombres(j+1)=nombres(j)

nombres(j)=aux

FinSi

FinPara

FinPara

//para i=1 hasta n

// Escribir nombres(i)

//FinPara

//coloco en una tabla de dos columnas, la primera los dos apellidos

//y en la segunda los nombres para saber cual es

//el mas corto

Dimension lista(123,2) //aca guardo los nombres y eso

para j=1 hasta n

contador_espacios=0 //aca guarda la cantida de espacios

//cuando encuentro el segundo signfica que a la derecha esta el nombres

//entonces lo que esta ahi lo pongo en la segunda columna del vector

anterior=1
 para i=1 hasta Longitud(nombres(j))

letra=Subcadena(nombres(j),i,i)

si letra=" "

contador_espacios=contador_espacios+1

FinSi

si contador_espacios=1

anterior=i

FinSi

FinPara

si contador_espacios=2

lista(j,1)=Subcadena(nombres(j),1,anterior)

lista(j,2)=Subcadena(nombres(j),anterior+1,Longitud(nombres(j)))

FinSi

FinPara

//listo ya esta todo en dos columnas

//para i=1 hasta 3

// para j=1 hasta 2

// Escribir lista(i,j) Sin Saltar

// FinPara

// Escribir ""

//FinPara
//busco si la primera columna esta en alguna lado de la fila

para i=1 hasta n

repitencia=0

para j=1 hasta n-1 //me fijo si los apellidos son iguales en algun momentos

si lista(i,1)=lista(j+1,1)

repitencia=repitencia+1

FinSi

FinPara

si repitencia<>0

para k=1 hasta n-1 //comparo si los apellidos son iguales

//si lo son busco los dos apellidos iguales

//uso el metodo de la burbuja pero con las longitudes

si lista(i,1)=lista(k+1,1)

si longitud(lista(i,2))<Longitud(lista(k+1,2))

aux=lista(i,2)

lista(i,2)=lista(k+1,2)

lista(k+1,2)=aux

FinSi

FinSi

FinPara

FinSi
 FinPara

Escribir "---------"

para i=1 hasta n

para j=1 hasta 2

Escribir lista(i,j) Sin Saltar

FinPara

Escribir ""

FinPara

FinSubProceso

Algoritmo sin_titulo

//10. Se van a introducir por teclado el nombre y los apellidos de 3 personas

//con el siguiente formato: Apellido1, Apellido2 Nombre Dichos datos

//deberán aparecer ordenados alfabéticamente por apellidos. En caso de

//igualdad de apellidos aparecerá primero aquel cuyo nombre tenga menor

//número de caracteres.

dimension nombres(1000)

Escribir "cuantos nombres va ingresar"

leer n

Escribir "ingrese los ",n," nombres de la siguiente forma, apellido 1, apellido 2 , y nombre"
 para i=1 hasta n

Leer nombres(i)

FinPara

ordenar(nombres,n)

FinAlgoritmo
11)---------------------------------

SubProceso cortar_en_letras(cad Por Referencia,vector Por Referencia,contador Por Referencia)

anterior=1

contador=0

para i=1 hasta Longitud(cad) //corto la palabra como siempre

letra=Subcadena(cad,i,i)

si letra=" "

contador=contador+1

vector(contador)=Subcadena(cad,anterior,i-1)

anterior=i+1

FinSi

si i=Longitud(cad)

contador=contador+1

vector(contador)=Subcadena(cad,anterior,Longitud(cad))

FinSi

FinPara

FinSubProceso

SubProceso cantidad_letra_y(vector,contador)

contador_de_y=0

para i=1 hasta contador //me dijo la cantidad de palabras con la letra y

para j=1 hasta Longitud(vector(i))

si Subcadena(vector(i),j,j)="y"

contador_de_y=contador_de_y+1 //guarda aca la cantidad de

palabras cony
 j=Longitud(vector(i)) //si ya tiene 1 y, corto el ciclo

FinSi

FinPara

FinPara

Escribir "cantidad de palabras con y:",contador_de_y

FinSubProceso

SubProceso mayor_palabra_con_y(vector,contador_y por referencia,contador)

estado=0

maximo_y=0 //en esta variable guardo la mayor cantidad de y en una palabra

para i=1 hasta contador

si estado=0 //el estado guardo la cantidad de y en la primera palabra

para j=1 hasta Longitud(vector(i))

si Subcadena(vector(i),j,j)="y"

contador_y=contador_y+1

FinSi

FinPara

estado=1 //me fijo si la primera palabra tiene y cual es el maximo

FinSi

para n=1 hasta Longitud(vector(i))

si Subcadena(vector(i),n,n)="y" //me fijo si tiene y cada palabra

maximo_y=maximo_y+1 //si tiene la sumo

FinSi

si maximo_y>contador_y //compruebo el maximo y lo guardo

contador_y=maximo_y
 FinSi

FinPara

maximo_y=0

FinPara

Escribir "la mayor cantidad de y en una palabra es:",contador_y

FinSubProceso

SubProceso contador_y_por_palabras(vector,contador_y,contador)

dimension vector_contador_de_y(contador_y)

cantidad_de_y=0 //voy a contar la cantida de y en cada palabra y la pasa al vecto de

cantidad de y por palabra

si contador_y <>0

para i=1 hasta contador

para j=1 hasta Longitud(vector(i))

si Subcadena(vector(i),j,j)="y"

cantidad_de_y=cantidad_de_y+1 //cuento las y en cada

palabra

FinSi

FinPara

si cantidad_de_y<>0 //guardo la cantidad de y por palabra, en el vector de

la cantidad de y

vector_contador_de_y(cantidad_de_y)=vector_contador_de_y(cantidad_de_y)+1

FinSi
 cantidad_de_y=0 //reinicio la variable aca, para que pase a la otra palabra
con 0 cantidad de y

FinPara

FinSi

si contador_y<>0

para i=1 hasta contador_y

Escribir "cantidad de palabras con ",i," letra y :",vector_contador_de_y(i)

FinPara

FinSi

FinSubProceso

Algoritmo sin_titulo

////11. Dado un párrafo terminado en un punto y separada cada palabra por un

//espacio en blanco, determinar la cantidad de palabras que contienen la

//letra “y” e indicar en forma de estadísticas la cantidad de palabras que

//contienen una sola vez, dos veces, tres veces y así sucesivamente el

//carácter indicado.

Dimension vector(123123)

contador=0

contador_y=0

Escribir "INGRESE UNA CADENA PARA SABER LA CANTIDAD DE Y"

leer cad

cortar_en_letras(cad,vector,contador)

Escribir ""

cantidad_letra_y(vector,contador)
 Escribir ""

mayor_palabra_con_y(vector,contador_y,contador)

Escribir ""

contador_y_por_palabras(vector,contador_y,contador)

FinAlgoritmo
12)------------------------------------

SubProceso cuadrado(cade)

x=longitud(cade)-3

//Escribir x," ",longitud(cade) //ejemplo, va a escribir por ejemplo de la palabra queso, la

tercera palabra primero

//Escribir longitud(cade)-x,"<--" //osea la "e", porque la "q" esta en la primera fila y se

escriba "sola" , la segunda no es escribe, porque asi es el ejemplo, y se escribe la tercera recien

para i=1 hasta longitud(cade)-1 //luego comienzo con la cuarta letra, seria la "s" y
asi

para j=1 hasta longitud(cade)

si i=1//copio la primera palabra como entra

Escribir Subcadena(cade,j,j) Sin Saltar

FinSi

si i>1 y i<longitud(cade)-1//entre la primera la ultima fila

si j=1

Escribir Subcadena(cade,longitud(cade)-x,(Longitud(cade)-
x)) Sin Saltar

x=x-1

FinSi

si j>1 y j<Longitud(cade)

Escribir " " Sin Saltar

FinSi

si j=Longitud(cade) //si la ultima columa es igual a la longitud

Escribir Subcadena(cade,longitud(cade)-i,longitud(cade)-i)
sin Saltar
 FinSi //escribor la ultima palabra de la cad,-1 , para que se lea de
abajo hacia arriba

FinSi

si i=Longitud(cade)-1 //copio la palabra al revez si problema

Escribir Subcadena(cade,Longitud(cade)+1-j,Longitud(cade)+1-j)
Sin Saltar

FinSi

FinPara

Escribir ""

FinPara

FinSubProceso

Algoritmo sin_titulo

//12. Escribir un procedimiento que lea una palabra de hasta 20 caracteres

//y la escriba como se ve en la figura: hola en cuadrado

Escribir "Ingrese la palabra para que se forme un cuadrado"

leer cad

cuadrado(cad)

FinAlgoritmo
13)-----------------------

SubProceso anagrama(cade1,cade2)

Dimension vector1(2000)

Dimension vector2(2000)

//tomamos las letras individuales

para i=1 hasta Longitud(cade1)

si subcadena(cade1,i,i)<>" "

contador1=contador1+1

vector1(contador1)=subcadena(cade1,i,i)

FinSi

FinPara

para i=1 hasta Longitud(cade2)

si subcadena(cade2,i,i)<>" "

contador2=contador2+1

vector2(contador2)=subcadena(cade2,i,i)

FinSi

FinPara

//ya tenemos todas las letras en dos vectores

existencia=0 //variable para verificar la existencia de la letra

si contador1=contador2 //PORQUE DE entrada tiene que tener la misma cantidad de letras

para i=1 hasta contador1//ve si la primera letra del vector se encuentra en la del
segundo y asi

existencia=0

para j=1 hasta contador2

 si vector1(i)=vector2(j)//me fijo si la letra se encuentra en el vector

vector2(j)="" //si se encuentra la elimino, porque si hay

dos iguales fallaria y asi no

existencia=1

j=contador2//lo cancelo porque si no seguiria borrando las

letras que coinciden , probar con "hola hola"<-->"hola hola" sin esa linea no funkaria

FinSi

FinPara

si existencia=0

i=contador1

Escribir "no es anagrama"

FinSi

FinPara

sino

Escribir "no es anagrama"

FinSi

si existencia=1

Escribir "es anagrama"

FinSi

FinSubProceso

Algoritmo sin_titulo
 //13. ver si una palabra es anagrama de otra

Escribir "ingrese una cadena"

leer cad1

Escribir "ingrese otra palabra para saber si es un anagrama"

leer cad2

anagrama(cad1,cad2)

FinAlgoritmo
14)------------------------------

SubProceso palabras_aleatorias(palabras por referencia)

palabras(1)="cancer"

palabras(2)="rusia"

palabras(3)="argelia"

palabras(4)="escudo"

palabras(5)="espada"

palabras(6)="lanza"

palabras(7)="granada"

palabras(8)="ametralladora"

palabras(9)="rifle"

palabras(10)="mortero"

palabras(11)="escopeta"

palabras(12)="automatica"

palabras(12)="cadencia"

palabras(13)="distancia"

palabras(14)="tanque"

palabras(15)="helicoptero"

palabras(16)="avion"

palabras(17)="caza"

palabras(18)="aerotransportador"

palabras(19)="teletransportador"

palabras(20)="manco"

palabras(21)="inodoro"

palabras(22)="libro"

palabras(23)="jabon"
 palabras(24)="dentrifrico"

palabras(25)="israel"

FinSubProceso

SubProceso juego(palabras,estado Por Referencia,adivinado Por Referencia, objetivo Por

Referencia)

dimension jugador(21312) //aca voy a guardar la palabra que elije

Dimension objet(21123) //aca voy a cortar la palabra random por letra

para i=1 hasta Longitud(objetivo)

objet(i)=Subcadena(objetivo,i,i)

FinPara

intento=0//aca guardo los intentos

puntaje=0

Repetir

estado=0

para i=1 hasta Longitud(objetivo)

si jugador(i)=""

Escribir "_ " Sin Saltar

SiNo

Escribir jugador(i) Sin Saltar

FinSi

FinPara

Escribir ""

Escribir ""
Escribir "ingrese letra"

leer letra

para i=1 hasta Longitud(objetivo)

si letra= objet(i)

jugador(i)=letra

estado=1

FinSi

FinPara

puntaje=puntaje+Aleatorio(1000,10000)

si estado=0

intento=intento+1

FinSi

//compruebo de que los 2 vectores sean iguales

comprobacion=1

para i=1 Hasta Longitud(objetivo)

si objet(i)<>jugador(i)

comprobacion=0

FinSi

FinPara

Escribir ""

si comprobacion= 1 y intento<8

intento=8

Escribir "ganaste"

FinSi
 Escribir "Puntos:",puntaje

Escribir "Intentos fallidos:",intento

Hasta Que intento=8

si intento=8 y comprobacion=0

Escribir "perdiste"

FinSi

FinSubProceso

Algoritmo sin_titulo

//14. Escribir un programa que comience leyendo en un vector una lista de

//palabras (máximo 25) y permita simular el siguiente juego:

//El ordenador selecciona aleatoriamente una palabra de la lista y a

//continuación el usuario intentará adivinar dicha palabra, letra a letra,

//permitiéndose un máximo de ocho fallos.

//Cada jugada o intento de adivinar una letra comenzará con un sorteo

//del valor de la jugada (número aleatorio de puntos entre 1000 y 10000)

//así como la presentación al usuario de la situación actual del juego

//(letras y posiciones adivinadas, total de puntos, total de fallos).

Dimension palabras(25)

Dimension adivinado(12312)

palabras_aleatorias(palabras)

estado=0

objetivo=palabras(Aleatorio(1,25))

//Borrar Pantalla

juego(palabras,estado,adivinado,objetivo)
FinAlgoritmo
15)---------------------------------------

subproceso resultado=reemplazo(cad,pri,seg)

dimension vector(1234)

//corto todo en letras

para i=1 hasta Longitud(cad)

vector(i)=Subcadena(cad,i,i)

FinPara

//reemplaza cada letra

para i=1 hasta Longitud(cad)

si vector(i)=pri

vector(i)=seg

FinSi

FinPara

//junto todo en la cad resultado

para i=1 hasta Longitud(cad)

resultado=resultado+vector(i)

FinPara

FinSubProceso

Algoritmo sin_titulo

//15. Diseñar un subprograma que reciba 3 parámetros:

//a. Una cadena de caracteres

//b. Dos caracteres individuales

//Y modifique a la cadena pasada de tal manera que cada ocurrencia del

//primer carácter sea reemplazada por el segundo.

 Escribir "ingrese la cadena"

leer cad

Escribir "ingrese el primer caracter individual"

leer pri

Escribir "ingrese el segundo caracter a reemplazar por el primero"

leer seg

Escribir reemplazo(cad,pri,seg)

FinAlgoritmo
16).-----------------------------------

subproceso mejorar(cad)

para i =1 hasta Longitud(cad)

//elimino espacio inicial

si estado=0

para j=1 hasta Longitud(cad) //esto es independiente del PARA principal

letra=subcadena(cad,i,i)

si letra=" " //me fijo si al comienzo hay espacio en blanco

cad=subcadena(cad,j+1,longitud(cad))

j=j-1 //para que vuelva a comparar la primera

SiNo

estado=1

FinSi

FinPara

FinSi

letrinha=Subcadena(cad,i,i)//variable para saber si hay espacio en blanco

lethrina_siguiente=subcadena(cad,i+1,i+1)//para saber si hay un espacio despues

del otro espacio

si letrinha=" " y lethrina_siguiente=" "

cad=subcadena(cad,1,i)+subcadena(cad,i+2,longitud(cad))

i=i-1 //le resto uno a la I para que compara de nuevo, por si hay mas de 3
espacios si hay dos funca joya pero con mas de 3 le pongo eso y funka

FinSi

//me fijo al final si hay espacios en blanco, esto es independiente del PARA
principal
 para k=1 hasta Longitud(cad)

letrilla=Subcadena(cad,Longitud(cad),Longitud(cad))

si letrilla=" " //me fijo si al final hay un espacio y si lo hay lo saco de la cad

cad=Subcadena(cad,1,Longitud(cad)-1)

FinSi

FinPara

FinPara

Escribir cad //,"<--" //si saco esas barras comprueba si funka al final o no

FinSubProceso

Algoritmo sin_titulo

//

//16. Diseñar un procedimiento que elimine los espacios blancos sobrantes

//de una cadena de caracteres dada. Se considera espacio sobrante

//cuando:

//Existen espacios blancos al comenzar la cadena. En este caso

//deben ser eliminados.

//Existen dentro de la cadena más de un espacio en blanco

//seguido. En este caso debe dejarse sólo un.

//Existen espacios en blanco al final de la cadena. En este caso

//deben ser eliminados.

Escribir "ingrese cadena"

leer cad

mejorar(cad)

FinAlgoritmo
17)-----------------------------

SubProceso acomodar(cad)

dimension vector(1123)

x=Longitud(cad)

para i=1 hasta longitud(cad)

vector(i)=subcadena(cad,i,i)

FinPara

Dimension vectoraux(4235)

para i=1 hasta Longitud(cad)-1

si vector(i)=" " y vector(i+1)<>" " //me fijo si es espacio y si el siguiente no lo es

vectoraux(i)=vector(i)

FinSi

si vector(i)<>" " y vector(i+1)<>" " //me fijo si no son espacios los dos

vectoraux(i)=vector(i)

FinSi

si vector(i)<>" " y vector(i+1)=" " //me fijo si es distinto del espacio y despues
espacio

vectoraux(i)=vector(i)

//porque tiene que quedar un espacio en blanco siempre que alla mas de
2, asi que si en el final hay mas de 2 deberia quedar 1, segun el enunciado
 FinSi

FinPara

cad=""

para i=1 hasta x

cad =cad+vectoraux(i)

FinPara

Escribir cad,"<-"

FinSubProceso

Algoritmo sin_titulo

//17. Se pide construir un módulo que tenga como entrada una cadena de

//caracteres, y suprima todas las secuencias de espacios en blanco mayor

//de 1. Por ejemplo, si la cadena original es:

//(' ','a','h',' ',' ',' ','c'), la cadena resultante debe ser (' ','a','h',' ','c') (usar

//variables de cadena distintas)

Escribir "Ingrese una cadena"

leer cade

acomodar(cade)

FinAlgoritmo
18)-------------------------

SubProceso carga(vector Por Referencia,n)

Escribir "Ingrese las ",n," letras"

para i=1 hasta n

leer vector(i)

FinPara

FinSubProceso

SubProceso eliminar_doble_espacio(vector,n Por Referencia)

para k=1 hasta n-1 //si son mas de 3 espacios va a ver 2 en blancos luego de la primera
permutacion y con esto se va a solucionar con una segunda vuelta o las que sean necesarias

para i=1 hasta n-1

si vector(i)=" " y vector(i+1)=" "

para j=i hasta n-1

aux=vector(j) //permuto todas las puciciones si hay

espacio, lo llevo hasta el final

vector(j)=vector(j+1)

vector(j+1)=aux

FinPara

FinSi

FinPara

FinPara

//para solucionar el problema de que al final me mete todos los espacios lo contro con
esto

para j=n hasta 1 Con Paso -1

 si vector(n)=" " y vector(n-1)=" "

n=n-1 //me fijo si al final y en la anteultima posicion hay un espacio si lo

hay, le resto a N que seria las posiciones y asi hasta que alla solo un espacio o ninguno depende
como se introdujo

FinSi

FinPara

//Escribir n

para i=1 hasta n

Escribir vector(i) Sin Saltar

FinPara

FinSubProceso

Algoritmo sin_titulo

//18. Se pide construir un módulo que tenga como entrada un vector de

//caracteres, y suprima todas las secuencias de espacios en blanco mayor

//de 1. Por ejemplo, si el vector original es

//(' ','a','h',' ',' ',' ','c'), el vector resultante debe ser (' ','a','h',' ','c')

//Las modificaciones se harán sobre el mismo vector de entrada y no se

//podrán usar vectores auxiliares.

dimension vector(123123)

Escribir "cuantas letras va a ingresar"

leer n

carga(vector,n)

eliminar_doble_espacio(vector,n)
FinAlgoritmo
1-Complementario------------------------

SubProceso anagramas(palabras)

dimension ordenar(1000,1000)

Dimension auxiliar(123123)

para i=1 hasta 10

para j=1 hasta longitud(palabras(i))

ordenar(i,j)=subcadena(palabras(i),j,j)

FinPara

FinPara

//para i=1 Hasta Longitud(palabras(1))

// Escribir ordenar(1,i) Sin Saltar

//FinPara

Escribir ""

Para k=1 hasta 10 //ordeno cada palabra del vector alfabeticamento

para i=1 hasta Longitud(palabras(k))

para j=1 Hasta Longitud(palabras(k))

si ordenar(k,j)>ordenar(k,i)

aux=ordenar(k,i)

ordenar(k,i)=ordenar(k,j)

ordenar(k,j)=aux

FinSi

FinPara
 FinPara

FinPara

//aca las muestros ordenadas, es opcional, esta bloqueado por el momento

//para i=1 Hasta 10

// para j=1 hasta longitud(palabras(i))

// Escribir ordenar(i,j) Sin Saltar

// FinPara

// Escribir ""

//FinPara

//paso las palabras ordenadas alfabeticamente a un vector auxiliar, para simpleficar el

pensamiento

para i=1 hasta 10

para j=1 Hasta Longitud(palabras(i))

auxiliar(i)=auxiliar(i)+ordenar(i,j)

FinPara

FinPara

//para i=1 hasta 10

// Escribir auxiliar(i)

//FinPara

//ahora solo me fijo si lo que esta en cada en el vector, se encuentra en algun otro lado del
mismo
 para i=1 hasta 10

para j=1 hasta 10

//compruebo si son iguales en algun lado del vector

si auxiliar(i)=auxiliar(j) y i<>j y auxiliar(j)<>"" //distitos de vacio porque

despues elimino para que no se repita

//si son iguales y las posiciones distintas(porque sino te pone dos

veces la misma palabra)

Escribir palabras(i),"-",palabras(j) //escribo las palabras

//elimino una vez que encuentra un anagrama para que no se

repita

//por ejemplo vaca-cava y luego cava-vaca, es lo mismo pero

queda mas cheto si no aparece 2 veces

auxiliar(j)=""

FinSi

FinPara

FinPara

FinSubProceso

Algoritmo sin_titulo

Dimension palabras(10)

palabras(1)="cava"

palabras(2)="empresa"

palabras(3)="tope"
 palabras(4)="torta"

palabras(5)="pote"

palabras(6)="trota"

palabras(7)="vaca"

palabras(8)="acva"

palabras(9)="presaem"

palabras(10)="tepo"

Escribir "Palabras pre-cargadas"

para i=1 hasta 10

Escribir palabras(i)

FinPara

Escribir ""

Escribir "ANAGRAMAS:"

anagramas(palabras)

FinAlgoritmo