P7e5) Hacer un programa que dado un arreglo de enteros de tamaño 10 que se encuentra precargado, solicite al

usuario un numero entero y elimine la primer ocurrencia de numero (un número igual) en el arreglo si existe. Para
ello tendrá que buscar la posición y si está, realizar un corrimiento a izquierda (completar con -1 la ultima posicion si
se elimina).

MAX=10;
Void Main(){
Definir arreglo enteros;
//Cargar arreglo
Crear buffer entrada;
Try{
Numero ingresado por el usuario;
Eliminar ocurrencia numero arreglo(arreglo,numero);
}
Catch (){
}
}

Void Eliminar ocurrencia numero arreglo(arreglo,numero){

Pos=obtener posicion numero arreglo(arreglo,numero);//depende del orden del arreglo
Si pos<MAX{
Corrimiento a izq arreglo(arreglo,pos); //|3|2|3|1|4|7|
Arreglo[MAX-1]=-1 //|3|2|3|4|7|-1|
}
}

Int obtener posicion numero arreglo(arreglo,numero){

Pos=0;
While (pos<MAX) y (arreglo[pos]!=numero){//pos == MAX no lo encontró, sino lo encontro
Pos++;
}
Retornar pos;
}

Void Corrimiento a izq arreglo(arreglo,pos){

While (pos<MAX-1) {//|3|2|3|4|7|7| pos==2
Arreglo[pos]=arreglo[pos+1];
Pos++;
}
}

P7e6) Hacer un programa que dado un arreglo de enteros de tamaño 10 que se encuentra precargado, solicite al
usuario un numero entero y elimine todas las ocurrencia de numero en el arreglo si existe. Mientras exista (en cada
iteración tiene que buscar la posición dentro del arreglo) tendrá que usar la posición para realizar un corrimiento a
izquierda (quedarán tantas copias de la última posición del arreglo como cantidad de ocurrencias del número).

MAX=10;
Void Main(){
Definir arreglo enteros;
//Cargar arreglo
Crear buffer entrada;
Try{
Numero ingresado por el usuario;
Eliminar ocurrencias numero arreglo(arreglo,numero);
}
Catch (){
}
}

Void Eliminar ocurrencias numero arreglo(arreglo,numero){

Pos=obtener posicion numero arreglo(arreglo,numero);//depende del orden del arreglo
while pos<MAX{
Corrimiento a izq arreglo(arreglo,pos); //|3|2|3|1|4|7|
Arreglo[MAX-1]=-1 //|3|2|3|4|7|-1|
Pos=obtener posicion numero arreglo(arreglo,numero);//depende del orden del arreglo
}
}
P7e19)
Se tiene un arreglo ORIGINAL precargado de secuencias de números de tamaño MAX con ceros entre secuencias, al
principio y al final del arreglo. Además se tiene un arreglo ORDEN1 precargado de tamaño MAX. ORDEN1 tiene
posiciones de inicio de secuencia de ORIGINAL que permite recorrer de forma ascendente y consecutiva las
secuencias que suman una cantidad par (ORDEN1 tiene valores -1 al final de las posiciones válidas). Se pide:
_Dada una posición válida ingresada por el usuario desde teclado, eliminar la secuencia en ORIGINAL con inicio en
esa posición y actualizar el arreglo ORDEN1.
ORIGINAL
|0|8|2|0|0|3|5|0|6|0|3|0|//1,5,8,10
ORDEN1
|8|5|1|-1|-1|-1|-1|-1|-1|-1|-1|-1|
Usuario carga posicion pos //pos=5,1,8,10
Si hayiniciosecuencia(ORIGINAL,pos){pos=10
Tamaño=tamañosecuencia(ORIGINAL,pos);//tam=1
Eliminar_secuencia_arreglo(ORIGINAL,pos);// |0|8|2|0|0|3|5|0|6|0|0|0|//1,5,8
Actualizar índices(ORDEN1,pos,tam);// |8|5|1|-1|-1|-1|-1|-1|-1|-1|-1|-1|
}

Actualizar índices(arreglo,pos,tam){// |8|5|1|-1|-1|-1|-1|-1|-1|-1|-1| pos=8 tam=1

I=0;
While i<MAX y arreglo[i]!=-1{
Si arreglo[i]==pos //elimina
Corrimiento izq(arreglo,i) |5|1|-1|-1|-1|-1|-1|-1|-1|-1|-1|
Sino si arreglo[i]>pos //descuenta
Arreglo[i]=arreglo[i]-tam
I++
Sino //no hace nada
I++
}
}

Boolean hayiniciosecuencia(arreglo,pos){
retornar (pos>=0 y pos<MAX y arreglo[pos]!=0 y arreglo[pos-1]==0)
}

P7e20)
_Cargar los índices de inicio de todas secuencias en el arreglo ORDEN2 de tamaño MAX, que está inicializado con -1.
_Suponiendo que hay un método que permite ordenar de forma ascendente un arreglo de las características de
ORDEN2 (el método ordena los índices de inicio de secuencia de según el tamaño de las secuencias a los que hacen
referencia), generar un arreglo ORDEN3 de tamaño MAX de índices de las secuencias de ORIGINAL con el orden
mencionado (deberá definir además los encabezados de el/los método/s prexistentes y hacer las llamadas cuando
los utilice).

Public static void ordenar_indices_tamanio(int[] arreglo){

….
}
Main(){
ORIGINAL,ORDEN1…
Cargar índices secuencias(ORIGINAL,ORDEN2){
Copiar_arreglo(ORDEN2,ORDEN3);
ordenar_indices_tamanio(ORDEN3);
o
Cargar índices secuencias(ORIGINAL,ORDEN3){
ordenar_indices_tamanio(ORDEN3);
}

Cargar índices secuencias(arreglo,destino){

Índice=1; //un inicio de sec es cuando esta parado en un <>0 y antes hay 0, ej…|0|!=0|…
Pos=0;
While índice < MAX
Si arreglo[indice-1]==0 y arreglo[indice]!=0{
Destino[pos]=índice;
Pos++;
}
Índice++;
}
}

Cargar índices secuencias(arreglo,destino){

Inicio=0;
Fin=-1;
While inicio < MAX
Inicio=obtener inicio sec(arreglo,fin+1);
Si inicio < MAX
Fin = obtener fin sec(arreglo,inicio);
Destino[pos]=inicio;
Pos++;
}
}
}

Void Copiar_arreglo(arreglo1,arreglo2){
For (pos,,,){
Arreglo[pos]=arreglo1[pos];
}
}
P7e21)
Suponer que se tiene un arreglo precargado de caracteres letras minúsculas de tamaño MAX. Se tiene además los
siguientes métodos:
_Un método que retorna cuantas repeticiones en el arreglo tiene un carácter ingresado como parámetro.
_Un método que ordena un arreglo de forma descendente por cantidad de caracteres que se repiten, por ejemplo
genera |’t’|’t’|’t’|’a’|’a’|’r’|’e’|.
Hacer un programa que:
_dado un numero positivo ingresado el usuario imprima por pantalla los caracteres vocales con cantidad mayor a la
cantidad ingresada sin realizar recorridos innecesarios. Por ejemplo si se ingresa un 2 imprime ‘a’ y no sigue
recorriendo el arreglo.
_mientras el usuario ingrese una vocal consonante minúscula muestre por pantalla la cantidad de repeticiones de
dicha consonante.
_deberá definir además los encabezados de el/los método/s prexistentes y hacer las llamadas cuando los utilice.

MAX=10;
Main(){
Numero ingresado por el usuario;
Si numero>0
Imprimir_caracteres_vocales(arreglo,numero);
Imprimir_repeticiones_consonantes(arreglo);
}

Void Imprimir_repeticiones_consonantes(arreglo){
Consonante ingresada por el usuario
Mientras !esvocal(consonante){
Imprimir(cantidad_repeticiones_arreglo_caracter(arreglo,consonante));
Consonante ingresada por el usuario;
}
}

Void Imprimir_caracteres_vocales(arreglo,numero){numero=2
ordenar_arreglo_por_caracteres_repetidos(arreglo);// |’t’|’t’|’t’|’a’|’a’|’r’|’e’|.
pos=0;
cantidad=MAX;
while (pos<MAX) y (cantidad>numero) {
cantidad = cantidad_repeticiones_arreglo_caracter(arreglo,arreglo[pos]);
if (cantidad>numero) y esvocal(arreglo[pos]){
imprimir(arreglo[pos])
}
pos=pos+ cantidad+1
}
}

Boolean esvocal(caracter){
Retorna (carácter==’a’ o carácter=’e’ o carácter=’i’ o carácter=’o’ o carácter=’u’)
}

Public static int cantidad_repeticiones_arreglo_caracter(char[] arreglo, char caracter);

Public static void ordenar_arreglo_por_caracteres_repetidos(char[] arreglo);