¿Cuál es la solución / lógica para el patrón numérico dado?

Puede haber muchos enfoques, ¡estoy sugiriendo uno!

Aquí estoy generalizando todo el código a una entrada de usuario n.

#include
int main () {
int i, j, n, val, print_val;
printf (“Ingrese el valor de n”);
scanf (“% d”, & n);
val = n * (n + 1) / 2;
para (i = n; i> = 1; i -) {
print_val = val;
para (j = 1; j <= i; j ++) {
printf (“% d \ t”, print_val);
print_val = print_val- (n-j + 1);
}
printf (“\ n”);
val = val-1;
}
devuelve 0;
}

Aquí están las salidas correspondientes para n = 10 yn = 5

Parece que el patrón anterior funciona así

Paso 1: lee ‘n’ como entrada

Paso 2: encuentre la suma de no comenzando de 1 a n (en este caso será (1 + 2 + 3 + 4 + 5) = 15 ciencia n = 5) lo llamaré total como referencia

Paso 3: imprima piramid usando el bucle e intente volver a colocar los valores codificados por debajo de los valores dinámicos

total, total-n, ((total-n) – (n-1)), (((total-n) – (n-1)) – (n-2)), ((((total-n) – (n-1)) – (n-2)) – (n-3))

Entonces, por ejemplo, se convertirá

15, (15–5), ((15–5) – (5–1)), (((15–5) – (5–1)) – (5–2)),

(((15–5) – (5–1)) – (5–2)) – (5–3)

= 15, 10, 6, 3, 1

Intenté resolverlo en C. Aquí está el código

#include
vacío principal(){
int n, i, j, k, h_num, num;
printf (“ingrese el valor de n: \ t”);
scanf (“% d”, & n);
h_num = n * (n + 1) / 2;
para (i = 0; i num = h_num-i;
k = n;
para (j = ni; j> 0; j–, k -) {
printf (“% d”, num);
num = num-k;
}
}
}

n es el número de filas y columnas ingresadas por el usuario

k es el número que se restará en cada iteración para obtener el siguiente valor

h_num es el número más alto

num es el número que se imprimirá con cada iteración del bucle interno

A continuación se muestran las capturas de pantalla de la salida con valores tomados como n = 3, n = 5 yn = 12

El patrón en la pregunta es como el patrón de abajo, pero girado en sentido horario una vez

1

3 2

6 5 4

7 8 9 10

11 12 13 15 15

Entonces, una forma es generar la matriz e imprimir su transposición

x = (1..15) .to_a
y = []
1. hasta (5) {| i | y << (x.shift (i) .reverse + [nil] * (5 - i))}
pone y.transpose.map {| k | k.reverse.join (”)}. join (“\ n”)

Otra forma es notar

• cada fila comienza desde 15 – rownum + 1 y
• los números sucesivos seguidos difieren al disminuir las cantidades a partir de 5

row_start = 15
diff_start = 5
mientras row_start> = 11
print row_start, ”
diff = diff_iter = diff_start

while diff_iter> (15 – row_start) + 1
print row_start – diff, ”
diff_iter – = 1
diff + = diff_iter
fin
imprimir “\ n”
row_start – = 1
fin

Ambos ejemplos anteriores están en rubí

Código Java

public static void main (String [] args) {
int n = 5, s = n * (n + 1) / 2;
para (int i = 0; i int x = s – i;
para (int j = 0; j System.out.print (x + “”);
x – = (nj);
}
System.out.println ();
}
}

#include
usando el espacio de nombres estándar;
int main () {
int n;
cout << "Ingrese el valor para n:";
cin >> n;
cout << "\ n";
int first_val = (n * (n + 1)) / 2;
int no_of_lines = n;
while (no_of_lines> 0) {
int num_of_subs = no_of_lines;
int reductor = n;
int k = first_val;
while (reduciendo> 0 && k> 0 && num_of_subs> 0) {
cout << k << "";
k- = reductor;
reductor–;
num_of_subs–;
}
cout << "\ n";
no_of_lines–;
first_val–;
}
}

Eso es demasiado fácil si piensas:

vamos a esos números en una matriz

e iterar matriz y restar 1 de todos y soltar el último número

y repita el proceso hasta que el tamaño de la matriz sea 1 (eso es todo):

Aquí está el código C ++:

#include
usando el espacio de nombres estándar;
solución vacía (vector vec) {
if (vec.size () == 0)
regreso;
para (int i = 0; i {
cout << vec [i] << "";
vec [i] – = 1; // resta 1 de todos y por último no requiere
}
vec.pop_back ();
cout << "\ n";
solución (vec);
}
int main () {
vector vec;
int n;
cin >> n;
// Elemento de matriz de entrada
para (int i = 0; i int a;
cin >> a;
vec.push_back (a);
}
solución (vec);
devuelve 0;
}