Tiene pinta de que no se está interpretando el código PHP, esto puede ocurrir porque no tengas instalado un servidor web por ejemplo, ¿como estás ejecutando el código?

Crea un fichero phpinfo.php y dentro pon únicamente:

<?php
phpinfo();
 

Y ejecútalo, a ver que pasa, si aparece el texto del fichero es que no se está ejecutando, qué servidor tienes instalado?

Suponiendo que tienes una estructura algo así:

struct persona {
    char nombre[20];
    char sexo; // 'M' o 'H'
    int fumador; // 1 o 0
 

La condición quedaría así:

struct persona p;
if (p.sexo == 'M' && p.fumador == 1) {
    printf("%s\n", p.nombre);
}
 

Y el código? Qué dudas tienes?

EDITO: Te faltan datos amigo, del cliente solo tenemos el id en ese fichero y tu quieres imprimir TODA su información...

Soy nuevo en tu lenguaje

Necesito una respuesta que me diga qué llevas hecho, la estructura de los ficheros csv que estás leyendo gracias...

No vas mal, deberías separar las tareas (como obtener media, moda, mediana y desviación) en funciones

#include <stdio.h>
#include <stdlib.h>
 
typedef unsigned short ushort;
 
void leer(float*, ushort);
void ordenar(float*, ushort);
void imprimir(float*, ushort);
 
float moda(float*, ushort);
float media(float*, ushort);
float mediana(float*, ushort);
float desviacion(float*, ushort);
 
int main(void) {
    const ushort longitud = 5;
    float notas[longitud];
 
    leer(notas, longitud);
    ordenar(notas, longitud);
    imprimir(notas, longitud);
 
    printf(
        "Menor: %.1f\n"
        "Mayor: %.1f\n"
        "Moda: %.1f\n"
        "Media: %.1f\n"
        "Mediana: %.1f\n"
        "Desviación: %.1f\n",
        notas[0],
        notas[longitud - 1],
        moda(notas, longitud),
        media(notas, longitud),
        mediana(notas, longitud),
        desviacion(notas, longitud)
    );
 
    return EXIT_SUCCESS;
}
 
void leer(float* notas, ushort longitud) {
    for(ushort nota = 0; nota < longitud; nota++) {
        printf("Nota %hu > ", nota + 1);
        scanf("%f", &notas[nota]);
    }
}
 
void ordenar(float *notas, ushort longitud) {
    for(ushort vuelta = 1; vuelta < longitud; vuelta++) {
        for(ushort nota = 0; nota < longitud - vuelta; nota++) {
            if (notas[nota] > notas[nota + 1]) {
                float actual = notas[nota];
                notas[nota] = notas[nota + 1];
                notas[nota + 1] = actual;
            }
        }
    }
}
 
void imprimir(float *notas, ushort longitud) {
    for(ushort nota = 0; nota < longitud; nota++) {
        printf("%.1f%s", notas[nota], nota < longitud - 1 ? ", " : "\n");
    }
}
 
float moda(float *notas, ushort longitud) {
    float moda = 0, anterior = 0;
    for (ushort vuelta = 0; vuelta < longitud; vuelta++) {
        ushort repeticiones = 0;
        for (ushort nota = 0; nota < longitud; nota++) {
            if (notas[vuelta] == notas[nota]) {
                repeticiones++;
            }
        }
        if (repeticiones > anterior) {
            anterior = repeticiones;
            moda = notas[vuelta];
        }
    }
    return moda;
}
 
float media(float *notas, ushort longitud) {
    float suma = 0;
    for(ushort nota = 0; nota < longitud; nota++) {
        suma += notas[nota];
    }
    return suma / longitud;
}
 
float mediana(float *notas, ushort longitud) {
    return
        longitud % 2 != 0 ?
        notas[(ushort) (longitud - 1) / 2] :
        (notas[(longitud - 1) / 2] + notas[(longitud - 1) / 2 + 1]) / 2;
}
 
float desviacion(float *notas, ushort longitud) {
    float suma = 0;
    for(ushort nota = 0; nota < longitud; nota++) {
        suma += pow(notas[nota] - media(notas, longitud), 2);
    }
    return sqrt(suma/longitud);
}
 

En la wikipedia tienes las fórmulas, según este artículo el discriminante se representa por la letra "D"
https://es.wikipedia.org/wiki/Ecuaci%C3%B3n_de_segundo_grado#Discriminante

Dentro de la cabecera "complex.h" existe una macro llamada "I", que sí, se trata de la constante imaginaria
http://en.cppreference.com/w/c/numeric/complex

float discriminante(float a, float b, float c) {
    sqrt(pow(b, 2) - 4 * a * c);
}
 
float solucionRealDoble(float a, float b) {
    return (-b / (2 * a));
}
 
float solucionReal1(float a, float b, float D) {
    return (-b + sqrt(D)) / (2 * a);
}
 
float solucionReal2(float a, float b, float D) {
    return (-b - sqrt(D)) / (2 * a);
}
 
float solucionCompleja1(float a, float b, float D) {
    return (-b / (2 * a)) + I * (sqrt(-D) / (2 * a));
}
 
float solucionCompleja2(float a, float b, float D) {
    return (-b / (2 * a)) - I * (sqrt(-D) / (2 * a));
}
 

Perdón supuse que tenías que guardar en ficheros, pero si sabes manejar arrays seguramente debas resolver el problema por ese camino.

Ahora que ya tienes las estructuras, puedes empezar a preguntarte qué necesitas para trabajar:

- 1 array donde quepan 10 canciones
- 1 array donde quepan los oyentes (los oyentes, como puedes comprobar en las estructuras, ya almacenan sus 3 votos en su array de canciones)

Una vez tengas toda esa memoria reservada, el siguiente paso es pedir al usuario que ingrese toda esa información (canciones y oyentes) o ponerla directamente en el código para probar más fácil la aplicación.

Siguiente: recorrer el array de oyentes y sus arrays de canciones para determinar cuales son la 1ra y la 2da más votadas.

Siguiente: recorrer el array de oyentes y sus canciones para comprobar si habría que asignarle puntos por tener una de las canciones más votadas entre sus favoritas. Durante este recorrido podrías crear un array donde guardes la cedula del oyente y la suma de sus puntos (lo ideal sería un campo puntuacion en la estructura del oyente, el cual irías acumulando), para más tarde obtener la cédula del que mayor puntuación ha obtenido y mostrarlo en pantalla.

Bastante verde sí...

Empieza por definir lo que necesitas, podrías definir una cabecera con los tipos de datos, no ibas mal con el "Oyente", pero seguramente la cedula sea una string (char[]), también te pide sus 3 canciones favoritas, etc...

//Género de las canciones
typedef enum {
    Pop, Rap, Rock, Romantica
} Genero;
 
//Sexo de los oyentes
typedef enum {
    Femenino, Masculino, Otro
} Sexo;
 
//Canción con los datos requeridos
typedef struct {
    unsigned short codigo;
    char* nombre;
    Genero genero;
} Cancion;
 
//Oyente con los datos requeridos
typedef struct {
    char* cedula;
    Sexo sexo;
    unsigned short edad;
    Cancion canciones[3];
} Oyente;
 

Ten en cuenta que para resolver este problema necesitas manejar ficheros y punteros por todos lados, así que ya puedes espabilar!

Está interesante!! Pero antes de nada queremos ver lo que tienes hecho y que dudas te atañen, un saludo!

Compi, no se trata de que en 'main'' hagas todo el trabajo, debes repasar conceptos como 'encapsulación', los objetos son los que saben sobre sí mismos y como comportarse, echa un ojo, en main simplemente los creas y los muestras, incluso podríamos haberles dado la capacidad de imprimirse ellos solos (incluso sobrecargando el operador <<) pero es demasiado, repasa...

#include <iostream>
 
using namespace std;
 
class Cuadrado {
private:
    float lado;
 
public:
 
    Cuadrado(float lado) {
        this->lado = lado;
    }
 
    float obtenerLado() {
        return this->lado;
    }
 
    float obtenerArea() {
        return this->lado * this->lado;
    }
 
    float obtenerPerimetro() {
        return this->lado * 4;
    }
 
};
 
int main(void) {
    Cuadrado c1(2), c2(7);
 
    cout
        << "Cuadrado 'c1'" << endl
        << "Lado: " << c1.obtenerLado() << endl
        << "Área: " << c1.obtenerArea() << endl
        << "Perímetro: " << c1.obtenerPerimetro() << endl << endl;
 
    cout
        << "Cuadrado 'c2'" << endl
        << "Lado: " << c2.obtenerLado() << endl
        << "Área: " << c2.obtenerArea() << endl
        << "Perímetro: " << c2.obtenerPerimetro() << endl << endl;
}