Hola a todos, hoy os dejo una serie de ejercicios propuestos y resueltos sobre arreglos o arrays en pseudocódigo.
Los ejercicios no tienen una única solución, el objetivo es que haga lo que pide y si se pide que se haga de una forma especifica hacerlo.
Esta vez, están hechos en PseInt, pero os recomiendo que los penséis un poco antes de poneros a programar. Los indices de los arrays o arreglos que usaremos sera el predeterminado por PseInt, es decir, que empezaran en 1. Puedes hacerlos como te convengan
¡Tenemos curso en udemy y tutellus!
También esta disponible en tutellus con una increíble oferta: ¡6€!
https://www.tutellus.com/tecnologia/desarrollo-web/iniciacion-a-la-programacion-con-pseint-29001?cupon=DDR
Aquí os dejo el curso de pseudocodigo:
Curso Pseudocódigo con Pseint
Si tienes alguna duda o quieres proponer alguna solución alternativa, deja un comentario en este post o mándanos un mensaje a administrador@discoduroderoer.es También dejare algunos comentarios para explicar que hace cada paso. Puedes ponerlos con //
ATENCIÓN: si copias el código y te salta algún tipo de error, revisar el tipo de lenguaje que usas. Puedes cambiarlo en Configurar-Opciones del lenguaje-personalizado
1) Crea un array o arreglo unidimensional con un tamaño de 5, asignale los valores numéricos manualmente (los que tu quieras) y muestralos por pantalla.
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio1
//Declaramos variables
Definir num como entero;
Definir TAMANIO como entero;
TAMANIO<-5
//Definimos el array
Dimension num[TAMANIO]
//Asignamos valores
num[1]<-1
num[2]<-2
num[3]<-3
num[4]<-4
num[5]<-5
//Recorremos el array y mostramos su contenido
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
Fin Para
FinProceso
|
2) Modifica el ejercicio anterior para que insertes los valores numéricos con
leer mediante un bucle y los muestre por pantalla.
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio2
//Declaramos variables
Definir num como entero
Definir TAMANIO como entero;
TAMANIO<-5;
//Definimos el array
Dimension num[TAMANIO]
//Introducimos valores
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
Escribir "Introduce un valor para la posición ",i
leer num[i]
Fin Para
//Recorremos el array y mostramos su contenido
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
FinPara
FinProceso
|
3) Crea un array o arreglo unidimensional con un tamaño de 10, inserta los valores numéricos que desees de la manera que quieras y muestra por pantalla la media de valores del array.
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio3
//Declaramos variables
Definir num como entero
Definir TAMANIO como entero
Definir suma Como Entero
TAMANIO<-10
//Definimos el array
Dimension num[TAMANIO]
//Introducimos valores
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
Escribir "Introduce un valor para la posición ",i
leer num[i]
Fin Para
//Recorremos el array, sumando su contenido
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
suma<-suma+num[i]
FinPara
FinProceso
|
4) Crea un array o arreglo unidimensional donde tu le indiques el tamaño por teclado y crear una función que rellene el array o arreglo con los múltiplos de un numero pedido por teclado. Por ejemplo, si defino un array de tamaño 5 y eligo un 3 en la función, el array contendrá 3, 6, 9, 12, 15. Muestralos por pantalla usando otra función distinta.
| Spoiler Inside |
SelectShow> |
SubProceso asignaValores ( num, TAMANIO, num_multiplo )
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
num[i]<-num_multiplo*i
Fin Para
Fin SubProceso
SubProceso mostrarArray ( num, TAMANIO )
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
Fin Para
Fin SubProceso
Proceso Ejercicio4
//La creacion de subprocesos es totalmente opcional
//Declaramos variables
Definir num como entero
Definir TAMANIO como entero
Definir suma Como Entero
definir num_multiplo como entero
//Definimos el tamaño del array por teclado
escribir "Introduce el tamaño del array"
leer TAMANIO
//Definimos el array
Dimension num[TAMANIO]
//Definimos el numero con el que rellenaremos el array con sus multiplos
escribir "Introduce el numero con el que rellenar"
leer num_multiplo
//invocamos a las funciones
asignaValores(num, TAMANIO, num_multiplo)
mostrarArray(num, TAMANIO)
FinProceso
|
5) Crea dos arrays o arreglos unidimensionales que tengan el mismo tamaño (lo pedirá por teclado), en uno de ellos almacenaras nombres de personas como cadenas, en el otro array o arreglo ira almacenando la longitud de los nombres, para ello puedes usar la función LONGITUD(cadena) que viene en PseInt. Muestra por pantalla el nombre y la longitud que tiene. Puedes usar funciones si lo deseas.
| Spoiler Inside |
SelectShow> |
SubProceso mostrarArrays ( longitud_nombres, nombres, TAMANIO )
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir "La longitud del nombre ",nombres[i]," es de ",longitud_nombres[i]
Fin Para
Fin SubProceso
Proceso Ejercicio5
//Declaramos variables
Definir longitud_nombres como entero
Definir nombres como cadena
Definir TAMANIO como entero
//Definimos el tamaño del array por teclado
escribir "Introduce el tamaño de los arrays"
leer TAMANIO
//Definimos el array
Dimension longitud_nombres[TAMANIO]
Dimension nombres[TAMANIO]
//Introducimos los nombres y la longitud de los mismos
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir "Introduce un nombre para la posicion ",i
leer nombres[i]
longitud_nombres[i]<-Longitud(nombres[i])
Fin Para
//Invocamos la función
mostrarArrays(longitud_nombres, nombres, TAMANIO)
FinProceso
|
6) Pedir valores numericos en dos arrays distintos y almacenar el resultado de los valores de cada posición (posición 0 del arreglo 1 + posición 0 del arreglo 2) y mostrar el contenido de los 3 arreglos de esta forma. valor pos 0 arreglo 1 + valor pos 0 arreglo 2 = valor pos 0 arreglo 3 valor pos 1 arreglo 1 + valor pos 1 arreglo 2 = valor pos 1 arreglo 3 …
| Spoiler Inside |
SelectShow> |
Proceso ejercicio_arreglos_DDR_4
//Tamaño del arreglom se puede cambiar
TAMANIO = 5
Dimension a1(TAMANIO)
Dimension a2(TAMANIO)
Dimension a3(TAMANIO)
//Recorremos de 0 a Tamaño-1
//Podemos rellenar el arreglo a1, a2 y a3
Para i<-0 Hasta TAMANIO-1 Con Paso 1 Hacer
Escribir "Introduce el valor del arreglo a1 en la posicion ",i
leer a1(i)
Escribir "Introduce el valor del arreglo a2 en la posicion ",i
leer a2(i)
a3(i) = a1(i) + a2(i)
Fin Para
//Mostramos los datos en el formato dicho
Para i<-0 Hasta TAMANIO-1 Con Paso 1 Hacer
Escribir a1(i) ," + ",a2(i)," = ", a3(i)
Fin Para
FinProceso
|
7) Buscar un elemento dentro de un arreglo que nosotros le pedimos por teclado. Indicar las posición donde se encuentra. Si hay más de uno, indicar igualmente la posición.
| Spoiler Inside |
SelectShow> |
Proceso ejercicio_arreglos_DDR_5
//Tamaño del arreglom se puede cambiar
TAMANIO = 5
dimension a1(TAMANIO)
a1(0)=2
a1(1)=5
a1(2)=4
a1(3)=3
a1(4)=2
//Introducimos el numero a buscar
Escribir "Inserta elemento a buscar"
leer numeroBuscado
//Usado para marcar si existe o no el elemento buscado
encontrado = falso
//Recorremos el arreglo buscando los elementos
Para i<-0 Hasta TAMANIO-1 Con Paso 1 Hacer
Si numeroBuscado = a1(i) Entonces
Escribir "Se ha encontrado el numero ",numeroBuscado," en la posicion ",i
encontrado = verdadero //Ya existe algun elemento
Fin Si
Fin Para
//Sino encuentro nada, muestro un mensaje
Si no encontrado Entonces
Escribir "No se ha encontrado ningun elemento"
Fin Si
FinProceso
|
8) Pediremos los IDs (números) de alumnos de dos clases, álgebra y análisis. Queremos mostrar todos los alumnos comunes en las dos asignaturas.
Estos alumnos se guarden en un tercer arreglo y que sea el que se muestre. También indica el numero de alumnos que se repiten.
| Spoiler Inside |
SelectShow> |
SubProceso contador <- buscarElementos ( algebra, analisis, comunes Por Referencia, TAMANIO )
contador = 0
Para i<-0 Hasta TAMANIO Con Paso 1 Hacer
Para j<-0 Hasta TAMANIO Con Paso 1 Hacer
Si algebra(i) = analisis(j) Entonces
comunes(contador) = algebra(i)
contador = contador + 1
Fin Si
Fin Para
Fin Para
Fin SubProceso
SubProceso rellenarArreglo ( arreglo, TAMANIO, materia )
Para i<-0 Hasta TAMANIO Con Paso 1 Hacer
Escribir "Inserta el ID del alumno de la materia ",materia," en la posicion ",i
Leer arreglo(i)
Fin Para
Fin SubProceso
Proceso ejercicio_arreglos_DDR_6
TAMANIO = 4
Dimension algebra(TAMANIO)
dimension analisis(TAMANIO)
Dimension comunes(TAMANIO)
rellenarArreglo(algebra, TAMANIO-1, "Algebra")
rellenarArreglo(analisis, TAMANIO-1, "Analisis")
num_alumnos_comunes = buscarElementos(algebra, analisis, comunes, TAMANIO-1)
Escribir "Hay ",num_alumnos_comunes," comunes"
Para i<-0 Hasta num_alumnos_comunes Con Paso 1 Hacer
Escribir comunes(i)
Fin Para
FinProceso
|
9) Pedir por teclado el tamaño de un arreglo de números y pedir los valores numéricos con los que se rellena. Los valores no se pueden repetir. Mostrar el arreglo con los valores al final.
| Spoiler Inside |
SelectShow> |
Algoritmo Ejercicio_DDR_7_arreglos
//Indicamos el tamaño
Escribir "Introduce el tamaño del arreglo"
leer tamanio
Dimension numeros_no_repetidos(tamanio)
//Variables usadas
numero_elementos = 0
elemento = 0
elemento_no_repetido = Verdadero
//No salimos hasta que el numero de elementos sea igual al del tamaño
Mientras numero_elementos < tamanio Hacer
//Pedimos un valor numerico
Escribir "Escribe un valor numerico, no repetido"
leer elemento
//Recorro de nuevo el arreglo
Para i<-0 Hasta numero_elementos-1 Con Paso 1 Hacer
//Comprobamos que el numero existe
Si elemento = numeros_no_repetidos(i) Entonces
elemento_no_repetido = Falso
Fin Si
Fin Para
//Si no entra en el anterior Si .. entonces
//Quiere decir que no esta en el arreglo
Si elemento_no_repetido Entonces
//Asigno el valor no repetico
numeros_no_repetidos(numero_elementos) = elemento
//Aumento el numero de elementos
numero_elementos = numero_elementos +1
Sino
Escribir "Este elemento existe en el arreglo"
Fin Si
//Reinicio la variable
elemento_no_repetido = Verdadero
Fin Mientras
//Muestro el arreglo
Para i<-0 Hasta tamanio-1 Con Paso 1 Hacer
Escribir numeros_no_repetidos(i)
Fin Para
FinAlgoritmo
|
10) Suponga un array con N números enteros generados aleatoriamente y mostrados en pantalla, N debe ser un número impar, mostrar en pantalla el valor que ocupa el centro del array.
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio_8_DDR_arrays
//Validamos que el numero sea impar
Repetir
Escribir "Escribe un numero impar"
leer impar
Hasta Que impar % 2 = 1
//Creamos el arreglo
dimension numeros_aleatorios[impar]
//Rellenamos con numeros aleatorios
Para i<-0 Hasta impar-1 Con Paso 1 Hacer
numeros_aleatorios[i] = Aleatorio(0,20)
escribir numeros_aleatorios[i]
Fin Para
//Espacio
Escribir ""
//Valor de la posicion central
pos_central = trunc(impar / 2)
Escribir "Posicion central: ", numeros_aleatorios[pos_central]
FinProceso
|
11) Suponga un array con N notas de 0 a 20, calcule el promedio de aprobados y el promedio de los desaprobados e indique la cantidad de aprobados y desaprobados.
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio_9_DDR_arrays
//Pedimos el tamaño del arreglo
Escribir "Escribe un numero para el tamaño del arreglo"
leer tamanio
//Creamos el arreglo
dimension numeros_aleatorios[tamanio]
aprobados = 0
desaprobados = 0
sum_aprobados = 0
sum_desaprobados = 0
//
Para i<-0 Hasta tamanio-1 Con Paso 1 Hacer
numeros_aleatorios[i] = Aleatorio(0,20)
Escribir numeros_aleatorios[i]
Si numeros_aleatorios[i] >=10 Entonces
aprobados = aprobados + 1
sum_aprobados = sum_aprobados + numeros_aleatorios[i]
Sino
desaprobados = desaprobados + 1
sum_desaprobados = sum_desaprobados + numeros_aleatorios[i]
Fin Si
Fin Para
//Calculamos el promedio
prom_aprobados = sum_aprobados / aprobados
prom_desaprobados = sum_desaprobados / desaprobados
//Mostramos los valores
Escribir "Hay ",aprobados," aprobados"
Escribir "Hay ",desaprobados," desaprobados"
Escribir "El promedio de los aprobados es ",prom_aprobados
Escribir "El promedio de los desaprobados es ",prom_desaprobados
FinProceso
|
12) Suponga un array que contiene N notas de 0 a 20 generados aleatoriamente y mostradas en pantalla, de acuerdo a la nota contenida, indique cuántos estudiantes son:
- Deficientes 0-5
- Regulares 6-10
- Buenos 11-15
- Excelentes 16-20
| Spoiler Inside |
SelectShow> |
Proceso Ejercicio_10_DDR_arrays
//Pedimos el tamaño del arreglo
Escribir "Escribe un numero para el tamaño del arreglo"
leer tamanio
//Creamos los arreglos
dimension numeros_aleatorios[tamanio]
dimension contadores[4]
//Recooremos el arreglo
Para i<-0 Hasta tamanio-1 Con Paso 1 Hacer
numeros_aleatorios[i] = Aleatorio(0,20)
Escribir numeros_aleatorios[i]
//Segun el valor, añadimos uno mas al arreglo
Si numeros_aleatorios[i]>=0 y numeros_aleatorios[i]<=5 Entonces
contadores[0] = contadores[0] + 1
Sino
si numeros_aleatorios[i]>=6 y numeros_aleatorios[i]<=10
contadores[1] = contadores[1] + 1
Sino
si numeros_aleatorios[i]>=11 y numeros_aleatorios[i]<=15
contadores[2] = contadores[2] + 1
sino
si numeros_aleatorios[i]>=16 y numeros_aleatorios[i]<=20
contadores[3] = contadores[3] + 1
fin si
FinSi
fin SI
Fin Si
Fin Para
//Mostramos los valores
Para i<-0 Hasta 3 Con Paso 1 Hacer
Segun i Hacer
0:
Escribir "Deficientes (0-5): ", contadores[i]
1:
Escribir "Regulares (6-10): ", contadores[i]
2:
Escribir "Buenos (11-15): ", contadores[i]
3:
Escribir "Excelentes (16-20): ", contadores[i]
Fin Segun
Fin Para
FinProceso
|
13) Realizar un programa con el siguiente menú:
1. Llenar Vector A de manera aleatoria.
2. Llenar Vector B de manera aleatoria.
3. Realizar C=A+B
4. Realizar C=B-A
5. Mostrar (Permitiendo al usuario elegir entre el Vector A, B, o C).
6. Salir. NOTA.
El rango de los número aleatorios para los Vectores será de [-100 a 100]. Validar opción 3, 4 y mostrar C de 5.
La longitud de los Vectores es la misma, por lo tanto solo se solicitará una vez.
| Spoiler Inside |
SelectShow> |
Proceso ejercicio_arreglos_6
//Constantes usadas
MINIMO = -100
MAXIMO = 100
FORMA_1 = 1
FORMA_2 = 2
//Pedimos la longitud de los arreglos
Escribir "Escribe una longitud"
leer longitud_arreglos
//Dimensiones de los arreglos
Dimension A(longitud_arreglos)
Dimension B(longitud_arreglos)
Dimension C(longitud_arreglos)
arreglo_A_rellenado = FALSO
arreglo_B_rellenado = FALSO
opcion_menu = 0
Repetir
//Menu
Escribir "1. Llenar Vector A de forma aleatoria";
Escribir "2. Llenar Vector B de forma aleatoria";
Escribir "3. Realizar C = A + B";
Escribir "4. Realizar C = B - A";
Escribir "5. Mostrar arreglo";
Escribir "6. Salir";
//elijo una opcion del menu
Escribir "Elige una opcion"
leer opcion_menu
salir = FALSO
Segun opcion_menu Hacer
//Opciones del menu
1:
//relleno el arreglo A
llenarArreglo(A, longitud_arreglos, MINIMO, MAXIMO)
arreglo_A_rellenado = VERDADERO
Escribir "el arreglo A ha sido rellenado"
2:
//relleno el arreglo B
llenarArreglo(B, longitud_arreglos, MINIMO, MAXIMO)
arreglo_B_rellenado = VERDADERO
Escribir "el arreglo B ha sido rellenado"
3:
Si arreglo_A_rellenado Y arreglo_B_rellenado Entonces
//relleno el arreglo C
rellenarC(A, B, C, longitud_arreglos, FORMA_1)
Escribir "el arreglo C ha sido rellenado"
Sino
Si no arreglo_A_rellenado Entonces
Escribir "Tienes que rellenar el arreglo A"
Fin Si
Si no arreglo_B_rellenado Entonces
Escribir "Tienes que rellenar el arreglo B"
Fin Si
Fin Si
4:
Si arreglo_A_rellenado Y arreglo_B_rellenado Entonces
//relleno el arreglo C
rellenarC(A, B, C, longitud_arreglos, FORMA_2)
Escribir "el arreglo C ha sido rellenado"
Sino
Si no arreglo_A_rellenado Entonces
Escribir "Tienes que rellenar el arreglo A"
Fin Si
Si no arreglo_B_rellenado Entonces
Escribir "Tienes que rellenar el arreglo B"
Fin Si
Fin Si
5:
//Submenu
opcion_submenu = 0
Repetir
Escribir "Escribe que arreglo quieres mostrar"
Escribir "1. A"
Escribir "2. B"
Escribir "3. C"
Escribir "4. Salir"
leer opcion_submenu
salir_submenu = FALSO
//mostrar arreglos
Segun opcion_submenu Hacer
1:
mostrarArreglo(A, longitud_arreglos)
2:
mostrarArreglo(B, longitud_arreglos)
3:
mostrarArreglo(C, longitud_arreglos)
4:
salir_submenu = Verdadero
De Otro Modo:
Escribir "Elige alguna de las opciones"
Fin Segun
Mientras Que no salir_submenu
6:
salir = VERDADERO
De Otro Modo:
Escribir "Escribe una opcion entre 1 y 6"
Fin Segun
Mientras Que no salir
FinProceso
//rellena el arreglo
Subproceso llenarArreglo ( arreglo Por Referencia, longitud_arreglos, min, max )
Para i<-0 Hasta longitud_arreglos-1 Con Paso 1 Hacer
arreglo(i) <- Aleatorio(min,max)
Fin Para
Fin subproceso
//Muestra un arreglo concreto
Subproceso mostrarArreglo ( arreglo Por Referencia, longitud_arreglos)
Para i<-0 Hasta longitud_arreglos-1 Con Paso 1 Hacer
escribir arreglo(i) , " " Sin Saltar
Fin Para
Escribir ""
Fin subproceso
//Rellena el arreglo C
subproceso rellenarC ( arregloA Por Referencia, arregloB Por Referencia,arregloC Por Referencia,longitud_arreglos, tipo )
Si tipo = 1 Entonces
//punto 3
Para i<-0 Hasta longitud_arreglos-1 Con Paso 1 Hacer
arregloC(i) = arregloA(i) + arregloB(i)
Fin Para
Sino
//punto 4
Para i<-0 Hasta longitud_arreglos-1 Con Paso 1 Hacer
arregloC(i) = arregloB(i) - arregloA(i)
Fin Para
Fin Si
Fin subproceso
|
14) Queremos calcular el numero de billetes y monedas de una cantidad pasado por teclado. Los billetes son:
- 500 €
- 200 €
- 100 €
- 50 €
- 20 €
- 10 €
- 5 €
Las monedas son:
- 2 €
- 1 €
- 0.5 €
- 0.2 €
- 0.1 €
- 0.05 €
- 0.02 €
- 0.01 €
Recomiendo que las monedas las paséis a céntimos
| Spoiler Inside |
SelectShow> |
Algoritmo ejercicio_arreglos_7
//Constantes usadas
NUMERO_BILLETES <- 7
NUMERO_MONEDAS <- 8
TOTAL <- NUMERO_BILLETES + NUMERO_MONEDAS
//arreglo de billetes
dimension billetes(NUMERO_BILLETES)
billetes(0)<-500
billetes(1)<-200
billetes(2)<-100
billetes(3)<-50
billetes(4)<-20
billetes(5)<-10
billetes(6)<-5
//arreglo de monedas
dimension monedas(NUMERO_MONEDAS)
//las cantidades estan en centimos
monedas(0)<-200
monedas(1)<-100
monedas(2)<-50
monedas(3)<-20
monedas(4)<-10
monedas(5)<-5
monedas(6)<-2
monedas(7)<-1
dimension cantidad_bill_mon(TOTAL)
//Indices para los arreglos de billetes y monedas
indice_billetes<-0
indice_monedas<-0
//Pedimos la cantidad
escribir "Dame una cantidad mayor que 0"
leer cantidad
//Comprobamos si la cantidad es mayor que 0
Si cantidad > 0 Entonces
//Saco la parte decimal y la entera
cantidad_entera <- trunc(cantidad)
cantidad_decimal <- trunc(((cantidad - cantidad_entera) *100) + 0.1)
//Recorro la cantidad_bill_mon
Para i<-0 Hasta TOTAL-1 Con Paso 1 Hacer
//Si la i esta entre 0 y 6 en este caso, tocamos los billetes
Si i<NUMERO_BILLETES Entonces
//Ponemos la cantidad de billetes diviendo entre su numero y truncamos
cantidad_bill_mon(i) <- trunc(cantidad_entera / billetes(indice_billetes))
//Actualizamos la cantidad entera usando el modulo (lo que sobra)
cantidad_entera <- cantidad_entera MOD billetes(indice_billetes)
//Aumentamos el indice de los billetes
indice_billetes <- indice_billetes +1
Sino
//Solo para monedas de 1 y 2 euros (caso especial)
Si indice_monedas>=0 y indice_monedas<=1 Entonces
//Ponemos la cantidad de monedas diviendo entre su numero y truncamos
cantidad_bill_mon(i) <- trunc(cantidad_entera / (monedas(indice_monedas) / 100))
//Actualizamos la cantidad entera usando el modulo (lo que sobra)
cantidad_entera <- cantidad_entera MOD (monedas(indice_monedas) /100)
Sino
//Ponemos la cantidad de monedas diviendo entre su numero y truncamos (parte decimla)
cantidad_bill_mon(i) <- trunc(cantidad_decimal / monedas(indice_monedas))
//Actualizamos la cantidad entera usando el modulo (lo que sobra)
cantidad_decimal <- cantidad_decimal MOD monedas(indice_monedas)
Fin Si
//Aumentamos el indice de las monedas
indice_monedas <- indice_monedas + 1
Fin Si
Fin Para
//reiniciamos los indices
indice_billetes<-0
indice_monedas<-0
//Recorremos de nuevo
Para i<-0 Hasta TOTAL-1 Con Paso 1 Hacer
//Si la i esta entre 0 y 6 en este caso, tocamos los billetes
Si i<NUMERO_BILLETES Entonces
//Si hemos rellenado una cantidad, la mostramos
Si cantidad_bill_mon(i) > 0 Entonces
Escribir "Cantidad de ",billetes(indice_billetes), "€ es de: ",cantidad_bill_mon(i)
Fin Si
//Aumentamos el indice de las billetes
indice_billetes <- indice_billetes + 1
Sino
//Si hemos rellenado una cantidad, la mostramos
Si cantidad_bill_mon(i) > 0 Entonces
//En este caso, llo volvemos a pasar a su valor original
Escribir "Cantidad de ",(monedas(indice_monedas) / 100), "€ es de: ",cantidad_bill_mon(i)
Fin Si
//Aumentamos el indice de las monedas
indice_monedas <- indice_monedas + 1
Fin Si
Fin Para
Sino
escribir "La cantidad debe se mayor que 0"
Fin Si
FinAlgoritmo
|
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
hola me podrian ayudar con un ejercicio de arreglo que no me sale por nada del mundo
Si tienes alguna duda, puedes mandarme un email a administrador@discoduroderoer.es y me comentas el problema con detalle.
También lo puedes explicar aquí en este post.
Un saludo y gracias por tu comentario.
Soy estudiante de ingeniería informática en Murcia, aquí dejo una solución al primer ejercicio:
Léxico
Lmax= 5;
I:entero[1.lmax];
Long:entero[1, lmax];
T: Tipo Tabla[1,Lmax] de entero >= 0;
Algoritmo
: Long<–5;
T1<–1;
T2<–2;
T3<–3;
T4<–4;
T5<–5;
i Recorriendo [1, Long] Hacer
escribir( Ti);
Fin_Recorriendo;
Fin
me pueden hacer el de cajero con los billetes de $500,$200,$100 y $50 que solo agarre esos para retirar el dinero
¿Podrías especificar un poco mas? No se a que ejercicio te refieres.
Una ayuda por favor tengo tres ejercicios con vectores ayedenme auquesea con uno
1.- Sea un torneo hipico en el cual se registran 10 carreras del torneo como sigue: numero de carrera, nombre del jockey, nombre del caballo, distancia que recorre, tiempo registrado.
Además se cuenta con la información de los caballos: Nombre del caballo,peso, edad, raza o procedencia.
Nota: los caballos no deben sobrepasar los 7 años tampoco debe haber nombre duplicado del caballo.
En el mencionado torneo se van a registrar los 2 primeros caballos ganadores de cada una de las carreras, para así poder premiar al caballo de mayor nùmero de carreras ganadas. se le pide lo siguiente:
a) Crear las estructuras de datos adecuadas para el tratamiento de esta información
b)Registrar un nuevo caballo que mantenga el orden descendente de edad.
c)Mostrar los caballos ganadores con su nombre del primer y segundo lugar de cada una de las carreras.
d)Mostrar el nombre del caballo que a obtenido el mayor numero de carreras ganadas
e)Mostrar el nombre del Jockey que ah obtenido el mayor número de carreras ganadas.
f) Separar las carreras en 2 de MIL METROS y DOS MIL metros respectivamente donde se registra la información por orden ascendente de tiempo registrado en los caballos.
Te respondo en un correo.
Saludos
Proceso sin_titulo
//Crear un algoritmo que Ingrese 7 números en un arreglo. Luego almacenarlos en otro vector en orden inverso al vector original e imprimir
//el vector original y el inverso.
definir num,i,numnue como entero;
dimension num(10);
dimension numnue(10);
Escribir «Ingresaremos 10 numeros »
Para i<-1 Hasta 10 Hacer
Escribir "Numero ",i,"";
leer num(i);
Fin Para
Escribir "Numeros ingresados en el primer vector";
Para i<-1 Hasta 10 Hacer
Escribir num(i);
Fin Para
escribir "- – – – – – – – – – ";
Escribir "Numeros ingresados en el Segundo vector";
Para i<-1 Hasta 10 Hacer
numnue(i)=num(i)
Fin Para
Para i<-10 Hasta 1 Hacer
escribir numnue(i);
Fin Para
FinProceso
podrian ayudarme con unos ejercicios de arreglos por favor…
aca se los dejo y se los agradeceria muchisimo
Caso 1:
Realizar un algoritmo que permita llenar un arreglo de largo N (validar que el valor mínimo de N sea 3) que contenga las temperaturas de la ciudad de Valdivia en grados Celcius. El arreglo se debe llenar en forma aleatoria en un rango entre -20° y 40°, y además se solicita mostrar el promedio de temperaturas sobre 0°. Si no hubo temperaturas sobre 0° mostrar el mensaje adecuado.
Caso 2
Realizar un algoritmo que permita llenar un arreglo de largo N con números enteros positivos y validar que el valor de N y los elementos sean positivos. Luego modificar los elementos del arreglo de la siguiente forma:
Si el elemento se encuentra en posición índice impar y tiene 2 dígitos, es aumentar el valor de la decena de este. Mostrar el valor modificado. (WTF)
-Después no dijo nada más de este caso-
Caso 3:
Un frigorífico de carnes de cordero ubicado en el centro de la ciudad de Punta Arenas necesita computarizar las medidas de los corderos almacenados allí. Por cada cordero se deben almacenar las siguientes variables:
– Número de serie: Cadena de caracteres
– Edad: Aleatoria en un rango entre 1 y 10
– Sexo: Si es macho (M) o hembra (H)
– Peso: En kilos
El frigorífico tiene una capacidad para recibir como máximo 100 corderos. Debe realizar un algoritmo que permita ingresar dicha información en arreglos paralelos y validar la información.
Almacenar en un nuevo arreglo los números de series de todos los corderos hembras obesas (peso>40kg) y mostrar el arreglo con los números de serie. En caso que no tuviera hembras obesas mostrar el mensaje correspondiente.
Hola,
Te respondo por email.
Un saludo