Ejercicios de shell scripting#
Crea un script llamado disk.sh que imprima por pantalla el porcentaje que esta ocupada la partición /home. Tiene que quedar:
75% /home
#!/bin/bash
df -h | grep home | tr -s ' '| cut -d' ' -f5-
Crea un script llamado mem.sh, obtiene solamente la memoria en MB ocupada y haz que se escriban en un archivo llamado free.log cada vez que se ejecute, sin borrar el anterior registro.
#!/bin/bash
free -h | grep Mem | tr -s ' ' | cut -d' ' -f4 >> free.log
Crea un script llamado mac.sh que obtiene la MAC de tu tarjeta de red
#!/bin/bash
ip link show enp2s0 | grep link | tr -s ' ' | cut -d' ' -f3
Crea un script llamado listar_usuario_grupo.sh que saque por pantalla el nombre de los usuarios que hay creados en el sistema y al grupo que pertenecen, por ejemplo
alumno1 : smr1
alumno2 : smr1
alumno3 : asir1
alumno4 : asir2
#!/bin/bash
for i in $(cat /etc/passwd | grep bash | grep -v root | cut -d':' -f1)
do
groups $i
done
Crea un script llamado lastlog_ip.sh que muestre un listado ordenado con el nº de veces que se a logueado cada ip, por ejemplo
16 10.2.104.100
11 10.2.3.100
10 139.47.103.76
9 10.2.105.100
8 2.153.195.106
8 10.2.4.100
8 10.2.105.106
#!/bin/bash
for i in $(last -w | tr -s ' ' | cut -d' ' -f3 | sort | grep '\.' | uniq);
do
echo $(last -w| grep -c $i) $i
done | sort -rn
#last -w | tr -s ' ' | cut -d' ' -f3 | grep '\.' | sort | uniq -c | sort -r
Crea un script llamado lastlog.sh que muestre un listado ordenado con el nº de veces que se a logueado cada usuario y el grupo al que pertenecen, por ejemplo
44 alumno1 smr1
32 alumno2 smr1
14 alumno3 asir1
4 alumno4 asir2
#!/bin/bash
for i in $(last -w | sort | cut -d' ' -f1 | uniq | egrep -v reboot | egrep -v wtmp)
do
echo $(last -w| grep -c $i) $i $(groups $i | cut -d':' -f2)
done | sort -rn
#last -w | tr -s ' ' | cut -d' ' -f1 | sort | uniq -c | sort -r
Crea un script llamado tabla_multiplicar_read.sh que pide un número al usuario y muestre su tabla de multiplicar
#!/bin/bash
echo "Introduce un número para mostrar su tabla de multiplicar: "
read numero
for ((i=1;i<11;i++))
do
resultado=$((numero * i))
echo "$numero x $i = $resultado"
done
Crea un script llamado tabla_multiplicar.sh, ahora no preguntara por el numero al usuario y haz muestre su tabla de multiplicar cuando se ejecute por ejemplo ./tabla_multiplicat.sh <N> siendo <N> un numero del 1 al 10.
En el caso de ejecutar
./tabla_multiplicat.sh --helpmostrara un mensaje de ayuda (consejo utiliza una función)En el caso de ejecutar
./tabla_multiplicar.sh X Y Z ..., es decir con más de un argumento saldrá un mensajeNo se puede dar más de un argumentoEn el caso de ejecutar
./tabla_multiplicar.shsin argumentos se ejecutara la opción de –help
#!/bin/bash
mostrar_ayuda() {
echo "Uso: ./tabla_multiplicar.sh [número]
Este script muestra la tabla de multiplicar del número que se le pase como argumento.
Opciones:
--help Muestra este mensaje de ayuda.
Ejemplos:
./tabla_multiplicar.sh 4 Muestra la tabla de multiplicar del 4."
}
if [[ $# -eq 0 ]]
then
# Sin argumentos: mostrar ayuda
mostrar_ayuda
elif [[ $1 == "--help" ]]
then
mostrar_ayuda
else
numero=$1
for ((i=1;i<11;i++))
do
resultado=$((numero * i))
echo "$numero x $i = $resultado"
done
fi
#!/bin/bash
mostrar_ayuda() {
echo "Uso: ./tabla_multiplicar_array.sh [número]
Este script muestra la tabla de multiplicar del número que se le pase como argumento.
Opciones:
--help Muestra este mensaje de ayuda.
Ejemplos:
./tabla_multiplicar.sh 4 Muestra la tabla de multiplicar del 4."
}
if [[ $# -eq 0 ]]
then
# Sin argumentos: mostrar ayuda
mostrar_ayuda
elif [[ $1 == "--help" ]]
then
mostrar_ayuda
else
numero=$1
for ((i=1;i<11;i++))
do
A[$i]=$i
done
longitud=${#A[@]}
for((i=1;i<$longitud;i++))
do
echo "$numero x ${A[$i]} = $(($numero * ${A[$i]}))"
done
fi
Crea una carpeta llamada imagenes, entra dentro y ejecuta los siguiente comandos:
for i in jpeg jpg png gif tiff bmp svg
do
for((j=0;j<10;j++))
do
echo imag_${RANDOM}.$i > imag_${RANDOM}.$i
done
done
Crea un script llamado imag.sh que cambie todas extensiones de todos los archivos a png conservando el nombre
#!/bin/bash
nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
T=0.00
for((i=1;i<=$nlineas;i++))
do
T=$(echo "scale=2; $T+$(head -$i temperatura.dat | tail -1)" | bc -l)
done
T_media=$(echo "scale=2; $T/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"
Crea un script llamado temperatura.sh, que lea las temperatura del archivo temperatura.dat y saque por pantalla la temperatura media
#!/bin/bash
nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
T=0.00
for((i=1;i<=$nlineas;i++))
do
T=$(echo "scale=2; $T+$(head -$i temperatura.dat | tail -1)" | bc -l)
done
T_media=$(echo "scale=2; $T/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"
#!/bin/bash
media=$(awk '{ suma += $1 } END { print suma/NR }' temperatura.dat )
ntemperaturas=$(awk 'END { print NR }' temperatura.dat)
echo "Tenemos $ntemperaturas temperaturas, de media T = $media"
#!/bin/bash
nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
for((i=1;i<=$nlineas;i++))
do
T[$i]=$(head -$i temperatura.dat | tail -1)
done
suma=0.00
for((i=1;i<=$nlineas;i++))
do
suma=$(echo $suma+${T[$i]} | bc -l)
done
echo $suma
T_media=$(echo "scale=2; $suma/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"
Haz un script llamado rnd.sh que muestre 5 números aleatorios del 1 al 10 seguidos de el mismo número de As,
1 A
3 AAA
1 A
6 AAAAAA
2 AA
Haz que el reciba como argumento de entrada en numero de intentos, es decir ./rnd.sh 5
En el caso de no recibir ningún numero haz que saque 5
#!/bin/bash
n=${1:-5}
for (( i = 0 ; i < n ; i++ ))
do
x=$((RANDOM % 10 + 1))' '
out=$x' '
for (( j=0 ; j<x ; j++ ))
do
out=${out}A
done
echo $out
done
#!/bin/bash
n=${1:-5}
for (( i = 0 ; i < n ; i++ ))
do
x=$((RANDOM % 10 + 1))' '
A[$i]=$x' '
for (( j=0 ; j<x ; j++ ))
do
A[$i]=${A[$i]}A
done
done
for (( i = 0 ; i < n ; i++ ))
do
echo ${A[$i]}
done
Crea un script llamado adivina.sh que escoja un numero aleatorio entre 1 y 20, pregunte al usuario, le diga si es más pequeño o más grande y que continué hasta que acierte.
Cuando el usuario acierte haz que muestre el número de intentos.
#!/bin/bash
# Generar un número aleatorio entre 1 y 20
numero_secreto=$((RANDOM % 20 + 1))
echo $numero_secreto
intentos=0
echo "¡Adivina el número entre 1 y 20!"
acertado=0
while [[ $acertado == 0 ]]
do
intentos=$((intentos+1))
read -p "Introduce tu número: " respuesta
# Comparar el número ingresado con el número secreto
if [[ $respuesta -lt $numero_secreto ]]; then
echo "El número es más grande."
elif [[ $respuesta -gt $numero_secreto ]]; then
echo "El número es más pequeño."
else
echo "¡Correcto! El número era $numero_secreto."
echo "Lo has adivinado en $intentos intento(s)."
acertado=1
fi
done
Crea un script en Bash llamado piedra_papel_tijera.sh que simule el juego de (Piedra, Papel o Tijera) entre dos jugadores durante un número dado de partidas.
Cada jugador debe elegir aleatoriamente entre piedra, papel o tijera. El programa deberá contar cuántas veces gana el Jugador 1, cuántas gana el Jugador 2 y cuántas veces empatan.
La salida debe ser un resumen con los porcentajes de empate, victoria del Jugador 1 y victoria del Jugador 2, con dos cifras decimales de precisión.
Una vez creado el script, muestra los resultados, como sigue:
for i in 10 50 100 1000 10000 100000;
do
echo $i $(./piedra_papel_tijera.sh $i)
done
10 Empate = 40.00 %, Gana 1 = 40.00 %, Gana 2 = 20.00 %
50 Empate = 36.00 %, Gana 1 = 46.00 %, Gana 2 = 18.00 %
100 Empate = 31.00 %, Gana 1 = 32.00 %, Gana 2 = 37.00 %
1000 Empate = 34.30 %, Gana 1 = 34.40 %, Gana 2 = 31.30 %
10000 Empate = 33.75 %, Gana 1 = 33.01 %, Gana 2 = 33.24 %
100000 Empate = 33.30 %, Gana 1 = 33.24 %, Gana 2 = 33.44 %
#!/bin/bash
opcion=( "piedra" "papel" "tijera" )
contador_gana1=0
contador_gana2=0
contador_empate=0
n_turnos=${1:-10}
for (( i=1; i<=n_turnos; i++ ))
do
jugador1=${opcion[$(($RANDOM % 3))]}
jugador2=${opcion[$(($RANDOM % 3))]}
#echo "$jugador1, $jugador2"
#Empates
if [ $jugador1 == $jugador2 ]
then
contador_empate=$(($contador_empate+1))
fi
#Gana 1
if [ $jugador1 == "piedra" ] && [ $jugador2 == "tijera" ]
then
contador_gana1=$(($contador_gana1+1))
fi
if [ $jugador1 == "papel" ] && [ $jugador2 == "piedra" ]
then
contador_gana1=$(($contador_gana1+1))
fi
if [ $jugador1 == "tijera" ] && [ $jugador2 == "papel" ]
then
contador_gana1=$(($contador_gana1+1))
fi
#Gana 2
if [ $jugador2 == "piedra" ] && [ $jugador1 == "tijera" ]
then
contador_gana2=$(($contador_gana2+1))
fi
if [ $jugador2 == "papel" ] && [ $jugador1 == "piedra" ]
then
contador_gana2=$(($contador_gana2+1))
fi
if [ $jugador2 == "tijera" ] && [ $jugador1 == "papel" ]
then
contador_gana2=$(($contador_gana2+1))
fi
done
#echo "$contador_empate, $contador_gana1, $contador_gana2"
port_empate=$(echo "scale=2 ; $contador_empate*100/$n_turnos" | bc -l)
port_gana1=$(echo "scale=2 ; $contador_gana1*100/$n_turnos" | bc -l)
port_gana2=$(echo "scale=2 ; $contador_gana2*100/$n_turnos" | bc -l)
echo "Empate = $port_empate %, Gana 1 = $port_gana1 %, Gana 2 = $port_gana2"
Haz un script llamado notas.sh que a partir de un fichero donde se recogen las calificaciones de los alumnos en los distintos módulos denominado calificaciones.txt con el siguiente formato:
Lucía Sánchez: 10, 6, 6, 5, 8
María Vargas: 9, 7, 4, 4, 7
Lucía Pérez: 7, 5, 10, 8, 4
Miguel González: 9, 7, 10, 3, 5
Miguel López: 6, 4, 6, 10, 9
Elena García: 3, 3, 3, 10, 4
Pedro Torres: 6, 4, 10, 9, 4
Se pide:
El número de alumnos matriculados.
El número de alumnos que han aprobado todos los módulos.
El número de alumnos que han suspendido sólo un módulo.
El número de alumnos que han suspendido dos módulo.
El número de alumnos que han suspendido tres módulos o más.
Indicar el número de alumnos aprobados/suspensos en porcentaje.
#!/bin/bash
archivo="calificaciones.txt"
todos_aprobados=0
un_suspenso=0
dos_suspensos=0
tres_o_mas_suspensos=0
num_alumnos=$(wc -l $archivo | cut -d' ' -f1)
for ((i=1; i<=num_alumnos; i++))
do
linea=$(sed -n ${i}p $archivo)
aprobado_1=0
aprobado_2=0
aprobado_3=0
aprobado_4=0
aprobado_5=0
nota_1=$(echo $linea |cut -d':' -f2|cut -d',' -f1)
if [ $nota_1 -ge 5 ]; then aprobado_1=1 ; fi
nota_2=$(echo $linea |cut -d':' -f2|cut -d',' -f2)
if [ $nota_2 -ge 5 ]; then aprobado_2=1 ; fi
nota_3=$(echo $linea |cut -d':' -f2|cut -d',' -f3)
if [ $nota_3 -ge 5 ]; then aprobado_3=1 ; fi
nota_4=$(echo $linea |cut -d':' -f2|cut -d',' -f4)
if [ $nota_4 -ge 5 ]; then aprobado_4=1 ; fi
nota_5=$(echo $linea |cut -d':' -f2|cut -d',' -f5)
if [ $nota_5 -ge 5 ]; then aprobado_5=1 ; fi
sum_aprobados=$((aprobado_1 + aprobado_2 + aprobado_3 + aprobado_4 + aprobado_5))
if [ $sum_aprobados -eq 5 ]; then todos_aprobados=$((todos_aprobados+1)) ; fi
if [ $sum_aprobados -eq 4 ]; then un_suspenso=$((un_suspenso+1)) ; fi
if [ $sum_aprobados -eq 3 ]; then dos_suspensos=$((dos_suspensos+1)) ; fi
if [ $sum_aprobados -lt 3 ]; then tres_o_mas_suspensos=$((tres_o_mas_suspensos+1)) ; fi
echo -e "$linea : \033[32m$sum_aprobados \033[0mmod. aprobados "
done
porcentaje_aprobados=$(echo "scale=2; ($todos_aprobados / $num_alumnos) * 100" | bc)
porcentaje_suspensos=$(echo "scale=2; (($num_alumnos-$todos_aprobados) / $num_alumnos) * 100" | bc)
echo -e "\033[34m-------------- Resultados ---------------- \033[0m"
echo -e "Número total de alumnos matriculados:\033[32m $num_alumnos \033[0m"
echo -e "Número de alumnos que han aprobado todos los módulos:\033[32m $todos_aprobados\033[0m"
echo -e "Número de alumnos que han suspendido solo un módulo:\033[32m $un_suspenso\033[0m"
echo -e "Número de alumnos que han suspendido dos módulos:\033[32m $dos_suspensos\033[0m"
echo -e "Número de alumnos que han suspendido tres módulos o más:\033[32m $tres_o_mas_suspensos\033[0m"
echo -e "Porcentaje de alumnos aprobados:\033[35m $porcentaje_aprobados %\033[0m"
echo -e "Porcentaje de alumnos suspensos:\033[35m $porcentaje_suspensos %\033[0m"
Descarga el archivo calendario.dat, encontrara 543 citas donde el primer campo es el mes, el segundo campo es el día, el tercer campo es la hora y el cuarto la cita
Crea una script llamado analizar_cal.sh que considere las siguientes entradas:
Muestra un mensaje de ayuda
./analizar_cal.sh --help salida: Uso : analizar [OPCION] Options: - mes <mes> muestra el número de citas que hay en un mes - d <día> muestra el numero de citas que hay para ese día para todos los meses
En el caso de no dar ninguna entrada tambien mostrará el mensaje de ayuda
Muestra el número de citas que hay por mes
./analizar_cal.sh -mes Julio 39
Muestra el número de citas que hay por un determinado día para todos los meses
./analizar_cal.sh -d 4 11
Muestra el número de citas que se han producido durante todo el año de forma ordenada
./analizar_cal.sh -resumen citas | head 23 Reunión de trabajo. 16 Cita con el médico. 14 Llamada con un cliente. 14 Entrega de proyectos. 14 Cumpleaños de un amigo. 14 Clase de yoga o ejercicio. 14 Cena con amigos. 14 Aniversario de boda. 13 Conferencia o seminario. 10 Visita al dentista.
Muestra el numero de citas que hay por diferentes franjas horarias
./analizar_cal.sh -resumen horas De 10:00-10:59 hay 87 citas De 11:00-10:59 hay 80 citas De 12:00-10:59 hay 99 citas De 13:00-10:59 hay 97 citas De 14:00-10:59 hay 79 citas De 15:00-10:59 hay 101 citas
#!/bin/bash
function show_help() {
echo "Uso : analizar [OPCION]"
echo "Options:"
echo "- mes <mes> muestra el numero de citas que hay en un mes"
echo "- d <dia> muestra el numero de citas que hay para ese dia para todos los meses"
}
archivo=calendario.dat
if [[ $# -gt 0 ]]
then
if [[ $1 == "--help" ]]
then
show_help
fi
if [[ $1 == "-mes" ]]
then
grep -c $2 $archivo
fi
if [[ $1 == "-d" ]]
then
cat $archivo | grep -c " $2 "
fi
if [[ $1 == "-resumen" ]]
then
if [[ $2 == citas ]]
then
cat $archivo | tr -s ' ' | cut -d' ' -f4- | sort | uniq -c | sort -r
fi
if [[ $2 == horas ]]
then
hora=$(cat $archivo | tr -s ' ' | cut -d' ' -f3 | cut -d':' -f1 | sort | uniq -c | tr -s ' '| cut -d' ' -f3)
c=0
for i in $hora
do
c=$((c+1))
cita=$(cat $archivo | tr -s ' ' | cut -d' ' -f3 | cut -d':' -f1 | sort | uniq -c | tr -s ' '| grep $i | cut -d' ' -f2 | head -$c | tail -1)
echo De $i:00-10:59 hay $cita citas
done
fi
fi
else
show_help
fi
Crea un script llamado rep.sh que diga el numero de veces que estan repetidos los siguientes nombres del archivo nombres.dat
#!/bin/bash
sort nombres.dat | uniq -c | sort -nr
nlineas=$(wc -l nombres.dat | cut -d' ' -f1)
for((i=1;i<=$nlineas;i++))
do
A[$i]=$(head -$i nombres.dat | tail -1)
done
count=0
for((i=1;i<=$nlineas;i++))
do
encontrado=0
for((j=1;j<=${#B[@]};j++))
do
if [ ${B[j]} == ${A[i]} ]
then
encontrado=1
fi
done
if [[ $encontrado -eq 0 ]]
then
count=$((count+1))
B[$count]=${A[i]}
fi
done
for((i=1;i<=${#B[@]};i++))
do
C[$i]=0
for((j=1;j<=${#A[@]};j++))
do
if [ ${B[i]} == ${A[j]} ]
then
C[$i]=$((${C[i]}+1))
fi
done
done
for((i=1;i<=${#B[@]};i++))
do
echo "${C[i]} ${B[i]}"
done | sort -rn
Sube al curso un script llamado monedas.sh que tire tres monedas y escriba en un archivo el resultado.
Haz que lea el archivo y obtenga el porcentaje de veces que salen 3 caras.
En el caso de que no se proporcione el número de tiradas ni el archivo, tomara por defecto el archivo llamado tiradas.dat y hará 100 tiradas.
En el caso de que no encuntre el archivo cuando lo va a leer, tomara por defecto monedas.dat, si este no existe, mostrará que no existe.
$ ./monedas.sh -help
-n <tiradas> <archivo>
-read <archivo>
#!/bin/bash
function show_help() {
echo -e "\033[32m -help\033[0m"
echo -e "\033[32m -n <tiradas> <archivo> \033[0m"
echo -e "\033[32m -read <archivo> \033[0m"
}
if [[ $1 == '-help' ]]
then
show_help
fi
if [[ $1 == '-n' ]]
then
tiradas=${2:-100}
outfile=${3:-monedas.dat}
for((i=0;i<$tiradas;i++))
do
echo $((RANDOM % 2)) $((RANDOM % 2)) $((RANDOM % 2))
done > $outfile
fi
if [[ $1 == '-read' ]]
then
readfile=${2:-monedas.dat}
if test -f $readfile
then
echo -e "\033[32m Leemos el archivo $readfile \033[0m"
tres_caras=$(grep -c '1 1 1' $readfile)
n_total=$(wc -l $readfile | cut -d ' ' -f1)
echo -e "\033[33m Tenemos $((tres_caras * 100 / n_total))% de tiradas con tres caras \033[0m"
else
echo -e "\033[31m El archivo $readfile no existe\033[0m"
fi
fi
Crea un script en Bash llamado ips.sh que cumpla con los siguientes requisitos:
Si ejecutas el script con ./ips.sh -help, debe mostrar la siguiente ayuda:
-help : muestra la ayuda
-file <archivo> <número_ips> : Crea un archivo llamado <archivo> con <número_ips>.
-find <archivo> <ip> : Muestra cuantas veces aparece la <ip>
-read <archivo> : Muestra de forma ordenada las IPs por número de conexiones
Si ejecutas el script sin argumentos ./ips.sh, también debe mostrar la ayuda.
Si ejecutas el ./ips.sh -file sin indicar el <número_ips> tomara por defecto 50, en el caso de no darle el <archivo> tomará por defecto ip.dat. Cada línea tendrá una IP aleatoria dentro del rango 192.168.2.0/28. La primera IP utilizable es 192.168.2.1 y la última es 192.168.2.14.
Si ejecutas el ./ips.sh -find lee el <archivo>, si no existe o no se le indica, mostrará por pantalla «El archivo no existe», en el caso de que no se proporcione <ip> mostrará por pantalla «Proporcionar ip»
Si ejecutas el ./ips.sh -read lee el <archivo>, si no existe o no se le indica, mostrará por pantalla «El archivo no existe»
#!/bin/bash
function show_help() {
echo -e "\033[32m-help : muestra la ayuda\033[0m"
echo -e "\033[32m-file <archivo> <número_ips> : Crea un archivo llamado <archivo> con <número_ips> \033[0m"
echo -e "\033[32m-find <archivo> <ip> : Muestra cuantas veces aparece la <ip> \033[0m"
echo -e "\033[32m-read <archivo> : Muestra de forma ordenada las IPs por número de conexiones \033[0m"
}
if [[ $1 == '-help' ]]
then
show_help
fi
if [[ $# -eq 0 ]]
then
show_help
fi
if [[ $1 == '-file' ]]
then
tiradas=${3:-50}
outfile=${2:-ip.dat}
for((i=0;i<$tiradas;i++))
do
echo 192.168.2.$((RANDOM % 14 + 1))
done > $outfile
fi
if [[ $1 == '-find' ]]
then
readfile=$2
ip=$3
if test -z $3
then
echo -e "\033[31m Proporcionar ip\033[0m"
else
if test -f $readfile
then
echo -e "\033[32m Leemos el archivo $readfile \033[0m"
grep -c $ip $readfile
else
echo -e "\033[31m El archivo $readfile no existe\033[0m"
fi
fi
fi
if [[ $1 == '-read' ]]
then
readfile=$2
if test -f $readfile
then
echo -e "\033[32m Leemos el archivo $readfile \033[0m"
cat $readfile | sort | uniq -c | sort -rn
else
echo -e "\033[31m El archivo $readfile no existe\033[0m"
fi
fi
Sube al curso un script llamado dados.sh que obtenga dos números aleatorios entre el 1 y el 6, obtén la suma de los dos dados, Haz que salga por pantalla el numero de tiradas y el porcentaje de veces que sale cada una.
Haz que el número de tiradas lo reciba como un argumento, el caso de que no reciba ningún argumento haz que haga 1000 tiradas
$ ./dados.sh
De 1000 tiradas : 2(1%) 3(7%) 4(10%) 5(12%) 6(14%) 7(17%) 8(14%) 9(12%) 10(10%) 11(7%) 12(1%)
#!/bin/bash
tiradas=${1:-1000}
for ((i = 2; i <= 12; i++)); do
frecuencias[$i]=0
done
for ((i = 1; i <= tiradas; i++)); do
dado1=$((RANDOM % 6 + 1))
dado2=$((RANDOM % 6 + 1))
suma=$((dado1 + dado2))
frecuencias[$suma]=$((frecuencias[$suma]+1))
done
echo "De $tiradas tiradas:"
output=""
for ((i = 2; i <= 12; i++)); do
porcentaje=$((frecuencias[$i] * 100 / tiradas))
output+="$i(${porcentaje}%) "
done
echo "$output"
Crea un script en Bash llamado adivina_cpu.sh que simule un juego automático de adivinanza en el que la CPU intenta adivinar un número secreto aleatorio, generado al inicio del programa. El número estará comprendido entre 1 y un valor máximo definido por la variable n_max_adivinar. En cada intento, la CPU elige otro número al azar dentro del rango posible, ajustando los límites mínimo y máximo según si el número es menor o mayor al número secreto.
El script debe cumplir con los siguientes requisitos:
No se deben repetir los números ya probados.
Tras cada intento, si el número elegido es menor que el número secreto, se actualiza el mínimo.
Si el número elegido es mayor, se actualiza el máximo.
El proceso se repite hasta que se adivine el número secreto.
Al final, se muestra el número total de intentos que necesitó la CPU para adivinar el número.
Cuando el usuario acierte haz que muestre el número de intentos.
#!/bin/bash
n_max_adivinar=20
numero_secreto=$((RANDOM % $n_max_adivinar + 1))
intento=0
comparar=-1
maximo=$n_max_adivinar
minimo=0
while [[ $comparar != 0 ]]
do
intento=$((intento+1))
numero_elegido=$((RANDOM % $((maximo-minimo)) + 1 + $minimo))
repetido=1
while [[ $repetido -eq 1 ]]
do
repetido=0
for((i=0;i<=${#I[@]};i++))
do
if [[ ${I[$i]} -eq $numero_elegido ]]
then
repetido=1
fi
done
if [[ $repetido -eq 1 ]]
then
numero_elegido=$((RANDOM % $((maximo-minimo)) + 1 + $minimo))
fi
done
if [[ $numero_elegido -lt $numero_secreto ]]
then
comparar=-1
minimo=$numero_elegido
fi
if [[ $numero_elegido -gt $numero_secreto ]]
then
comparar=1
maximo=$numero_elegido
fi
if [[ $numero_elegido -eq $numero_secreto ]]
then
comparar=0
fi
#echo $intento $numero_secreto $numero_elegido $comparar $maximo $minimo $repetido
I[$intento]=$numero_elegido
done
#sacamos el número de intentos que ha hecho hasta adividnar el resultado
echo $intento
Para testearlo puedes usar:
ntot=100
sum=0
for((i=0;i<$ntot;i++))
do
n=$(./adivina_cpu.sh)
sum=$((sum+n))
done
resultado=$(echo "1/($sum/$ntot)" | bc -l)
printf "%.2f\n" "$resultado"
0.23
Como se puede ver, la probabilidad de acertar el número se incrementa notablemente gracias a dos factores clave del algoritmo: evitar repetir números y ajustar dinámicamente los valores máximo y mínimo tras cada intento.
Si no se evitaran los números repetidos y no se acotara el intervalo con el mínimo y el máximo, cada intento sería completamente aleatorio dentro del rango total (por ejemplo, del 1 al 20). En ese caso, la probabilidad de acertar en un intento sería simplemente: 1/20=0.05 es decir, solo un 5% de probabilidad frente al 23%
Crea un script llamado tragaperras.sh que simule una máquina tragaperras con tres rodillos. Cada rodillo muestra un número aleatorio del 0 al 9. Las reglas del juego son las siguientes:
Cada partida cuesta 1 moneda.
Si aparecen dos números iguales, el jugador gana 2 monedas.
Si aparecen tres números iguales, el jugador gana 3 monedas.
Si los tres números son 7, el jugador gana 10 monedas.
El programa debe simular una cantidad significativa de partidas y calcular:
El número total de monedas ganadas.
El número total de monedas gastadas.
El balance final.
Y, finalmente, responder a la pregunta: ¿Es rentable esta tragaperras para el jugador?
Haz que el número de tiradas lo reciba como un argumento, el caso de que no reciba ningún argumento haz que haga 1000 tiradas
#!/bin/bash
tiradas=${1:-10000}
ganadas=0
gastadas=0
for ((i=1; i<=tiradas; i++)); do
gastadas=$((gastadas+1))
#generamos cada rodillo
r1=$((RANDOM % 10))
r2=$((RANDOM % 10))
r3=$((RANDOM % 10))
if [[ $r1 -eq $r2 && $r2 -eq $r3 ]]; then
if [[ $r1 -eq 7 ]]; then #caso de 777
ganadas=$((ganadas+10))
else #caso 3 iguales sin contar el 777
ganadas=$((ganadas+3))
fi
elif [[ $r1 -eq $r2 || $r1 -eq $r3 || $r2 -eq $r3 ]]; then #caso 2 iguales sin contar 3 iguales
ganadas=$((ganadas+2))
fi
done
echo "Tiradas realizadas: $tiradas"
echo "Monedas gastadas: $gastadas"
echo "Monedas ganadas: $ganadas"
balance=$((ganadas - gastadas))
echo "Balance final: $balance"
if ((balance > 0)); then
echo "Esta tragaperras ES rentable para el jugador."
else
echo "Esta tragaperras NO es rentable para el jugador."
fi
Gestión de usuarios locales#
Crea un script llamado usuarios_WSL.sh, que cumpla las siguientes condiciones:
./usuarios_WSL.sh -help
-help Mostrar esta ayuda.
-crear <N> Crear N usuarios de forma aleatoria dentro de los grupos X, Y o Z.
-borrar Borrar todos los usuarios creados por este script.
-listar Mostrar los usuarios por grupo creados por este script.
Opción -crear <N>: Creará N usuarios con nombres generados automáticamente con el siguiente formato: uX01, uY23, uZ15, etc.,
La letra (X, Y o Z) corresponde a un grupo al que se asignará el usuario.
El número es un sufijo aleatorio de dos cifras (01 a 99).
Si no tenemos <N> creará por defecto 10 usuarios
#!/bin/bash
function show_help() {
echo '
-help Mostrar esta ayuda.
-crear <N> Crear N usuarios de forma aleatoria dentro de los grupos X, Y o Z.
-borrar Borrar todos los usuarios creados por este script.
-listar Mostrar los usuarios por grupo creados por este script.
'
}
grupos=(X Y Z)
if [[ $# -gt 0 ]]
then
if [[ $1 == "-help" ]]
then
show_help
fi
if [[ $1 == "-crear" ]]
then
num_usuarios=${2:-10}
for ((i=1; i<=num_usuarios; i++)); do
grupo=${grupos[$RANDOM % ${#grupos[@]}]}
sufijo=$(printf "%02d" $((RANDOM % 99 )))
usuario="u${grupo}${sufijo}"
useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
echo "Usuario $usuario creado en el grupo $grupo con contraseña por defecto 'cambiame'."
done
fi
if [[ $1 == "-borrar" ]]
then
for g in ${grupos[@]};
do
echo Borro usuarios del grupo $g
for u in $(cat /etc/passwd | cut -d':' -f1 | grep u$g);
do
echo Borramos el usuario $u
userdel -r $u
done
done
fi
if [[ $1 == "-listar" ]]
then
for g in ${grupos[@]};
do
echo Usuarios del grupo $g
for u in $(cat /etc/passwd | cut -d':' -f1 | grep u$g);
do
echo $u
done
done
fi
else
show_help
fi
Crea un script llamado usuarios.sh, utiliza para ello un clon enlazado de la «MV Ubuntu Server 24.04»
./usuarios.sh -help
usuarios.sh -addgroup <grupo> : Crea un grupo si no existe
usuarios.sh -delgroup <grupo> : Elimina un grupo si existe
usuarios.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado
: Si el grupo no existe lo crea primero
: Si no damos grupo usa por defecto el grupo usuario1
usuarios.sh -deluser <usuario> : Elimina un usuario si existe
usuarios.sh -lista : Lista todos los grupos y sus usuarios
En el caso de ejecutar ./usuarios.sh sin argumentos obtendremos el mensaje de ayuda.
Chequea tu script con las siguientes características:
cat usuarios.sh
for g in GA GB GC GD
do
./usuarios.sh -addgroup $g
for u in 01 02 03 04
do
usuario=usuario_${g}_${u}
./usuarios.sh -adduser ${usuario} ${g}
done
done
./usuarios.sh -lista
./usuarios.sh -help
El script muestra una ayuda con las opciones que puede tiene
#!/bin/bash
function show_help() {
echo "Uso del script:"
echo "./usuarios.sh -addgroup <grupo> : Crea un grupo si no existe"
echo "./usuarios.sh -delgroup <grupo> : Elimina un grupo si existe"
echo "./usuarios.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado (o en uno con su mismo nombre)"
echo "./usuarios.sh -deluser <usuario> : Elimina un usuario si existe"
echo "./usuarios.sh -lista : Lista todos los grupos y sus usuarios"
}
if [[ $# -gt 0 ]]
then
if [[ $1 == "-addgroup" ]]
then
if [[ $(grep -c $2 /etc/group) -gt 0 ]]
then
echo "No se crea el grupo, el grupo $2 existe."
else
echo "Creamos el grupo $2"
groupadd $2
fi
fi
if [[ $1 == "-delgroup" ]]
then
groupdel $2
fi
if [[ $1 == "-adduser" ]]
then
usuario=$2
grupo=${3:-$usuario}
echo "creamos el $usuario en $grupo"
if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
then
echo "No se crea el usuario, el usuario $usuario ya existe."
else
if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
then
groupadd $grupo
echo "Creamos el grupo $grupo"
fi
useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
echo "Usuario $usuario creado en el grupo $grupo con contraseña por defecto 'cambiame'."
fi
fi
if [[ $1 == "-deluser" ]]
then
if [[ $(grep -c $2 /etc/passwd) -gt 0 ]]
then
userdel -r $2
echo "Usuario $2 eliminado."
else
echo "No se borra el usuario, el usuario $2 no existe."
fi
fi
if [[ "$1" == "-lista" ]]
then
#solo listamos los grupos que tienen usuarios
for g in $(cut -d':' -f1 /etc/group)
do
if [[ $(members $g ) != "" ]]
then
echo ----- $g------
members $g
fi
done
fi
else
show_help
fi
Genera la siguiente lista de usuarios en el archivo lista.dat
for((i=0;i<40;i++))
do
R=$RANDOM
echo tunombre_$R G$(($R%4))
done > lista.dat
Crea un script llamado crear_usuarios_lista.sh que genere por defecto los usuarios que encuentra en el archivo lista.dat, con la contraseña
cambiame, haz que si recibe el nombre de otro archivo como lista lo utilice. En el caso de que el grupo no exista haz que lo cree en el sistemaCrea otro script llamado borrar_usuarios_lista.sh que borre los usuarios que aparecen en el archivo lista.dat, haz que utilice este archivo por defecto en el caso de no recibir ningun archivo.
Crea otro script llamdo crear_usuarios_grupo_lista.sh que lea solo la primera columna de un archivo llamado nombre_grupo.dat, creará todos los usuarios dentro del grupo llamado nombre_grupo, en el caso de que no exista creara primero el grupo.
Crea otro script llamdo borrar_usuarios_grupo_lista.sh que lea solo la primera columna de un archivo llamado nombre_grupo.dat, borrará todos los usuarios que encuentre en la lista, al final y sólo en el caso de que el grupo se haya quedado bacio se borrará tambien el grupo.
#!/bin/bash
#Vamos a crear los usuarios que aparecen en la lista.dat
#$cat listda.dat
# usuario1 Grupo1
# usuario2 Grupo2
# usuario3 Grupo1
archivo=${1:-lista.dat}
for usuario in $(cat $archivo | cut -d' ' -f1 )
do
grupo=$(grep $usuario $archivo | cut -d' ' -f2)
if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
then
echo -e "\033[31m No se crea el usuario, el usuario $usuario ya existe. \033[0m"
else
if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
then
groupadd $grupo
echo -e "\033[34m Creamos el grupo $grupo \033[0m"
fi
useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
echo -e "\033[34m Creamos el usuario $usuario en el grupo $grupo con contraseña por defecto 'cambiame'.\033[0m"
fi
done
#!/bin/bash
#Vamos a crear los usuarios que aparecen en la lista.dat
archivo=${1:-lista.dat}
for usuario in $(cat $archivo | cut -d' ' -f1 )
do
if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
then
echo -e "\033[34m Borramos el $usuario \033[0m"
userdel -r $usuario
else
echo -e "\033[31m El usuario $usuario no existe \033[0m"
fi
done
#!/bin/bash
#Vamos a crear los usuarios que aparecen en el archvio grupo.dat
if [[ $# == 0 ]]
then
echo -e "\033[31m El primer argumento es el archivo con el nombre del grupo.dat \033[0m"
else
if test -e $1
then
archivo=$1
echo -e "\033[33m Leemos el archivo $archivo \033[0m"
grupo=$(echo $archivo | sed 's/.dat//')
for usuario in $(cat $archivo | cut -d' ' -f1 )
do
if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
then
echo -e "\033[31m No se crea el usuario, el usuario $usuario ya existe.\033[0m"
else
if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
then
groupadd $grupo
echo -e "\033[34m Creamos el grupo $grupo \033[0m"
fi
echo -e "\033[34m Creamos el usuario $usuario en el grupo $grupo \033[0m"
useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
echo -e "\033[34m Usuario $usuario creado en el grupo $grupo con contraseña por defecto 'cambiame'.\033[0m"
fi
done
else
echo -e "\033[31m El archivo $1 no existe \033[0m"
fi
fi
#!/bin/bash
if [[ $# == 0 ]]
then
echo -e "\033[31m El primer argumento es el archivo con el nombre del grupo.dat \033[0m"
else
if test -e $1
then
archivo=$1
echo -e "\033[33m Leemos el archivo $archivo \033[0m"
grupo=$(echo $archivo | sed 's/.dat//')
idg=$(grep $grupo /etc/group | cut -d':' -f3)
for usuario in $(cat $archivo | cut -d' ' -f1 )
do
if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
then
userdel -r $usuario
echo -e "\033[34m Borramos el usuario $usuario $grupo \033[0m"
else
echo -e "\033[31m No se borra el usuario, el usuario $usuario no existe.\033[0m"
fi
done
n_usuarios_grupo=$(cat /etc/passwd | cut -d':' -f4 | sort | uniq -c | grep $idg | tr -s ' ' | cut -d' ' -f2)
if [[ $n_usuarios_grupo -eq 0 ]]
then
echo -e "\033[34m Borramos el $grupo ya que no tiene usuarios \033[0m"
groupdel $grupo
else
echo -e "\033[31m No se borra el $grupo ya que tiene $n_usuarios_grupo usuarios \033[0m"
fi
else
echo -e "\033[31m El archivo $1 no existe \033[0m"
fi
fi
Gestión de usuarios LDAP#
Crea un script llamado usuarios_ldap.sh, utiliza para ello un clon enlazado de la “MV Ubuntu Server 24.04” con un ldap configurado aqui
Uso del script:
./usuarios_ldap.sh -addgroup <grupo> : Crea un grupo si no existe
./usuarios_ldap.sh -delgroup <grupo> : Elimina un grupo si existe
./usuarios_ldap.sh -lsgroup : Elimina un grupo si existe
./usuarios_ldap.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado
./usuarios_ldap.sh -deluser <usuario> : Elimina un usuario si existe
./usuarios_ldap.sh -lista : Lista todos los grupos y sus usuarios
./usuarios_ldap.sh -lsuser : Elimina un grupo si existe
#!/bin/bash
LDAP="dc=ldap,dc=tunombre,dc=local"
LDAPadmin="cn=admin,$LDAP"
password=alumno
passwd_defecto_usuario=cambiame
function crear_grupo(){
NAMEG=$1 #GA
NUMBERGID=$2 #501
cat << EOF > grupo.ldif
dn: cn=${NAMEG},ou=grupos,$LDAP
objectClass: posixGroup
cn: ${NAMEG}
gidNumber: ${NUMBERGID}
EOF
ldapadd -x -D $LDAPadmin -w $password -f grupo.ldif
rm -fr grupo.ldif
}
function crear_usuario(){
NAME=$1 #tunombre1
NUMBERID=$2 #1001
NUMBERGID=$( ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP cn=$3 gidNumber | grep gid | cut -d':' -f2)
cat << EOF > usuarios.ldif
dn: uid=${NAME},ou=usuarios,$LDAP
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: ${NAME}
cn: ${NAME}
sn: ${NAME}
gidNumber: ${NUMBERGID}
uidNumber: ${NUMBERID}
userPassword: $passwd_defecto_usuario
homeDirectory: /home/$NAME
loginShell: /bin/bash
EOF
ldapadd -x -D $LDAPadmin -w $password -f usuarios.ldif
#rm -fr usuarios.ldif
}
function show_help() {
echo -e "\033[34m Uso del script:\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -addgroup <grupo> : Crea un grupo si no existe\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -delgroup <grupo> : Elimina un grupo si existe\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -lsgroup : Elimina un grupo si existe\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado \033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -deluser <usuario> : Elimina un usuario si existe\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -lista : Lista todos los grupos y sus usuarios\033[0m"
echo -e "\033[34m ./usuarios_ldap.sh -lsuser : Elimina un grupo si existe\033[0m"
}
if [[ $# -gt 0 ]]
then
if [[ $1 == "-addgroup" ]]
then
if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
then
echo -e "\033[31m No se crea el grupo, el grupo $2 existe. \033[0m"
else
echo -e "\033[34m Creamos el grupo $2 \033[0m"
#tomamos el ultimo gidNumbrer:
gidN=$(ldapsearch -xLLL -b $LDAP | grep gidNumber | cut -d':' -f2 | tail -1)
if [ -z $gidN ] #-z indica que la variable esta vacía
then
gidN=500
fi
gidN=$((gidN+1))
crear_grupo $2 $gidN
fi
fi
if [[ $1 == "-delgroup" ]]
then
if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
then
ldapdelete -x -w $password -D $LDAPadmin "cn=$2,ou=grupos,$LDAP"
echo -e "\033[34m Borramos el grupo $2 \033[0m"
else
echo -e "\033[31m No se borra el grupo, el grupo $2 no existe. \033[0m"
fi
fi
if [[ $1 == "-lsgroup" ]]
then
ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP "(objectClass=posixGroup)" cn gidNumber
fi
if [[ $1 == "-adduser" ]]
then
if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
then
echo -e "\033[31m No se crea el usuario, $2 existe. \033[0m"
else
#tomamos el ultimo gidNumbrer:
uidN=$(ldapsearch -xLLL -b $LDAP | grep uidNumber | cut -d':' -f2 | tail -1)
if [ -z $uidN ] #-z indica que la variable esta vacía
then
uidN=1000
fi
uidN=$((uidN+1))
grupo=$3
if [ -z $grupo ]
then
echo -e "\033[31m No se crea el usuario, necesitamos un grupo. \033[0m"
else
echo -e "\033[34m Creamos el usuario $2 \033[0m"
crear_usuario $2 $uidN $grupo
fi
fi
fi
if [[ $1 == "-deluser" ]]
then
if [[ $(ldapsearch -xLLL -b $LDAP uid=$2 | grep -c 'ldap') -gt 0 ]]
then
ldapdelete -x -w $password -D $LDAPadmin "uid=$2,ou=usuarios,$LDAP"
echo -e "\033[34m Borramos el usuario $2 \033[0m"
else
echo -e "\033[31m No se borra el usuario, el usuario $2 no existe. \033[0m"
fi
fi
if [[ $1 == "-lsuser" ]]
then
ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP "(objectClass=posixAccount)" cn uidNumber
fi
else
show_help
fi
Crea un script llamado usuarios_lista_ldap.sh, haz que todos los usuarios se lean de un archivo llamado grupo.dat. Haz que todos los usuarios pertenezcan al grupo con el mismo nombre que el archivo sin la extensión .dat. En el caso de que no exista el grupo haz que se cree.
En el archivo grupo.dat, hay una lista de emails, haz que se creer el usuario correspondiente al email, es decir usuario1@gmail.com creara el usuario usuario1. En el caso de -borrar borrara todos los usuarios del archivo, finalmente si no quedan usuarios en el grupo borra el grupo
./usuarios_lista_ldap.sh -help
./usuarios_lista_ldap.sh -crear <archivo.dat>
./usuarios_lista_ldap.sh -borrar <archivo.dat>
#head -2 grupo.dat
usuario1@gmail.com
usuario2@gmail.com
#!/bin/bash
#listar y borrar los usuarios de un grupo entero