Konverter für römische Zahlen in C++

1. Konverter für römische Zahlen in C++
2. Konvertieren Sie eine Dezimalzahl in C++ in eine römische Zahl
3. C++-Codebeispiel zum Konvertieren einer Dezimalzahl in eine römische Zahl
4. Abschluss

In der heutigen Welt gibt es mehrere Zahlensysteme, mit denen wir es zu tun haben, um die Zahlen auf unterschiedliche Weise darzustellen. Eines davon ist das römische Zahlensystem.

Die alten Römer erfanden sie zum Zählen und für alltägliche Aktivitäten. Dieser Artikel behandelt das römische Zahlensystem und das Programm zum Umwandeln einer Dezimalzahl in eine römische Zahl.

Konverter für römische Zahlen in C++

Römische Ziffern stellen eine Zahl in einem bestimmten Format zum Zählen und für andere Zwecke dar.

Sie müssen von diesen römischen Ziffern in Schulen gehört und ihr praktisches Beispiel in Uhren gesehen haben. Römische Ziffern stellen oft die Zahlen in den Uhren dar.

Das römische Zahlensystem wird durch eine Kombination von sieben Buchstaben aus dem lateinischen Alphabet dargestellt. Jedem der sieben Buchstaben oder Symbole ist ein bestimmter Wert zugeordnet.

Die sieben Buchstaben und ihre spezifischen Werte sind unten angegeben.

I - 1
V - 5
X - 10
L - 50
C - 100
D - 500
M - 1000

Beachten Sie jedoch, dass wir nach 1000 kein Symbol für 10000 haben. Daher ist die höchste Zahl, die die römischen Ziffern darstellen können, 3999.

Lassen Sie uns nun darüber sprechen, wie man Dezimalzahlen in römische Zahlen umwandelt.

Eine Zahl in einer römischen Ziffer wird in absteigender Reihenfolge von links nach rechts geschrieben; In einigen Fällen wird jedoch die subtraktive Notation befolgt, um die Wiederholung derselben vier aufeinanderfolgenden Zeichen zu vermeiden, z. B. (IIII oder XXXX). Die subtraktive Notation wird mit den Zahlen verwendet, die 4 und 9 enthalten.

In der subtraktiven Schreibweise wird I vor V oder X gesetzt, um daraus ein IV (vier) oder IX (neun) zu machen. Ebenso wird X vor L oder C gesetzt, um daraus ein XL oder XC zu machen.

Daher werden Symbole in der subtraktiven Notation durch Kombinieren von zwei Symbolen hergestellt. Schauen wir uns deshalb die römischen Ziffern an, die auch die subtraktive Schreibweise beinhalten.

SYMBOL        Number
I             1
IV            4
V             5
IX            9
X             10
XL            40
L             50
XC            90
C             100
CD            400
D             500
CM            900
M             1000

Konvertieren Sie eine Dezimalzahl in C++ in eine römische Zahl

Gehen Sie wie folgt vor, um eine ganze Zahl in eine römische Zahl umzuwandeln:

1. Wiederholen Sie den folgenden Vorgang, bis die angegebene Dezimalzahl Null wird.
2. Wir müssen die Dezimalzahl mit den Basiswerten in der angegebenen Reihenfolge 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 vergleichen.
3. Wenn der Basiswert kleiner oder gleich der angegebenen Dezimalzahl (größter Basiswert) ist, teilen Sie die Dezimalzahl durch den Basiswert.
4. Hängen Sie nun das entsprechende Symbol des Basiswertes, den Quotienten mal in eine Variable ein. Beispiel: Wenn der Quotient 3 und der Basiswert 10 ist, dann wird die entsprechende Darstellung von 10, also X, dreimal als XXX in der Antwort wiederholt.
5. Der Rest wird jedoch die neue Zahl für weitere Teilungen.
6. Die Variable, an die die Symbole angehängt sind, bis die Dezimalzahl Null wird, enthält die Antwort.

Nehmen wir die Zahl 2954 als Dezimalzahl, die mit dem obigen Algorithmus in eine römische Zahl umgewandelt werden soll.

Ausgang:

MMCMLIV

Erläuterung:

Bühne 1:

1. Anfangs ist die Dezimalzahl 2954.
2. Seit 2954>=1000 entspricht der größte Basiswert 1000.
3. Die Division von 2954 durch 1000 ergibt einen Quotienten = 2 und einen Rest = 954. Da das entsprechende Symbol für 1000 M ist, wird es zweimal wiederholt.
4. Daher ist das Ergebnis vorerst gleich MM.
5. Der Rest wird zur neuen Zahl für die Durchführung der weiteren Divisionen.

Stufe 2:

1. Jetzt wird die Nummer 954
2. Vergleich mit den Basiswerten 1000>954>=900. Daher ist der größte Basiswert 900.
3. Die Division von 954 durch 900 ergibt Quotient = 1 und Rest = 54. Da das entsprechende Symbol für 900 CM ist, wird es einmal angehängt.
4. Daher wird das Ergebnis jetzt MMCM.
5. Der Rest wird zur neuen Zahl für die Durchführung der weiteren Divisionen.

Stufe 3:

1. Jetzt wird die Zahl 54.
2. Vergleich mit den Basiswerten 90>54>=50. Daher ist der größte Basiswert 50.
3. Die Division von 54 durch 50 ergibt Quotient = 1 und Rest = 4. Da das entsprechende Symbol für 50 L ist, wird es einmal angehängt.
4. Daher wird das Ergebnis jetzt MMCML.
5. Der Rest wird zur neuen Zahl für die Durchführung der weiteren Divisionen.

Stufe 4:

1. Jetzt wird die Zahl 4.
2. Vergleich mit den Basiswerten 5>4>=4. Daher ist der größte Basiswert 4.
3. Die Division von 4 durch 4 ergibt Quotient = 1 und Rest = 0. Da das entsprechende Symbol für 4 IV ist, wird es einmal angehängt.
4. Daher lautet das Ergebnis jetzt MMCMLIV.
5. Da nun der Rest Null wird, werden die Iterationen gestoppt, und wir haben unsere erforderliche Antwort.

C++-Codebeispiel zum Konvertieren einer Dezimalzahl in eine römische Zahl

Sehen wir uns ein Codebeispiel an, um eine Dezimalzahl in C++ in eine römische Zahl umzuwandeln.

#include <bits/stdc++.h>
using namespace std;

int subDig(char n1, char n2, int i, char c[]) {
  c[i++] = n1;
  c[i++] = n2;
  return i;
}

int digit(char ch, int n, int i, char c[]) {
  for (int j = 0; j < n; j++) {
    c[i++] = ch;
  }
  return i;
}

int convertRoman(int num) {
  char c[10001];
  int i = 0;
  while (num != 0) {
    if (num >= 1000) {
      i = digit('M', num / 1000, i, c);
      num = num % 1000;
    } else if (num >= 500) {
      if (num < 900) {
        i = digit('D', num / 500, i, c);
        num = num % 500;
      } else {
        i = subDig('C', 'M', i, c);
        num = num % 100;
      }
    } else if (num >= 100) {
      if (num < 400) {
        i = digit('C', num / 100, i, c);
        num = num % 100;
      } else {
        i = subDig('C', 'D', i, c);
        num = num % 100;
      }
    } else if (num >= 50) {
      if (num < 90) {
        i = digit('L', num / 50, i, c);
        num = num % 50;
      } else {
        i = subDig('X', 'C', i, c);
        num = num % 10;
      }
    } else if (num >= 10) {
      if (num < 40) {
        i = digit('X', num / 10, i, c);
        num = num % 10;
      } else {
        i = subDig('X', 'L', i, c);
        num = num % 10;
      }
    } else if (num >= 5) {
      if (num < 9) {
        i = digit('V', num / 5, i, c);
        num = num % 5;
      } else {
        i = subDig('I', 'X', i, c);
        num = 0;
      }
    } else if (num >= 1) {
      if (num < 4) {
        i = digit('I', num, i, c);
        num = 0;
      } else {
        i = subDig('I', 'V', i, c);
        num = 0;
      }
    }
  }

  for (int j = 0; j < i; j++) {
    cout << c[j];
  }
}

int main() {
  int number = 2954;

  convertRoman(number);

  return 0;
}

Ausgang:

MMCMLIV

Im obigen Code haben wir die Zahl num anhand der if/else-Bedingungen mit den Basiswerten verglichen und basierend darauf die entsprechende Variable zur Antwort hinzugefügt.

Die Zahlen, die der subtraktiven Notation folgen, wurden jedoch mit der Funktion subDig separat behandelt, bei der der Antwort zwei Buchstabensymbole hinzugefügt wurden.

Der oben besprochene Code ist ziemlich lang; Lassen Sie uns daher einen anderen Ansatz diskutieren, bei dem unser Code auf einen viel kürzeren als den zuvor besprochenen hinausläuft.

Ansatz 2

Dieser Ansatz basiert darauf, die Basiswerte und ihre entsprechenden Symbole separat in einem Array zu speichern und sie während einer Schleife zu verwenden.

Lassen Sie uns den Code dafür sehen.

#include <bits/stdc++.h>
using namespace std;

int convertRoman(int num) {
  int base_values[] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
  string symbols[] = {"I",  "IV", "V",  "IX", "X",  "XL", "L",
                      "XC", "C",  "CD", "D",  "CM", "M"};
  int i = 12;
  while (num > 0) {
    int quot = num / base_values[i];
    num = num % base_values[i];
    while (quot--) {
      cout << symbols[i];
    }
    i--;
  }
}
int main() {
  int number = 2543;
  convertRoman(number);
  return 0;
}

Ausgang:

MMDXLIII

Im obigen Code haben wir die Basiswerte und ihre entsprechenden Symbole in einem Array gespeichert und dann die Zahl mit den Basiswerten in absteigender Reihenfolge verglichen.

Anschließend wird die Zahl durch den größten Basiswert dividiert und Quotient und Rest gebildet. Nun wird das entsprechende Symbol mehrfach mit einer while-Schleife ausgegeben.

Abschluss

In diesem Artikel haben wir die Umwandlung von Dezimalzahlen in römische Zahlen besprochen. Römische Zahlen sind eine Möglichkeit, die Dezimalzahl mit Symbolen darzustellen.

Römische Ziffern werden in absteigender Reihenfolge und von links nach rechts geschrieben. Für einige wenige Fälle verwenden wir jedoch eine subtraktive Notation, bei der ein kleineres Symbol vor einem größeren geschrieben wird.

Diese Fälle treten bei den Nummern 4 und 9 auf und werden in diesem Artikel erklärt.