C Piscine — Shell 01

Segundo asalto: aquí ya no se crean archivos, se procesa — pipes, filtros, variables de entorno y los comandos que convierten la terminal en una cadena de montaje. 9 ejercicios (ex00–ex08).

La introducción — Si Shell 00 abría con Mike Oldfield, Shell 01 abre con… el artículo completo de Wikipedia sobre la nutria europea (Lutra lutra): su pelaje de dos capas, sus 5–15 kg, sus madrigueras con entrada submarina. Conclusión textual del enunciado: «Las nutrias son adorables». Nada de esto se usa en ningún ejercicio. El absurdo gratuito en los prólogos es tradición de los subjects de 42 — y un primer filtro de lectura: aprender a distinguir lo decorativo de lo evaluable.

GGlosario de teoría

Shell 01 da por sabidas muchas piezas de Unix: cómo viaja el texto de un comando a otro, qué hace el shell con las comillas y los $, y media docena de herramientas de texto. Aquí está cada una explicada desde cero, con un ejemplo sacado de los propios ejercicios (las salidas están ejecutadas). En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Flujos y tuberías

Entrada estándar, salida estándar y salida de error

Todo programa de Unix arranca con tres canales abiertos: la entrada estándar (stdin, descriptor 0), de donde lee; la salida estándar (stdout, descriptor 1), donde escribe sus resultados; y la salida de error (stderr, descriptor 2), para los mensajes de error. Por defecto stdin es el teclado y las dos salidas son la pantalla, pero el shell puede conectarlos a archivos (>, <) o a otros programas (|).

Casi todos los comandos del módulo leen de stdin si no les das un archivo: tr, sed, awk, sort, rev, wc. Por eso se pueden encadenar. La Moulinette compara lo que tu script deja en stdout.

Tubería (pipe, |)

a | b ejecuta los dos comandos a la vez y conecta la salida estándar de a con la entrada estándar de b: lo que a imprime no sale por pantalla, lo lee b. Se pueden encadenar tantos como quieras, y a la cadena entera se la llama pipeline.

$ printf 'b\na\nc\n' | sort -r
c
b
a

Es la pieza central del módulo: ex01 tiene tres etapas y ex07, ocho. stderr no pasa por la tubería; solo stdout.

De dónde viene: la idea es de Doug McIlroy, en Bell Labs; Ken Thompson la añadió a Unix en 1973, junto con la barra vertical para escribirla.

Filtro

Un programa que lee texto por stdin, lo transforma y escribe el resultado por stdout, sin preguntar nada ni guardar nada. grep quita líneas, cut se queda con columnas, tr cambia caracteres, sort ordena, rev invierte. Cada uno hace una sola cosa, y los problemas grandes se resuelven poniendo varios en fila con tuberías. Es la llamada filosofía Unix: «escribe programas que hagan una cosa y la hagan bien, y que trabajen juntos».

Salto de línea (\n) y cat -e

El final de una línea no es «nada»: es un byte, el 10 en ASCII, que se escribe \n. printf 'hola' produce 4 bytes y printf 'hola\n', 5. Como el salto no se ve, el enunciado pasa las salidas por cat -e, que pinta un $ en cada final de línea:

$ printf 'hola\n' | cat -e
hola$

Si en un ejemplo el prompt $> aparece pegado a la salida, como en ex01, ex05 y ex07, es que no hay salto final. La Moulinette compara byte a byte, así que un \n de más o de menos es un fallo.

El shell

Script de shell, /bin/sh y permiso de ejecución

Un script es un archivo de texto con comandos, los mismos que escribirías a mano, que un shell (el intérprete de comandos) lee y ejecuta de arriba abajo. Hay varios shells: bash, zsh, dash… El enunciado pide que los de este módulo funcionen con /bin/sh, el shell POSIX básico (en Ubuntu, /bin/sh es dash), así que no valen extras propios de bash.

Hay dos maneras de lanzarlo: sh find_sh.sh, que solo necesita poder leerlo, o ./find_sh.sh, como en los ejemplos del enunciado, que además necesita el permiso de ejecución (chmod +x); sin él da Permission denied. Una primera línea #!/bin/sh (el shebang) indica con qué intérprete ejecutarlo en ese segundo caso; si falta, lo ejecuta el mismo shell desde el que lo lanzas. Los scripts de este repo no lo llevan.

Variable de entorno y expansión con $

Una variable de entorno es un par nombre=valor que un proceso hereda del que lo lanzó. Así se le pasan datos a un script sin argumentos: la Moulinette hace algo como FT_USER=daemon ./print_groups.sh, y dentro del script $FT_USER vale daemon.

Escribir $NOMBRE (o ${NOMBRE}) es una expansión: antes de ejecutar la línea, el shell cambia ese trozo por el valor. Las llaves sirven para marcar dónde acaba el nombre, como en "${FT_LINE1},${FT_LINE2}p" de ex07, que con FT_LINE1=7 y FT_LINE2=15 se convierte en 7,15p antes de llegar a sed. En este módulo se usan FT_USER, FT_LINE1, FT_LINE2, FT_NBR1 y FT_NBR2.

Comodines (*, ?)

Antes de ejecutar un comando, el shell busca palabras con * (cualquier secuencia de caracteres) o ? (un carácter cualquiera) y las cambia por los nombres de archivo del directorio que encajan. Es el propio shell quien lo hace, no el comando. Si nada encaja, sh deja la palabra tal cual:

$ echo *.sh       # en un directorio con a.sh
a.sh
$ echo *.zzz
*.zzz

Por eso en ex02 el patrón va entre comillas, find . -name '*.sh': tiene que llegarle a find el texto *.sh, no la lista de archivos del directorio actual. Y por eso el nombre de ex05, lleno de * y ?, no se puede escribir sin comillas.

Comillas simples, dobles y barra invertida

Son la manera de decirle al shell «esto no lo interpretes». Hay tres niveles:

  • Comillas simples '…': nada se interpreta, ni $, ni *, ni \. La única limitación es que dentro no puede haber otra comilla simple.
  • Comillas dobles "…": se siguen expandiendo $ y $( ), pero no los comodines ni los espacios, y \ solo es especial delante de $, `, ", \ y el salto de línea.
  • Barra invertida \ fuera de comillas: protege solo el carácter siguiente.
$ X=42; echo '$X' "$X"
$X 42

Las comillas dobles alrededor de una variable ("$FT_USER") hacen que su valor llegue entero como un solo argumento aunque tenga espacios o asteriscos. El nombre de ex05 combina todo: va entre simples, y cada comilla simple del nombre se escribe '\'' (cerrar, comilla protegida, abrir).

Sustitución de comandos $( )

$(comando) ejecuta el comando y pone en su lugar lo que ha impreso (quitando los saltos de línea del final). Sirve para guardar un resultado en una variable:

$ echo "hoy: $(echo uno dos | tr ' ' '-')"
hoy: uno-dos

En ex08, n1=$(printf '%s' "$FT_NBR1" | sed …) guarda en n1 el número ya traducido a dígitos normales, para usarlo después en la línea de bc.

Herramientas de texto

Expresión regular y anclas ^ y $

Una expresión regular (regex) es un patrón que describe un conjunto de textos. Lo usan grep, sed y awk. Las piezas de este módulo: un carácter normal se representa a sí mismo; . es cualquier carácter; * repite lo anterior cero o más veces (así que .* es «cualquier cosa»); \. es un punto de verdad; ^ ancla al principio de la línea y $ al final.

Ejemplos del módulo: ^# son las líneas que empiezan por # (ex07), \.sh$ es «.sh» justo al final (ex02) y .*/ es todo hasta la última barra, porque * se come todo lo que puede. Ojo: el * de una regex y el comodín del shell se parecen pero no son lo mismo.

sed y la sustitución s/…/…/

sed (stream editor) aplica órdenes de edición a cada línea que le llega. La más usada es s/patrón/reemplazo/: cambia la primera coincidencia del patrón; con g al final (s/…/…/g), todas. Varias órdenes se separan con ;, y el separador / puede ser otro carácter, como |:

$ echo ./sub/file2.sh | sed 's|.*/||; s|\.sh$||'
file2

Con -n no imprime nada salvo lo que se le pida con p: sed -n '2,3p' saca solo las líneas 2 y 3, que es lo que hace ex07 con FT_LINE1 y FT_LINE2.

awk: patrón, acción, campos y NR

awk es un pequeño lenguaje para procesar texto línea a línea. Un programa awk es una lista de patrón {acción}: para cada línea que cumple el patrón se ejecuta la acción. Si falta el patrón, vale para todas; si falta la acción, se imprime la línea. Además awk parte cada línea en campos separados por espacios: $1, $2… y cuenta las líneas en NR (number of records).

$ printf '  ether 52:54:00:12:34:56  txqueuelen 1000\n' | awk '/ether/ {print $2}'
52:54:00:12:34:56
$ printf 'uno\ndos\ntres\ncuatro\n' | awk 'NR % 2 == 1'
uno
tres

El primero es ex04 (los espacios del principio no cuentan como campo) y el segundo, ex06.

De dónde viene: el nombre son las iniciales de sus autores, Aho, Weinberger y Kernighan, que lo escribieron en Bell Labs en 1977.

Campo y delimitador (cut)

Muchos archivos de texto son tablas: cada línea es un registro y un carácter fijo, el delimitador, separa sus campos. cut -d: -f1 parte cada línea por : y se queda con el primer campo:

$ echo 'root:x:0:0:root:/root:/bin/bash' | cut -d: -f1
root

A diferencia de awk, cut no agrupa delimitadores: dos : seguidos son un campo vacío entre medias. Es lo que hace falta con /etc/passwd.

tr: cambiar o borrar caracteres

tr (translate) trabaja carácter a carácter, no con palabras ni patrones. tr 'abc' 'xyz' cambia cada a por x, cada b por y y cada c por z; tr -d 'abc' borra esos caracteres.

$ echo "a b c" | tr ' ' ','
a,b,c

En ex01 hace las dos cosas: cambia espacios por comas y borra el \n final. En ex07 cambia los saltos de línea por @ para tener todo en una línea, y sed remata.

find: condiciones y acciones

find recorre un directorio y todos sus subdirectorios y, para cada entrada, evalúa una expresión. Las condiciones son verdaderas o falsas: -type f (archivo regular), -type d (directorio), -name '*.sh' (el nombre encaja con el patrón). Puestas una detrás de otra se unen con «y»; -o es «o». Si no se da ninguna acción, imprime la ruta de lo que cumple la expresión, una por línea y empezando por el propio ..

Un enlace simbólico no es ni -type f ni -type d (es -type l), así que ni ex02 ni ex03 lo cuentan.

Sistema y números

Usuario, grupo e id

Unix identifica a cada usuario con un número (UID) y un nombre. Los grupos son conjuntos de usuarios que comparten permisos: cada usuario tiene un grupo principal y puede estar en otros (en Ubuntu, por ejemplo, sudo o adm). id usuario enseña todo; id -G solo los números de grupo y id -Gn sus nombres, separados por espacios. En ex01, para FT_USER=daemon el enunciado espera daemon,bin; la lista depende de cada máquina.

/etc/passwd

El archivo donde Unix guarda la lista de cuentas, una por línea, con siete campos separados por :: nombre, contraseña (hoy siempre x: la de verdad, cifrada, está en /etc/shadow), UID, GID, descripción, directorio personal y shell. Puede tener líneas de comentario que empiezan por # (en macOS, las primeras). ex07 trabaja solo con el primer campo, el nombre.

Dirección MAC e interfaz de red

Una interfaz es cada punto por el que la máquina se conecta a una red: la tarjeta Ethernet, el wifi, el lazo local lo, las interfaces virtuales que crean las máquinas virtuales o Docker. La dirección MAC es el identificador de 48 bits de una interfaz, escrito como seis bytes en hexadecimal: 52:54:00:12:34:56. Los tres primeros bytes identifican al fabricante. ifconfig la muestra en la línea que empieza por ether; lo no tiene.

Base de numeración

Una base es cuántos símbolos se usan para escribir números. En base 10 hay diez (0–9) y cada posición vale diez veces más que la de su derecha; en base 5 hay cinco y cada posición vale cinco veces más: 10 en base 5 es 5 y 4321 en base 5 es 4·125 + 3·25 + 2·5 + 1 = 586. A partir de base 11 hacen falta símbolos nuevos, y por convención se usan letras: A = 10, B = 11, C = 12…

Los símbolos son una convención: nada impide usar ', \, ", ?, ! en vez de 0–4. Eso es todo lo que tiene de raro ex08: el primer ejemplo, traducido, es 10321201 (88926) más 14120222 (145062) en base 5, que suman 233988, que en base 13 se escribe 82671 y, con el alfabeto de salida, Salut.

bc, la calculadora del shell

bc lee operaciones por stdin y escribe el resultado. Trabaja con enteros de cualquier tamaño y tiene dos variables especiales: ibase, la base en la que lee los números, y obase, la base en la que los escribe.

$ echo "obase=16; 255" | bc
FF
$ echo "obase=13; ibase=5; 4 + 4" | bc
8
$ echo "ibase=5; obase=13; 4 + 4" | bc
10

La tercera es la trampa: una vez puesto ibase=5, el 13 de obase=13 se lee en base 5 y vale 8, así que el resultado sale en base 8. Por eso ex08 fija obase primero. Para bases mayores que 10, bc usa las cifras 0–9 y las letras A–F.

Operador % (resto)

a % b es el resto de dividir a entre b: 7 % 2 = 1, 8 % 2 = 0. Con % 2 se distingue par (resto 0) de impar (resto 1). En ex06, NR % 2 == 1 selecciona las líneas 1, 3, 5…, y en ex07, NR % 2 == 0, las 2, 4, 6…

Moulinette

El corrector automático de 42 (en francés, el pasapurés). Tras la evaluación entre pares, ejecuta tus scripts con sus propias variables de entorno y compara la salida con la esperada, byte a byte, sin margen de discusión. Que funcione «en tu máquina con tu usuario» no basta: tiene que dar exactamente la salida pedida con otros datos. Tampoco puede haber en el repositorio archivos que el enunciado no pide.

ex00Exam

Entregable: ninguno

El único ejercicio sin código: apuntarse al examen del viernes — al evento en la agenda y al proyecto Exam00. El enunciado pide comprobarlo dos veces, y luego tres. No es humor (bueno, no solo): cada piscine hay gente que hace toda la semana de ejercicios y descubre el viernes que no está inscrita en el examen. En 42 la burocracia también es parte del sistema — Vogsphere no perdona.

ex01print_groups

Entregable: print_groups.sh

Mostrar los grupos del usuario indicado en la variable de entorno FT_USER, separados por comas, sin espacios.

id -Gn "$FT_USER" | tr ' ' ',' | tr -d '\n'

Primera aparición de dos ideas clave del módulo: los scripts se parametrizan por variables de entorno (la Moulinette exporta FT_USER antes de ejecutar), y tr es el transformador de caracteres más barato del sistema.

ex02find_sh

Entregable: find_sh.sh

Buscar todos los .sh del directorio actual y subdirectorios y mostrar solo el nombre, sin ruta y sin extensión.

find . -type f -name '*.sh' | sed 's|.*/||; s|\.sh$||'

find localiza (./sub/file2.sh) y sed recorta con dos sustituciones encadenadas: s|.*/|| borra todo hasta la última barra (fuera la ruta) y s|\.sh$|| borra la extensión anclada al final. Detalle de estilo: usar | como delimitador de sed evita el baile de contrabarras al trabajar con rutas — el clásico s/\/ruta\/…// ilegible.

ex03count_files

Entregable: count_files.sh

Contar archivos regulares y directorios (incluido .) del directorio actual hacia abajo.

find . -type f -o -type d | wc -l

find con dos condiciones unidas por -o (OR) emite una línea por coincidencia — y . siempre es la primera —, y wc -l las cuenta. El patrón generador | contador es el pan de cada día en Unix: no se cuenta "a mano", se produce un flujo y se mide. (Guiño del enunciado: la salida de ejemplo es, cómo no, 42.)

ex04MAC

Entregable: MAC.sh

Mostrar las direcciones MAC de la máquina, una por línea.

ifconfig | awk '/ether/ {print $2}'

En la salida de ifconfig, cada interfaz física tiene una línea ether xx:xx:xx:xx:xx:xx …. El one-liner de awk hace las dos cosas a la vez: /ether/ filtra esas líneas y {print $2} imprime su segundo campo, la MAC. Es el ejercicio-presentación de awk: patrón + acción, campos ya troceados gratis. (La alternativa moderna sería ip link | awk '/link\/ether/ {print $2}' — pero el enunciado manda: man ifconfig.)

ex05¿Puedes crearlo?

Entregable: "\?$*'MaRViN'*$?\"

Crear un archivo que contenga exactamente 42 (2 bytes, sin salto) y cuyo nombre sea, literalmente:

"\?$*'MaRViN'*$?\"
$ printf '42' > '"\?$*'\''MaRViN'\''*$?\"'

El nombre es una mina anti-shell: comillas dobles, backslashes, $, *, ? y comillas simples — todo con significado especial. La solución es entender de una vez el quoting: entre comillas simples nada se interpreta… excepto la propia comilla simple, que no puede aparecer. El truco '\'' cierra la cadena, mete una comilla escapada y la reabre. Para Unix el nombre es válido sin más: cualquier byte salvo / y NUL puede formar parte de un nombre de archivo. (En Windows/NTFS este archivo directamente no puede existir — ", * y ? están prohibidos.)

MaRViN — Marvin, el Androide Paranoico de La guía del autoestopista galáctico: un robot con "un cerebro del tamaño de un planeta" condenado a tareas triviales… como que lo usen a él de nombre de archivo imposible. Segunda referencia a Douglas Adams de la piscine, y no será la última.

ex06Skip

Entregable: skip.sh

Ejecutar ls -l pero mostrando solo una de cada dos líneas, empezando por la primera.

ls -l | awk 'NR % 2 == 1'

NR es el número de línea que awk lleva contado. La condición NR % 2 == 1 (impar) selecciona 1ª, 3ª, 5ª… y, como no hay bloque {…}, awk aplica su acción por defecto: imprimir. Un programa completo en 11 caracteres. La versión sed equivalente — sed -n 'p;n' — también cabe en un tuit; elegir herramienta es parte del aprendizaje.

ex07r_dwssap

Entregable: r_dwssap.sh

El gran pipeline del módulo. Sobre /etc/passwd: quitar comentarios, quedarse con una de cada dos líneas (empezando por la segunda), invertir cada nombre de usuario, ordenarlos en alfabético inverso, quedarse con los que caen entre las líneas FT_LINE1 y FT_LINE2, unirlos con ", " y terminar con un punto.

grep -v '^#' /etc/passwd | awk 'NR % 2 == 0' | cut -d: -f1 \
  | rev | sort -r | sed -n "${FT_LINE1},${FT_LINE2}p" \
  | tr '\n' '@' | sed 's/@$/./; s/@/, /g'

Siete etapas, cada una un comando mínimo que hace una sola cosa:

  1. grep -v '^#' — fuera comentarios.
  2. awk 'NR%2==0' — líneas pares (la "una de cada dos, empezando por la segunda").
  3. cut -d: -f1 — primer campo de cada línea (el usuario; : separa los 7 campos de passwd).
  4. rev — invierte cada línea carácter a carácter.
  5. sort -r — orden alfabético inverso.
  6. sed -n "${FT_LINE1},${FT_LINE2}p" — imprime solo el rango de líneas pedido (sed acepta rangos numéricos directamente).
  7. tr + sed final — sustituye los saltos por un marcador, convierte el último en . y el resto en ", ".

Es la tesis del módulo entero: problemas aparentemente enrevesados se descomponen en filtros triviales conectados por pipes. El enunciado avisa: «sigue los pasos exactamente en el orden indicado» — cambiar el orden de sort y el recorte de rango da resultados distintos.

El nombre — r_dwssap es passwd_r escrito del revés: el ejercicio se autodescribe (passwd + reverse). Leer nombres al revés es deporte nacional en 42.

ex08add_chelou

Entregable: add_chelou.sh

El jefe final. Sumar dos números que llegan en variables de entorno, cada uno escrito en una base inventada, y mostrar el resultado en una tercera base inventada:

n1=$(printf '%s' "$FT_NBR1" | sed "s/'/0/g; s/\\\\/1/g; s/\"/2/g; s/?/3/g; s/!/4/g")
n2=$(printf '%s' "$FT_NBR2" | sed 's/m/0/g; s/r/1/g; s/d/2/g; s/o/3/g; s/c/4/g')
echo "obase=13; ibase=5; $n1 + $n2" | bc \
  | sed 's/0/g/g; s/1/t/g; s/2/a/g; s/3/i/g; s/4/o/g; s/5/ /g;
         s/6/l/g; s/7/u/g; s/8/S/g; s/9/n/g; s/A/e/g; s/B/m/g; s/C/f/g'

La clave es darse cuenta de que una "base rara" solo es un cambio de alfabeto: con sed se traducen los símbolos a dígitos normales, bc (la calculadora de precisión arbitraria de Unix) hace la conversión de bases y la suma de verdad (ibase=5, obase=13 — el obase se fija primero, cuando aún se lee en decimal), y un último sed traduce los dígitos del resultado (0–9, A, B, C — así imprime bc las bases hasta 16) al alfabeto final. Los símbolos elegidos (\, ", ?…) obligan además a repasar el quoting del ex05: escapar el backslash dentro de un sed dentro de unas comillas dobles tiene su miga (s/\\\\/1/g).

¿Y los alfabetos no son arbitrarios? El de salida, leído con sus 13 símbolos en orden de valor, deletrea "gtaio luSnemf" — anagrama de "Salut mon eg…"; de hecho el primer ejemplo del enunciado da como resultado Salut ("hola" en francés). Todo el ejercicio está montado para que el resultado salude.

El nombre — chelou es verlan (el argot francés de invertir sílabas) de louche: "raro", "turbio". Literalmente: "suma rara". El verlan es al francés lo que r_dwssap a passwd — hasta el argot del enunciado invierte cosas.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a donde está explicado. En Shell 01 casi todo se defiende ejecutando: ten preparada una carpeta de pruebas con algunos .sh y saber cambiar las variables de entorno en la misma línea del comando. Están agrupadas en: los comandos, casos límite y entrega. Antes de mirar la respuesta, intenta contestar tú.

Los comandos

¿Qué hace exactamente el | de print_groups?

Conecta la salida estándar de un comando con la entrada estándar del siguiente, y los tres comandos se ejecutan a la vez. id -Gn escribe los grupos separados por espacios, el primer tr los recibe y cambia espacios por comas, y el segundo borra el salto de línea. Solo pasa stdout: los errores siguen saliendo por pantalla. → tubería, ex01

¿Por qué quitas el salto de línea en print_groups?

Porque el ejemplo del enunciado lo muestra así: el prompt sale pegado a la lista (…libvirt$>). La Moulinette compara byte a byte y el \n es un byte más. En cambio find_sh y count_files sí lo llevan: en sus ejemplos con cat -e cada línea acaba en $. → salto de línea, ex01

Explícame el sed de find_sh.

Son dos sustituciones seguidas, con | como separador para no escapar las barras. s|.*/|| borra desde el principio hasta la última / (el .* se come todo lo que puede), y s|\.sh$|| borra .sh solo si está al final. ./sub/file2.sh queda en file2. → sed, ex02

En r_dwssap, ¿da igual el orden de los pasos?

No, y el enunciado lo avisa. Invertir los nombres antes o después de ordenar cambia el orden (se ordena toor, no root), y recortar FT_LINE1–FT_LINE2 antes de ordenar se quedaría con otros usuarios. La selección de líneas pares también tiene que hacerse después de quitar los comentarios, o cambian las parejas. → ex07

En add_chelou, ¿por qué obase va antes que ibase?

Porque bc lee cada número en la base de entrada vigente. Si primero pones ibase=5, el 13 de obase=13 se lee en base 5 y vale 8: echo "ibase=5; obase=13; 4 + 4" | bc da 10 (8 en base 8) en vez de 8. → bc, ex08

Casos límite

¿Por qué '*.sh' entre comillas en find_sh?

Para que el patrón le llegue a find sin tocar. Sin comillas, si en el directorio actual hay un a.sh, el shell cambia *.sh por a.sh antes de ejecutar, y find . -name a.sh solo encuentra ese: probado en una carpeta con a.sh, sub/b.sh y sub/x y.sh, sin comillas sale solo ./a.sh. → comodines, ex02

¿Y por qué "$FT_USER" con comillas dobles?

Para que el valor llegue a id como un solo argumento pase lo que pase. Con las dobles se sigue expandiendo el $, pero los espacios y los * del valor ya no se interpretan. Con simples, id recibiría el texto literal $FT_USER. → comillas, variables de entorno

¿count_files cuenta el .? ¿Y los enlaces simbólicos?

El . sí, como pide el enunciado: find lo imprime el primero, porque es un directorio. Los enlaces simbólicos no: no son -type f ni -type d sino -type l. Lo mismo pasa con un enlace.sh en find_sh. → find, ex03

¿Por qué MAC.sh saca más de una dirección?

Porque saca una por cada interfaz con línea ether: la tarjeta de red, el wifi y también las interfaces virtuales (en un puesto con máquinas virtuales aparece, por ejemplo, una 52:54:00:…, el prefijo de QEMU/libvirt). El lazo local lo no tiene MAC. El enunciado pide «las direcciones MAC», en plural, una por línea. → MAC, ex04

¿Cómo demuestras que el archivo de ex05 tiene solo 42?

Con ls -l, que da un tamaño de 2 bytes, o con cat -e, que enseña 42 sin $ al final. Para no tener que escribir el nombre se puede usar un comodín, como hace el enunciado: ls -lRa *MaRV* | cat -e. → comillas, ex05

Entrega

¿Con qué se ejecutan los scripts? ¿Necesitan permisos?

El enunciado pide que funcionen con /bin/sh, así que nada exclusivo de bash. Si se lanzan como en los ejemplos, ./find_sh.sh, necesitan permiso de ejecución; con sh find_sh.sh, no. Ojo: en este repo solo print_groups.sh tiene la x, los demás están a -rw-r--r--, y ./skip.sh daría Permission denied. → script

¿Puedo dejar en el repo mis archivos de prueba?

No. El enunciado dice que solo se entregan los archivos pedidos y la Moulinette lo comprueba. Las carpetas de prueba, fuera del repositorio. → Moulinette