Program Strings;
Var
      NomeInicial, NomeFinal : String;
      i, tam : Integer;
 Begin
       Write('Informe o nome: ');
       Readln(NomeInicial);
       Tam:=Length(NomeInicial);
       NomeFinal:='';
       If Tam>3 then
       Begin
              For i:=4 to Tam do
              Begin
                     NomeFinal:=NomeFinal+NomeInicial[i];
              End;
       End
      Else
           Write('O nome possui menos que 4 caracteres.');
       Write(NomeFinal);
 End.

Sintaxe: array[ limiteInferior .. limiteSuperior ]  of  tipo;"

Exemplificando a declaração de um vetor:
Var
 Nome : array[1..5] of string;

Ou seja, foi declarado um vetor, identificado como Nome, que possui 5 posições do tipo String. Para acessar uma de suas posições basta fazer referência a uma delas através do índice do vetor, com a seguinte sintaxe: Nome[i], onde i é um número inteiro qualquer de 1 a 5(pois como foi definido 5 é o limite máximo do índice). Por exemplo, Nome[3]:='Suzana'; desta forma foi atribuído a posição 3 do vetor Nome a palavra Suzana.

Porém queremos criar um programa para realizar a leitura de 5 nomes que irão preencher as posições deste vetor declarado. Não é necessário repetir a leitura 5 vezes, é possível poupar trabalho. Para tanto utilizaremos a estrutura de repetição For to do da seguinte forma:
 For i:=1 to 5 do
 Begin
       Write('Informe o Nome ',i,': ');
       ReadLn(Nome[i]);
 End;

E para finalizar iremos exibir os nomes na tela na ordem inversa em que foram digitados. Mas uma vez não é necessário escrever 5 vezes o comando WriteLn(). Usaremos neste caso o comando For Downto Do, da seguinte forma.

For i:=5 downto 1 do
      WriteLn(Nome[i]);

Como existe apenas um comando dentro da estrutura for, não é necessário a utilização de Begin e End; Segue abaixo o código fonte completo deste programa exemplo de vetor unidimensional.
Program ExemploVetor3;
Var
      Nomes  : array [1..5] of string;
      i  : integer; 
 Begin
       For i:=1 to 5 do
       Begin
             Write('Informe o nome ',i,': ');
             Readln(Nomes[i]);
       End;
       For i:=5 downto 1 do
            WriteLn(Nomes[i]); 
 End.

Jogo da Memoria

Obs.: Funções são um bloco de programa que pode ser acionado a qualquer momento e retorna um valor de acordo com o tipo declarado.

Program Tabuada;
Var
   Cont, N : Integer;
   Op  : Char;
Function Soma(Cont, N: integer):integer;
Begin
         Soma:=Cont+N; 
End;
Function Divisao(Cont, N: integer):real;
Begin
         Divisao:=N/Cont; 
End;
Function Mult(Cont, N: integer):integer;
Begin
         Mult:=Cont*N; 
End;
Function Subtrair(Cont, N: integer):integer;
Begin
         Subtrair:=N-Cont; 
End;
 Begin
         Cont:=1;
         Write('Digite o Número: ');
         ReadLn(N);
         Write('Informe a Operação(* / + -): ');
         ReadLn(Op);
         While Cont<=10 do
         Begin
               Case Op of
               '*': WriteLn(N,' * ',Cont,' = ',Mult(Cont,N));
               '/': WriteLn(N,' / ',Cont,' = ',Divisao(Cont,N):1:2);
               '+': WriteLn(N,' + ',Cont,' = ',Soma(Cont,N));
               '-': WriteLn(N,' - ',Cont,' = ',Subtrair(Cont,N));
               Else Begin
                             WriteLn('Operação não encontrada.');
                             Cont:=10;
                       End;
              End;   
              Cont:=Cont+1;
       End;
 End.

Program DecimalparaHexa;
Const
      MaxCasas=8;
Type
      Hexas = array[1..MaxCasas] of String[1];
Var
      Hexa: Hexas;
      escreve : boolean;
      Valor, aux, i, cont : Integer;
 Begin
         Write('Informe o número decimal: ');
         ReadLn(Valor);
         aux:=valor;
         escreve:=false;
         For i:=1 to MaxCasas Do // Inicializa o vetor Hexadecimal.
                Hexa[i]:='0';
         For i:=1 to MaxCasas Do
         Begin
                 if aux mod 16 < 10 then
                       str(aux mod 16,Hexa[i])
                 else
                      case aux mod 16 of
                      10:Hexa[i]:='A';
                      11:Hexa[i]:='B';
                      12:Hexa[i]:='C';
                      13:Hexa[i]:='D';
                      14:Hexa[i]:='E';
                      15:Hexa[i]:='F';
                      End;
                      aux:=aux div 16;
                 End;
                 Write('Resultado em Hexadecimal: '); 
                 For i:=MaxCasas downto 1 Do
                 Begin
                       If Hexa[i]<>'0' then
                            escreve:=true;
                       If escreve then
                            Write(Hexa[i]);
                End; 
 End.

Program VolumeCilindro;
Const
         pi  = 3.1416;
Var
         Raio, Altura : Real;
Function CalcArea(pi,Raio:Real):Real;
Begin
         CalcArea:=pi*raio*raio;
End;
Function CalcVolume(Altura: Real):Real;
Begin
        CalcVolume:=CalcArea(pi,raio)*Altura;
End;
 Begin
         Write('Para calcular o volume do cilindro informe o valor do raio da base: ');
         ReadLn(Raio);
         Write('Agora informe a altura do cilindro: ');
         ReadLn(Altura);
         Write('O volume do cilindro é = ',CalcVolume(Altura):0:2);
 End.

Program DecimalparaBinario;
Const
      Bits=8;
Type
      Binarios = array[1..Bits] of char;
Var
      Binario: Binarios;
      Valor, aux, i : Integer;
 Begin
         Write('Informe o número decimal: ');
         ReadLn(Valor);
         aux:=valor;
         For i:=1 to Bits Do
                Binario[i]:='0';
         For i:=1 to Bits Do
         Begin
                if aux mod 2 = 0 then
                      Binario[i]:='0'
                else
                      Binario[i]:='1';
                aux:=aux div 2;
         End;
         Write('Resultado em binário: '); 
         For i:=Bits downto 1 Do
         Begin
               Write(Binario[i]);
         End; 
 End.

Program Kmhparams;
Var
      kmh, ms : real;
Begin
      WriteLn('Este programa faz a conversão de km/h para m/s.');
      Write('Informe a velocidade em km/h: ');
      ReadLn(kmh);
      ms:=kmh/3.6;
      Write(kmh:0:2,' km/h equivale a ',ms:0:2,' m/s.');
 End.

Program ParImpar;
Var
     Num : integer;
     Par : boolean;
 Begin
     Write('Informe o número a ser testado: ');
     ReadLn(Num);
     If Num mod 2 = 0 then
        Par:=true
     Else
        Par:=false;
     If Par Then
        Write('O número é par.')
     Else
        Write('O número é ímpar.');
 End.

 jogodavelhapascal.pdf

Program CalcPotencia;
Var
      expoente, i, potencia, num      : integer;  { variáveis inteiras expoente, i(índice),  num(base) e a potência.}
Begin                                                    
         Write(’Informe um número para a base: ‘); 
         ReadLn(num);
         Write(’Informe um número inteiro para o expoente: ‘);
         ReadLn(expoente);
         potencia:=num; {potencia inicia com a própria base.}
         if (expoente=0) then
                potencia:=1 {se o expoente for 0 então a valor da potencia será sempre igual a 1.}
         else
            if (expoente>0) then {se expoente for positivo.}
            begin
                  for i:=2 to expoente do  {o índice inicia em 2 pois quando expoente igual a 1 a potencia é igual a própria base.}
                      potencia:=num*potencia;                
                 write(’O resultado da potencia quando a base é ‘,num, ‘ e o expoente é ‘,expoente,’ é igual a ‘,potencia);
            end      
            else
                  if (expoente<0) then {se o expoente for negativo}
                  begin
                           expoente:=expoente*-1; {multiplica-se o expoente por -1 para obter o número de repetições}
                           for i:=2 to expoente do   
                                potencia:=num*potencia;
                          write(’O resultado da potencia quando a base é ‘,num, ‘ e o expoente é ‘,expoente,’ é igual a 1/’,potencia);  {o resultado é igual a 1 dividido pela potencia encontrada. pois o expoente é negativo.}
                  end;                        

End.

Program AreaTriangulo;
Var
         base, altura : real;
Function Area(b, h : real): real;
Begin
         Area:=(b*h)/2;
End;
 Begin
        Write('Informe o valor da base: ');
        ReadLn(base);
        Write('Informe o valor da altura: ');
        ReadLn(altura);
        WriteLn('A área deste triângulo é ',Area(base,altura):0:2);
 End.

Obs.: Um variável do tipo String   -  "Define uma cadeia de caracteres. Se nenhuma restrição de tamanho for especificada, um dado do tipo string é capaz de armazenar uma sequência contendo até 255 caracteres, onde cada caracter ocupa um byte de espaço na memória".

Program Vetores2;
Type
        nomes = array[1..5] of string;
Var
        nome : nomes;
        i : integer; 
 Begin
        For i:=1 to 5 do
        Begin 
                Write('Posição: ',i,' - Informe o nome: ');
                ReadLn(Nome[i]);
        End;
        Write('Indique qual posição do vetor deseja visualizar: ');
        ReadLn(i);
        WriteLn('Posição: ',i,' - ',Nome[i]);
 End.

Iniciar as explicações com problemas simples não deve ser um fator causador de desmotivação, tenho certeza que todo o conhecimento teórico adquirido será útil para produzir um programador mais eficiente.

Quando utilizamos o computador para resolver um problema precisamos conhecer o problema, a resolução para produzir resultado esperado e as variáveis dele. Isto serve para qualquer problema até para os mais complexos.

O problema exemplo é: calcular a média entre dois valores e exibir o resultado. O programador deve saber como resolver este problema antes de iniciar a programação. Pois, deverá orientar o computador sobre como resolvê-lo.
 
A resolução é: 1- Obter os dois valores. 2- Somar os valores e dividir a soma por dois. 3- Apresentar o resultado.

As variáveis são duas: os dois valores. Para construir um programa dinâmico é necessário que os valores sejam variáveis. O objetivo é calcular a média entre dois valores. Estes não estão definidos. Devem variar a cada vez que o programa é acionado.

Seguindo este método você irá conseguir resolver outros problemas mais complexos.

Saudações.