Interquartilsabstand (IQR) in C berechnen

Einführung

In diesem Labor lernen Sie, wie man den Interquartilsabstand (IQR) in der C-Programmierung berechnet. Das Labor behandelt die Schritte zum Lesen und Sortieren eines Zahlenarrays, zum Ermitteln der Positionen des ersten und dritten Quartils (Q1 und Q3) und zur Berechnung des IQR als Differenz zwischen Q3 und Q1. Am Ende dieses Labors haben Sie ein solides Verständnis dafür, wie Sie diese statistische Analyse mit C durchführen.

Das Array lesen und sortieren

In diesem Schritt lernen Sie, wie Sie ein Zahlenarray lesen und sortieren, um den Interquartilsabstand (IQR) zu berechnen. Wir verwenden C-Programmierung, um diese Aufgabe zu erledigen.

Erstellen wir zunächst eine C-Quelldatei für unsere IQR-Berechnung:

cd ~/project
nano iqr_calculation.c

Schreiben wir nun den Anfangscode zum Lesen und Sortieren eines Arrays:

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

// Funktion zum Vergleichen von ganzen Zahlen für qsort
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    int numbers[MAX_SIZE];
    int n, i;

    // Anzahl der Elemente einlesen
    printf("Geben Sie die Anzahl der Elemente ein (max %d): ", MAX_SIZE);
    scanf("%d", &n);

    // Arrayelemente eingeben
    printf("Geben Sie %d ganze Zahlen ein:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &numbers[i]);
    }

    // Array sortieren
    qsort(numbers, n, sizeof(int), compare);

    // Sortiertes Array ausgeben
    printf("Sortiertes Array: ");
    for (i = 0; i < n; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    return 0;
}

Kompilieren Sie das Programm:

gcc -o iqr_calculation iqr_calculation.c

Führen Sie das Programm aus und geben Sie einen Beispieleintrag ein:

./iqr_calculation

Beispielausgabe:

Geben Sie die Anzahl der Elemente ein (max 100): 6
Geben Sie 6 ganze Zahlen ein:
45 22 14 65 97 72
Sortiertes Array: 14 22 45 65 72 97

Zerlegen wir den Code:

Wir definieren eine maximale Arraygröße von 100 Elementen.
Die Funktion compare() wird von qsort() verwendet, um ganze Zahlen zu sortieren.
Wir lesen die Anzahl der Elemente über die Benutzereingabe ein.
qsort() wird verwendet, um das Array aufsteigend zu sortieren.
Das sortierte Array wird dann ausgegeben.

Q1- und Q3-Positionen ermitteln und IQR = Q3 - Q1 berechnen

In diesem Schritt erweitern wir das vorherige Programm, um den Interquartilsabstand (IQR) zu berechnen, indem wir die Positionen von Q1 und Q3 ermitteln.

Öffnen Sie die vorherige Quelldatei:

cd ~/project
nano iqr_calculation.c

Aktualisieren Sie den Code, um den IQR zu berechnen:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_SIZE 100

// Funktion zum Vergleichen von ganzen Zahlen für qsort
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// Funktion zur Berechnung von Q1 und Q3
double calculateQuartile(int *arr, int n, double position) {
    int index = floor(position);
    double fraction = position - index;

    if (fraction == 0) {
        return arr[index - 1];
    } else {
        return arr[index - 1] * (1 - fraction) + arr[index] * fraction;
    }
}

int main() {
    int numbers[MAX_SIZE];
    int n, i;
    double q1, q3, iqr;

    // Anzahl der Elemente einlesen
    printf("Geben Sie die Anzahl der Elemente ein (max %d): ", MAX_SIZE);
    scanf("%d", &n);

    // Arrayelemente eingeben
    printf("Geben Sie %d ganze Zahlen ein:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &numbers[i]);
    }

    // Array sortieren
    qsort(numbers, n, sizeof(int), compare);

    // Positionen von Q1 und Q3 berechnen
    double q1_pos = 0.25 * (n + 1);
    double q3_pos = 0.75 * (n + 1);

    // Q1 und Q3 berechnen
    q1 = calculateQuartile(numbers, n, q1_pos);
    q3 = calculateQuartile(numbers, n, q3_pos);

    // IQR berechnen
    iqr = q3 - q1;

    // Ergebnisse ausgeben
    printf("Sortiertes Array: ");
    for (i = 0; i < n; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    printf("Q1: %.2f\n", q1);
    printf("Q3: %.2f\n", q3);
    printf("IQR: %.2f\n", iqr);

    return 0;
}

Kompilieren Sie das aktualisierte Programm:

gcc -o iqr_calculation iqr_calculation.c -lm

Führen Sie das Programm aus und geben Sie einen Beispieleintrag ein:

./iqr_calculation

Beispielausgabe:

Geben Sie die Anzahl der Elemente ein (max 100): 7
Geben Sie 7 ganze Zahlen ein:
12 15 18 22 25 30 35
Sortiertes Array: 12 15 18 22 25 30 35
Q1: 15.00
Q3: 30.00
IQR: 15.00

Wichtige Punkte im Code:

calculateQuartile() verarbeitet Arrays mit gerader und ungerader Größe.
Q1 wird am 25. Perzentil berechnet.
Q3 wird am 75. Perzentil berechnet.
IQR wird als Q3 - Q1 berechnet.
Für nicht ganzzahlige Positionen wird eine lineare Interpolation verwendet.

Ausgabe des IQR

In diesem letzten Schritt konzentrieren wir uns auf die Formatierung und Darstellung der Ergebnisse des Interquartilsabstands (IQR) in einer klaren und informativen Weise.

Öffnen Sie die vorherige Quelldatei:

cd ~/project
nano iqr_calculation.c

Aktualisieren Sie den Code, um die IQR-Ausgabe zu verbessern und beschreibende Texte hinzuzufügen:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_SIZE 100

// Vorherige Funktionen bleiben gleich (compare und calculateQuartile)

int main() {
    int numbers[MAX_SIZE];
    int n, i;
    double q1, q3, iqr;

    // Bildschirm löschen für eine bessere Darstellung
    printf("\033[2J\033[1;1H");

    // Einführung in den IQR
    printf("Interquartilsabstand (IQR) Rechner\n");
    printf("=====================================\n\n");

    // Anzahl der Elemente einlesen
    printf("Geben Sie die Anzahl der Elemente ein (max %d): ", MAX_SIZE);
    scanf("%d", &n);

    // Arrayelemente eingeben
    printf("Geben Sie %d ganze Zahlen ein:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &numbers[i]);
    }

    // Array sortieren
    qsort(numbers, n, sizeof(int), compare);

    // Positionen von Q1 und Q3 berechnen
    double q1_pos = 0.25 * (n + 1);
    double q3_pos = 0.75 * (n + 1);

    // Q1 und Q3 berechnen
    q1 = calculateQuartile(numbers, n, q1_pos);
    q3 = calculateQuartile(numbers, n, q3_pos);

    // IQR berechnen
    iqr = q3 - q1;

    // Detaillierte Ausgabe
    printf("\nErgebnisse der Datenanalyse\n");
    printf("--------------------\n");
    printf("Ursprünglicher Datensatz: ");
    for (i = 0; i < n; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n\n");

    // Formatierte IQR-Ausgabe
    printf("Quartilsanalyse:\n");
    printf("1. Quartil (Q1): %.2f\n", q1);
    printf("3. Quartil (Q3): %.2f\n", q3);
    printf("Interquartilsabstand (IQR): %.2f\n", iqr);

    // Interpretation des IQR
    printf("\nInterpretation:\n");
    printf("Der IQR gibt die Streuung der mittleren 50%% der Daten an.\n");
    printf("Ein kleinerer IQR deutet auf konsistentere Daten hin,\n");
    printf("während ein größerer IQR auf mehr Variabilität hindeutet.\n");

    return 0;
}

Kompilieren Sie das aktualisierte Programm:

gcc -o iqr_calculation iqr_calculation.c -lm

Führen Sie das Programm aus und geben Sie einen Beispieleintrag ein:

./iqr_calculation

Beispielausgabe:

Interquartilsabstand (IQR) Rechner
=====================================

Geben Sie die Anzahl der Elemente ein (max 100): 7
Geben Sie 7 ganze Zahlen ein:
12 15 18 22 25 30 35

Ergebnisse der Datenanalyse
--------------------
Ursprünglicher Datensatz: 12 15 18 22 25 30 35

Quartilsanalyse:
1. Quartil (Q1): 15.00
3. Quartil (Q3): 30.00
Interquartilsabstand (IQR): 15.00

Interpretation:
Der IQR gibt die Streuung der mittleren 50% der Daten an.
Ein kleinerer IQR deutet auf konsistentere Daten hin,
während ein größerer IQR auf mehr Variabilität hindeutet.

Wichtige Verbesserungen:

Hinzufügen eines Befehls zum Löschen des Bildschirms für eine bessere Darstellung
Verbesserte Ausgabeformatierung
Einschließlich einer Interpretation des IQR
Beibehaltung der vorherigen Berechnungslogik

Zusammenfassung

In diesem Labor haben Sie zunächst gelernt, wie man ein Zahlenarray in der C-Programmierung liest und sortiert. Sie haben eine C-Quelldatei erstellt, den Anfangscode geschrieben, um die Arrayelemente einzulesen und mithilfe der qsort()-Funktion zu sortieren. Anschließend haben Sie das sortierte Array ausgegeben, um den Sortiervorgang zu überprüfen.

Als Nächstes werden Sie das vorherige Programm modifizieren, um den Interquartilsabstand (IQR) zu berechnen, indem Sie die Positionen des ersten Quartils (Q1) und des dritten Quartils (Q3) ermitteln und dann den IQR als Q3 - Q1 berechnen. Schließlich werden Sie den berechneten IQR ausgeben.

Berechnung des Interquartilsabstands (IQR) in C

Einführung

Lesen reicht nicht – Programmieren ist Praxis.

Das Array lesen und sortieren

Q1- und Q3-Positionen ermitteln und IQR = Q3 - Q1 berechnen

Dein Coding-Labor im Browser.

Ausgabe des IQR

Zusammenfassung