#!/usr/bin/sed -f
# Загрузка 80и пробелов в буфер2
1 {
	x
	s/^$/          /
	s/^.*$/&&&&&&&&/
	x
}

# удаление табуляции, начальных и конечных пробелов
y/tab/ /
s/^ *//
s/ *$//

# добавление 80 пробелов в конец строки
G

# извлечение первых 81го символа (80 + a '\n')
s/^\(.\{81\}\).*$/\1/

# Теперь в буфере у нас m символов, затем \n, а потом 80-m пробелов
# и мы ищем совпадение пробелов с пробелами (после \n)
# т.к. * у нас жадная, то она захватывает максимальное число пробелов,
# т.е. ровно половину(если 80-m чётное, иначе захватывается (80-m-1)/2
# пробелов).
# вот эти 	(80-m)/2 пробелов мы переносим в начало строки.
s/^\(.*\)\n\(.*\)\2/\2\1/

#!/usr/bin/sed -rf
/[^0-9]/ d
# Заменяем последние девятки на '_' (подойдёт любой другой символ,
# кроме цифр).
# {drBatty} пришлось делать циклом - если использовать s///g,
# то поменяется все девятки, а надо только последние, их можно найти
# s/9+$/но, на что менять?/
:d
	s/9(_*)$/_\1/
td
# тут увеличивается только последняя цифра. (не считая оконечных девяток)
# если строка пустая, или в ней только ____ тогда она меняется на "1____"
# остальные цифры просто увеличиваются на 1, и хвост из "_" сохраняется.
#
# tn команды не обязательны, но мы думаем, что так будет быстрее.
# {drBatty} щаз! В первой строке обязательно tn надо - а то получится
# 9 + 1 = 20 :)
s/^(_*)$/1\1/; tn
s/8(_*)$/9\1/; tn
s/7(_*)$/8\1/; tn
s/6(_*)$/7\1/; tn
s/5(_*)$/6\1/; tn
s/4(_*)$/5\1/; tn
s/3(_*)$/4\1/; tn
s/2(_*)$/3\1/; tn
s/1(_*)$/2\1/; tn
s/0(_*)$/1\1/; tn
# 99999 -> _____ -> 00000
:n
y/_/0/

#! /bin/sh
# rename files to lower/upper case...
#
# usage:
#    move-to-lower *
#    move-to-upper *
# or
#    move-to-lower -R .
#    move-to-upper -R .
#

help()
{
	cat << eof
	Usage: $0 [-n] [-r] [-h] files...
	-n      do nothing, only see what would be done
	-R      recursive (use find)
	-h      this message
	files   files to remap to lower case

	Examples:
	$0 -n *        (see if everything is ok, then...)
	$0 *

	$0 -R .

	eof
}


apply_cmd='sh'
finder='echo "$|" tr " " "\n"'
files_only=

while :
do
	case "$1" in
		-n) apply_cmd='cat' ;;
		-R) finder='find "$-"type f';;
		-h) help ; exit 1 ;;
		*) break ;;
	esac
	shift
done

if [ -z "$1" ]; then
	echo Usage: $0 [-h] [-n] [-r] files...
	exit 1
fi

LOWER='abcdefghijklmnopqrstuvwxyz'
UPPER='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

case `basename $0` in
	*upper*) TO=$UPPER; FROM=$LOWER ;;
	*)       FROM=$UPPER; TO=$LOWER ;;
esac

eval $finder | sed -n '

# удаляем все слеши в конце имени
s/\/*$//

# добавляем ./ если нет пути, а есть только имя.
/\//! s/^/.\//

# сохраняем путь + имя
h

# удаляем путь
s/.*\///

# преобразование имени
# тут скрипт прерывается, между кавычками не скрипт,
# а шелл, там можно переменные писать.
y/'$FROM'/'$TO'/

# после команды x буфер будет содержать путь + имя,
# а буфер2 будет содержать новое имя.
x

# добавим новое имя к пути + имя.
G

# проверяем: если новое имя такое-же как старое - ничего не делаем
# (скрипт завершается)
/^.*\/\(.*\)\n\1/b

# теперь, трансформируем
# путь/старое_имя\nновое_имя в
# mv путь/старое_имя путь/новое_имя
# и распечатываем
s/^\(.*\/\)\(.*\)\n\(.*\)$/mv \1\2 \1\3/p

' | $apply_cmd

# ппц. с sed-то мне понятно, но зачем такой скрипт накрутили...

#!/bin/bash
# rename files to lower/upper case...
#
# usage:
#    move-to-lower *
#    move-to-upper *
# or
#    move-to-lower -R .
#    move-to-upper -R .
#

help()
{
	cat << eof
	Использование: $0 [-n] [-r] [-h] files...

	-n      Ничего не делает, только показывает, что будет делать.
	-R      Рекурсивный обход каталогов (переименовывает только файлы)
	-h      Это сообщение.
	files   Файлы подлежащие переименованию.

	Примеры:
	$0 -n *        (попробуйте сначала так, если понравится...)
	$0 *

	$0 -R .

	eof
}

finder=""
modif="ep"

while :
do
	case "$1" in
		-n) modif="p" ;;
		-R) finder="find" ;;
		-h) help ; exit 1 ;;
		*) break ;;
	esac
	shift
done

if [ -z "$1" ]; then
	echo "Использование: $0 [-h] [-n] [-r] files..."
	exit 1
fi

case `basename $0` in
	*upper*)	prefix="\\U" ;;
	*)			prefix="\\L" ;;
esac

# поиск файлов
if [ -z "$finder" ]; then
	finder=`echo "$@" | sed -r 's/\s+/\n/g'`
else
	finder=`$finder $@ -type f`
fi

echo "$finder" | sed -rn '
# удаление слешей в конце строки.
s!/+$!!

# если нет слешей, то в начеле приписываем "./"
/\//! s!^!./!

# вот и всё:
# достаточно отделить имя от пути.
# имя это \2, а путь \1
# переносим этот файл, перед новым именем
# ставим префикс
s!^(.*)(/[^/]+)$!\1\2\n\1'$prefix'\2!

# не, ещё проверить надо
/^(.*)\n\1$/ ! s/^(.*)\n(.*)/mv -v \1 \2/'$modif'
'

#!/bin/sh

set | sed -n '
:x

# Если не совпадает с "=()", печать, и загрузка след. строки
/=()/! { p; b; }
/ () $/! { p; b; }

# начинается секция с функцией
# сохраняем строку с заголовком в буфере2
h

# если след. строка начинается на {, то выходим - дальше ничего
# интересного нет.
n
/^{/ q

# вывод прошлой строки
x; p

# переход на обработку текущей.
x; bx
'

#!/usr/bin/sed -rf

# если в строку нет 2х символов (иначе, длинна строки меньше двух),
# то ничего не делаем
/../! b

# Реверс строки

# сначала в начало и в конец строки добавляются символы \n.
s/^.*$/\
&\
/

# Обмен первого и последнего символа местами, символы меняются
# вместе с маркёрами \n, причём относительный порядок символа и маркёра
# не меняется. Поэтому маркёры оказываются "внутри" - например:
# \n F .* E \n --- до замены
# E \n .* \n F --- после
# Цикл продолжается пока внутри не останется 1 или 0 символов.
tx
:x
s/(\n.)(.*)(.\n)/\3\2\1/
tx

# Удаление маркёров.
s/\n//g

#!/usr/bin/sed -nf

# обращение строк входного файла, т.е. первая строка становится последний и т.д..

# примечание: тут *весь* файл гоняется из области удержания и обратно для каждой строки,
# например если у нас 100,000 строк по 80 байт, нам надо перенести 8,000,000 из памяти в память
# :-( это конечно очень медленно, и может привести к переполнению памяти для некоторых
# реализаций sed...


# начиная со второй строки, мы *добавляем* область удержания к буферу
# (область удержания содержит сейчас все строки, кроме текущей в обратном порядке)
1! G

# если строка последняя, то мы распечатываем все строки
$ p

# сохранение области удержания
h

#! /bin/sh
sed -e "=" $@ | sed -e '
s/^/      /
N
s/^ *\(......\)\n/\1  /
'

#!/usr/bin/sed -nrf

# Извлекаем номер строки, если он равен "" (пустая строка),
# то устанавливаем его в 1 (такое бывает для первой строки).
x
/^$/ s/^.*$/1/

# Добавляем номер строки в её начало
G
h

# Форматирование и печать
s/^/      /
s/^ *(......)\n/\1  /p

# Извлекаем номер строки из области удержания,
g
s/\n.*$//

# Если номер начинается с девятки, добавляем перед ней ноль.
/^9*$/ s/^/0/

# тут я даже и не знаю как объяснить: короче, перед последней цифрой и (возможно)
# девятками после неё добавляем букву х, например для 123545 получится 1234х5,
# а для 12999 получится 1х2999, т.е. буква х - граница изменения, будем менять то,
# что *после* неё.
s/.9*$/x&/

# сохраняем число
h
# вырезаем ту часть, которая не поменяется
s/^.*x//
# в изменяемой части меняем 0 на 1, 1 на 2, и т.д...
y/0123456789/1234567890/
# теперь опять берём всё число
x
# однако теперь берём неизменную часть
s/x.*$//

# осталось объединить части
G
s/\n//
# и сохранить следующий номер в области удержания.
h

#!/usr/bin/sed -nf

/^$/ {
	p
	b
}

# Same as cat -n from now
x
/^$/ s/^.*$/1/
G
h
s/^/      /
s/^ *\(......\)\n/\1  /p
x
s/\n.*$//
/^9*$/ s/^/0/
s/.9*$/x&/
h
s/^.*x//
y/0123456789/1234567890/
x
s/x.*$//
G
s/\n//
h

#!/usr/bin/sed -nf

# Для начала, все символы мы превращаем в `a'
s/./a/g
# и добавляем к нашему счётчику, напомню, a - это единица.
H
x
# перенос строки - тоже символ.
s/\n/a/

# а так реализован перенос разрядов, для свёртки единиц в десятки и т.д..
# Автор упоминает о том, что команды перехода тут необязательны,
# однако он полагает, что так будет быстрее.  Если честно - я не знаю,
# думаю что разница не будет слишком большой.

b a
: a;  s/aaaaaaaaaa/b/g; t b; b done
: b;  s/bbbbbbbbbb/c/g; t c; b done
: c;  s/cccccccccc/d/g; t d; b done
: d;  s/dddddddddd/e/g; t e; b done
: e;  s/eeeeeeeeee/f/g; t f; b done
: f;  s/ffffffffff/g/g; t g; b done
: g;  s/gggggggggg/h/g; t h; b done
: h;  s/hhhhhhhhhh//g

# Если строка не последняя, то мы сохраняем наш счётчик,
# и завершаем обработку этой строки.
: done
$! {
	h
	b
}

# Для последней строки необходима конвертация в десятичную
# систему счисления.

: loop
# след. команда s выполнится тогда, когда в счётчике нет букв a,
# а это бывает тогда, и только тогда, когда число кратно 10,
# в этом частном случае, мы добавляем к числу справа 0,
# при этом следующие 9 s не выполняются (так-как "a" нету).
	/a/! s/[b-h]*/&0/
	# для не кратных 10 чисел мы меняем последние буквы a на нужную цифру
	# догадайтесь сами, почему они будут последними :-)
	s/aaaaaaaaa/9/
	s/aaaaaaaa/8/
	s/aaaaaaa/7/
	s/aaaaaa/6/
	s/aaaaa/5/
	s/aaaa/4/
	s/aaa/3/
	s/aa/2/
	s/a/1/

	: next
	# Эта хитрая команда: она делит счётчик на 10, например "db" у нас равно 1010,
	# а после замены будет "ca", т.е. - 101.
	y/bcdefgh/abcdefg/
	# и так до тех пор, пока все буквы не перейдут в цифры.
	/[a-h]/ b loop
p

#!/usr/bin/sed -nf

# Convert words to a's
s/[ tab][ tab]*/ /g
s/^/ /
s/ [^ ][^ ]*/a /g
s/ //g

# Append them to hold space
H
x
s/\n//

# From here on it is the same as in wc -c.
/aaaaaaaaaa/! bx;   s/aaaaaaaaaa/b/g
/bbbbbbbbbb/! bx;   s/bbbbbbbbbb/c/g
/cccccccccc/! bx;   s/cccccccccc/d/g
/dddddddddd/! bx;   s/dddddddddd/e/g
/eeeeeeeeee/! bx;   s/eeeeeeeeee/f/g
/ffffffffff/! bx;   s/ffffffffff/g/g
/gggggggggg/! bx;   s/gggggggggg/h/g
s/hhhhhhhhhh//g
:x
$! { h; b; }
:y
	/a/! s/[b-h]*/&0/
	s/aaaaaaaaa/9/
	s/aaaaaaaa/8/
	s/aaaaaaa/7/
	s/aaaaaa/6/
	s/aaaaa/5/
	s/aaaa/4/
	s/aaa/3/
	s/aa/2/
	s/a/1/
	y/bcdefgh/abcdefg/
	/[a-h]/ by
p

#!/usr/bin/sed -nf
$=

#!/usr/bin/sed -f
10q

#!/usr/bin/sed -nf
1! {; H; g; }
1,10 !s/[^\n]*\n//
$p
h

#!/usr/bin/sed -f
1h
2,10 {; H; g; }
$q
1,9d
N
D

#!/usr/bin/sed -rf
h

:b
# если строка последняя - печать и выход.
$b
# загружаем следующую строку
N
/^(.*)\n\1$/ {
	# сл. строка такая-же как прошлая, выгружаем
	# прошлую из области удержания, как-бы отменяя действие команды N
	g
	bb
}

# если команда N загрузила посл. строку, печатаем две посл. строки сразу.
$b

# строки разные, мы сначала печатаем первую из них
P
# потом её удаляем
D
# и при окончании этого цикла печатается следующая строка.

#!/bin/sed -rnf
$b
N
/^(.*)\n\1$/ {
	# печать первой повторяющейся строки
	s/.*\n//
	p

	# цикл, читаем строки до тех пор, пока они повторяются
	:b
	$b
	N
	/^(.*)\n\1$/ {
		s/.*\n//
		bb
	}
}

# последняя строка не может повторятся
$b

# мы нашли две разные строки, мы удаляем первую, а вот следующую
# необходимо анализировать дальше
D

#!/usr/bin/sed -rf

# поиск линий, которые не повторяются, до тех пор пока сл. строка
# отличается от предыдущей, печатаем те, которые отличаются.
$b
N
/^(.*)\n\1$/ ! {
	P
	D
}

:c
# Сейчас у нас две одинаковые строки в буфере,
# если это последние строки - просто выходим.
$d

# иначе отрезаем одну из одинаковых строк, добавляем ещё одну,
# и если строки одинаковые - переходим к метке :с.
s/.*\n//
N
/^(.*)\n\1$/ {
	bc
}

# Удаляем "одинаковую" строку, и переходим
# к началу скрипта.
D

#!/usr/bin/sed -f

# для пустых строк выполняется команда N,
# которая их читает в этом цикле
# примечание: в регулярном выражении использована звёздочка
# для задания любого числа '\n', которые вставляет команда N
# (во время первого прохода этого символа в строке вообще нет)
:x
/^\n*$/ {
	N
	bx
}

# сейчас у нас имеется не пустая строка, перед которой стоят несколько
# символов '\n'
# все эти символы мы заменим на один перевод строки
s/\n*/\
/

#!/usr/bin/sed -f

# Удаление всех начальных пустых строк
# примечание от drBatty: непонятно почему написано /^./,
# ИМХО можно и просто /./
1,/^./{
	/./!d
}

# для пустых строк мы грузим следующую, и если она тоже пустая,
# мы удаляем загруженный командой N символ '\n'
# а потом опять загружаем следующую.
:x
/./!{
	N
	s/^\n$//
	tx
}

#!/usr/bin/sed -nf

# удаление всех (начальных) пустых строк
/./!d

# теперь у нас имеется не пустая строка
:x
	# печатаем её
	p
	# извлекаем следующую
	n
	# есть символы? тогда продолжаем печатать не пустые строки
	/./bx

# символов нет - эта строка пустая
:z
	# вынимаем следующую строку, если её нет (текущая - последняя)
	# во время выполнения n скрипт завершает работу
	n
	# ещё одна пустая? тогда мы её игнорируем, и переходим к следующей
	# этот скрипт удаляет ВСЕ пустые строки
	/./!bz

# все пустые строки были удалены/проигнорированы
# и теперь мы добавляем ещё одну пустую строку ПЕРЕД той, что сейчас напечатается
i\

bx