Slovní vyjádření čísel – demonstrační program

_slovne.md

Slovní vyjádření čísel

Tento program je proof of concept. Reálné využití je takřka nulové, jde o to, že program napsaný v C umí vypsat slovně zadané číslo.

Zdrojový kód je přenositelný, lze jej zkompilovat na jakémkoliv operačním systému podporující kompilaci z jazyka C (Windows, Linux, MacOS jakožto 3 hlavní platformy), na hlavních architekturách, jako x86, x86_64, ARM32, ARM64 a MIPS.

Použití

Program se dá použít jako terminál nebo jako příkazový nástroj. Program se nachází v režimu terminálu tehdy, když není zadán argument příkazového řádku.

Režim terminálu:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> 852

Vstup uživatele: 852.000000
Číslo vyjádřeno slovy je:

osm set padesát dvě

Režim příkazového řádku:

$ slovne 666
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Vstup uživatele: 666.000000
Číslo vyjádřeno slovy je:

šest set šedesát šest

Pokud uživatel zadá cokoliv jiného, než číslo, program vypíše chybu:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> blbost

CHYBA! Zadaný vstup není číslo!

Pokud uživatel zadá číslo mimo stanovený rozsah, program vypíše chybu:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> 1000000000000000000

CHYBA! Zadané číslo je mimo stanovený rozsah!

Číslo lze zadávat i s desetinnou tečkou:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> 3.14

Vstup uživatele: 3.140000
Číslo vyjádřeno slovy je:

tři celých jedna desetina čtyři setiny

Řád desetimiliontin se zaokrouhluje na miliontiny:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> 0.0000007

Vstup uživatele: 0.000001
Číslo vyjádřeno slovy je:

nula celých jedna miliontina

Zadávat lze i záporná čísla:

$ slovne
------------------------------------------------------
  Konvertor čísla na slovní vyjádření
------------------------------------------------------

Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.
Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.

Zadejte číslo zde> -800

Vstup uživatele: -800.000000
Číslo vyjádřeno slovy je:

minus osm set

Níže jsou zdrojové kódy tohoto programu.

definice.h

/**************************************************
 * Program pro slovní výpis vstupního čísla
 * Užití: slovne <cislo>
 * Pokud uživatel nezadá ono číslo, program si vstup
 * vyžádá.
 *
 * Rozsah je od -10^18 do +10^18
 *
 * Kód vytvořil: Marek Poláček (Polda18)
 *
 * Soubor: definice.h
 **************************************************/

#pragma once

#ifndef __DEFINICE_H__
#define __DEFINICE_H__

// Definice přepínačů
//------------------------------------------------------
#define PREPINAC_JEDNOTKY           0
#define PREPINAC_STOVKY             1
#define PREPINAC_RADY_CELE          2
#define PREPINAC_RADY_DESETINNE     3

// Definice slovních jednotek
//------------------------------------------------------

// Trojřády
#define TRILION             "trilion"
#define TRILIONY            "triliony"
#define TRILIONU            "trilionů"

#define BILION              "bilion"
#define BILIONY             "biliony"
#define BILIONU             "bilionů"

#define MILIARDA            "miliarda"
#define MILIARDY            "miliardy"
#define MILIARD             "miliard"

#define MILION              "milion"
#define MILIONY             "miliony"
#define MILIONU             "milionů"

#define TISIC               "tisíc"
#define TISICE              "tisíce"

// Stovky
#define STO                 "sto"
#define STE                 "stě"
#define STA                 "sta"
#define SET                 "set"

// Jednotky
#define JEDEN               "jeden"
#define JEDNA               "jedna"
#define JEDNO               "jedno"
#define DVA                 "dva"
#define DVE                 "dvě"
#define TRI                 "tři"
#define CTYRI               "čtyři"
#define PET                 "pět"
#define SEST                "šest"
#define SEDM                "sedm"
#define OSM                 "osm"
#define DEVET               "devět"

#define DESET               "deset"
#define JEDENACT			"jedenáct"
#define DVANACT				"dvanáct"
#define TRINACT				"třináct"
#define CTRNACT				"čtrnáct"
#define PATNACT				"patnáct"
#define SESTNACT			"šestnáct"
#define SEDMNACT			"sedmnáct"
#define OSMNACT				"osmnáct"
#define DEVATENACT			"devatenáct"

#define DVACET              "dvacet"
#define TRICET              "třicet"
#define CTYRICET            "čtyřicet"
#define PADESAT             "padesát"
#define SEDESAT             "šedesát"
#define SEDMDESAT           "sedmdesát"
#define OSMDESAT            "osmdesát"
#define DEVADESAT           "devadesát"

#define NULA                "nula"

#define CELYCH              "celých"

#define DESETINA            "desetina"
#define DESETINY            "desetiny"
#define DESETIN             "desetin"
#define SETINA              "setina"
#define SETINY              "setiny"
#define SETIN               "setin"
#define TISICINA            "tisícina"
#define TISICINY            "tisícíny"
#define TISICIN             "tisícin"
#define DESETITISICINA      "desetitisícina"
#define DESETITISICINY      "desetitisíciny"
#define DESETITISICIN       "desetitisícin"
#define STOTISICINA         "stotisícina"
#define STOTISICINY         "stotisíciny"
#define STOTISICIN          "stotisícin"
#define MILIONTINA          "miliontina"
#define MILIONTINY          "miliontiny"
#define MILIONTIN           "miliontin"

#endif

funkce.c

/**************************************************
 * Program pro slovní výpis vstupního čísla
 * Užití: slovne <cislo>
 * Pokud uživatel nezadá ono číslo, program si vstup
 * vyžádá.
 *
 * Rozsah je od -10^18 do +10^18
 *
 * Kód vytvořil: Marek Poláček (Polda18)
 *
 * Soubor: funkce.c
 **************************************************/

// Důležité globální knihovny
//------------------------------------------------------
#include <stdio.h>
#include <stdbool.h>

// Důležité lokální knihovny
//------------------------------------------------------
#include "definice.h"
#include "funkce.h"

// Definice funkcí
//------------------------------------------------------

// Privátní funkce
void slovo_jednotky(int pocet, int prepinac) {
    switch (pocet) {
    case 1:
        switch (prepinac) {
        case PREPINAC_JEDNOTKY:
        case PREPINAC_RADY_DESETINNE:
            fprintf(stdout, JEDNA);
            break;
        case PREPINAC_STOVKY:
            fprintf(stdout, JEDNO);
            break;
        case PREPINAC_RADY_CELE:
            fprintf(stdout, JEDEN);
            break;
        }
        break;
    case 2:
        switch (prepinac) {
        case PREPINAC_JEDNOTKY:
        case PREPINAC_STOVKY:
        case PREPINAC_RADY_DESETINNE:
            fprintf(stdout, DVE);
            break;
        case PREPINAC_RADY_CELE:
            fprintf(stdout, DVA);
            break;
        }
        break;
    case 3:
        fprintf(stdout, TRI);
        break;
    case 4:
        fprintf(stdout, CTYRI);
        break;
    case 5:
        fprintf(stdout, PET);
        break;
    case 6:
        fprintf(stdout, SEST);
        break;
    case 7:
        fprintf(stdout, SEDM);
        break;
    case 8:
        fprintf(stdout, OSM);
        break;
    case 9:
        fprintf(stdout, DEVET);
        break;
    }
}

void slovo_nactky(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, JEDENACT);
        break;
    case 2:
        fprintf(stdout, DVANACT);
        break;
    case 3:
        fprintf(stdout, TRINACT);
        break;
    case 4:
        fprintf(stdout, CTRNACT);
        break;
    case 5:
        fprintf(stdout, PATNACT);
        break;
    case 6:
        fprintf(stdout, SESTNACT);
        break;
    case 7:
        fprintf(stdout, SEDMNACT);
        break;
    case 8:
        fprintf(stdout, OSMNACT);
        break;
    case 9:
        fprintf(stdout, DEVATENACT);
        break;
    }
}

// Desítky
void slovo_desitky(int cislo) {
    switch (cislo) {
    case 1:
        fprintf(stdout, DESET);
        break;
    case 2:
        fprintf(stdout, DVACET);
        break;
    case 3:
        fprintf(stdout, TRICET);
        break;
    case 4:
        fprintf(stdout, CTYRICET);
        break;
    case 5:
        fprintf(stdout, PADESAT);
        break;
    case 6:
        fprintf(stdout, SEDESAT);
        break;
    case 7:
        fprintf(stdout, SEDMDESAT);
        break;
    case 8:
        fprintf(stdout, OSMDESAT);
        break;
    case 9:
        fprintf(stdout, DEVADESAT);
        break;
    }
}

// Veřejné funkce
// Oddělovač
void oddelovac() {
    putchar(' ');
}

// Řády
void slovo_miliontiny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, MILIONTINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, MILIONTINY);
        break;
    default:
        fprintf(stdout, MILIONTIN);
    }
}

void slovo_stotisiciny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, STOTISICINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, STOTISICINY);
        break;
    default:
        fprintf(stdout, STOTISICIN);
    }
}

void slovo_desetitisiciny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, DESETITISICINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, DESETITISICINY);
        break;
    default:
        fprintf(stdout, DESETITISICIN);
    }
}

void slovo_tisiciny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, TISICINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, TISICINY);
        break;
    default:
        fprintf(stdout, TISICIN);
    }
}

void slovo_setiny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, SETINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, SETINY);
        break;
    default:
        fprintf(stdout, SETIN);
    }
}

void slovo_desetiny(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, DESETINA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, DESETINY);
        break;
    default:
        fprintf(stdout, DESETIN);
    }
}

void slovo_tisice(int pocet) {
    if (pocet > 9) {
        fprintf(stdout, TISIC);
        return;
    }

    switch (pocet) {
    case 2:
    case 3:
    case 4:
        fprintf(stdout, TISICE);
        break;
    default:
        fprintf(stdout, TISIC);
    }
}

void slovo_miliony(int pocet) {
    if (pocet > 9) {
        fprintf(stdout, MILIONU);
        return;
    }

    switch (pocet) {
    case 1:
        fprintf(stdout, MILION);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, MILIONY);
        break;
    default:
        fprintf(stdout, MILIONU);
    }
}

void slovo_miliardy(int pocet) {
    if (pocet > 9) {
        fprintf(stdout, MILIARD);
        return;
    }

    switch (pocet) {
    case 1:
        fprintf(stdout, MILIARDA);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, MILIARDY);
        break;
    default:
        fprintf(stdout, MILIARD);
    }
}

void slovo_biliony(int pocet) {
    if (pocet > 9) {
        fprintf(stdout, BILIONU);
        return;
    }

    switch (pocet) {
    case 1:
        fprintf(stdout, BILION);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, BILIONY);
        break;
    default:
        fprintf(stdout, BILIONU);
    }
}

void slovo_triliony(int pocet) {
    if (pocet > 9) {
        fprintf(stdout, TRILIONU);
        return;
    }

    switch (pocet) {
    case 1:
        fprintf(stdout, TRILION);
        break;
    case 2:
    case 3:
    case 4:
        fprintf(stdout, TRILIONY);
        break;
    default:
        fprintf(stdout, TRILIONU);
    }
}

// Stovky
void slovo_stovky(int pocet) {
    switch (pocet) {
    case 1:
        fprintf(stdout, STO);
        break;
    case 2:
        fprintf(stdout, STE);
        break;
    case 3:
    case 4:
        fprintf(stdout, STA);
        break;
    default:
        fprintf(stdout, SET);
    }
}

// Číslovky
void slovo_cislovky(int cislo, int prepinac) {
    if (cislo < 10) {
        slovo_jednotky(cislo, prepinac);
        return;
    }

    if (cislo > 10 && cislo < 20) {
        slovo_nactky(cislo % 10);
        return;
    }

    slovo_desitky(cislo / 10);
    
    if (cislo % 10 > 0) {
        oddelovac();
        slovo_jednotky(cislo % 10, prepinac);
    }
}

funkce.h

/**************************************************
 * Program pro slovní výpis vstupního čísla
 * Užití: slovne <cislo>
 * Pokud uživatel nezadá ono číslo, program si vstup
 * vyžádá.
 *
 * Rozsah je od -10^18 do +10^18
 *
 * Kód vytvořil: Marek Poláček (Polda18)
 *
 * Soubor: funkce.h
 **************************************************/

#pragma once

#ifndef __FUNKCE_H__
#define __FUNKCE_H__

// Deklarace funkcí
//------------------------------------------------------

// Oddělovač
void oddelovac();

// Řády
void slovo_miliontiny(int pocet);
void slovo_stotisiciny(int pocet);
void slovo_desetitisiciny(int pocet);
void slovo_tisiciny(int pocet);
void slovo_setiny(int pocet);
void slovo_desetiny(int pocet);
void slovo_tisice(int pocet);
void slovo_miliony(int pocet);
void slovo_miliardy(int pocet);
void slovo_biliony(int pocet);
void slovo_triliony(int pocet);

// Stovky
void slovo_stovky(int pocet);

// Číslovky
void slovo_cislovky(int cislo, int prepinac);

#endif

main.c

/**************************************************
 * Program pro slovní výpis vstupního čísla
 * Užití: slovne <cislo>
 * Pokud uživatel nezadá ono číslo, program si vstup
 * vyžádá.
 * 
 * Rozsah je od -10^18 do +10^18
 * 
 * Kód vytvořil: Marek Poláček (Polda18)
 * 
 * Soubor: main.c
 **************************************************/

// Důležité globální knihovny
//------------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdbool.h>

// Důležité lokální knihovny
//------------------------------------------------------
#include "definice.h"
#include "funkce.h"

// Počátek programu
int main(int argc, char** argv) {
    fprintf(stdout, "------------------------------------------------------\n");
    fprintf(stdout, "  Konvertor čísla na slovní vyjádření\n");
    fprintf(stdout, "------------------------------------------------------\n\n");

    bool precteno = false;      // Pokud je číslo úspěšně přečteno
    bool minus;                 // Operátor záporného čísla
    double cislo;               // Sem zadáme číslo pro konverzi
    int jednotky_celkem, tisice_celkem, miliony_celkem;
    int miliardy_celkem, biliony_celkem, triliony_celkem;           // Dělení celočíselné části
    int kvadriliony = 0;                                            // Případ přetečení až na doraz
    int tisiciny_celkem, miliontiny_celkem;                         // Dělení desetinné části
    double celacast, desetinnacast, absolutni;                      // Převzetí celé a desetinné části, smazání znaménka
    double zbytek;                                                  // Výpočet zbytku

    // Práce s argumenty příkazu
    if (argc < 2) {
        // Argument nezadán, zeptat se na číslo
        fprintf(stdout, "Zadejte číslo v rozsahu od -10^18 do +10^18 bez těchto mezních hodnot.\n");
        fprintf(stdout, "Číslo může být desetinné, zadávejte ho však s desetinnou tečkou.\n\n");
        fprintf(stdout, "Zadejte číslo zde> ");
        fflush(stdin);
        precteno = fscanf_s(stdin, "%lf", &cislo);
        putchar('\n');     // Odřádkování
    }
    else {
        // Argument zadán, přečíst z argumentu
        precteno = sscanf_s(argv[1], "%lf", &cislo);
    }

    if (!precteno) {
        // Nebylo zadáno číslo
        fprintf(stderr, "CHYBA! Zadaný vstup není číslo!\n");
        return 1;
    }

    minus = cislo < 0;
    absolutni = (minus) ? -cislo : cislo;

    if (absolutni >= 1.e+18) {
        // Číslo je mimo stanovený rozsah
        fprintf(stderr, "CHYBA! Zadané číslo je mimo stanovený rozsah!\n");
        return 2;
    }

    // Převzetí celé části a výpočet zbytku
    celacast = floor(absolutni);
    desetinnacast = absolutni - celacast;

    // Výpočet celé části
    triliony_celkem = (int)floor(celacast / 1.e+15);
    biliony_celkem = (int)(floor(celacast / 1.e+12)
        - triliony_celkem * 1.e+3);
    miliardy_celkem = (int)(floor(celacast / 1.e+9)
        - triliony_celkem * 1.e+6
        - biliony_celkem * 1.e+3);
    miliony_celkem = (int)(floor(celacast / 1.e+6)
        - triliony_celkem * 1.e+9
        - biliony_celkem * 1.e+6
        - miliardy_celkem * 1.e+3);
    tisice_celkem = (int)(floor(celacast / 1.e+3)
        - triliony_celkem * 1.e+12
        - biliony_celkem * 1.e+9
        - miliardy_celkem * 1.e+6
        - miliony_celkem * 1.e+3);
    jednotky_celkem = (int)(celacast
        - triliony_celkem * 1.e+15
        - biliony_celkem * 1.e+12
        - miliardy_celkem * 1.e+9
        - miliony_celkem * 1.e+6
        - tisice_celkem * 1.e+3);
    
    // Výpočet desetinné části
    tisiciny_celkem = (int)(desetinnacast * 1.e+3);
    miliontiny_celkem = (int)(desetinnacast * 1.e+6 - tisiciny_celkem * 1.e+3);

    // Výpočet zbytku (určeno pro zaokrouhlení)
    zbytek = (desetinnacast - tisiciny_celkem / 1000. - miliontiny_celkem / 1000000.) * 1000000.;

    // Ošetření přetečení
    if (zbytek >= .5)
        ++miliontiny_celkem;   // Pokud je zbytek větší nebo rovno 5 desetimiliontinám,
                        // zvyš počet miliontin o jednu

    if (miliontiny_celkem > 999) {
        // Ošetření přetečení miliontin
        miliontiny_celkem %= 1000;
        ++tisiciny_celkem;
    }

    if (tisiciny_celkem > 999) {
        // Ošetření přetečení tisícin
        tisiciny_celkem %= 1000;
        ++jednotky_celkem;
    }

    if (jednotky_celkem > 999) {
        // Ošetření přetečení jednotek
        jednotky_celkem %= 1000;
        ++tisice_celkem;
    }

    if (tisice_celkem > 999) {
        // Ošetření přetečení tisíců
        tisice_celkem %= 1000;
        ++miliony_celkem;
    }

    if (miliony_celkem > 999) {
        // Ošetření přetečení milionů
        miliony_celkem %= 1000;
        ++miliardy_celkem;
    }

    if (miliardy_celkem > 999) {
        // Ošetření přetečení miliard
        miliardy_celkem %= 1000;
        ++biliony_celkem;
    }

    if (biliony_celkem > 999) {
        // Ošetření přetečení bilionů
        biliony_celkem %= 1000;
        ++triliony_celkem;
    }

    if (triliony_celkem > 999) {
        // Ošetření přetečení trilionů
        triliony_celkem %= 1000;
        ++kvadriliony;      // Nejvyšší přetečení
    }

    // Výpočet číselných jednotek
    //------------------------------------------------------

    // Připraveno pro stovky, desítky a jednotky trojic řádů
    int triliony_stovky, triliony;                          // množiny trilionů
    int biliony_stovky, biliony;                            // množiny bilionů
    int miliardy_stovky, miliardy;                          // množiny miliard
    int miliony_stovky, miliony;                            // množiny milionů
    int tisice_stovky, tisice;                              // množiny tisíců
    int stovky, jednotky;                                   // jednotky
    int desetiny, setiny, tisiciny;                         // množiny tisícin
    int desetitisiciny, stotisiciny, miliontiny;            // množiny miliontin

    // Výpočet jednotlivých částí
    //------------------------------------------------------

    // Celá část
    // Triliony
    triliony_stovky = triliony_celkem / 100;
    triliony = triliony_celkem % 100;

    // Biliony
    biliony_stovky = biliony_celkem / 100;
    biliony = biliony_celkem % 100;

    // Miliardy
    miliardy_stovky = miliardy_celkem / 100;
    miliardy = miliardy_celkem % 100;

    // Miliony
    miliony_stovky = miliony_celkem / 100;
    miliony = miliony_celkem % 100;

    // Tisíce
    tisice_stovky = tisice_celkem / 100;
    tisice = tisice_celkem % 100;

    // Jednotky
    stovky = jednotky_celkem / 100;
    jednotky = jednotky_celkem % 100;

    // Desetinná část
    // Tisíciny
    desetiny = tisiciny_celkem / 100;
    setiny = tisiciny_celkem % 100 / 10;
    tisiciny = tisiciny_celkem % 10;

    // Miliontiny
    desetitisiciny = miliontiny_celkem / 100;
    stotisiciny = miliontiny_celkem % 100 / 10;
    miliontiny = miliontiny_celkem % 10;

    // Výsledky
    fprintf(stdout, "Vstup uživatele: %lf\n", cislo);
    fprintf(stdout, "Číslo vyjádřeno slovy je:\n\n");

    // Slovní vyjádření zadaného čísla
    //------------------------------------------------------

    // Nulové číslo
    if (!cislo) {
        fprintf(stdout, NULA);
        putchar('\n');
        return 0;
    }

    // Znaménko
    if (minus)
        fprintf(stdout, "minus ");

    // Výpis číselného vyjádření kvadrilionů - pouze jedna možnost, tedy ukončit program
    if (kvadriliony) {
        fprintf(stdout, "%s kvadrilion\n", JEDEN);
        return 0;
    }

    // Výpis jednotek
    //------------------------------------------------------

    // Stovky trilionů
    if (triliony_stovky) {
        slovo_cislovky(triliony_stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(triliony_stovky);
    }

    // Pokud existují zároveň stovky a jednotky trilionů
    if (triliony_stovky && triliony)
        oddelovac();

    // Jednotky trilionů
    if (triliony)
        slovo_cislovky(triliony, PREPINAC_RADY_CELE);

    // Pokud existují všechny řády z trojřádu trilionů
    if (triliony_celkem) {
        oddelovac();
        slovo_triliony(triliony_celkem);
    }

    // Pokud existuje zároveň alespoň jeden z trojřádu trilionů a alespoň jeden z trojřádu bilionů
    if (triliony_celkem && biliony_celkem)
        oddelovac();

    // Stovky bilionů
    if (biliony_stovky) {
        slovo_cislovky(biliony_stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(biliony_stovky);
    }

    // Pokud existují zároveň stovky a jednotky bilionů
    if (biliony_stovky && biliony)
        oddelovac();

    // Jednotky bilionů
    if (biliony)
        slovo_cislovky(biliony, PREPINAC_RADY_CELE);

    // Pokud existuje alespoň jeden z řádů v trojřádu bilionů
    if (biliony_celkem) {
        oddelovac();
        slovo_biliony(biliony_celkem);
    }

    // Pokud existuje alespoň jeden z řádu trilionů a jeden z řádu miliard
    // nebo jeden z řádu bilionů a jeden z řádu miliard
    if (triliony_celkem && miliardy_celkem
        || biliony_celkem && miliardy_celkem)
        oddelovac();

    // Stovky miliard
    if (miliardy_stovky) {
        slovo_cislovky(miliardy_stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(miliardy_stovky);
    }

    // Pokud existují zároveň stovky a jednotky miliard
    if (miliardy_stovky && miliardy)
        oddelovac();

    // Jednotky miliard
    if (miliardy)
        slovo_cislovky(miliardy, PREPINAC_RADY_CELE);

    // Pokud existuje jakýkoliv z řádů miliard
    if (miliardy_celkem) {
        oddelovac();
        slovo_miliardy(miliardy_celkem);
    }

    // Pokud existuje jakýkoliv z řádů trilionů a milionů, bilionů a milionů nebo miliard a milionů
    if (triliony_celkem && miliony_celkem
        || biliony_celkem && miliony_celkem
        || miliardy_celkem && miliony_celkem)
        oddelovac();

    // Stovky milionů
    if (miliony_stovky) {
        slovo_cislovky(miliony_stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(miliony_stovky);
    }

    // Pokud existují stovky a jednotky milionů
    if (miliony_stovky && miliony)
        oddelovac();

    // Jednotky milionů
    if (miliony)
        slovo_cislovky(miliony, PREPINAC_RADY_CELE);

    // Pokud existuje trojřád milionů
    if (miliony_celkem) {
        oddelovac();
        slovo_miliony(miliony_celkem);
    }

    // Pokud existují trojřád trilionů a tisíců, trojřád bilionů a tisíců, trojřád miliard a tisíců
    // nebo trojřád milionů a tisíců
    if (triliony_celkem && tisice_celkem
        || biliony_celkem && tisice_celkem
        || miliardy_celkem && tisice_celkem
        || miliony_celkem && tisice_celkem)
        oddelovac();

    // Stovky tisíců
    if (tisice_stovky) {
        slovo_cislovky(tisice_stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(tisice_stovky);
    }

    // Pokud existují stovky a jednotky tisíců
    if (tisice_stovky && tisice)
        oddelovac();

    // Jednotky tisíců
    if (tisice)
        slovo_cislovky(tisice, PREPINAC_RADY_CELE);

    // Pokud existuje trojřád tisíců
    if (tisice_celkem) {
        oddelovac();
        slovo_tisice(tisice_celkem);
    }

    // Pokud existuje trojřád trilionů a jednotek, bilionů a jednotek, miliard a jednotek,
    // milionů a jednotek nebo tisíců a jednotek
    if (triliony_celkem && jednotky_celkem
        || biliony_celkem && jednotky_celkem
        || miliardy_celkem && jednotky_celkem
        || miliony_celkem && jednotky_celkem
        || tisice_celkem && jednotky_celkem)
        oddelovac();

    // Stovky
    if (stovky) {
        slovo_cislovky(stovky, PREPINAC_STOVKY);
        oddelovac();
        slovo_stovky(stovky);
    }

    // Pokud existují stovky a jednotky
    if (stovky && jednotky)
        oddelovac();

    // Jednotky
    if (jednotky)
        slovo_cislovky(jednotky, PREPINAC_JEDNOTKY);

    // Desetinná část
    if (celacast > 0 && desetinnacast > 0) {
        // Celá část je nenulová a desetinná je nenulová
        oddelovac();
        fprintf(stdout, CELYCH);
        oddelovac();
    }
    else if (desetinnacast > 0) {
        // Celá část je nulová a desetinná je nenulová
        fprintf(stdout, NULA);
        oddelovac();
        fprintf(stdout, CELYCH);
        oddelovac();
    }

    // Desetiny
    if (desetiny) {
        slovo_cislovky(desetiny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_desetiny(desetiny);
    }

    // Pokud existují desetiny a setiny
    if (desetiny && setiny)
        oddelovac();

    // Setiny
    if (setiny) {
        slovo_cislovky(setiny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_setiny(setiny);
    }

    // Pokud existují desetiny a tisíciny nebo setiny a tisíciny
    if (desetiny && tisiciny
        || setiny && tisiciny)
        oddelovac();

    // Tisíciny
    if (tisiciny) {
        slovo_cislovky(tisiciny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_tisiciny(tisiciny);
    }

    // Pokud existují desetiny a desetitisíciny, setiny a desetitisíciny
    // nebo tisíciny a desetitisíciny
    if (desetiny && desetitisiciny
        || setiny && desetitisiciny
        || tisiciny && desetitisiciny)
        oddelovac();

    // Desetitisíciny
    if (desetitisiciny) {
        slovo_cislovky(desetitisiciny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_desetitisiciny(desetitisiciny);
    }

    // Pokud existují desetiny a stotisíciny, setiny a stotisíciny,
    // tisíciny a stotisíciny nebo desetitisíciny a stotisíciny
    if (desetiny && stotisiciny
        || setiny && stotisiciny
        || tisiciny && stotisiciny
        || desetitisiciny && stotisiciny)
        oddelovac();

    // Stotisíciny
    if (stotisiciny) {
        slovo_cislovky(stotisiciny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_stotisiciny(stotisiciny);
    }

    // Pokud existují desetiny a miliontiny, setiny a miliontiny,
    // tisíciny a miliontiny, desetitisíciny a miliontiny nebo
    // stotisíciny a miliontiny
    if (desetiny && miliontiny
        || setiny && miliontiny
        || tisiciny && miliontiny
        || desetitisiciny && miliontiny
        || stotisiciny && miliontiny)
        oddelovac();

    // Miliontiny
    if (miliontiny) {
        slovo_cislovky(miliontiny, PREPINAC_RADY_DESETINNE);
        oddelovac();
        slovo_miliontiny(miliontiny);
    }

    // Finální odřádkování
    putchar('\n');

    // Konec programu
    return 0;
}