Начнем с легкого.... 

{ Составить программу подсчета различных букв в слове. }
var s:string;
    r:real;
    i,j,n:integer;
begin
    r:=0;
    readln(s);
    for i:=1 to length(s) do begin
       n:=0;
       for j:=1 to length(s) do begin
          if s[i]=s[j] then inc(n);
       end;
       r:=r+1/n;
    end;
    writeln('количество различных букв = ', r:1:0);
end.

{ все ли элементы массива различны? }
var a:array[1..10] of integer;
    i,j:integer;
begin
     writeln('введите 10 элементов массива');
     for i:=1 to 10 do readln( a[i] );
     i:=1;
     while (i<10) and (j<11) do begin
       j:=i+1;
       while (j<11) and (a[i]<>a[j]) do inc(j);
       inc(i);
     end;
     if i<11 then writeln('в массиве есть одинаковые элементы')
             else writeln('все элементы массива различны');
end.

(*  -------------- вариант с циклом FOR ----------------- *)
var a:array[1..10] of integer;
    i,j:integer;
begin
     writeln('введите 10 элементов массива');
     for i:=1 to 10 do readln( a[i] );
     for i:=1 to 9 do begin
       for j:=i+1 to 10 do begin
          if a[i]=a[j] then break;
       end;
       if j<10 then break;
     end;
     if i<9 then writeln('в массиве есть одинаковые элементы')
             else writeln('все элементы массива различны');
end.

Ну вот и дошли до быстрой сортировки... Может, кому и полезно будет


{  реурсивные алгоритмы: быстрая сортировка, см. программу внизу           }
{  ----------------------------------------------------------------------- }
{                           БЫСТРАЯ СОРТИРОВКА.                            }
{       Устанавливаем I=1 и J=N. Сравниваем элементы  A[i]  и  A[J].  Если }
{  A[i]<=A[J], то уменьшаем J на 1 и проводим  следующее сравнение элемен- }
{  тов A[i] с A[J]. Последовательное уменьшение индекса J и сравнение ука- }
{  занных элементов  A[i] с A[J] продолжаем  до тех пор,  пока выполняется }
{  условие A[i] <= A[J]. Как только A[i] станет больше A[J], меняем места- }
{  ми элементы A[i] с A[J], увеличиваем индекс I на 1 и продолжаем сравне- }
{  ние  элементов  A[i] с A[J]. Последовательное увеличение  индекса  I  и }
{  сравнение (элементов A[i] с A[J]) продолжаем до тех  пор, пока выполня- }
{  ется условие A[i] <= A[J].  Как  только A[i] станет больше A[J],  опять }
{  меняем местами элементы A[i] с A[J], снова начинаем уменьшать J.        }
{       Чередуя уменьшение J и увеличение I, сравнение и необходимые обме- }
{  ны, приходим к некоторому элементу, называемому  пороговым или главным, }
{  характеризующим условие  I=J. В результате элементы массива оказываются }
{  разделенными на две части так, что все элементы слева - меньше главного }
{  элемента, а все элементы справа - больше главного элемента.             }
{       К этим  массивам применяем рассмотренный алгоритм, получаем четыре }
{  части и т.д. Процесс закончим, когда массив A станет полностью отсорти- }
{  рованным.                                                               }
{       При программировании алгоритма "Быстрой сортировки" удобно исполь- }
{  зовать рекурентные вызовы процедуры сортировки (рекурсию).              }
{  ----------------------------------------------------------------------- }

var a:array[1..10] of integer; { массив элементов }
    n:integer;

procedure QuickSort( L, R : Integer ); { Быстрая сортировка массива A[] }
var i,j,x,y : integer;
begin
  i := l; j := r;
  x := a[(l+r) div 2];
  repeat
    while (A[i]<x) do inc(i);
    while (x<A[j]) do dec(j);
    if ( i<=j ) then
    begin
      y:=A[i]; a[i]:=a[j]; a[j]:=y;
      inc(i); dec(j);
    end;
  until (i>j);
  if (l<j) then QuickSort(l,j);
  if (i<r) then QuickSort(i,r);
end;

begin
     writeln('введите 10 элементов массива:');
     for n:=1 to 10 do readln(a[n]);
     QuickSort( 1, 10 ); { на входе: левая и правая граница сортировки }
     writeln('после сортировки:');
     for n:=1 to 10 do writeln(a[n]);
end.

{ арифметические алгоритмы: моделирование вычитания двоичных чисел         }
{ ------------------------------------------------------------------------ }
var sr,sf,ss:string;

{ вычитание двоичных строк, первое число должно быть >= второго }
function BinSub(s1,s2:string):string;
var s:string; l,i,j:byte;
begin
    {выравнивание строк по длине}
    if length(s1)>length(s2) then while length(s2)<length(s1) do s2:='0'+s2
                             else while length(s1)<length(s2) do s1:='0'+s1;

    l:=length(s1); {начало алгоритма вычитания}
    s:='';
    for i:=l downto 1 do begin
       case s1[i] of
        '1': if s2[i]='0' then s:='1'+s else s:='0'+s;
        '0': if s2[i]='0' then s:='0'+s else begin
                s:='1'+s;
                if (s1[i-1]='1') then s1[i-1]:='0' else begin
                   j:=1;
                   while (i-j>0) and (s1[i-j]='0') do begin
                         s1[i-j]:='1';
                         inc(j);
                   end;
                   s1[i-j]:='0';
                end;
             end;
       end;
    end;
    {Уничтожение передних нолей}
    while (length(s)>1) and (s[1]='0') do delete(s,1,1);
    BinSub:=s;
end;

begin
     writeln('введите 1-е двоичное число:');
     readln(sf);
     writeln('введите 2-е двоичное число:');
     readln(ss);
     sr:=BinSub(sf,ss);
     writeln('результат вычитания = ',sr);
end.

{ Бэк-трекинг: Города                                                      }
{--------------------------------------------------------------------------}
{ Задача "Города".                                                         }
{    Широко известна  игра "Города". Называется какой-нибудь город, допус- }
{ тим, "Саратов". Кончается на "в", значит требуется назвать другой город, }
{ у которого в названии первая буква "в". Это может быть "Воронеж". Следу- }
{ ющий город должен начинаться на "ж" и т.д.  Запрещено повторять название }
{ городов. Надо написать программу, которая  из  набора  названий  городов }
{ (все названия разные) строит цепочку максимальной длины.                 }
{                                                                          }
{    Входные данные: файл TOWN.IN в 1-й строке содержит  количество слов в }
{ наборе. Начиная  со второй строки  (по одному в строке) следуют названия }
{ городов (все буквы в названиях - заглавные).                             }
{                                                                          }
{    Выходные данные: 1-я строка TOWN.OUT содержит  длину максимальной це- }
{ почки. Начиная со второй строки идет вариант цепочки,  т.е. названия (по }
{ одному в строке) городов в порядке, который требуют условия игры.        }
{                                                                          }
{    Примечание: Список городов во входном файле не превышает 20.          }
{                Время тестирования - 2 секунды. (Pentium)                 }
{                                                                          }
{ ПРИМЕР:                                                                  }
{   ┌──────── TOWN.IN ──────────────┬─────────── TOWN.OUT ───────────────┐ }
{   │5                              │5                                   │ }
{   │НОВОСИБИРСК                    │САМАРА                              │ }
{   │АСТРАХАН                       │АСТРАХАН                            │ }
{   │САМАРА                         │НОВОСИБИРСК                         │ }
{   │ВЛАДИМИР                       │КИРОВ                               │ }
{   │КИРОВ                          │ВЛАДИМИР                            │ }
{   └───────────────────────────────┴────────────────────────────────────┘ }
{--------------------------------------------------------------------------} 
{$M $8000,0,$1FFFF}
program towns;          { "Города". Решение А.Никитина, Самара  }
const mnt         = 20; { максимальное количество слов на входе }
var   list,chain,store :array [1..mnt] of string; { для списка и цепочек }
      numin       :integer; { реальное количество слов на входе }
      pc          :integer; { Указатель на хвост цепочки }
      ml          :integer; { Длина наибольшей цепочки }
      sym         :char;    { Первичная буква для перебора }

procedure read_data; { Начальные установки и чтение данных }
var i : integer;
begin
     pc:=0; ml:=0; numin:=0;
     assign(input,'TOWN.IN'); reset(input);
     fillchar(chain,sizeof(chain),0);
     readln(numin);
     if (numin>mnt) then numin:=mnt;
     for i:=1 to numin do readln(list[i]);
     close(input);
end;
procedure write_results; { Запись результатов в файл }
var i : integer;
begin
     assign(output,'TOWN.OUT'); rewrite(output);
     writeln(ml);
     if (ml>0) then begin
        for i:=1 to ml do writeln(store[i]);
     end;
     close(output);
end;
procedure store_chain; { Запоминаем только более длинную цепочку }
var i:integer;
begin
     if (pc>ml) then begin
        store:=chain;
        ml:=pc;
     end;
end;
{ Возвращает указатель названия по 1-й букве, 0 - такого элемента нет }
function find_next_item( c:char; n:integer ):integer;
var i:integer;
begin
    i:=1; find_next_item:=0;
    while (i<=numin) and (n>0) do begin
       if (list[i][1]=c) then dec(n);
       inc(i);
    end;
    if (n=0) then find_next_item:=pred(i);
end;
{ Алгоритм построения цепочек. }
procedure build_chain( c:char; n:integer ); { Метод: перебор с возвратом.  }
var i:integer;                              { Известен как "back-tracking" }
begin
    i:=find_next_item(c,n);
    if (i>0) then begin
       inc(pc); chain[pc]:=list[i]; list[i][1]:='X'; { вычеркиваем }
       build_chain(list[i][length(list[i])], 1);
       dec(pc); list[i][1]:=c; { возвращаем }
       build_chain(c, n+1);
    end else store_chain;
end;

begin
     read_data;
     for sym:='А' to 'Я' do build_chain(sym,1);
     write_results;
end.

Блин, моя любимая задача 


{ Бэк-трекинг: Проход по лабиринту                                         }
{ Есть матрица n:m, состоящая из 0 и 1. 1 - это стенка, 0 - проход.        }
{ Надо найти оптимальный проход из точки is,js (нчаало) в точку ie, je     }
{ (конец).                                                                 }
{                                                                          }
{ Входной файл LAB.IN содержит:                                            }
{ 1-я строка - размер поля                                                 }
{ 2-я строка - координаты начальной позиции (row,col)                      }
{ 3-я строка - координаты конечной позиции (row,col)                       }
{ 4-я строка и далее - схему лабиринта из 0 и 1                            }
{ Например:                                                                }
{ 10 10                                                                    }
{ 2 10                                                                     }
{ 1 6                                                                      }
{ 1 1 1 1 1 0 1 1 1 1                                                      }
{ 1 0 0 0 0 0 1 0 1 0                                                      }
{ 1 0 1 1 1 1 1 0 1 0                                                      }
{ 1 0 1 0 1 0 0 0 1 0                                                      }
{ 1 0 1 0 1 0 0 0 1 0                                                      }
{ 0 0 1 0 1 0 0 0 1 0                                                      }
{ 0 0 1 0 1 1 1 1 1 0                                                      }
{ 1 0 0 1 0 1 0 0 0 0                                                      }
{ 1 1 0 0 0 0 0 1 0 0                                                      }
{ 1 1 1 1 1 1 1 1 1 1                                                      }
{                                                                          }
{ Выходной файл LAB.OUT содержит маршрут прохода (i1:j1 ... in:jn):        }
{ 1:10                                                                     }
{ 2:10                                                                     }
{ 3:10                                                                     }
{ ....                                                                     }
{--------------------------------------------------------------------------} 
const LN = 50; LM = 50;
var a:array[1..LN,1..LM] of byte;
    p:array[1..LN*LM,1..2] of byte;
    s:array[1..LN*LM,1..2] of byte;
    n,m,si,sj,ei,ej,index,min:integer;

procedure INIT;
var i,j:integer;
begin
     assign(input,'lab.in'); reset(input);
     assign(output,'lab.out'); rewrite(output);
     readln(n,m);
     readln(si,sj);
     readln(ei,ej);
     for i:=1 to n do begin
         for j:=1 to n-1 do begin
             read(a[i,j]);
         end;
         readln(a[i,n]);
     end;
     index:=0; min:=ln*lm;
end;

procedure Store;
begin
    if (min > index) then begin
        move( p, s, sizeof(p) );
        min:=index;
    end;
end;

procedure DONE;
var i:integer;
begin
    for i:=1 to min do writeln(s[i,1],':',s[i,2]);
end;

procedure FindPath(i,j:integer);
begin
    a[i,j]:=2;
    inc(index);
    p[index,1]:=i; p[index,2]:=j;
    if (i=ei) and (j=ej) then begin
        Store;
    end else begin
        if (i>1) and (a[i-1,j]=0) then FindPath(i-1,j);
        if (i<n) and (a[i+1,j]=0) then FindPath(i+1,j);
        if (j>1) and (a[i,j-1]=0) then FindPath(i,j-1);
        if (j<m) and (a[i,j+1]=0) then FindPath(i,j+1);
    end;
    dec(index);
    a[i,j]:=0;
end;

begin
     INIT;
     FindPath(si,sj);
     DONE;
end.

Хорошая классическая задача
{ Бэк-трекинг: Последовательность                                          }
{--------------------------------------------------------------------------}
{ Дана последовательность натуральных чисел (значение каждого числа        }
{ от 1 до 1000). После-довательность может быть не отсортирована.          }
{ Надо найти вариант самой большой (по количеству элементов) неубывающей   }
{ последовательности, составленной из чисел этого ряда. Порядок включения  }
{ чисел в неубывающую последовательность должен соответствовать порядку    }
{ следования чисел в первоначальной последова-тельности. Иными словами,    }
{ числа с большими номерам и в новой последовательности размещаются правее }
{ чисел с меньшими номерами.                                               }
{                                                                          }
{ Входные данные: файл SEQ.IN в 1-й строке содержит количество чисел в     }
{ последовательности - N (1<=N<=100).                                      }
{ Со 2-й строки и далее указан ряд чисел, каждое число размещается на      }
{ новой строке. Поиск ошибок в файле не требуется, входные данные          }
{ корректны.                                                               }
{                                                                          }
{ Выходные данные:                                                         }
{ В файле SEQ.OUT помещаются выходные данные.                              }
{ 1-я строка содержит длину максимальной неубыващей последовательности.    }
{ 2-я строка и далее - пример такой последовательности, каждое число в     }
{ порядке следования размещается на новой строке.                          }
{                                                                          }
{ Пример возможного теста:                                                 }
{                                                                          }
{ Файл "SEQ.IN"	Файл "SEQ.OUT"                                             }
{ 12              7                                                        }
{ 59              4                                                        }
{ 4               21                                                       }
{ 21              27                                                       }
{ 36              34                                                       }
{ 18              45                                                       }
{ 27              47                                                       }
{ 79              93                                                       }
{ 34                                                                       }
{ 45                                                                       }
{ 47                                                                       }
{ 34                                                                       }
{ 93                                                                       }
{--------------------------------------------------------------------------}

{$M $8000,0,$4ffff} (* последовательность, Никитин *)
Const MaxItem = 100;
      TimeLimit = 29*18; {29 sec}

var Numbers, Seq, Best: array[1..MaxItem] of integer;
    pc,maxpc,num:integer;
    timer:longint absolute $0040:$006C;
    jiffy:longint;

Procedure Init;
var i:integer;
begin
     jiffy:=timer;
     fillchar(Numbers, Sizeof(Numbers),#0);
     Seq:=Numbers; Best:=Numbers; pc:=0; maxpc:=0;
     assign(input,'seq.in'); reset(input);
     readln(num); if num>MaxItem then num:=MaxItem;
     for i:=1 to num do readln(Numbers[i]);
     close(input);
end;

Procedure Done;
var i:integer;
begin
     assign(output,'seq.out'); rewrite(output);
     writeln(maxpc);
     for i:=1 to maxpc do writeln(Best[i]);
     close(output);
end;

procedure StoreChain;
begin
     if (pc>maxpc) then begin
         Best:=Seq;
         maxpc:=pc;
         if (maxpc=num) then begin
            Done;
            Halt(0);
         end;
     end;
end;

function testFWD(i:integer):integer;
var m:integer;
begin
     m:=Numbers[i]; inc(i);
     while (i<=num) and (m>Numbers[i]) do inc(i);
     if i>num then testFWD:=0 else testFWD:=i;
end;

procedure solution(n:integer); { Основная процедура }
var i,s:integer;
begin
   if ((timer-jiffy)>TimeLimit) then exit;
   i:=testFWD(n);
   if (i=0) then begin
       StoreChain;
   end else begin
       inc(pc);                       {проверили этот путь}
       Seq[pc]:=Numbers[i];
       solution(i);
       dec(pc);                       {идем по другому}
       s:=Numbers[i]; Numbers[i]:=-1; {вычеркнули}
       solution(n);
       Numbers[i]:=s;                 {вернули}
   end;
end;

var index:integer;
begin
     Init;
     index:=1;
     repeat
         pc:=1;
         Seq[pc]:=Numbers[index];
         solution(index);
         while (index<=num) and (Numbers[index]>=Seq[pc]) do inc(index);
     until (index>num);
     Done;
end.