Código Delphi [-]
CONST
  espacio=' ';
  maxpal=25;
  maxcar=15;
TYPE
  palabra=STRING[maxcar];
  cadenapal=ARRAY[1..maxpal] OF palabra;
  long_pal=0..maxpal;
  long_car=0..maxcar;
VAR  {Estas son las variables del programa principal}
  palalabra;
  frase:STRING;
  arraypal:cadenapal;
  npal:long_pal;
  ncar:long_car;

  procedure vector_palabras (var s:STRING);
var
  posicion:cadenapal;
  num:long_pal;
  n:integer;
  posic:long_car;
begin
 num:=0;
  repeat
   n:=1;
 **WHILE n<=length(s) AND s[n] DO n=n+1;**
   delete(s,1,n-1);
   posic:=pos(espacio,s);
   IF posic<>0 THEN
    begin
     num:=num+1;
     posicion[num]:=copy(s,1,posic-1);
     delete(s,1,posic);
    end;
  until posic=0;
  **IF s<>' '  THEN**
   begin
    num:=num+1;
    posicion[num]:=s;
   end;
end;

procedure mostrar_vector(var c:cadenapal;longitud:long_pal);
var
  r:long_pal;
begin
 FOR r:=1 TO longitud DO
  write(c[r],'//');
  writeln;
end;

Código Delphi [-]
CONST
  max=10;
  mm=10;
TYPE
  matriz=ARRAY[1..mm,1..max] OF integer;
VAR  {Estas son las variables del programa principal}
  mat,mat1,mat2:matriz;
  lado_i,lado_j:integer;
  i,j:integer;
  n_mayor,n_menor:integer;
  p_mayor,p_menor:ARRAY[1..2] OF integer;                

procedure mayor_menor_matriz(var n_mayor,n_menor:integer);
var
mat:matriz;
begin
leer_matriz(lado_i,lado_j,mat);
FOR i:=1 TO mm DO
n_mayor:=mat[1,1];
n_menor:=mat[1,1];
FOR i:=1 TO mm DO
FOR j:=1 TO max DO
IF mat[i,j]>n_mayor THEN
begin
n_mayor:=mat[i,j];
p_mayor[2]:=j;
p_mayor[1]:=i;
end;
IF mat[i,j]THEN
begin
n_menor:=mat[i,j];
p_menor[2]:=j;
p_menor[1]:=i;
end;
writeln ('El menor elemento es ',n_menor);
writeln ('El mayor es ',n_mayor);
readln;
end;

procedure intercambio_matriz(var n_mayor,n_menor:integer;mat:matriz);
var
nmenor,nmayor:integer;
i,j:integer;
mat_inter:matriz;
begin
mat_inter:=mat;
mayor_menor_matriz(n_mayor,n_menor);
nmenor:=n_menor;
nmayor:=n_mayor;
FOR i:=1 TO lado_i DO
FOR j:=1 TO lado_j DO
begin
IF nmenor=mat[i,j] THEN mat_inter[i,j]:=nmayor;
IF nmayor=mat[i,j] THEN mat_inter[i,j]:=nmenor;
end;
Mostrar_matriz (mat_inter,lado_i,lado_j);
readln;

Código Delphi [-]
var
  aux: Integer;
begin
  aux:= Minimo;
  Minimo:= Maximo;
  Maximo:= aux;
  ...

Código Delphi [-]
program Project1; {$APPTYPE CONSOLE}

uses
  SysUtils, Types;

const
  MAX_FIL = 5;
  MAX_COL = 5;

type
  TMatrix = array[1..MAX_FIL, 1..MAX_COL] of Integer;

(* Carga valores aleatorios *)
procedure LoadMatrix(var mat: TMatrix);
var
  f,c: Integer;
begin
  Randomize;
  for f:= 1 to 5 do
   for c:= 1 to 5 do
     mat[f,c]:= Random(100);
end;

(* Mostrar valores de matriz *)
procedure ShowMatrix(Mat: TMatrix);
var
  f,c: Integer;
begin
  Randomize;
  for f:= 1 to 5 do
  begin
    for c:= 1 to 5 do
      Write(mat[f,c]:3);
    writeln;
  end;
end;

(* devuelve posiciones de valores mínimo y máximo en Result *)
function MaxMinValues(Mat: TMatrix; var Mayor, Menor:integer): TRect; 
var
  f, c: Integer;
begin
  Mayor:= mat[1,1];
  Menor:= mat[1,1];
  for f:= 1 to  MAX_FIL do
    for c:= 1 to MAX_COL do
      if mat[f,c] < Menor then
      begin
        Menor:= Mat[f,c];
        Result.Left:= f;   // fila valor mínimo
        Result.Top:= c;  //  columna valor mínimo
      end
      else if Mat[f,c] > Mayor then
      begin
        Mayor:= Mat[f,c];
        Result.Right:= f;    // fila valor máximo
        Result.Bottom:= c; // columna valor máximo
      end;
end;

(* Intercambia posiciones de valores mínimo y máximo *)
procedure SwapValues(var Mat: TMatrix; T: TRect);
var
  aux: Integer;
begin
  aux:= Mat[T.Left,T.Top];
  Mat[T.Left,T.Top]:= Mat[T.Right, T.Bottom];
  Mat[T.Right, T.Bottom]:= aux;
end;

(* main *)
var
  May, Min: Integer;
  Mat: TMatrix;
  T: TRect;
begin
  LoadMatrix(Mat);
  Writeln('Carga inicial:');
  ShowMatrix(Mat);
  T:= MaxMinValues(Mat, May, Min);
  writeln (#10,'Menor elemento: ',Min,' Mayor elemento: ',May,#10);
  Writeln('Valores intercambiados');
  SwapValues(Mat, T);
  ShowMatrix(Mat);
  Readln;
end.