Curso de PHP – Clase 5 – Resolución de ejercicios

propuestos

Publicado el 24/05/2012 por Alejandro en Curso de PHP Básico • 2 comentarios

Etiquetas: curso, php

En la última clase teórica del curso de PHP vimos las estructuras iterativas que sirven

para repetir porciones de código. Exploramos los bucles for, foreach, while y do…

while. Propuse seis ejercicios para poner en práctica lo visto. Así que, sin más, voy a

pasar a mostrar como resolverlos.

Como siempre, el código fuente donde está la resolución de estos ejercicios lo pueden

encontrar aquí. Y la salida de ese código, aquí.

Ejercicio 1

Dado un array de 20 elementos que consiste en números reales (con coma decimal) y

que cada elemento representa la venta del día de un comercio. Calcular el promedio de

venta por día utilizando alguna estructura iterativa. Mostrar el resultado por pantalla.

Ya habíamos hecho un ejercicio para calcular un promedio. Aquí la ventaja es que los

valores están cargados en un array y nos da la posibilidad de usar algún bucle. El

enunciado no dice qué estructura utilizar así que podemos elegir.

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

<?php

$ventas_dia = array (120.25, 85.05, 90.36, 98.95, 102.51, 79.17, 89.55, 80.69, 86.77, 115.85, 124.25, 92.24, 94.97, 112.73, 127.85, 100.05, 105.42, 91.12, 99.51, 95.63 ); $total = 0; for ($i=0; $i<=count($ventas_dia)-1; $i++) { $total += $ventas_dia[$i]; } $promedio = $total / count($ventas_dia); echo 'El promedio de ventas es: '.$promedio; ?>

Primero definimos un array $ventas_dia y le cargamos los valores que son números

reales, es decir, números de coma flotante. Luego, se inicializa en cero la variable que

sumará todos los valores: $total.

El bucle que utilizo es el for. ¿Por qué elegí for? Porque el array tiene justo 20

elementos y este tipo de bucle permite iterar un número fijo de veces. Se comienza el

for en 0 porque el primer elemento del arreglo es $ventas_dia[0]. La condición para

seguir adelante las iteraciones será siempre que la variable $i que realiza el conteo sea

menor o igual que la cantidad de elementos del array.

La función count cuenta la cantidad de elementos del array. Pensemos esta parte. $i

debe contar de uno en uno desde 0 hasta 19. No hasta 20. Si $i llega a valer 20

tendremos un error de offset. Por lo tanto, tomamos el total de elementos del array con

la función count, eso nos dará 20 y luego le restamos 1.

Adentro del bucle lo que haremos es acumular los valores de cada elemento del array en

una suma. Usamos el operador += en vez de usar:

?

1 $total = $total + $ventas_dia[$i];

Pero es exactamente lo mismo.

Luego, hay que calcular el promedio que es la suma de todos los elementos dividido la

cantidad de elementos. Nuevamente utilizamos count para contar los elementos del

array. Finalmente utilizamos echo para mostrar el resultado por pantalla.

Salida

El promedio de ventas es: 99.646

Ejercicio 2

Dado el siguiente array: $nombres = array

(‘roberto’,’juan’,’marta’,’moria’,’martin’,’jorge’,’miriam’,’nahuel’,’mirta’). Realizar

un programa en PHP que lo recorra y genere un nuevo array con aquellos nombres que

comiencen con la letra m. Definir qué bucle conviene usar y luego mostrar el array por

pantalla sin usar var_dump ni print_r. Los nombres deben aparecer separados por

coma.

Bueno, para los que están siguiendo el curso, admito que hice una trampita: omití

explicar algo que es muy necesario para realizar este ejemplo. Me refiero a determinar

cuál es la primer letra de un string o cadena de caracteres. De todas formas, lo mejor

que pueden hacer cuando no entienden algo es investigar cómo se hace.

Existen muchas maneras de resolver este y todos los ejercicios, pero en este caso voy a

mostrarles dos variantes.

?

1

2

3

4

5

6

7

<?php // una manera de hacerlo $nombres = array ('roberto','juan','marta','moria','martin', 'jorge','miriam','nahuel','mirta'); $nombres_con_m = array();

$r = 0;

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

foreach ($nombres as $nombre) { if ($nombre[0] == 'm') { $nombres_con_m[$r] = $nombre; $r++; } }

foreach ($nombres_con_m as $clave=>$valor) { echo $valor; if (count($nombres_con_m)-1 != $clave) echo ', '; else echo '.'; } ?>

Definimos el array del enunciado y luego otro que lo dejamos vacío. Para dejar vacío un

array simplemente abrimos y cerramos los paréntesis después de la palabra clave array.

Vamos a contar utilizando un foreach. Primero inicializamos $r, nuestro contador en 0.

Iremos pasando de elemento en elemento con $nombres as $nombre. Recuerden:

$nombres es el nombre del array y $nombre la variable que tomará el valor del

elemento en cada iteración.

Para saber si la primera letra de una variable que tiene cadena de caracteres es una m,

hay que usar la instrucción que se ve en el código. Resulta que los strings son también

arrays y que puede indicarse cada caracter o letra poniendo un número entre corchetes e

indicando la posición del caracter que se desea. Como en este caso se necesita comparar

la primera letra, se pone un 0. El if chequeará que la primera letra del elemento $nombre

sea igual a m. Si lo es, $nombre pasará a ubicarse en el array $nombres_con_m en la

posición que $r lo indique. Luego, se incrementará $r.

Si se fijan, $r se utiliza para ir ubicando en el array nuevo los elementos que se tengan

que pasar. Es importante aclarar que al realizar la operación, los elementos no dejan de

estar en el array original, sino que es más bien una especie de copia. En realidad, son

referencias que se agregan a ese elemento, como si las posiciones de los arrays

apuntaran al mismo elemento.

Toda esa estructura sirve para seleccionar aquellos nombres que comienzan con la letra

m.

El segundo foreach sirve para mostrar por pantalla los resultados. Aquí aprovecho para

mostrar algo adicional que no expliqué en la clase teórica. Se trata de la clave y el valor

usados dentro del foreach. Recuerden de la clase de arrays, que estos estaban formados

por una clave asociada a un valor. Bien, el foreach permite manejar dentro del bucle a

ambos elementos. Recuerden también que en los arrays enumerativos, las claves son

números.

Este foreach lo que hará es mostrar los nombres con m. El if que aparece después

chequea si no se llegó al último elemento. Si esto es así, entonces muestra por pantalla

una coma para separar los nombres. Si se llegó al último elemento, en vez de una coma,

muestra un punto. Este if funciona únicamente con arrays enumerativos donde las claves

son números ordenados.

Salida

marta, moria, martin, miriam, mirta.

Veamos otra forma de resolverlo que tiene algunas similitudes

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

<?php // otra manera de hacerlo $nombres = array ('roberto','juan','marta','moria','martin', 'jorge','miriam','nahuel','mirta'); $nombres_con_m = array(); foreach ($nombres as $nombre) { if ($nombre[0] == 'm') $nombres_con_m[] = $nombre; }

for ($i=0; $i<=count($nombres_con_m)-1; $i++) { echo $nombres_con_m[$i]; // si es el ultimo paso if ($i == count($nombres_con_m)) echo '.'; else echo ', '; } ?>

El primer foreach tiene una diferencia. En vez de utilizar una variable para contar y

acomodar los nombres que empiezan con m, se agregan los elementos de forma directa

al final del array en la línea:

?

1 $nombres_con_m[] = $nombre;

Mucho más sencillo. ¿No creen?

Luego, en vez de un foreach, usamos un for para recorrer el array $nombres_con_m. Al

mostrarlo por pantalla, naturalmente hay que usar el índice $i y también en el chequeo

de si se está en el último elemento.

La salida de este código es exactamente la misma que con la otra variante.

Ejercicio 3

Realizar un programa que arme la estructura HTML de una tabla con 20 filas y 10

columnas utilizando dos bucles for. Dentro de las celdas debe ponerse una letra O.

Este ejercicio está bueno para combinar HTML con PHP. Noten que en este curso,

hasta el momento no he hecho mención alguna a la estructura del documento HTML.

Eso lo veremos la siguiente clase. Así que por ahora, no hace falta armar la estructura

conocida de este código de marcas. Sí de la tabla que vamos a generar.

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

<table> <?php for ($i=1; $i<=20; $i++): ?> <tr> <?php for ($s=1; $s<=10; $s++): ?> <td>O</td> <?php endfor; ?> </tr> <?php endfor; ?> </table>

Por fuera del código PHP van las etiquetas <table></table>. Usaremos dos bucles for

para iterar en cantidades fijas. Un for externo se encargará de repetir las filas y uno

interno se encargará de repetir las columnas. El de afuera se ejecutará 20 veces y el de

adentro 20 veces 10, es decir 20 x 10 que es igual a 200.

Se usa una variable contador $i para el externo y otra variable $s para el interno.

Recuerden que <tr></tr> se usa para definir las filas y que <td></td> son las celdas

propiamente.

Como ven, cuando se trabaja con HTML es más fácil utilizar la sintaxis alternativa de

las sentencias tanto iterativas como selectivas.

El resultado de este código lo pueden ver en la correspondiente salida cuyo enlace está

al principio del artículo.

Ejercicio 4

Dado un array enumerativo de 10 elementos de números enteros (sin coma decimal),

encontrar el máximo de todos esos números usando una estructura iterativa y mostrarlo

por pantalla.

Este es el típico ejercicio donde hay que usar un algoritmo para obtener el máximo

elemento de un arreglo.

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

$numeros = array (10, 2, 3, 14, 15, 1, 7, 9, 8, 11); $paso = 0;

while ($paso <= count($numeros)-1) { if ($paso == 0) $maximo = $numeros[0]; else { if ($numeros[$paso] > $maximo) $maximo = $numeros[$paso]; } $paso++; } echo 'El maximo es: '.$maximo;

?>

Definimos el array con los números e inicializamos una variable contadora llamada

$paso ya que opté por un while para poder mostrar su uso. Bien se podría haber

planteado con un for.

El while se ejecutará siempre que la variable contadora $paso tenga un valor menor o

igual al índice que corresponde al último elemento del array, al igual que el bucle for.

Por eso aparece el -1 restando luego del count($numeros).

El algoritmo es bastante simple pero vamos a explicarlo en detalle. En la primera

iteración, cuando $paso vale 0, aún no hay un máximo definido así que por defecto el

primer elemento pasará a ser el máximo. Luego, en el resto de los casos, habrá que

comparar el elemento actual de la iteración con el máximo, si este lo supera, entonces

será el nuevo máximo. Si esto no ocurre, no pasará nada. En cada iteración, como

estamos en un while habrá que alterar el valor de la variable que aparece en la

condición. En este caso, se incrementará $paso.

Al final del while, el valor mas grande del array quedará alojado en la variable

$maximo. Prueben cambiar los valores del array y verán que de todas formas el

algortimo seguirá funcionando.

Salida

El maximo es: 15

Ejercicio 5

Idem anterior pero encontrar el mínimo.

El algoritmo es el mismo, pero hay alguna variante. Veámoslo.

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

$numeros = array (10, 2, 3, 14, 15, 1, 7, 9, 8, 11); $paso = 0;

while ($paso <= count($numeros)-1) { if ($paso == 0) $minimo = $numeros[0]; else { if ($numeros[$paso] < $minimo) $minimo = $numeros[$paso]; } $paso++; } echo 'El minimo es: '.$minimo;

?>

Se debe cambiar el signo en la comparación. También cambiamos el nombre de la

variable $maximo por $minimo para que tenga relación con lo que va a almacenar.

¿Esperaban algo más complicado? La clave de este ejercicio es deducirlo analizando el

código del ejercicio anterior.

Salida

El minimo es: 1

Ejercicio 6

Hacer un programa que calcule todos los números primos entre 1 y 50 y los muestre

por pantalla. Un número primo es un número entero que sólo es divisible por 1 y por sí

mismo.

Este ejercicio me encanta y sirve para explicar como funciona la sentencia break y

también permite mostrar de qué forma evitarla.

Tendremos que recorrer todos los números del 1 al 50 y a cada uno de ellos dividirlos

por 1, luego por 2, luego por 3 y así sucesivamente. En cada división hay que verificar

qué ocurre con el resto. Si el resto da cero entonces el número es divisible. Si da distinto

de cero, entonces no es divisible. Es necesario utilizar el operador resto de la división

entera %.

Primero veamos una solución utilizando break

?

1

2 <?php // resolucion utilizando BREAK

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

for ($i=1; $i<=50; $i++) { $div = 2; $primo = true; do { if ($i % $div == 0) { $primo = false; break; } $div++; } while($i >= $div*2); if ($primo == TRUE ) echo $i.' '; } ?>

El for recorrerá desde el 1 hasta el 50. Es decir que $i será nuestro número a analizar si

es primo o no en cada iteración. $div será la variable que guardará el divisor y que se irá

incrementando. Usaremos un do… while a modo de bucle interno. En esta estructura, se

irá dividiendo a $i por $div todas las veces que sea necesario para probar si es primo o

no.

Recordemos la definición: un número es primo si es divisible por 1 y por sí mismo.

Todos los números son divisibles por 1, por lo tanto no tiene sentido probar la división

por 1, este es el motivo por el cual $div se inicializa en 2. A su vez, todos los números

son divisibles por sí mismos. Es decir que los primos no son divisibles por los que están

entre el 2 y el inmediato número inferior a sí mismos.

$div se irá incrementando en uno y en cada paso se hará el resto de la división entera: $i

% $div. Si da 0, significa que ese número es divisible por otro, entonces no es primo.

Por eso, usamos una variable booleana (con valores TRUE o FALSE) para indicar el

resultado.

El break rompe el bucle do…while cuando encuentra un número que divide a nuestro $i.

¿Por qué lo rompe? Supongamos que $i vale 28, $div empieza valiendo 2, al realizar la

división entera, el resultado es 0. Por lo tanto, 28 no es primo. ¿Tiene sentido seguir

incrementando $div y seguir dividiendo si ya sabemos que el número no es primo? No.

Por lo tanto, es toda una tentación utilizar break para interrumpir el ciclo.

Ese sería el caso en el que el número a analizar no es primo. Pero veamos qué ocurre

cuando sí lo es. La variable $primo arranca en TRUE en cada iteración del for. Dentro

del do… while será dividida por $div. Supongamos que $i vale 11. Sabemos que no es

divisible por 2, ni por 3, ni por 4 ni por 5. El valor de $primo no se alterará en ningún

momento y al finalizar el while seguirá siendo TRUE. Por lo tanto, como ven, luego del

while aparece un if donde se verifica el valor de $primo y en caso de ser verdadero, se

muestra el número $i por pantalla.

Ahora analicemos la condición de corte del while, que es lo más difícil de todo. El while

debe repetirse siempre que el valor de nuestro número $i sea igual o más grande que el

de $div por dos. Esto se entenderá mejor con un ejemplo. Supongamos que nuestro $i

vale 41. Debemos dividirlo por 1, 2, 3, 4, etc. Pero cuando lleguemos a la mitad

aproximadamente, es decir, 20 estaremos en el último posible divisor. ¿Por qué? Porque

si seguimos dividiendo usando como divisores los números que vienen después de la

mitad el resultado nunca podrá ser entero.

Ahora veamos como evitar ese break.

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

// resolucion sin utilizar break for ($i=1; $i<=50; $i++) { $div = 2; $primo = true; do { if ($i % $div == 0) $primo = false; $div++; } while(($i >= $div*2) && ($primo == TRUE));

if ($primo == TRUE ) echo $i.' '; }

Se incluye la variable $primo dentro de la condición del while. De esta forma, cuando

ya sepamos que el número no es el que buscamos, la variable $primo se pondrá en

FALSE y para que el while se vuelva a repetir es condición necesaria lo que expliqué

recién del valor de $i y de su divisor $div pero también que el valor de $primo sea

TRUE. El AND (&&) exige que ambas condiciones se cumplan al mismo tiempo para

continuar repitiendo el while.

La salida de ambos códigos es:

1 3 5 7 11 13 17 19 23 29 31 37 41 43 47

Y hasta acá hemos llegado. Si encuentran más ejercicios para hacer practiquen porque a

programar se aprende escribiendo código frente a la pantalla pasando horas y horas.

Espero que estas clases les sean de ayuda.

¡Hasta la próxima!