Tres pistas:
1. En C una sentencia es falsa si se evalúa a 0 y es verdadera si se evalúa diferente a 0.
2. while ejecuta su código asociado si la condición es cierta y repite.
3. scanf devuelve el número de conversiones realizadas con éxito, es decir, en caso de no poder hacer ninguna devuelve 0.

Sigo creyendo que es un problema de mala interpretación. Viendo algunas soluciones al tablero de las 8 reinas siempre hay algunas de ellas alineadas, aunque sea a dos saltos de caballo.

---

Se me ha ocurrido. A ver si en línea recta no quiere decir que el intervalo de de tres reinas significa la misma función de recta entre las tres:
Por ejemplo un salto de caballo [+2, -1], o un salto un poco más largo [+3, +2]. Entonces sí se podría decir que están alineadas por una recta, pero tal y como muestras en el ejemplo de tu ejercicio pues no es una recta; es una línea pero no es recta.

La alineación se refiere, cómo has dicho, en la misma diagonal, columna o fila. Para lo demás está bien. Si ya lo tienes resuelto así ya has terminado.

No.
Supongamos que mayor vale 100.
Consigues la nota de un alumno, supongamos 50.

Si comparas si nota > mayor (50 > 100) siempre saldrá como más grande mayor.

En cambio si haces, en un principio, que mayor vale 0, en la primera comparación harás nota > mayor (50 > 0), cosa que será verdadera y podrás hacer mayor = nota.

Empieza definiendo notamenor=100 y notamayor=0. En el for, por cada nota válida, si la nota > notamayor, actualizas notamayor = nota; y si la nota < notamenor, actualizas notamenor = nota.

Es al revés p1.wheight. Primero va la variable de tipo estructura (que es quien engloba) y después su variable interna.

C no retorna múltiples valores, solo uno.
Deberás pasar datos por referencia o hacer las variables n1, n2 y n3 globales.

Como te decía, la estructura no debe guardar el IMC, lo debes sacar de forma que no se pueda modificar, y eso es con una función.

Algo así:

Cada vez que en el código debas obtener el IMC de alguien usas la función.

¿Por qué? Imagínate que IMC se guarda en la estructura y la calculas:

Ahora tienes en p.IMC el índice de masa corporal, pero eso no evita que en cualquier otro punto del programa se haga

A partir de este momento el IMC será 25 porqué sí y no el resultado del cálculo.

A ver:
Dentro de una estructura no se puede poner código. Ahí intentas que IMC sea calculado por una operación matemática pero eso debes hacerlo en otro sitio.
Y aunque fuera C++, que sí permite código éste debe encapsulado en un método, no se puede escribir directamente.
Siendo coherentes con el código deberías eliminar todo lo referente al IMC de la estructura ya que si dejas allí la variable en cualquier momento se podría cambiar falseando el dato.

Haz una función que reciba la estructura, calcule la IMC a partir de sus datos y lo devuelva.

De todas formas veo algo raro con las funciones PrintPatient#(tPatient p#);
¿Las funciones hacen cosas diferentes? ya que tPatient, tPatient2 y tPatient3 son el mismo tipo de dato ¿porqué hay 3? Una cosa es el tipo de dato y la otra las variables.
Si las funciones PrintPatient# son todas iguales te basta que exista solo una y le vayas pasando las diferentes variables de los pacientes. Algo así:

Bueno, creo que te has complicado un poco.
Empieza instalando un valor que indique que la casilla está vacía, yo he usado el 0 (aprovechando que 0 significa también false y cualquier otro número true).

El primer paso de meter el 5 y el 6 en la primera y última fila es muy sencillo ya que la matriz está vacía. Caigan donde caigan están bien.

Para incluir el 2 y el 3 tampoco tiene mucha complicación. Se corre la matriz por filas desde el inicio hasta penúltima fila. Por fila:
· Buscar una misma columna vacía para y e y+1
· En y incluir el 2.
· En y+1 incluir el 3.

Para incluir los entre números aprovecha las marcas de casilla vacía. Prepara una bandera para indicar si debes escribir los unos o no.

Por cada fila:
· desactiva la badnera
· Por cada columna:
   · Si la bandera está desactivada y la casilla no está vacía:
      · activa la bandera (Después de activar esa bandera no debes hacer nada y esperar a la siguiente iteración)
   · Y si no:
      · Si la casilla está vacía:
         · escribe un 1 en ella
      · Y si no:
         · termina el bucle columna

Para terminar de rellenar la matriz recórrela casilla por casilla. Si la casilla está vacía introduce 1 o 4 aleatoriamente.

Esto en C11 quedaría así:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
 
/* Matriz global por lo que
 * al crearla se llena de ceros ( 0 )
 * así que aprovecharé eso para
 * marcar la posición vacía
 */
#define FILAS 4u
#define COLUMNAS 6u
 
int matriz[FILAS][COLUMNAS];
 
// devuelve una casilla vacia aleatoria
// en la fila y del array
unsigned columna_vacia_en_fila(unsigned fila) {
    unsigned x;
 
    do {
        x = rand()%COLUMNAS;
    } while(matriz[fila][x] && matriz[fila+1][x]);
 
    return x;
}
 
// incluir el 5 en la primera fila
// y el 6 en la última fila
void incluir_5_6() {
    unsigned x;
 
    x = rand()%COLUMNAS;
    matriz[0][x] = 5;
 
    x = rand()%COLUMNAS;
    matriz[FILAS-1][x] = 6;
}
 
// incluir el 2 en fila y+1
// y el 3 en la fila y+1
void incluir_2_3() {
    unsigned x, y;
 
    for(y=0; y<FILAS-1; ++y) {
        x = columna_vacia_en_fila(y);
        matriz[y][x] = 2;
        matriz[y+1][x] = 3;
    }
}
 
// incluir el 1 entre dos números en una fila
// por cada fila
void incluir_1_entre() {
    unsigned x, y;
    bool escribir;
 
    for(y=0; y<FILAS; ++y) {
        escribir = false;
        for(x=0; x<COLUMNAS; ++x) {
            if(!escribir && matriz[y][x]) {
                escribir = true;
            }
            else {
                if(matriz[y][x]) break;
                else matriz[y][x] = 1;
            }
        }
    }
}
 
// rellenar indistintamente con 1
// y 4 las casillas que faltan
void incluir_1_4() {
    unsigned x, y;
 
    for(y=0; y<FILAS; ++y) {
        for(x=0; x<COLUMNAS; ++x) {
            if(matriz[y][x] == 0) {
                matriz[y][x] = rand()%2? 4 : 1;
            }
        }
    }
}
 
// imprimir la matriz
void imprimir() {
    unsigned x, y;
 
    for(y=0; y<FILAS; ++y) {
        for(x=0; x<COLUMNAS; ++x) {
            printf("%d ", matriz[y][x]);
        }
        puts("\n");
    }
}
 
int main() {
    srand(time(NULL));
 
    incluir_5_6();
    incluir_2_3();
    incluir_1_entre();
    incluir_1_4();
 
    imprimir();
}

---

Gracias a un dato apuntado por NEBIRE en la siguiente respuesta me he dado cuenta de algo que se me había pasado por alto: el 2 y el 3 deben estar en la misma columna.
Solucionado en la reedición.