Úvod Do Unixu — Petr Baudiš

http://pasky.or.cz/~pasky/vyuka/2007-SWI095/

Projekty

Cvičení 25. 2. 15:40

#1 vypsat soubor s ocislovanymi radky odzadu
cat -n $1|tac
#2 vypsat soubor zrcadlove (posledni znak bude prvni)
tac $1|rev
#3 vypsat predposledni radek souboru
tail -n2 $1|head -n1
#4 vypsat Ahoj pozpatku
echo Ahoj|rev
#4 Alternativni reseni
echo johA
#5 Zkopirovat soubor ze vzdaleneho stroje
ssh kraut6am@u-pl15.ms.mff.cuni.cz cat /tmp/$1 > $1
#6 Vypsat datum ve formatu YYYY-MM-DD
date +%Y-%m-%d
#6 Alternativni reseni
date +%F
#7 Zkopirovat soubor na vzdaleny stroj
cat $1|ssh kraut6am@u-pl15.ms.mff.cuni.cz "cat > /tmp/$1"

Úkol – favg

řešení s cyklem

#!/bin/sh

ls | (while read line; do
x=`ls $line | wc -l`;
pocet=`expr $pocet + 1`;
soucet=`expr $soucet + $x`;
done; 
echo `expr $soucet / $pocet` > ~/avg/`printf %05d $(( $(ls ~/avg/ | sort | tail -n1) + 1 )) )`;

Nebo takhle (pokud neumíte funkce, použijte místo toho wc, princip ale zůstává, jen se pak soubor s mezerou v názvu počítá jako dva, stejně jako v tom skriptu výše):

#! /bin/sh

count(){ return $#; }

count * ;       d=$?
count */* ;     f=$?
count ~/avg/* ; n=$(($?+1))

echo $(($f/$d)) > ~/avg/$( printf %05s $n )

— Adam

Jenom připojuju tu variantu s wc a bez obtíží se souborama s mezerou. MZ.

echo $(( $(ls -d ./*/* | wc -l) / $(ls -d ./*/ | wc -l) )) >~/avg/$(printf "%0.5d" $(ls ~/avg | wc -l))

Úkol – smsl

#!/bin/sh

cislo=$(($RANDOM % `wc -l < sms.txt`+1));
smska=`cat sms.txt | head -n $cislo | tail -n 1`;
echo $smska | mail váš@mail -s sms;
echo $(date) $smska >> ~/sms_log/`date +%Y-%m`;
cat sms.txt | sed "$cislo"d > sms.new;
mv sms.new sms.txt;
echo $smska;

Úkol – last

(doufam ze je to dobre)

last | cut -d" "  -f1 | cat -n | sort -uk2 | sort -n | cut -f2 | head -n 10

Cvičení 16. 4. 15:40

1. nahradit // komentare za /* */
sed 's>//(.*)$>/*\1*/>'

2. naimplementujte grep
#!/bin/sh
re=$1;
shift;
sed -n "/$re/p" "$@2"

3. sed: vypiste hlavicku emailu (bez From)
sed '/^$/,$d;1d'
sed -n '2,/^$/p'

4. sed: vypiste tělo mailu
sed '1,/^$/d'

5. naimplementujte seq s 1 param.
#!/bin/sh
i=1;
while [ $i -lt $1 ]
do
 printf %d $i;
 i=`expr $i + 1`;
done

Cvičení 23. 4. 15:40

1. hadani cisel, interaktivni
#!/bin/sh
cislo=$(( $RANDOM % 100 ));
while read vstup; do
        if [ $cislo -lt $vstup ]; then
                echo "mensi"
        elif [ $cislo -gt $vstup ]; then
                echo "vetsi"
        else
                echo "spravne";
                exit
        fi
done;

2. nacti ze souboru "seznam" seznam souboru, podle poradi v nem je ocisluj
#!/bin/sh
i=1;
cat seznam | while read vstup; do
        mv $vstup `printf "%02d-%s" $i $vstup`;
        i=`expr $i + 1`;
done;

3. script bezi na roota s -v, jako uzivatel smazte cely disk
#!/bin/sh
if [ "$1" = "-v" ]; then
        verbose=" "
else
        verbose=">/dev/null"
fi
shift
ps axu | while read user pid x x x x x x x x cmd; do
        eval echo "Vidim proces $pid uzivatele $user: $cmd" $verbose;
        #tady neco zajimavyho
done

napriklad pomoci cyklem poustenym: touch '; rm -rf /'

4. zkonvertujte vsechny jpg na png v akt. adresari
#!/bin/sh
ls | while read line; do
        case $line in
        *.jpg)
                convert $line `echo $line | sed "s/.jpg\$/.png/"`;;
        esac
done;

Cvičení 30. 4. 15:40

1. vypiste kazdy radek v souboru 2x za sebou
sed "p" /etc/passwd

2. pri kazdem stisku Ctrl+C napiste pocet stisku a po 5ti umrete
#!/bin/sh
i=0;
trap 'i=`expr $i + 1`;echo $i' SIGINT;

while [ $i -lt 5 ];
do
 sleep 10;
done;
trap - SIGINT;

3. zkopirujte kompletni adresar na jiny stroj
tar cp . | ssh u-pl27 tar xp

4. skript na udrzeni ssh spojeni
ssh u-pl27 "printf spinkam; while true; do printf "."; sleep 10; done"

Cvičení 14.5. 17:20

Dali sme si cvičnou písemku. Zadání:

Titulky
=======

Napiste skript, ktery bude vykonavat nektere zakladni operace, ktere
clovek obcas potrebuje provadet s titulky k filmum/serialum. Vstupni
format predpokladejte oblibeny .sub, tedy - soubor ma na kazdem radku
jeden titulek ve formatu:

{f1}{f2}Text.

Kde f1 je cislo, ktere urcuje pocatecni snimek, od ktereho je titulek
zobrazen, a f2 je koncovy snimek, na kterem je titulek zrusen. Nemelo by
dochazet k prekryvani, radky jsou razeny sekvencne. Ukazkovy soubor
pro testy naleznete na http://www.bofh.cz/links/2x22.sub

Skript bere data ze standardniho vstupu a vraci vysledek na standardni
vystup. Skript musi podporovat nasledujici parametry:

-s <n>		Posun titulku dopredu nebo dozadu o n ramcu. Pokud se
      		zacatek i konec nejakeho radku posunou do zapornych
      		hodnot, zruste danou radku. Pokud se zacatek dostane
      		do zapornych hodnot a konec je v kladnych, zacatek
      		nastavte na 0.

-f <fps1> <fps2>
		Zmena poctu ramcu za sekundu z fps1 na fps2. Videa z
		ruznych zdroju maji casto ruzny pocet ramcu za sekundu, 
      		prestoze se jedna o jeden a tentyz film. Pocitejte i s
      		tim, ze velmi casto pouzivane fps maji i tri desetinna
      		mista (pokud chcete, muzete predpokladat, ze na tri
		desetinna mista bude zadano fps vzdy). Zaokrouhlujte az
		jednotlive hodnoty ramcu, zaokrouhlit fps 23.976 na 24
		nebo dokonce na 23 vyusti na konci filmu jiz v prilis
		velkou chybu.

-c <n>		Orez - oriznout za ntym ramcem.

-t		Kontrola spravnosti - cisla ramcu jsou nezaporna,
      		titulky jdou v souboru tak, jak jdou za sebou ve
      		filmu, neprekryvaji se. Nic nevypisuje, pouze
      		vraci navratovou hodnotu (shellovy prikaz exit).

Parametr -t lze pouzivat pouze samostatne. Parametry -s, -f a -c by
melo jit libovolne kombinovat v ramci jednoho spusteni.

submod -s -5000 -f 23.976 25.000 -c 50 < subtitles.sub > subtitles2.sub 
submod -f 23.976 25.000 -s -5000 -c 50 < subtitles.sub > subtitles2.sub

Pozor na poradi - tato dve spusteni delaji neco jineho, poradi provadeni je
od prvniho parametru dale.

jedna z možností implementace (by [exa])

#!/bin/bash

# we consider the process to be a linear operation (only multiplying and adding), so
# we can "accumulate" all the needed moves&scales from the command line 
# in 2 vars (which saves time, hell yeah.)

MOVE=0
SCALE=1  #don't scale nor move by default

CUT='no'
CUT_FRAME=0

DO_CHECK='no'

#TODO. It would be much better if someone checked whether
#supplied values really are numbers.
                                
function add_scale ()           
{                               
        #we don't have any better calculator than awk
        SCALE=`awk "BEGIN { print $2*$SCALE/$1 }" `
        MOVE=`awk "BEGIN { print $1*$MOVE/$2 }" `
}                               
                                
function add_move ()            
{                               
        MOVE=$(( $MOVE + $1 ))  
}                               
                                
function set_cut ()             
{                               
        CUT='y'                 
        CUT_FRAME=$1            
}                               
                                
function enable_sanity_check () 
{                               
        DO_CHECK='y'            
}                               
                                
function do_filter()            
{                               
        if [ $CUT != "y" ] ; then 
                sed -e 's/\t/ /g' |
                sed -ne 's/^{\([0-9]*\)}{\([0-9]*\)}\(.*\)$/\1\t\2\t\3/p' |
                awk -F\\t "{ printf \"{%0.0f}{%0.0f}%s\n\", \
                        \$1*${SCALE}+${MOVE}, \
                        \$2*${SCALE}+${MOVE}, \$3 }"
        else                    
                sed -e 's/\t/ /g' |
                sed -ne 's/^{\([0-9]*\)}{\([0-9]*\)}\(.*\)$/\1\t\2\t\3/p' |
                awk -F\\t "{ printf \"%0.0f\t%0.0f\t%s\n\", \
                        \$1*${SCALE}+${MOVE}, \
                        \$2*${SCALE}+${MOVE}, \$3 }" |
                while read line ; do
                        [ "`echo -e "$line" |cut -f1 `" -le $CUT_FRAME ] ||exit
                                echo "$line"
                done |          
                sed -ne 's/^\([0-9]*\)\t\([0-9]*\)\t\(.*\)$/{\1}{\2}\3/p'
        fi                      
}                               
                                
function do_check()             
{                               
        local frame=0           
        
        sed -ne 's/^{\([0-9]*\)}{\([0-9]*\)}.*$/\1\n\2/p' |
        while read line ; do
                [ $line -lt $frame ] && exit 1
                frame=$line
        done
        exit $?
}

while [ "$1" ] ; do 
        case "$1" in
                "-s") add_move "$2" ; shift ;;
                "-f") add_scale "$2" "$3" ; shift ; shift ;;
                "-c") set_cut "$2" ; shift ;;
                "-t") enable_sanity_check ;;
                *) echo "submod: not handling unrecognized arg '$1'" >&2
        esac
        shift
done


if [ $DO_CHECK == "y" ] 
then 
        do_check
        exit $?
else do_filter
fi

Pasky mi jen nenápadně vyčetl, že 'function' a 'local' jsou bash-extensiony, takže ve zkoušce to asi nebude žádoucí :)

local bohužel ve všech shellech není a, kde je, nechová se stejně, viz /Unixový Shell, nicméně slovo function prostě stačí vynechat, a je to. — Adam

Matfiz : ÚvodDoUnixu/Baudiš