Ejercicio 1

Dado un array de 20 elementos que consiste en nmeros reales (con coma decimal) y
que cada elemento representa la venta del da de un comercio. Calcular el promedio de
venta por da utilizando alguna estructura iterativa. Mostrar el resultado por pantalla.

<?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 nmeros
reales, es decir, nmeros 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 nmero fijo de veces. Se comienza el
for en 0 porque el primer elemento del arreglo es $ventas_dia[0]. La condicin 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 funcin 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 funcin 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:

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

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

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

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

<?php

// una manera de hacerlo

$nombres = array ('roberto','juan','marta','moria','martin',
'jorge','miriam','nahuel','mirta');
$nombres_con_m = array();

$r = 0;
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 vaco. Para dejar vaco un
array simplemente abrimos y cerramos los parntesis despus 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 iteracin.

Para saber si la primera letra de una variable que tiene cadena de caracteres es una m,
hay que usar la instruccin que se ve en el cdigo. Resulta que los strings son tambin
arrays y que puede indicarse cada caracter o letra poniendo un nmero entre corchetes e
indicando la posicin 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
posicin 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 operacin, los elementos no dejan de
estar en el array original, sino que es ms 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 terica. 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 tambin que en los arrays enumerativos, las claves son
nmeros.

Este foreach lo que har es mostrar los nombres con m. El if que aparece despus
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 nmeros ordenados.

Salida

marta, moria, martin, miriam, mirta

1 marta, moria, martin, miriam, mirta.

Veamos otra forma de resolverlo que tiene algunas similitudes

 <?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 lnea:

$nombres_con_m[] =$nombre;

1 $nombres_con_m[] = $nombre;

Mucho ms 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 tambin en el chequeo
de si se est en el ltimo elemento.

La salida de este cdigo 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.
<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 cdigo 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 ms fcil utilizar la sintaxis alternativa de
las sentencias tanto iterativas como selectivas.

Ejercicio 4

Dado un array enumerativo de 10 elementos de nmeros enteros (sin coma decimal),

encontrar el mximo de todos esos nmeros usando una estructura iterativa y
mostrarlo por pantalla.

Este es el tpico ejercicio donde hay que usar un algoritmo para obtener el mximo
elemento de un arreglo.

<?php

$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 nmeros e inicializamos una variable contadora llamada
$paso ya que opt por un while para poder mostrar su uso. Bien se podra 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

iteracin, cuando $paso vale 0, an no hay un mximo definido as que por defecto el
primer elemento pasar a ser el mximo. Luego, en el resto de los casos, habr que
comparar el elemento actual de la iteracin con el mximo, si este lo supera, entonces
ser el nuevo mximo. Si esto no ocurre, no pasar nada. En cada iteracin, como
estamos en un while habr que alterar el valor de la variable que aparece en la
condicin. 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 vern que de todas formas el
algortimo seguir funcionando.

Salida

El maximo es: 15

El maximo es: 15

Ejercicio 5

Idem anterior pero encontrar el mnimo.

El algoritmo es el mismo, pero hay alguna variante. Vemoslo.

<?php

$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 comparacin. Tambin cambiamos el nombre de la

variable $maximo por $minimo para que tenga relacin con lo que va a almacenar.
Esperaban algo ms complicado? La clave de este ejercicio es deducirlo analizando el
cdigo del ejercicio anterior.

Salida

PHP
El minimo es: 1

El minimo es: 1
Ejercicio 6

Hacer un programa que calcule todos los nmeros primos entre 1 y 50 y los muestre
por pantalla. Un nmero primo es un nmero entero que slo es divisible por 1 y por s
mismo.

Este ejercicio sirve para explicar como funciona la sentencia break y tambin permite
mostrar de qu forma evitarla.

Tendremos que recorrer todos los nmeros del 1 al 50 y a cada uno de ellos dividirlos
por 1, luego por 2, luego por 3 y as sucesivamente. En cada divisin hay que verificar
qu ocurre con el resto. Si el resto da cero entonces el nmero es divisible. Si da distinto
de cero, entonces no es divisible. Es necesario utilizar el operador resto de la divisin
entera %.

Primero veamos una solucin utilizando break

<?php
// resolucion utilizando BREAK

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 nmero a analizar si
es primo o no en cada iteracin. $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 definicin: un nmero es primo si es divisible por 1 y por s mismo.

Todos los nmeros son divisibles por 1, por lo tanto no tiene sentido probar la divisin
por 1, este es el motivo por el cual $div se inicializa en 2. A su vez, todos los nmeros
son divisibles por s mismos. Es decir que los primos no son divisibles por los que estn
entre el 2 y el inmediato nmero inferior a s mismos.

$div se ir incrementando en uno y en cada paso se har el resto de la divisin entera: $i

% $div. Si da 0, significa que ese nmero 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 dowhile cuando encuentra un nmero que divide a nuestro $i.
Por qu lo rompe? Supongamos que $i vale 28, $div empieza valiendo 2, al realizar la
divisin 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 nmero no es primo? No.
Por lo tanto, es toda una tentacin utilizar break para interrumpir el ciclo.

Ese sera el caso en el que el nmero a analizar no es primo. Pero veamos qu ocurre
cuando s lo es. La variable $primo arranca en TRUE en cada iteracin 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 ningn
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 nmero $i por pantalla.

Ahora analicemos la condicin de corte del while, que es lo ms difcil de todo. El while
debe repetirse siempre que el valor de nuestro nmero $i sea igual o ms 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 nmeros que vienen despus de la
mitad el resultado nunca podr ser entero.

Ahora veamos como evitar ese break.

// 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 condicin del while. De esta forma, cuando
ya sepamos que el nmero no es el que buscamos, la variable $primo se pondr en
FALSE y para que el while se vuelva a repetir es condicin necesaria lo que expliqu
recin del valor de $i y de su divisor $div pero tambin 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 cdigos es:

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

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