# Lesbarkeit

Quelle: https://dev.inf.zone/exercises/03/readability/

![Charlotte's Web Cover](https://dev.inf.zone/exercises/03/readability/charlottes_web.jpg)

## Aufgabe

**Auf einen Blick**

- **Was:** Ein Programm, das schätzt, ab welcher (US-amerikanischen) Klassenstufe man einen englischen Text verstehen kann.
- **Datei:** `readability.c` in einem Ordner `readability`.
- **Eingabe:** ein Text (`Text: Congratulations! Today is your day. You're off to Great Places! You're off and away!`).
- **Ausgabe:** die Klassenstufe, hier `Grade 3`. Ab 16 lautet die Ausgabe `Grade 16+`, unter 1 `Before Grade 1`.

### So funktioniert der Coleman-Liau-Index

Der Index schätzt die Klassenstufe aus zwei Größen: Wie lang sind die Wörter, und wie lang sind die Sätze?

1. **Buchstaben:** Es zählen nur die Buchstaben `a` bis `z` und `A` bis `Z`. Ziffern, Satzzeichen, Apostrophe und Leerzeichen zählen nicht.
2. **Wörter:** Jede durch Leerzeichen getrennte Zeichenfolge ist ein Wort, auch `self-conscious` oder „Schritt-für-Schritt-Anleitung“.
3. **Sätze:** Jedes `.`, `!` und `?` beendet einen Satz.
4. **Durchschnitte:** \(L\) ist die Zahl der Buchstaben pro 100 Wörter, \(S\) die Zahl der Sätze pro 100 Wörter:
   \[ L = \frac{\text{Buchstaben}}{\text{Wörter}} \cdot 100 \qquad S = \frac{\text{Sätze}}{\text{Wörter}} \cdot 100 \]
5. **Index:** Man setzt \(L\) und \(S\) in die Formel ein und rundet das Ergebnis auf die nächste ganze Zahl:
   \[ \text{index} = 0.0588 \cdot L - 0.296 \cdot S - 15.8 \]
6. **Ausgabe:** Ist der gerundete Index 16 oder größer, lautet die Ausgabe `Grade 16+`; ist er kleiner als 1, `Before Grade 1`; sonst `Grade X` mit dem gerundeten Index als X.

**Beispiel** mit dem Text `Congratulations! Today is your day. You're off to Great Places! You're off and away!`:

| Schritt     | Rechnung                                              | Ergebnis |
| ----------- | ----------------------------------------------------- | -------- |
| Buchstaben  | ohne Leerzeichen, `!`, `.` und die Apostrophe in `You're` | 65       |
| Wörter      | 13 Leerzeichen, also 14 Wörter                        | 14       |
| Sätze       | `!`, `.`, `!`, `!`                                    | 4        |
| \(L\)       | \(65 / 14 \cdot 100\)                                 | 464.29   |
| \(S\)       | \(4 / 14 \cdot 100\)                                  | 28.57    |
| Index       | \(0.0588 \cdot 464.29 - 0.296 \cdot 28.57 - 15.8\)    | 3.04     |
| Ausgabe     | gerundet 3                                            | `Grade 3` |

Woher solche Lesbarkeitsformeln kommen, steht am Ende der Seite unter „Zum Weiterlesen“.

## Demo

[Terminal-Aufzeichnung ansehen](https://asciinema.org/a/2YTPtsNbRP2p4bD4drEjHaoRj)

## Spezifikation

-   Implementieren Sie Ihr Programm in C in einer Datei namens `readability.c` in einem Ordner namens `readability`.
-   Ihr Programm fragt mit `get_string` und der Aufforderung `Text: ` nach einem Text.
-   Es zählt Buchstaben, Wörter und Sätze nach den Regeln 1 bis 3 oben. Sie können davon ausgehen, dass der Text mindestens ein Wort enthält, nicht mit einem Leerzeichen beginnt oder endet und keine mehrfachen Leerzeichen hintereinander enthält.
-   Es berechnet den Coleman-Liau-Index nach den Regeln 4 und 5 und gibt nach Regel 6 genau eine Zeile aus: `Grade X`, `Grade 16+` oder `Before Grade 1`, jeweils mit Zeilenumbruch.

## Hilfestellung

Klicken Sie auf die folgenden Tipps, um einige Ratschläge zu erhalten. Versuchen Sie aber zunächst, selbst so weit wie möglich zu kommen.

**Ordner und Datei anlegen**

Prüfen Sie vor `mkdir readability` mit `pwd`, in welchem Verzeichnis Sie sich befinden. Wenn Sie gerade [Scrabble](https://dev.inf.zone/exercises/03/scrabble/) bearbeitet haben, sind Sie vermutlich noch in `scrabble`. Mit `cd ../` gelangen Sie eine Ebene nach oben. Danach legen Sie Ordner und Datei an wie bei [Scrabble](https://dev.inf.zone/exercises/03/scrabble/#schritt-für-schritt).

**Beginnen Sie mit Code, der kompilierbar ist**

```c
#include <ctype.h>
#include <cs50.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

int main(void)
{

}
```

Die eingebundenen Header-Dateien geben Ihnen Zugriff auf Funktionen, die Ihnen bei dieser Aufgabe helfen können.

**Versuchen Sie das Problem in Pseudocode zu beschreiben**

Die Aufgabe besteht aus vier kleineren Problemen:

1. Den Benutzer nach einem Text fragen.
2. Buchstaben, Wörter und Sätze des Textes zählen.
3. Den Coleman-Liau-Index berechnen.
4. Die Klassenstufe ausgeben.

Schreiben Sie diese Teilprobleme als Kommentare in Ihr Programm und bearbeiten Sie sie dann nacheinander:

```c
#include <ctype.h>
#include <cs50.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Prompt the user for some text

    // Count the number of letters, words, and sentences in the text

    // Compute the Coleman-Liau index

    // Print the grade level
}
```

> [!WARNING]
> Der letzte Tipp zeigt Ihnen Schritt für Schritt den Großteil einer möglichen Lösung. Idealerweise schauen Sie sich diesen erst an, nachdem Sie die Aufgabe bearbeitet haben - oder zumindest ernsthaft versucht haben, die Aufgabe zu bearbeiten.

**Wandeln Sie den Pseudocode in Code um**

**Text abfragen.** `get_string` aus der [CS50-Bibliothek](https://manual.cs50.io/3/get_string) fragt den Benutzer nach einer Zeichenkette:

```c
string text = get_string("Text: ");
```

**Buchstaben zählen.** Schreiben Sie eine Funktion `count_letters`, die eine Zeichenkette entgegennimmt und die Zahl ihrer Buchstaben als `int` zurückgibt:

```c
int count_letters(string text)
{
    // Return the number of letters in text
}
```

Ob ein Zeichen ein Buchstabe ist, müssen Sie nicht selbst prüfen: Suchen Sie im [CS50-Handbuch](https://manual.cs50.io/) nach einer passenden Funktion aus der C-Standardbibliothek.

**Wörter zählen.** Schreiben Sie ebenso eine Funktion `count_words`. Unter den Annahmen aus der Spezifikation (keine Leerzeichen am Anfang oder Ende, keine mehrfachen Leerzeichen) gibt es eine einfache Beziehung zwischen der Zahl der Wörter und der Zahl der Leerzeichen. Sie können natürlich auch eine Lösung versuchen, die mit mehrfachen Leerzeichen oder ganz ohne Wörter zurechtkommt.

**Sätze zählen.** Fehlt noch `count_sentences`, die jedes `.`, `!` und `?` zählt.

Zusammen sieht das Gerüst so aus:

```c
#include <ctype.h>
#include <cs50.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

int count_letters(string text);
int count_words(string text);
int count_sentences(string text);

int main(void)
{
    // Prompt the user for some text
    string text = get_string("Text: ");

    // Count the number of letters, words, and sentences in the text
    int letters = count_letters(text);
    int words = count_words(text);
    int sentences = count_sentences(text);

    // Compute the Coleman-Liau index

    // Print the grade level
}

int count_letters(string text)
{
    // Return the number of letters in text
}

int count_words(string text)
{
    // Return the number of words in text
}

int count_sentences(string text)
{
    // Return the number of sentences in text
}
```

**Index berechnen und ausgeben.**

-   Teilen Sie zwei `int`-Werte, ist in C auch das Ergebnis ein `int`: Die Nachkommastellen werden abgeschnitten, nicht gerundet (aus `3.7` wird `3`). Wandeln Sie deshalb bei der Berechnung von \(L\) und \(S\) mindestens einen Wert in `float` um, bevor Sie teilen.
-   Zum Runden gibt es die Funktion `round`, die laut [Handbuch](https://manual.cs50.io/3/round) in `math.h` deklariert ist.
-   Vergleichen Sie für die Ausgabe den *gerundeten* Index mit 16 und 1 (Regel 6).

## Testen

Führen Sie Ihr Programm mit den folgenden Texten aus und prüfen Sie, ob die angegebene Klassenstufe erscheint. Kopieren Sie nur den Text, ohne zusätzliche Leerzeichen.

-   `One fish. Two fish. Red fish. Blue fish.` (Before Grade 1)
-   `Would you like them here or there? I would not like them here or there. I would not like them anywhere.` (Grade 2)
-   `Congratulations! Today is your day. You're off to Great Places! You're off and away!` (Grade 3)
-   `Harry Potter was a highly unusual boy in many ways. For one thing, he hated the summer holidays more than any other time of year. For another, he really wanted to do his homework, but was forced to do it in secret, in the dead of the night. And he also happened to be a wizard.` (Grade 5)
-   `In my younger and more vulnerable years my father gave me some advice that I've been turning over in my mind ever since.` (Grade 7)
-   `Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do: once or twice she had peeped into the book her sister was reading, but it had no pictures or conversations in it, "and what is the use of a book," thought Alice "without pictures or conversation?"` (Grade 8)
-   `When he was nearly thirteen, my brother Jem got his arm badly broken at the elbow. When it healed, and Jem's fears of never being able to play football were assuaged, he was seldom self-conscious about his injury. His left arm was somewhat shorter than his right; when he stood or walked, the back of his hand was at right angles to his body, his thumb parallel to his thigh.` (Grade 8)
-   `There are more things in Heaven and Earth, Horatio, than are dreamt of in your philosophy.` (Grade 9)
-   `It was a bright cold day in April, and the clocks were striking thirteen. Winston Smith, his chin nuzzled into his breast in an effort to escape the vile wind, slipped quickly through the glass doors of Victory Mansions, though not quickly enough to prevent a swirl of gritty dust from entering along with him.` (Grade 10)
-   `A large class of computational problems involve the determination of properties of graphs, digraphs, integers, arrays of integers, finite families of finite sets, boolean formulas and elements of other countable domains.` (Grade 16+)

### Korrektheit

Führen Sie in Ihrem Terminal den folgenden Befehl aus, um die Korrektheit Ihrer Arbeit zu überprüfen:

```bash
check50 -l inf-zone/exercises/2026/readability
```

### Style

Führen Sie den folgenden Befehl aus, um den Stil Ihres Codes mit `style50` zu analysieren:

```bash
style50 readability.c
```

## Abgeben

Geben Sie im Ordner `readability` ab:

```bash
inf upload readability
```

Danach sehen Sie, welche Tests Ihr Programm besteht und ob die Übung für die Bonuspunkte zählt. Wie Sie `inf` installieren und sich anmelden, steht unter [Abgeben mit `inf`](https://dev.inf.zone/faq/uebung-solutions/#inf-installieren).

## Zum Weiterlesen: Wie misst man Lesbarkeit?

Für die Lösung der Aufgabe nicht nötig.

Laut [Scholastic](https://www.scholastic.com/teachers/teaching-tools/collections/guided-reading-book-lists-for-every-level.html) liegt das Leseniveau von E. B. Whites _Charlotte's Web_ zwischen der zweiten und vierten Klasse, das von Lois Lowrys _The Giver_ zwischen der achten und zwölften. Oft legen menschliche Fachleute ein solches Leseniveau fest, nachdem sie das Buch gelesen haben.

Man kann es aber auch berechnen. Längere Wörter und längere Sätze gehen meist mit einem höheren Leseniveau einher. Darauf beruhen verschiedene „Lesbarkeitstests“, die das Leseniveau eines Textes per Formel bestimmen. Der Coleman-Liau-Index ist einer davon; er wurde entwickelt, um die US-amerikanische Klassenstufe zu schätzen, die man zum Verständnis eines Textes braucht.