Pascal/Turbo Pascal - AYUDAAAAAA

Necesito ayuda en una matriz....... me pide almacenar en una matriz n*n en forma dela diagonal segundaria ejemplo

16 15 13 10
14 12 9 6
11 8 5 3
7 4 2 1

no se si entienden

Pense en crear un FOR que me vaya recorriendo las diagonales, en ese caso 7 luego hacer operaciones con filas y columnas

Hasta que entendí lo que quieres :).
Ok, la idea es llenar la matriz siguiendo la diagonal y en forma invertida. En realidad el número que se almacena en cada posición de la matriz no es importante, el problema es cómo recorrer la matriz en la forma correcta, es decir por sus diagonales.
Siempre que tengo problemas de matrices comienzo escribiendo cómo tendría que generar los indices, para este caso la lista de pares de indices a generar es la siguiente para el caso de una matriz de 5x5 (25 elementos en total)
1,1
1,2
2,1
1,3
2,2
3,1
1,4
2,3
3,2
4,1
1,5
2,4
3,3
4,2
5,1
---
2,5
3,4
4,3
5,2
3,5
4,4
5,3
4,5
5,4
5,5
Si sigues con el dedo los pares en la matriz verás este es el orden correcto comenzando desde la esquina superior izquierda. Notarás que la lista está separada en dos luego del par 5,1, esto es así por dos razones que saltan a la vista. Una allí parece terminar una serie repetitiva y salta a otra muy distinta, esto coincide con el "quiebre" de la matriz, es decir cuando se alcanza la diagonal principal opuesta. El cambio en la generación de la serie parece indicar que se necesitan dos algoritmos diferente para cada mitad de la matriz y luego verás que esto es así.
Concentremosnos en la primera parte de la lista:
El lado de la "I" de la lista parece ser erratica, pero hay un patron, siempre comienza en 1 pero termina en un valor más que la serie anterior: (1), (1,2), (1,2,3), (1,2,3,4), (1,2,3,4,5), el valor final sugiere un for cuyo indice (del for, no de la matriz) parece ser el tope de un ciclo que siempre comienza en uno. Algo como esto:
For LI:=1 to 5 do
For I:=1 to LI do
WriteLn(I);
Si ejecutas este pequeño programa verás que se genera la serie correcta para I (al menos para la parte superior izquierda de la matriz).

Parece que ya tenemos un cuarto del problema resuelto. Vamos a ver cómo metemos J en todo esto:
La lista nos muestra esta serie para J: (1), (2,1), (3,2,1), (4,3,2,1), (5,4,3,2,1) que no es ni más ni menos que la inversa de I, esto se resolvería con algo como esto:
For LJ:=1 to 5 do
For J:=LJ downto 1 do
WriteLn(J);
pero hay que meter esto en el código anterior, pues no puedes ejecutar los dos por separado, hay que mezclarlos de alguna manera, yo encontré esta:
LI:=1;
LJ:=1;
for Li:=1 to 5 do
begin
I:=1;
J:=LJ;
for I:=1 to LI do
begin
WriteLn(I,J:2);
J:=J-1;
end;
LJ:=LJ+1;
end;
Que no es ni más ni menos que simular cuatro fors usando solo dos for, al ejecutar el programa verás que se forma la primera parte de la lista. Hemos resuelto la mitad del problema.

Vamos con la segunda parte de la lista.
La serie para "I" de la segunda parte es esta: (2,3,4,5), (3,4,5), (4,5), (5), que parece ser la traspuesta de la serie "I" para la primera parte de la lista menos uno de los conjuntos, el último. Esto tiene sentido ya que ese conunto ya lo habíamos generado en la parte anterior. Para generar esta serie podemos usar casi el mismo método que antes para I, solo que en vez de variar el final, estamos variando el inicio de la serie que siempre termina en 5, así:
for LI:=2 to 5 do
for I:=LI to 5 do
WriteLn(I);
Con la salvedad de que no comenzamos en 1 sino en 2 para no repetir una serie que ya habiamos generado. Tres cuarto del problema resuelto.

Ahora vamos con "J" de la segunda parte.
La serie es: (5,4,3,2), (5,4,3), (5,4), (5), o sea, la serie traspuesta de la primera parte, pero aquí tenemos una ventaja, que se me había pasado por alto, el tamaño de cada conjunto de la serie es igual al de los conjuntos de la serie "I", lo que sugiere que el mismo ciclo for interno se puede usar para un indicie y para el otro también, mientras uno sube, el otro baja de valor, aprovechemoslo y surge este código:
for LI:=2 to 5 do
begin
J:=5;
for I:=LI to 5 do
begin
WriteLn(I,J:2);
J:=J-1;
end;
end;
Problema resuelto, entonces. Solo resta generar los valores a almacenar. Tu pides que esos valores estén invertidos, comenzando por el mayor y terminando en el menor (es decir, de 25 -> 1), ningún problema, una resta hará el trabajo.
Esta es la versión final del algorítmo, con alguna mejora para simplificar:
Num:=25;

var
J, I, LI, Num: integer;
A:Array[1..5,1..5] of integer;
begin
Num:=25;
for Li:=1 to 5 do
begin
I:=1;
J:=Li;
for I:=1 to LI do
begin
WriteLn(I,J:2);
A[I,J]:=Num;
Num:=Num-1;
J:=J-1;
end;
end;

WriteLn('---');

for LI:=2 to 5 do
begin
J:=5;
for I:=LI to 5 do
begin
WriteLn(I,J:2);
A[I,J]:=Num;
Num:=Num-1;
J:=J-1;
end;
end;
end.

Que te aproveche :).

Bueno gracias por tu ayuda.... ya e entedido un poco....

Bueno ya lo e pasado y lo tengo casi listo... pero hay un problema a la hora de ver la matriz en pantalla en orden osea, la forma diagonal.....

Como te dije, los calculos los hace perfectos pero no me da la mattriz en diagonal.... pienso que es algo que no veo... a ver si tu lo ves...

TE mando aqui el codigo casi listo.... solo correlo y ves como queda

me urge tu ayuda, tengo que entregar una tarea de varias pregutna el martes, y me falta esa sola

rogram ejr2;
uses crt;

type
matriz= Array [1..5,1..5] of integer;
var
A:matriz;
j,i,k,num:integer;

begin
clrscr;
num:=25;
for k:=1 to 5 do
begin
i:=1;
j:=k;
for i:=1 to k do
begin
A[i,j]:=num;
write(A[i,j]);
num:=num-1;
j:=j-1;
end;
writeln;
end;
readkey;
writeln(\'------\');

for k:=2 to 5 do
begin
j:=3;
for i:=k to 5 do
begin
A[i,j]:=num;
write(A[i,j]);
num:=num-1;
j:=j-1;
end;
writeln;
end;
readkey;
end.

Te he respondido a tu e-mail.

gracias diego