Práctica: Comunicación entre Procesos

9/23

Lectura

El desafío de esta clase consiste en crear un archivo con al menos 30 líneas de texto del lenguaje de programación que más te guste.

Luego de esto, crea dos nuevos archivos con el contenido de este archivo, uno con la primera mitad y el otro con la segunda mitad. Pero no puedes usar un editor de texto ni copiar el texto a mano, debes usar los comandos que estudiamos en clases anteriores para obtener el resultado que necesitas y enviarlo al archivo indicado.

Finalmente, usa el comando date para obtener la fecha y hora de hoy. Y añade ese resultado al final del primer archivo que creaste (el que debía tener al menos 30 líneas). No puedes copiar y pegar, debes hacerlo directamente desde la terminal y sin editores de texto. Pero ten mucho cuidado de no borrar el resto de contenido de tu archivo.

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 1525

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Solo en el caso de que alguien este perdido, le dejo los comandos que esta usando la mayoría.

vi test.txt “–> Para crear el archivo, presionas i para editar y luego esc cuando hayas terminado.”
:x "–>Para cerrar el archivo y guardar"
cat test.txt "–>Para comprobar que el archivo esta ok."
head -15 test.txt > test_head.txt "–>Para crear archivo con las primeras 15 líneas"
tail -15 test.txt > test_tail.text "–>Para crear el archivo con las ultimas 15 líneas"
date >> test.txt “–>Para concatenar la fecha en el archivo original.”

Primero calculamos el total de líneas del fichero.

cat dummy.csv | wc -l

Luego podemos meter ese valor dentro de una variable.

n=$(cat dummy.csv | wc -l | cat)

También metemos en variable el cálculo de la mitad de ese total de líneas. Como el total puede ser impar, el segundo bloque no es exactamente la mitad sino la diferencia del total con el primer bloque.

n1="$(($n/2))"
n2="$(($n-($n/2)))"

Ahora añadimos el primer bloque de líneas a un fichero nuevo utilizando esas variables. Y de igual manera con el segundo bloque.

head -n $n1 dummy.csv > dummy_1.csv
tail -n $n2 dummy.csv > dummy_2.csv

Para añadir la fecha de la modificación en el primer fichero podemos concatenar un pipe con esa inserción.

head -n $n1 dummy.csv > dummy_1.csv | date >> dummy_1.csv

Para no necesitar un pipe podríamos haberlo hecho así:

echo -e "$(head -n $n1 dummy.csv)\n$(date)" > dummy_1.csv

Todas estas acciones las podemos concatenar en una única línea de comando.

n=$(cat dummy.csv | wc -l | cat) && n1="$(($n/2))" && n2="$(($n-($n/2)))" && echo -e "$(head -n $n1 dummy.csv)\n$(date)" > dummy_1.csv && tail -n $n2 dummy.csv > dummy_2.csv

Para simplificar el comando podemos meter el nombre del fichero en una variable.

f=dummy && n=$(cat $f.csv | wc -l | cat) && n1="$(($n/2))" && n2="$(($n-($n/2)))" && echo -e "$(head -n $n1 $f.csv)\n$(date)" > $f"_1.csv" && tail -n $n2 $f.csv > $f"_2.csv"

Y lo optimizamos metiendo el propio comando también dentro de otra variable (sin la definición del nombre del fichero):

split='n=$(cat $f.csv | wc -l | cat) && n1="$(($n/2))" && n2="$(($n-($n/2)))" && echo -e "$(head -n $n1 $f.csv)\n$(date)" > $f"_1.csv" && tail -n $n2 $f.csv > $f"_2.csv"'

Ahora tenemos un código reutilizable que ejecutaremos de la siguiente manera:

f=dummy && eval $split

Esto nos permite subdividir los ficheros que ya hemos dividido.

f=dummy_1 && eval $split

El resultado sería:

./
../
dummy.csv
dummy_1.csv
dummy_1_1.csv
dummy_1_2.csv
dummy_2.csv

Aprendo 30% con el profe y el otro 70% en los comentarios xdd

% nano archivo1.txt (creamos el archivo de 30 líneas)
% touch archivo_head.txt
% touch archivo_tail.txt
% head -n 15 archivo1.txt > archivo_head.txt
% tail -n 15 archivo1.txt > archivo_tail.txt
% date >> archivo1.txt

(Recordad que ‘>’ se utiliza para truncar y sobrescribir, por el contrario ‘>>’ se usa para añadir al final del texto ya creado)

head -n 15 30.txt > 15primeras.txt | tail -n 15 30.txt > 15ultimas.txt | date >> 30.txt

todo esto en una sola linea

Creación del archivo con 30 lineas, primera mitad y segunda mitad de las 30 lineas.
.

.
salida primera mitad y segunda mitad de las 30 lineas.
.

.
Salida de 30 lineas con date.

No puedo creer que me funcionó

memozoid@VM:~/learning$ cat main.py | wc -l
52
memozoid@VM:~/learning$ touch mitad1.py mitad2.py
memozoid@VM:~/learning$ head -n 26 main.py > mitad1.py
memozoid@VM:~/learning$ tail -n 26 main.py > mitad2.py
memozoid@VM:~/learning$ cat mitad1.py | wc -l
26
memozoid@VM:~/learning$ cat mitad2.py | wc -l
26

🐱‍💻 Aplicando conocimiento adquirido.

Reto terminado, los comandos que utilice fueron:

touch index.js
vim index.js // Y agregue el código 
head -n 15 index.js > first.js
tail -n 15 index.js > second.js
date >> index.js

vim index.html#creo el archivo principal de 34 lineas
touch parte_uno.txt#creo el segundo archivo
touch parte_dos.txt#creo el segundo archivo
head -n 17 index.html > parte_uno.txt
tail -n 17 index.html > parte_dos.txt
date >> index.html

$ touch main.c
$ vim main.c
$ head -n $(cat main.c | wc -l | awk '{ print $1 / 2 }') main.c >> primera.txt
$ tail -n $(cat main.c | wc -l | awk '{ print $1 / 2 }') main.c >> segunda.txt
$ date >> primera.txt
  1. file1.php con toda la sentencia
  2. Se ejecuta la expresión head -n 12 > file2.php toma las primeras 12 líneas y se envían al file2.php
  3. Se ejecuta la expresión tail -n 12 > file3.php toma las últimas 12 líneas y se envían al file3.php
  4. Se ejecuta la expresión date >> file1.php toma la fecha actual del sistema y la envía al final del contenido del file1.php


Hola. Los comandos que utilice para realizar la tarea fueron los siguientes (utilizare ** como inicio y final de comentario para explicar lo que hice):
$vim practica1.txt Creo un archivo con 15 líneas, oprimo ESC y :x para guardar y cerrar
$touch file1.txt Creo un archivo vacío llamado file1
$touch file2.txt Creo un segundo archivo vació llamado file2
$head -n 15 practica1.txt >file1.txt miro las primeras 15 líneas y el resultado lo redirecciono a file1
$tail -n 15 practica1.txt>file2.txt miro las ultimas 15 líneas y el resultado lo redirecciono a file2
$date>>practica1.txt uso el comando date y redirecciono el resultado a practica1.txt

Luego uso el comando cat con cada archivo para ver el contenido de cada uno.

Saludos.

Yo primero cree un archivo con 30 lineas (las escribi a mano, supongo que en un futuro aprenderé a hacerlo de forma automática xd) y despues ejecute los siguientes comandos:

head -n 15 “nombre_del_archivo_30_lineas” > “nombre_archivo_primeras_15_lineas”

tail -n 15 “nombre_del_archivo_30_lineas” > “nombre_archivo_ultimas_15_lineas”

date >> “nombre_del_archivo_30_lineas”

Espero se entienda jeje

Es un archivo Python de 82 lineas 🐍 🐍 🐍
Agregamos 41 con head al archivo codigo_superior y los 41 de abajo con tail

(base) aldo@ALDOMATUS:~/curso_terminal$ head -n 41 codigo.py > codigo_superior.txt
(base) aldo@ALDOMATUS:~/curso_terminal$ tail -n 41 codigo.py > codigo_inferior.txt

Hago visualización de ambos archivos superior e inferior

(base) aldo@ALDOMATUS:~/curso_terminal$ cat codigo_superior.txt
(base) aldo@ALDOMATUS:~/curso_terminal$ cat codigo_inferior.txt

Agregamos la fecha con >> y visualizamos con cat

(base) aldo@ALDOMATUS:~/curso_terminal$ date >> codigo_inferior.txt
(base) aldo@ALDOMATUS:~/curso_terminal$ cat codigo_inferior.txt

comparto mi ejercicio,

head -n 13 index.html > index2.html | tail -n 14 index.html > index3.html | date >> index.html```

nota: use el alfabeto para el ejercicio.

Muy buen ejercicio.

Aquí mi solución:

[peter@nycgia ~]$ head -n 15 reto.php > primera-mitad.txt
[peter@nycgia ~]$ tail -n 15 reto.php > segunda-mitad.txt
[peter@nycgia ~]$ date >> reto.php
vim index.html #creo el archivo principal de 34 lineas
touch parte_uno.txt #creo el segundo archivo
touch parte_dos.txt #creo el segundo archivo
head -n 17 index.html > parte_uno.txt
tail -n 17 index.html > parte_dos.txt
date >> index.html

¡Y listo! 🖐🏽😊

tony@tony-VirtualBox:~/home$ touch archivo1
tony@tony-VirtualBox:~/home$ touch archivo2
tony@tony-VirtualBox:~/home$ touch archivo3
tony@tony-VirtualBox:~/home$ ls
archivo1 archivo2 archivo3
tony@tony-VirtualBox:~/home$ head -n 15 archivo1 > archivo2
tony@tony-VirtualBox:~/home$ tail -n 15 archivo1 > archivo3
tony@tony-VirtualBox:~/home$ date > archivo1
tony@tony-VirtualBox:~/home$ head -n 15 archivo2 > archivo1
tony@tony-VirtualBox:~/home$ head -n 15 archivo3 >> archivo1
tony@tony-VirtualBox:~/home$ date >> archivo1

Crear archivo: touch archivo-30-lineas.txt
Editar archivo-30-lineas.txt: vim archivo-30-lineas.txt
Tomar las primeras 15 lineas y copiarlas a otro: head -n 15 archivo-30-lineas.txt > archivo-primeras-15-lineas.txt
Tomar las ultimas 15 lineas y copiarlas a otro: tail -n 15 archivo-30-lineas.txt > archivo-ultimas-15-lineas.txt
Obtener la fecha e incluirlas al primer archivo: date >> archivo-30-lineas.txt.

Muy buenas a todos. Quisiera compartir el logro de este desafío:

  1. Crear archivo con 30 líneas

     touch Desafio.txt
    

Dentro de este archivo rellené en el editor de texto desde la línea 1 hasta la 30, con 1° línea, 2° línea… 30° línea.

  1. Copiar las primeras 15 líneas a un archivo distinto.

     head -n 15 Desafio.txt > PrimerasQuince.txt
    
  2. Veo que el archivo se haya creado.

     ls -al
    
  3. Reviso si están las primeras 15 líneas en el archivo

     cat PrimerasQuince.txt
    
  4. Sigo con las últimas 15 líneas para un archivo distinto.

     tail -n 15 Desafio.txt > UltimasQuince.txt
    
  5. Reviso que el archivo se haya creado.

     ls -al
    
  6. Agrego el comando “date” al archivo Desafio.txt

     date >> Desafio.txt
    
  7. Siento que me invade un sentimiento de logro y voy comprendiendo lo eficiente que resulta usar la terminal.

  8. Comparto y les deseo lo mejor a todos los que vendran ❤️

touch arhivo.txt
nano archivo.txt

Se ingresa el texto para luego crear los otros archivos.

head -n 30 archivo.txt > first-line.txt
tail -n 30 archivo.txt > last-line.txt

date >> archivo.txt



Buen día a todos.
Pueden practicar con el archivo Bash Script que les comparto a continuación, y también lo pueden correr con $./snow.sh

        #!/bin/bash
         
        LINES=$(tput lines)
        COLUMNS=$(tput cols)
         
        declare -A snowflakes
        declare -A lastflakes
         
        clear
         
        function move_flake() {
        i="$1"
         
        if [ "${snowflakes[$i]}" = "" ] || [ "${snowflakes[$i]}" = "$LINES" ]; then
        snowflakes[$i]=0
        else
        if [ "${lastflakes[$i]}" != "" ]; then
        printf "\033[%s;%sH \033[1;1H " ${lastflakes[$i]} $i
        fi
        fi
         
        printf "\033[%s;%sH*\033[1;1H" ${snowflakes[$i]} $i
         
        lastflakes[$i]=${snowflakes[$i]}
        snowflakes[$i]=$((${snowflakes[$i]}+1))
        }
         
        while :
        do
        i=$(($RANDOM % $COLUMNS))
         
        move_flake $i
         
        for x in "${!lastflakes[@]}"
        do
        move_flake "$x"
        done
         
        sleep 0.1
        done

Mi primer reto con Vim y linux.

Este sería mi resultado
.
:~$ touch practica9.txt
:~$ nano practica9.txt
:~$ cat practica9.txt
:~$ touch practica9a.txt
:~$ touch practica9b.txt
:~$ head -n 15 practica9.txt > practica9a.txt
:~$ cat practica9a.txt
:~$ tail -n 16 practica9.txt > practica9b.txt
:~$ cat practica9b.txt
:~$ date >> practica9.txt
:~$ cat practica9.txt
.
Estuvo bastante bueno el desafío

Hola, mostrando avances de la practica.

Lo primero que hice fue:

  • Crear un archivo con 30 lineas
vim practica.txt

(Soy un poco flojo así que solamente agregué números del 1 al 30 en el archivo xD)

  • Después, creé los dos archivos contenedores
touch 15practica.txt
touch 30practica.txt
  • Una vez creados los contenedores, continue con la parte de repartir las mitades de “practicas.txt” a sus respectivos archivos
head -n 15 practica.txt > 15practica.txt
tail -n 15 practica.txt > 30practica.txt

(*Esto funciona porque se que hay 30 líneas en el archivo “practica.txt”, ¿me pregunto sí habra una manera mejor de repartir la mitad del contenido?)

Por ultimo, agregué la fecha al archivo que contenia la primera mitad de “practica.txt”

date >> 15practica.txt

Sayonara

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ vim practica_comandos.txt

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ touch primer_archivo

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ touch segundo_archivo

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ cat practica_comandos.txt | wc
      8     207    1233

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ cat practica_comandos.txt
 Lo que mas me ha gustado de aprender a programar han sido tener obstaculos sabe                                                                                                                s?...
Si obstaculos,una version mia anterior, intentaba encontrar una solucion tempora                                                                                                                l sin sacar el conocimiento profundo de las cosas. Ya sabes todo rapido.Lo bueno                                                                                                                 de aprender como autodidacta es esa habilidad de buscar las soluciones por una                                                                                                                 misma. Te da disciplina y eso realmente me agrada. Se muy bien
que lo que aprendo aqui es mi fututo. Y no quiero que la base de mis conocimient                                                                                                                os sean debiles.
Por el momento va bien, me han dicho que esto de ser autodidacta es solitario.Pe                                                                                                                ro la verdad busque la manera de asociarme y conocer personas del circulo, ya sa                                                                                                                bes tomar contexto y que la presion social de las personas que admiro tambien me                                                                                                                 juegue a favor. He venido de puras facultades autoritarias con un sentido de la                                                                                                                 enseñanza muy pasiva, estoy realmente orgullosa de construir cada paso en mi ca                                                                                                                rrera
profesional como autodidacta.
Todo depende de mi! es como ser emprededora del conocimiento.
Y me encanta permitirme equivocarme , es lo que se necesita para algun dia ser e                                                                                                                xperta. Las personas expertas en un campo son las personas que mas errores han c                                                                                                                ometido y solucionado en un campo.
Vamos!! Buena madrugada, nunca pares de aprender!!!

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ head -n 4 practica_comandos.txt > primer_archivo.txt

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ cat primer_archivo.txt
 Lo que mas me ha gustado de aprender a programar han sido tener obstaculos sabe                                                                                                                s?...
Si obstaculos,una version mia anterior, intentaba encontrar una solucion tempora                                                                                                                l sin sacar el conocimiento profundo de las cosas. Ya sabes todo rapido.Lo bueno                                                                                                                 de aprender como autodidacta es esa habilidad de buscar las soluciones por una                                                                                                                 misma. Te da disciplina y eso realmente me agrada. Se muy bien
que lo que aprendo aqui es mi fututo. Y no quiero que la base de mis conocimient                                                                                                                os sean debiles.
Por el momento va bien, me han dicho que esto de ser autodidacta es solitario.Pe                                                                                                                ro la verdad busque la manera de asociarme y conocer personas del circulo, ya sa                                                                                                                bes tomar contexto y que la presion social de las personas que admiro tambien me                                                                                                                 juegue a favor. He venido de puras facultades autoritarias con un sentido de la                                                                                                                 enseñanza muy pasiva, estoy realmente orgullosa de construir cada paso en mi ca                                                                                                                rrera

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ tail -n 4 practica_comandos.txt > segundo_archivo.txt

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ cat segundo_archivo.txt
profesional como autodidacta.
Todo depende de mi! es como ser emprededora del conocimiento.
Y me encanta permitirme equivocarme , es lo que se necesita para algun dia ser e                                                                                                                xperta. Las personas expertas en un campo son las personas que mas errores han c                                                                                                                ometido y solucionado en un campo.
Vamos!! Buena madrugada, nunca pares de aprender!!!

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ date >> practica_comandos.txt

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$ cat practica_comandos.txt
 Lo que mas me ha gustado de aprender a programar han sido tener obstaculos sabe                                                                                                                s?...
Si obstaculos,una version mia anterior, intentaba encontrar una solucion tempora                                                                                                                l sin sacar el conocimiento profundo de las cosas. Ya sabes todo rapido.Lo bueno                                                                                                                 de aprender como autodidacta es esa habilidad de buscar las soluciones por una                                                                                                                 misma. Te da disciplina y eso realmente me agrada. Se muy bien
que lo que aprendo aqui es mi fututo. Y no quiero que la base de mis conocimient                                                                                                                os sean debiles.
Por el momento va bien, me han dicho que esto de ser autodidacta es solitario.Pe                                                                                                                ro la verdad busque la manera de asociarme y conocer personas del circulo, ya sa                                                                                                                bes tomar contexto y que la presion social de las personas que admiro tambien me                                                                                                                 juegue a favor. He venido de puras facultades autoritarias con un sentido de la                                                                                                                 enseñanza muy pasiva, estoy realmente orgullosa de construir cada paso en mi ca                                                                                                                rrera
profesional como autodidacta.
Todo depende de mi! es como ser emprededora del conocimiento.
Y me encanta permitirme equivocarme , es lo que se necesita para algun dia ser e                                                                                                                xperta. Las personas expertas en un campo son las personas que mas errores han c                                                                                                                ometido y solucionado en un campo.
Vamos!! Buena madrugada, nunca pares de aprender!!!
mi., 19 de ago. de 2020  3:15:19

brend@LAPTOP-GKP23NF4 MINGW64 ~/development (master)
$

Creación de archivo con 30 líneas

echo | awk '{for($i = 1; $i<31; $i++) print "Línea " $i}' > practica_comunicacion_entre_procesos.txt

Creación de segundo archivo (primer archivo nuevo)

head -n 15 practica_comunicacion_entre_procesos.txt > practica_comunicacion_entre_procesos_nuevo_1.txt

Creación de tercer archivo (segundo archivo nuevo)

tail -n 15 practica_comunicacion_entre_procesos.txt > practica_comunicacion_entre_procesos_nuevo_1.txt

Añadir fecha al primer archivo

date >> practica_comunicacion_entre_procesos.txt

Creo que este reto no es para todos. Pues en la clase anterior, solo se explican por encima los conceptos.

crear archivo de texto de por lo menos 30 lineas:

ls > test.txt
ls >> test.txt

comprobar número de lineas

cat test.txt | wc -l
54

crear archivo con la primer mitad del original y comprobar:

head -n 27 test.txt > test1.txt
cat test1.txt | wc -l
27

crear archivo con la segunda mitad del original y comprobar :

tail -n 27 test.txt > test2.txt
cat test2.txt wc -l
27

agregar fecha al final del archivo original y comprobar:

date >> test.txt
tail -n 1 test.txt
mar sep 22 18:58:59 -03 2020

Uno lo puede hacer tan complejo o tan simple como quiera, solo por abrir la mente a nuevos conceptos…

echo "Creando el archivo de entrada con N lineas"
ls -lsh /bin > archivo_entrada.txt 

echo "Partiendo el archivo en mitades… sin importar si es o no par el numero de lineas"
puntoMedio=$(wc -l archivo_entrada.txt | awk '{printf "%.0f\n", $1 / 2}')
head -n $puntoMedio archivo_entrada.txt > primer_mitad.txt ; date >> primer_mitad.txt
tail -n $(($puntoMedio+1))  archivo_entrada.txt > segunda_mitad.txt

echo "Comprobando los resultados: Lineas en archivos"
wc -l archivo_entrada.txt primer_mitad.txt segunda_mitad.txt

echo "Comprobando los resultados: Extractos de archivos"
head -n $(($puntoMedio+3)) archivo_entrada.txt | tail -n 6
tail -n 4 primer_mitad.txt 
head -n 3 segunda_mitad.txt 

Compañeros les comparto mi practica la verdad me costo, pedi apoyo, por que
1.- considero que el profesor no se explico bien con el procedimiento
2.- creo que debe ser un poco mas detallado al explicar los comandos.

Listo!

<code>
VERONICA GARCIA@VERONICAGARCIA MINGW64 ~/Documents
$ head -n 15 Prueba1_linea_comandos.py > primeraParte.py

VERONICA GARCIA@VERONICAGARCIA MINGW64 ~/Documents
$ tail -n 14 Prueba1_linea_comandos.py > segundaParte.py

VERONICA GARCIA@VERONICAGARCIA MINGW64 ~/Documents
$ date
Tue Mar 16 12:46:53 HPS 2021

VERONICA GARCIA@VERONICAGARCIA MINGW64 ~/Documents
$ date >> Prueba1_linea_comandos.py

Hola a todos, os comparto una posible linea de comando, espero que os ayude a entender el concepto de “PIPE” tubería

Salida | entrada y salida && entrada y salida

cat 30.txt | head -n 15 > 1.txt && tail -n 15 > 2.txt

Se me dificultó mucho la redirección de salida, pero ustedes me guiaron. Gracias.

root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# touch 30_lineas.txt
root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# touch primera_15.txt
root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# touch segundas_15.txt
root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# head -n 15 30_lineas.txt > primera_15.txt
root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# tail -n 15 30_lineas.txt > segundas_15.txt
root@LAPTOP:/mnt/c/users/XX/Terminal_y_linea_de_comandos# date >> 30_lineas.txt
printf "for i in range(0,30): print(i)" l python3 > trabajo.txt
head -n 15 trabajo.txt > trabajo1.txt
tail -n 15 trabajo.txt > trabajo2.txt
date >> trabajo.txt

El archivo donde tengo las 30 líneas de texto se llama prueba.txt

head -n 15 prueba.txt > lineas.txt & tail -n 15 prueba.txt > carros.txt

Usando Pipes:

Archivo Principal PHP:

Mitad 1 con head:

Mitad 2 con tail:

<geradotdf@Gerardo-PC:~/development$ cat prueba.txt | wc -l
30
geradotdf@Gerardo-PC:~/development$ head -n 15 prueba.txt > 1ºparte.txt
geradotdf@Gerardo-PC:~/development$ tail -n 15 prueba.txt > 2ºparte.txt
geradotdf@Gerardo-PC:~/development$ cat 1ºparte.txt | wc -l
15
geradotdf@Gerardo-PC:~/development$ cat 2ºparte.txt | wc -l
15
geradotdf@Gerardo-PC:~/development$ date >> prueba.txt
geradotdf@Gerardo-PC:~/development$ cat prueba.txt | wc -l
31>

djbaena@Duvan:~$ vim archivo.txt
djbaena@Duvan:~$ head -n 15 archivo.txt > Primeras-15-lineas.txt
djbaena@Duvan:~$ ls
Primeras-15-lineas.txt archivo.txt development learnig
djbaena@Duvan:~$ vim Primeras-15-lineas.txt
djbaena@Duvan:~$ tail -n 15 archivo.txt > Segundas-15-lineas.txt
djbaena@Duvan:~$ ls
Primeras-15-lineas.txt Segundas-15-lineas.txt archivo.txt development learnig
djbaena@Duvan:~$ vim Segundas-15-lineas.txt
djbaena@Duvan:~$ vim Primeras-15-lineas.txt
djbaena@Duvan:~$ date >>archivo.txt
djbaena@Duvan:~$ vim archivo.txt

Practica
Input

Output

¡Sí pude! De a pocos vamos aprendiendo 😄

Asi me quedo 😄

**~$ touch prueba.txt**
**~$ nano prueba.txt**
**~$ head -n "15" prueba.txt > prueba1.txt**
**~$ cat prueba1.txt**
hola mi nombre es pedro
vivo en platzi
me gusta el sushi
mi hermano se llamo juan
y vive en youtube
mi tio es azucarero
mi madre es odontologa
mauro es mi profe de platzi
me gusta el anime
pero no soy otaku :
si me bano
leo mangas muy poco
tambien veo directos en Twich
mi sueno es ser azucarero
tener una pequena wuaifu
**~$ tail -n "15" prueba.txt > prueba2.txt**
**~$ cat prueba2.txt**
vivir en google
en la calle wulabi
sidney 4312
besos es el ser mas rico del mundo
el bitcoin caera muy pronto
asi que aprovechen de comprar cuando baje
asi lo pueden volver a vender cuando suba dentro de 10 meses
no me gusta el trading
me gusta wordpress
blogger tiene que ser mas completo
pero para ser gratis esta chido
eliminare mi wasap por sus nuevas politicas
ya casi termino
otra linea mas y listo
FIN DEL MUNDO
~$ **date >> prueba.txt**
~$ **cat prueba.txt**
hola mi nombre es pedro
vivo en platzi
me gusta el sushi
mi hermano se llamo juan
y vive en youtube
mi tio es azucarero
mi madre es odontologa
mauro es mi profe de platzi
me gusta el anime
pero no soy otaku :
si me bano
leo mangas muy poco
tambien veo directos en Twich
mi sueno es ser azucarero
tener una pequena wuaifu
vivir en google
en la calle wulabi
sidney 4312
besos es el ser mas rico del mundo
el bitcoin caera muy pronto
asi que aprovechen de comprar cuando baje
asi lo pueden volver a vender cuando suba dentro de 10 meses
no me gusta el trading
me gusta wordpress
blogger tiene que ser mas completo
pero para ser gratis esta chido
eliminare mi wasap por sus nuevas politicas
ya casi termino
otra linea mas y listo
FIN DEL MUNDO
Thu Jan 14 22:32:18 -04 2021

(

aqui el reto:

hmap-VirtualBox:~$ pwd
/home/hmap
hmap@hmap-VirtualBox:~$ ls
articulo.txt  Documentos  Imágenes  Plantillas  snap
Descargas     Escritorio  Música    Público     Vídeos
hmap@hmap-VirtualBox:~$ cat articulo.txt
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JPanel;

import java.util.ArrayList;
import java.util.Random;

public class Snake extends JFrame {

    public Snake() {
		setTitle("Snake");

		setSize(width,height);

		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JFrame.setDefaultLookAndFeelDecorated(false);
		setUndecorated(true);
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		this.setLocation(dim.width/2-this.getSize().width/2, dim.height/2-this.getSize().height/2);

        setVisible(true);

    }

	public static void main(String[] args) {
		Snake snake1 = new Snake();
	}
}


this.addKeyListener(new Teclas());
Point snake;

    public class ImagenSnake extends JPanel {
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(new Color(0,0,255));
            g.fillRect(snake.x,snake.y,widthPoint,heightPoint);
        }
    }
hmap@hmap-VirtualBox:~$ head -n 15 articulo.txt > mitad_superior.txt
hmap@hmap-VirtualBox:~$ ls
articulo.txt  Documentos  Imágenes            Música      Público  Vídeos
Descargas     Escritorio  mitad_superior.txt  Plantillas  snap
hmap@hmap-VirtualBox:~$ cat mitad_superior.txt
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JPanel;

import java.util.ArrayList;
import java.util.Random;

public class Snake extends JFrame {
hmap@hmap-VirtualBox:~$ tail -n 15 articulo.txt > mitad_inferior.txt
hmap@hmap-VirtualBox:~$ ls
articulo.txt  Escritorio          mitad_superior.txt  Público
Descargas     Imágenes            Música              snap
Documentos    mitad_inferior.txt  Plantillas          Vídeos
hmap@hmap-VirtualBox:~$ cat mitad_inferior.txt
		Snake snake1 = new Snake();
	}
}


this.addKeyListener(new Teclas());
Point snake;

    public class ImagenSnake extends JPanel {
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(new Color(0,0,255));
            g.fillRect(snake.x,snake.y,widthPoint,heightPoint);
        }
    }
hmap@hmap-VirtualBox:~$ date >> mitad_superior.txt
hmap@hmap-VirtualBox:~$ cat mitad_superior.txt
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JPanel;

import java.util.ArrayList;
import java.util.Random;

public class Snake extends JFrame {
sáb 09 ene 2021 08:22:03 -05


el primer archivo se le agregran 30 items
copiar los primeros 15 items en el segundo archivo
copiar los segundos 15 items en el tercer archivo
en el primer archivo agregar la fecha con el comando date
al final del los 30 items
jk007@LAPTOP-O6POPH28:~$ head -n 15 archivo.txt >> arch1al15.txt
jk007@LAPTOP-O6POPH28:~$ cat arch1al15.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
jk007@LAPTOP-O6POPH28:~$ tail -n 15 archivo.txt >> arch15al30.txt
jk007@LAPTOP-O6POPH28:~$ cat arch15al30.txt
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
jk007@LAPTOP-O6POPH28:~$ date
Wed Jan 6 20:57:15 CST 2021
jk007@LAPTOP-O6POPH28:~$ date >> archivo.txt
jk007@LAPTOP-O6POPH28:~$ archivo.txt
archivo.txt: command not found
jk007@LAPTOP-O6POPH28:~$ cat archivo.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Wed Jan 6 20:57:46 CST 2021
jk007@LAPTOP-O6POPH28:~$

Cree el archivo1 con un programa en python de 35 lineas y aplique los siguientes comandos:

Solución:

nano codigo.java
head -n 15 codigo.java > parte1.java
tail -n 15 codigo.java > parte2.java
date >> codigo.java

Los comandos que he utilizado para solucionar lo propuesto

vim codigo.sql
touch file1.sql && touch file2.sql
head -n 15 codigo.sql > file1.sql
tail -n 15 codigo.sql > file2.sql
date >> codigo.sql

Muy practicos estos comandos, buena actividad

Reto completado, lo hice con una archivo que tenia de prueba de 23 líneas de código

![](

`//Este código es para saber cuantas filas tiene mi archivo de texto "milenguaje.txt"
cat milenguaje.txt | wc -l

//Luego de saber que tiene 84 líneas, las 42 primeras pasaran al archivo "primeramitad.txt"
head -n 42 milenguaje.txt > primeramitad.txt

//Para concluir las 42 últimas pasaran al archivo "segundamitad.txt"
tail -n 42 milenguaje.txt > segundamitad.txt`

Espero les sirva.
Bendiciones.

# archivo 30 líneas
programacion.txt 

# archivo 1-15 líneas
head -n 15 programacion.txt > prog_1_15.txt

# archivo 15 - 30 líneas
tail -n 15 programacion.txt > prog_15_30.txt

#fecha y hora actual al final del archivo
date >> programación.txt

Práctica terminada:

adrs in ~/learning [I] ➜ cat my_file.txt
L 1
L 2
L 3
L 4
L 5
L 6
L 7
L 8
L 9
L 10
L 11
L 12
L 13
L 14
L 15
L 16
L 17
L 18
L 19
L 20
L 21
L 22
L 23
L 24
L 25
L 26
L 27
L 28
L 29
L 30
adrs in ~/learning [I] ➜ head -n 15 my_file.txt > group_1
adrs in ~/learning [I] ➜ cat group_1
L 1
L 2
L 3
L 4
L 5
L 6
L 7
L 8
L 9
L 10
L 11
L 12
L 13
L 14
L 15
adrs in ~/learning [I] ➜ tail -n 15 my_file.txt > group_2
adrs in ~/learning [I] ➜ cat group_2
L 16
L 17
L 18
L 19
L 20
L 21
L 22
L 23
L 24
L 25
L 26
L 27
L 28
L 29
L 30
adrs in ~/learning [I] ➜ date >> my_file.txt
adrs in ~/learning [I] ➜ cat my_file.txt
L 1
L 2
L 3
L 4
L 5
L 6
L 7
L 8
L 9
L 10
L 11
L 12
L 13
L 14
L 15
L 16
L 17
L 18
L 19
L 20
L 21
L 22
L 23
L 24
L 25
L 26
L 27
L 28
L 29
L 30
Sat Nov 28 00:28:41 -05 2020

Este es mi ejemplo, solo llene un archiovo con el resultado del contenido de un directorio

root@E1-CO-K003:/home/diego# ls -l /var/lib/ > File1.txt
root@E1-CO-K003:/home/diego# cat File1.txt | wc -l
35
root@E1-CO-K003:/home/diego# head -n 17 File1.txt > file2.txt && tail -n 18 File1.txt > file3.txt && date >> File1.txt
root@E1-CO-K003:/home/diego# cat file2.txt
total 0
drwxr-xr-x 1 root      root      512 Aug  4 16:40 AccountsService
drwxr-xr-x 1 root      root      512 Mar 12  2020 PackageKit
drwxr-xr-x 1 root      root      512 Dec  5 09:42 apt
drwxr-xr-x 1 root      root      512 Sep 21  2019 boltd
drwxr-xr-x 1 root      root      512 Dec  5 09:26 command-not-found
drwxr-xr-x 1 root      root      512 Dec  5 09:43 dbus
drwxr-xr-x 1 root      root      512 Apr 10  2020 dhcp
drwxr-xr-x 1 root      root      512 Dec  5 09:44 dpkg
drwxr-xr-x 1 root      root      512 Dec  5 09:33 emacsen-common
drwxr-xr-x 1 root      root      512 Aug  4 16:41 fwupd
drwxr-xr-x 1 root      root      512 Dec  5 09:34 ghostscript
drwxr-xr-x 1 root      root      512 Apr 20  2020 git
drwxr-xr-x 1 root      root      512 Aug  4 16:47 initramfs-tools
drwxr-xr-x 1 landscape landscape 512 Aug  4 16:42 landscape
drwxr-xr-x 1 root      root      512 Jan 21  2019 logrotate
drwxr-xr-x 1 root      root      512 Aug  4 16:41 man-db
root@E1-CO-K003:/home/diego# cat file3.txt
drwxr-xr-x 1 root      root      512 Apr 15  2020 misc
drwxr-xr-x 1 root      root      512 Dec  5 09:43 pam
drwxr-xr-x 1 root      root      512 Apr  1  2020 plymouth
drwx------ 1 root      root      512 Aug  4 16:39 polkit-1
drwx------ 1 root      root      512 Aug  4 16:39 private
drwxr-xr-x 1 root      root      512 Aug  4 16:39 python
drwxr-xr-x 1 root      root      512 Dec  5 09:43 snapd
drwxr-xr-x 1 root      root      512 Aug  4 16:39 sudo
drwxr-xr-x 1 root      root      512 Aug  4 16:47 systemd
drwxr-xr-x 1 tss       tss       512 Dec  3  2019 tpm
drwxr-xr-x 1 root      root      512 Mar 30  2020 ubuntu-advantage
drwxr-xr-x 1 root      root      512 Jul 20 19:23 ubuntu-release-upgrader
drwxr-xr-x 1 root      root      512 Dec  5 09:34 ucf
drwxr-xr-x 1 root      root      512 Apr 13  2020 unattended-upgrades
drwxr-xr-x 1 root      root      512 Jun  3  2020 update-manager
drwxr-xr-x 1 root      root      512 Dec  5 09:44 update-notifier
drwxr-xr-x 1 root      root      512 Aug  4 16:40 usbutils
drwxr-xr-x 1 root      root      512 Aug  4 16:39 vim
root@E1-CO-K003:/home/diego# tail -n 5 File1.txt
drwxr-xr-x 1 root      root      512 Jun  3  2020 update-manager
drwxr-xr-x 1 root      root      512 Dec  5 09:44 update-notifier
drwxr-xr-x 1 root      root      512 Aug  4 16:40 usbutils
drwxr-xr-x 1 root      root      512 Aug  4 16:39 vim
Sat Dec  5 10:16:49 -05 2020
root@E1-CO-K003:/home/diego# cat File1.txt | wc -l
36
root@E1-CO-K003:/home/diego#```

paso 1

touch archivo.py
vim archivo.py

paso 2

wc -l archivo.py

paso 3

head -n 15 archivo.py > primera_mitad.txt
tail -n 15 archivo.py > segunda_mitad.txt

paso 3

date >> archivo.py

Lo logre!!! 😃 ❤️



mdcravero@srv-icaro:~$ cat query.sql | wc -l
40
mdcravero@srv-icaro:~$ tail -20 query.sql > query1.sql
mdcravero@srv-icaro:~$ head -20 query.sql > query2.sql
mdcravero@srv-icaro:~$ date
Tue 03 Nov 2020 12:46:08 AM UTC
mdcravero@srv-icaro:~$ date >> query1.sql
mdcravero@srv-icaro:~$ cat query1.sql
-- asigno valor al campo fecha devolucion segun condiciones
  set @fec_dev = (select tipo = case tipo
                        when 'A' then convert(char(10),(getdate() + 1),103)
                        when 'B' then convert(char(10),(getdate() + 2),103)
                        when 'C' then convert(char(10),(getdate() + 3),103)
                   end
                from peliculas where codigo = @pelicula)
-- inserto un registro nuevo en la tabla alquileres
  insert into alquileres
        (fecha_hora, cliente, pelicula, fecha_devolucion, anulado_SN, devuelto_SN)
        values(getdate(), @cliente, @pelicula, @fec_dev, 'N', 'N')
-- valido si hay errores, si hay errores cancelo transaccion
  if @@error <> 0
    begin
      print 'Error al insertar registro...'
      rollback transaction
      return
    end
  commit transaction
end
Tue 03 Nov 2020 12:46:28 AM UTC
mdcravero@srv-icaro:~$

Completado!

touch main.cc
vim main.cc
head -n 15 main.cc > first_half.cc
tail -n 15 main.cc > second_half.cc
echo "// `date`" >> main.cc

¡Papitas!

date >> mitadPrimera.txt
head -n 29 comunicacionProcesos.txt > mitadPrimera.txt

cesar@LAPTOP-CESARRJ:~$ vim reto30.txt
cesar@LAPTOP-CESARRJ:~$ cat reto30.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
cesar@LAPTOP-CESARRJ:~$ touch reto301.txt reto302.txt
cesar@LAPTOP-CESARRJ:~$ ls
hola.txt prueba reto301.txt
nuevo.txt reto30.txt reto302.txt
cesar@LAPTOP-CESARRJ:~$ head -15 reto30.txt > reto301.txt
cesar@LAPTOP-CESARRJ:~$ tail -15 reto30.txt > reto302.txt
cesar@LAPTOP-CESARRJ:~$ vim reto302.txt
cesar@LAPTOP-CESARRJ:~$ vim reto301.txt
cesar@LAPTOP-CESARRJ:~$ date
Mon Oct 19 21:52:57 MST 2020
cesar@LAPTOP-CESARRJ:~$ date >> reto30.txt
cesar@LAPTOP-CESARRJ:~$ cat reto30.txt | wc -l
31
cesar@LAPTOP-CESARRJ:~$ cat reto301.txt | wc -l
15
cesar@LAPTOP-CESARRJ:~$ cat reto302.txt | wc -l
15

Increible ejercicio, me costo un poco terminarlo pero lo logre

head -n 15 dump1.sql > mitadSuperior.txt | tail -n 15 dump1.sql > mitadInferior.txt | date >> dump1.sql

esteban@esteban-VirtualBox:~/practica$ ls
lineas.txt p15.txt u15.txt
esteban@esteban-VirtualBox:~/practica$ head -n 15 lineas.txt > p15.txt
esteban@esteban-VirtualBox:~/practica$ tail -n 15 lineas.txt > u15.txt
esteban@esteban-VirtualBox:~/practica$ date >> u15.txt
esteban@esteban-VirtualBox:~/practica$ cat p15.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
esteban@esteban-VirtualBox:~/practica$ cat u15.txt
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
lun dic 16 13:29:11 -04 2019

Archivo de un reto del curso de C que estoy haciendo simultaneamente, he aprendido montones en ambos.

[herrboh@Neuron-V CLI_Platzi]$ touch head_content.txt tail_content.txt
[herrboh@Neuron-V CLI_Platzi]$ ls
challenge_str2.c  head_content.txt  ls_output.txt  poema.txt  tail_content.txt
[herrboh@Neuron-V CLI_Platzi]$ head -n 18 challenge_str2.c > head_content.txt 
[herrboh@Neuron-V CLI_Platzi]$ tail -n 17 challenge_str2.c > tail_content.txt 
[herrboh@Neuron-V CLI_Platzi]$ date >> tail_content.txt 
[herrboh@Neuron-V CLI_Platzi]$ cat head_content.txt 
#include <stdio.h>
#include <string.h>

void compareChars(int argcx, char * argvx[]){
	
	

	char longest_string[100];
	strcpy(longest_string,argvx[0]);
	

	for(int i = 0; i < argcx; i++)
	{
		if(strlen(longest_string) < strlen(argvx[i])){
			strcpy(longest_string, argvx[i]);
		}

	}
[herrboh@Neuron-V CLI_Platzi]$ cat tail_content.txt 

	printf("La cadena de chars mas larga es = %s\n", longest_string);

}


int main(int argc, char * argv[])
{
	
	
	compareChars(argc, &argv[0]);

	


	return 0;
}
Sun 15 Dec 2019 08:42:28 PM -05
MBP-de-Luis:Terminal luiscarlosruiz$ touch archivo.txt
MBP-de-Luis:Terminal luiscarlosruiz$ touch archivo1.txt
MBP-de-Luis:Terminal luiscarlosruiz$ touch archivo2.txt
MBP-de-Luis:Terminal luiscarlosruiz$ head -n 15 archivo.txt > archivo1.txt
MBP-de-Luis:Terminal luiscarlosruiz$ tail -n 15 archivo.txt > archivo2.txt
MBP-de-Luis:Terminal luiscarlosruiz$ date >> archivo1.txt
MBP-de-Luis:Terminal luiscarlosruiz$ cat archivo1.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Wed Feb 26 21:57:17 -05 2020
MBP-de-Luis:Terminal luiscarlosruiz$ ```

Después de hacer esta práctica me sentí con super poderes jajaja

Cree un archivo test1.txt con touch lo edite en nano para agregarle 30 palabras que sirvieran de contenido.
Posteriormente cree dos archivos mas test2.txt y test3.txt con touch nuevamente y les anexe el contenido de test1.txt redireccionando head -n 15 test1.txt > test2.txt y tail -n 15 text1.txt > test3.txt. Por ultimo el date lo agregue con la utilidad de añadir un resultado a un archivo ya creado date >> test1.txt

Perfectamente completado el reto
Last login: Fri Apr 10 02:28:00 on ttys001
MacBook-de-Rosa:~ Rosa$ touch linea30p.txt
MacBook-de-Rosa:~ Rosa$ vim linea30p.txt
MacBook-de-Rosa:~ Rosa$ head -n 15 linea30p.txt
Hagamos un trato

Compañera
usted sabe
puede contar
conmigo
no hasta dos
o hasta diez
sino contar
conmigo

si alguna vez
advierte
que la miro a los ojos
y una veta de amor
MacBook-de-Rosa:~ Rosa$ touch inicio.txt
MacBook-de-Rosa:~ Rosa$ head -n 15 linea30p.txt > inicio.txt
MacBook-de-Rosa:~ Rosa$ touch final.txt
MacBook-de-Rosa:~ Rosa$ tail -n 15 linea30p.txt > final.txt
MacBook-de-Rosa:~ Rosa$ date >> linea30p.txt
MacBook-de-Rosa:~ Rosa$ ls
Applications MacKeeper Backups Ross-Palaci linea30p.txt
Creative Cloud Files Movies Rv431! Pb nuevo.txt
Desktop Music Rv431! Pb.pub practica.txt
Documents Pictures T6400160C1820C1820
Downloads Public final.txt
Library Rosa-Palaci inicio.txt
MacBook-de-Rosa:~ Rosa$ cat linea30p.txt
Hagamos un trato

Compañera
usted sabe
puede contar
conmigo
no hasta dos
o hasta diez
sino contar
conmigo

si alguna vez
advierte
que la miro a los ojos
y una veta de amor
reconoce en los míos
no alerte sus fusiles
ni piense qué delirio
a pesar de la veta
o tal vez porque existe
usted puede contar
conmigo

si otras veces
me encuentra
huraño sin motivo
no piense qué flojera
igual puede contar
conmigo

pero hagamos un trato
yo quisiera contar
con usted

es tan lindo
saber que usted existe
uno se siente vivo
y cuando digo esto
quiero decir contar
aunque sea hasta dos
aunque sea hasta cinco
no ya para que acuda
presurosa en mi auxilio
sino para saber
a ciencia cierta
que usted sabe que puede
contar conmigo.
Fri Apr 10 14:19:20 CDT 2020
MacBook-de-Rosa:~ Rosa$ cat inicio.txt
Hagamos un trato

Compañera
usted sabe
puede contar
conmigo
no hasta dos
o hasta diez
sino contar
conmigo

si alguna vez
advierte
que la miro a los ojos
y una veta de amor
MacBook-de-Rosa:~ Rosa$ cat final.txt
con usted

es tan lindo
saber que usted existe
uno se siente vivo
y cuando digo esto
quiero decir contar
aunque sea hasta dos
aunque sea hasta cinco
no ya para que acuda
presurosa en mi auxilio
sino para saber
a ciencia cierta
que usted sabe que puede
contar conmigo.
MacBook-de-Rosa:~ Rosa$ date
Fri Apr 10 14:21:07 CDT 2020
MacBook-de-Rosa:~ Rosa$

Hola tú! Sí! Te hablo a ti larva que igual estás empezando y que todavía te revuelves con algunas cosas de terminal.
¿No sabes dónde copiar y pegar tu archivo?
En el buscador de archivos, busca en “Este Equipo” el archivo que creaste con la terminal en la clase pasada. Esa ruta guardala en tu corazón o en una nota que no vayas a perder.
¿Tienes problemas para leer tu archivo con el visor la aplicación?
Tampoco supe como liberar el permiso, pero usando la clase pasada cree un archivo .txt y usando la ruta de lo que te acabo de comentar, copie ahí el archivo que acaban de comentar. Así pude trabajar con los archivos
¿Aún tienes miedo con la terminal?
Usa los comandos de la clase pasada:

  • ls para saber que carpetas tienes
    pwd para saber dónde estás
    cd para moverte en las carpetas (ve una por una, a tu ritmo, sin prisas).
    cat para que muestre todo el contenido
    nano para editar (fue el que más me gustó)

Espero les haya servido.

Se va volando como larva man

touch texto.txt
touch superior.txt
touch inferioir.txt
nano texto.txt
head -n 15 texto > superior.txt
tail -n 15 texto > inferior.txt
date >> texto.txt

Hola comunidad, comparto mi aporte

Con este script en .sh creé el archivo con 30 lineas:

#!/bin/bash
i=1
until [ $i -gt 30 ]
do
echo Linea $i
((i=i+1))
done

Luego de enviar el output a el archivo30.txt, con los siguientes comandos creé los otros archivos:

head -n 15 archivo30.txt > Mitad1.txt | tail -n 15 archivo30.txt > Mitad2.txt

Termino agregandole la fecha al final del archivo:

tail -n 15 archivo30.txt

Directorio y archivo

Observando la información del número de líneas del archivo

Separando el documento original en 2 archivos

Leyendo ambos archivos generados y creando un nuevo archivo con la información de ambas partes

Agregando la fecha al archivo creado

Resultado

Demoré cierto tiempo pero lo logré jaja, vamos aprendiendo más sobre la terminal y aprendiendo a usarla. Ánimo!!!

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ ls
original.css

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ head -n 15 original.css >> firstFile.css

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ tail -n 15 original.css >> secondFile.css

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ ls
firstFile.css  original.css  secondFile.css

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ date
ma., 31 de mar. de 2020 13:16:53

Ema Cast@emacastillozam MINGW64 ~/Desktop/platzi/11.Curo-de-Introduction-a-la-terminal-y-linea-de-comandos/desafio
$ date >> original.css
  1. con un archivo data.txt (datos generados desde mockaroo que no ayuda a generar datos de prueba para hacer pruebas)
  2. nos ubicamos en la carpeta donde esta el archivo (con cd /ubicación)
  3. trabajamos con el comando head que nos ayuda a imprimir desde la línea 1 hasta la línea deseada que es enviada como modificador en este caso 15 head -15 data.txt > inicio.txt
  4. trabajamos con el comando tail que nos ayuda a imprimir desde la última línea hasta la línea deseada que es enviada como modificador en este caso 15 tail-15 data.txt > inicio.txt
  5. imprimimos la fecha con el comando date y lo insertamos en el archivo original es decir en data.txt date >> date.txt

Demore pero lo consegui:

francisco86@SSPC:~$ touch practica.txt
francisco86@SSPC:~$ for contador in {1..30}
> do
> echo "Linea numero $contador" >> practica.txt
> contador=contador+1
> done
francisco86@SSPC:~$ touch parte1.txt
francisco86@SSPC:~$ head -n 15 practica.txt > parte1.txt
francisco86@SSPC:~$ cat parte1.txt
francisco86@SSPC:~$ touch parte2.txt
francisco86@SSPC:~$ tail -n 15 practica.txt > parte2.txt
francisco86@SSPC:~$ cat parte2.txt
francisco86@SSPC:~$ date >> practica.txt

Reto completo.
Aqui les dejo que comandos use para esta práctica.
touch practica_para_terminal.py
"Cree un archivo para python"
vim practica_para_terminal.py
"Realize el codigo dentro del archivo con el editor vim"
python practica_para_terminal.py
"Corri el programa y verificar de no tener errores"
touch parte_1.txt parte_2.txt
"Cree 2 archivos en .txt para realizar el trabajo"
cat practica_para_terminal.py | wc -l
"Este código me ayudo a saber cuantas lineas tenia mi programa me dio 41"
head -n 20 practica_para_terminal.py >> parte_1.txt
"Aqui copie las primeras 20 lineas a la parte_1"
Tail -n 21 practica_para_terminal.py >> parte_2.txt
"Bueno aqui se fueron las otras 21"
date >>parte_1.txt
"Por último añadi el date a la parte uno y finalice el rero"
Animo tu tambien puedes.
Nunca pares de aprender!!!

Siguiendo los comentarios de otros compañeros pude crear todo en una sola línea.
Para ejecutar los comando en cadena usar el operador lógico && mayor referencia en el link: https://blog.carreralinux.com.ar/2018/09/ejecucion-encadenada-de-comandos-con-bash/
![](

Reto cumplido:

aurelio@lubuntu-pc:~$ cat hola.txt | wc -l
332
aurelio@lubuntu-pc:~$ touch hola1.txt
aurelio@lubuntu-pc:~$ touch hola2.txt
aurelio@lubuntu-pc:~$ head -166 hola.txt > hola1.txt
aurelio@lubuntu-pc:~$ tail -166 hola.txt > hola2.txt
aurelio@lubuntu-pc:~$ cat hola1.txt | wc -l
166
aurelio@lubuntu-pc:~$ cat hola2.txt | wc -l
166
aurelio@lubuntu-pc:~$ date >> hola.txt 

Comprobar el contenido del archivo con el que se va a trabajar:

cat _nombre_tu_archivo_

Contar la cantidad de lineas que tiene tu archivo:

wc _nombre_tu_archivo_

Pasar la mitad superior a un archivo (puede no existir el archivo, lo va a crear), recuerda que el símbolo de > (mayor que) sirve para indicar donde guardar el contenido, en este caso tu archivo:

head -n _cantidad_lineas_mitad_total_ > _nombre_archivo_donde_guardar_mitad_superior_

Comprobar el contenido del archivo con la mitad superior:

cat _nombre_archivo_donde_guardar_mitad_superior_

Pasar la mitad inferior a un archivo (puede no existir el archivo, lo va a crear)

tail -n _cantidad_lineas_mitad_total_ > _nombre_archivo_donde_guardar_mitad_inferior_

Comprobar el contenido del archivo con la mitad inferior:

cat _nombre_archivo_donde_guardar_mitad_inferior_

Agregar la fecha actual al archivo con la mitad superior, recuerda que dos símbolos juntos >> (mayor que), agregan la salida al final del archivo indicado:

date >> _nombre_archivo_donde_guardar_mitad_superior_

Comprobar que se haya agregado la fecha al contenido del archivo con la mitad superior:

cat _nombre_archivo_donde_guardar_mitad_superior_

usrl@svlus64:~/terminal$ wc -l index.html
63 index.html
usrl@svlus64:~/terminal$ head -n 31 index.html > head.txt
usrl@svlus64:~/terminal$ tail -n 32 index.html > tail.txt
usrl@svlus64:~/terminal$ wc -l index.html head.txt tail.txt
63 index.html
31 head.txt
32 tail.txt
126 total
usrl@svlus64:~/terminal$ date >> index.html
usrl@svlus64:~/terminal$ wc -l index.html
64 index.html
usrl@svlus64:~/terminal$ tail -n 2 index.html
</html>
Tue Jun 2 18:22:07 CDT 2020
usrl@svlus64:~/terminal$

Dato curioso:
Si usamos el comando _cat _de la siguiente manera "cat > archivo.txt" , se abrirá un espacio en blanco para editarlo. Terminamos de editar con ctrl + C (o ctrl + D). Así, creamos un archivo nuevo con el comando.

Realizado! 😄
Pero me surgió una duda ¿Se puede obtener la fecha de creación/modificación de un archivo mediante la terminal? 🤔

Fascinante desafio

Quiero contarles lo que me ocurrio con NANO.

Mi listado tenia 35 lineas como tenia un titulo y un par de espacios, entonces supuse que esas lineas contarían. al poner las cantidades en head y tail en head si ponía el limite pero en tail ya que del numero (x) se saltaba a otra linea no. Después de varios intentos me di cuenta que en tail me contaba a partir del espacio, Elimine los espacios y tire el head y tail y en el tail me repetía lineas del head. Lo que llegué a la conclusión (tal vez lo mencionó el profesor y no escuche) de que ya que nos piden una fecha en el primer archivo, las cantidades deben ser igual (head y tail) por esa razón ya que si deduces que tail se cuenta a partir de 16 en adelante, se te repite la linea 15 de head en este caso. Debo seguir investigando o si alguien sabe el porque de una manera mas sencilla por favor explicar, pero esta es mi opinion debe ser partes iguales porque la fecha hace parte de las primeras 15 lineas aunque no se vean la cuenta.

Entonces parece que head tiene 16 lineas ( me refiero al texto que debe tener la fecha) pero solo cuenta 15 y lo mismo con tail solo que en este caso no tendria fecha tiene sus 15 lineas.

SI ALGUIEN TIENE UNA RESPUESTA MEJOR o que tenga mas logica compartela porfa

este fue el proceso

kevin@DESKTOP-S9R3J0P:~$ nano movies.txt
kevin@DESKTOP-S9R3J0P:~$ head -n 20 movies.txt > PELIS1.txt
kevin@DESKTOP-S9R3J0P:~$ tail -n 20 movies.txt > PELIS2.txt
kevin@DESKTOP-S9R3J0P:~$ date >> PELIS1.txt
kevin@DESKTOP-S9R3J0P:~$ cat PELIS1.txt
1.CAPTAIN AMERICA THE FIRST AVENGER
2.CAPTAIN MARVEL
3.IRON-MAN
4.IRON-MAN 2
5.THE INCREDIBLE HULK
6.THOR
7.THE AVENGERS
8.IRON-MAN 3
9.THOR DARK WORLD
10.CAPTAIN AMERICA WINTEWR SOLDIER
11.GUARDIANS OF THE GALAXY
12.GUARDIANS OF THE GALAXY VOL 2
13.THE AVENGERS AGE UF ULTRON
14.ANT-MAN
15.CAPTAIN AMERICA CIVIL WAR
16.SPIDER-MAN HOMECOMING
17.DOCTOR STRANGE
18.BLACK PANTHER
19.THOR RAGNAROK
20.THE AVENGERS INFINITY WAR
Wed Jun 10 12:00:45 -05 2020
kevin@DESKTOP-S9R3J0P:~$ cat PELIS2.txt
21.ANT-MAN AND THE WASP
22.THE AVENGERS ENDGAME
23. SPIDER-MAN FAR FROM HOME
24.BLACK WIDOW
25.THE ETERNALS
26.SHANG CHI AND THE LEGEND OF THE TEN RINGS
27.SPIDER-MAN ¿SPIDERVERSE?
28.THOR LOVE AND THUNDER
29.DOCTOR STRANGE IN THE MULTIVERSE OF MADNESS
30.BLACK PANTHER 2
31.CAPTAIN MARVEL 2
32.ANT-MAN 3 ???
33.BLADE
34.GUARDIANS OF THE GALAXY VOL 3
35.FANTASTIC FOUR

Un consejo para todos, no hace falta crear un archivo con el comando touch para luego agregarle la información. Si vas a agregar datos en un nuevo archivo con el modificador “>”, solo basta realizar esto:
date > nuevo_archivo.txt
No hace falta primero crear el archivo con touch y luego agregar la información…
OJO:
Al usar “>” si el archivo existe reemplaza la información, sino existe el archivo se crea y se agrega la información.
Al usar “>>” si el archivo existe se agrega la información al final del archivo, sino existe el archivo se crear y se agrega la información.