The Programming Project

Sunday, January 22, 2023

Leet Code Integer to Roman

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

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

For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

  • I can be placed before V (5) and X (10) to make 4 and 9. 
  • X can be placed before L (50) and C (100) to make 40 and 90. 
  • C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer

Example 1:

Input: s = "III"
Output: 3
Explanation: III = 3.

Example 2:

Input: s = "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.

Example 3:

Input: s = "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

 

Constraints:

  • 1 <= s.length <= 15
  • s contains only the characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
  • It is guaranteed that s is a valid roman numeral in the range [1, 3999].


 Python Code


class Solution(object):

    def intToRoman(self, numb):
        temp = numb
        list_digits = []

        while temp > 0:
            list_digits.append(temp % 10)
            temp = int(temp / 10)
            self.numberlength += 1
        if self.numberlength == 4:
            for i in range(list_digits[3]):
                self.output += "M"
            self.numberlength -= 1
        if self.numberlength == 3:
            self.numberlength -= 1
            if list_digits[2] * 100 == 400 or list_digits[2] * 100 == 900:
                self.output += self.exceptionSymbols[self.position(
                    list_digits[2] * 100)]
            else:
                if list_digits[2] * 100 == 500:
                    self.output += "D"
                elif list_digits[2] * 100 == 800:
                    self.output += "DCCC"
                elif list_digits[2] * 100 == 700:
                    self.output += "DCC"
                elif list_digits[2] * 100 == 600:
                    self.output += "DC"
                elif list_digits[2] * 100 == 300:
                    self.output += "CCC"
                elif list_digits[2] * 100 == 200:
                    self.output += "CC"
                elif list_digits[2] * 100 == 100:
                    self.output += "C"
                else:
                    self.output += ""
        if self.numberlength == 2:
            self.numberlength -= 1
            if list_digits[1] * 10 == 40 or list_digits[1] * 10 == 90:
                self.output += self.exceptionSymbols[self.position(
                    list_digits[1] * 10)]
            else:
                if list_digits[1] * 10 == 50:
                    self.output += "L"
                elif list_digits[1] * 10 == 80:
                    self.output += "LXXX"
                elif list_digits[1] * 10 == 70:
                    self.output += "LXX"
                elif list_digits[1] * 10 == 60:
                    self.output += "LX"
                elif list_digits[1] * 10 == 30:
                    self.output += "XXX"
                elif list_digits[1] * 10 == 20:
                    self.output += "XX"
                elif list_digits[1] * 10 == 10:
                    self.output += "X"
                else:
                    self.output += ""
        if self.numberlength == 1:
            self.numberlength -= 1
            if list_digits[0] == 4 or list_digits[0] == 9:
                self.output += self.exceptionSymbols[self.position(
                    list_digits[0])]
            elif list_digits[0] == 5:
                self.output += "V"
            elif list_digits[0] == 8:
                self.output += "VIII"
            elif list_digits[0] == 7:
                self.output += "VII"
            elif list_digits[0] == 6:
                self.output += "VI"
            elif list_digits[0] == 3:
                self.output += "III"
            elif list_digits[0] == 2:
                self.output += "II"
            elif list_digits[0] == 1:
                self.output += "I"
            else:
                self.output += ""
        return self.output

    def position(self, symb):
        counter = 0
        while symb != self.exceptionValues[counter]:
            counter += 1
        return (counter)

    def __init__(self) -> None:
        self.exceptionValues = [4, 9, 40, 90, 400, 900]
        self.exceptionSymbols = ["IV", "IX", "XL", "XC", "CD", "CM"]
        #self.symbol = ['I', 'V', 'X', 'L', 'C', 'D', 'M']
        #self.value = [1, 5, 10, 50, 100, 500, 1000]
        self.output = ""
        self.numberlength = 0


obj = Solution()
num = int(input("Enter an integer range(1,3999):"))
print(obj.intToRoman(num))
Posted by at No comments:
Labels: ,

Saturday, January 21, 2023

Karl Pearson Coefficient of Correlation and Scatter diagram Regression Line

 A simple program to calculate the correlation between two variates (X and Y) and the Karl Pearson Coefficient of correlation. The scatter diagram along with the regression line of Y on X has been plotted. 




import matplotlib.pyplot as plt
import numpy as np
import math


class RegressionLine:

    def plotScatterDiagram(self):
        x = np.array(self._xValues)
        y = np.array(self._yValues)
        plt.scatter(x, y)
        # calculating regression of y on x
        self._bYX = (self._karlPCoefficient*self._sigmaY)/self._sigmaX
        self._bXY = (self._karlPCoefficient*self._sigmaX)/self._sigmaY
        x = np.linspace(self._minX,self._maxX,100)
        y = (self._bYX)*x + (self._sumY/self._N - (self._sumX/self._N)*self._bYX )
        plt.title('Regression line of y on x')
        plt.plot(x, y, '-r', label='regression line of y on x')
        plt.xlabel('x', color='#1C2833')
        plt.ylabel('y', color='#1C2833')
        plt.show()
    def parityString(self, string):
        while len(string) < 9:
            string += " "
        return string

    def accept(self):
        self._N = int(input("Enter the total number of values:"))
        print("Enter the data for x and y:")
        for i in range(self._N):
            print("Enter the value at position ", (i + 1))
            self._xValues.append(float(input("Enter a x value: ")))
            self._yValues.append(float(input("Enter a y value: ")))
        print("Enter 0 is you don't want a change of scale:")
        self._A = float(input("Enter the assumed mean for x-data set:"))
        self._B = float(input("Enter the assumed mean for y-data set:"))

    def calculateCovariance(self):
        for i in range(self._N):
            if self._maxX < self._xValues[i]:
                self._maxX = self._xValues[i]
            if self._minX > self._xValues[i]:
                self._minX = self._xValues[i]
            self._uValues.append(self._xValues[i] - self._A)
            self._vValues.append(self._yValues[i] - self._B)
            self._uvValues.append(self._uValues[i] * self._vValues[i])
            self._sumXY += self._uvValues[i]
            self._sumX += self._uValues[i]
            self._sumY += self._vValues[i]
        self._coVarianceXY = (1 / self._N) * (
            self._sumXY - (1 / self._N) * self._sumX * self._sumY)
        # print covariance table
        if self._A == 0 and self._B == 0:
            print(self.parityString("X"), self.parityString("Y"),
                  self.parityString("XY"))
            for i in range(self._N):
                print(self.parityString(str(self._xValues[i])),
                      self.parityString(str(self._yValues[i])),
                      self.parityString(str(self._uvValues[i])))
            print("-------------------------------------")
            print(self.parityString(str(self._sumX)),
                  self.parityString(str(self._sumY)),
                  self.parityString(str(self._sumXY)))
            print("-------------------------------------")
            print("Cov(X,Y)=", self._coVarianceXY)
        else:
            print(self.parityString("X"), self.parityString("u"),
                  self.parityString("Y"), self.parityString("v"),
                  self.parityString("uv"))
            for i in range(self._N):
                print(self.parityString(str(self._xValues[i])),
                      self.parityString(str(self._uValues[i])),
                      self.parityString(str(self._yValues[i])),
                      self.parityString(str(self._vValues[i])),
                      self.parityString(str(self._uvValues[i])))
            print("-----------------------------------------------")
            print(self.parityString(" "), self.parityString(str(self._sumX)),
                  self.parityString(" "), self.parityString(str(self._sumY)),
                  self.parityString(str(self._sumXY)))
            print("-----------------------------------------------")
            print("Cov(X,Y)=", self._coVarianceXY)

    def calculateKarlPearson(self):
        self._sigmaX = self.calculateSD(self._uValues)
        self._sigmaY = self.calculateSD(self._vValues)
        self._karlPCoefficient = self._coVarianceXY / (self._sigmaX *
                                                       self._sigmaY)
        print("r =", round(self._karlPCoefficient, 3))

    def calculateSD(self, _valuesList):
        standard_deviation = 0.0
        mean = 0
        for i in range(self._N):
            mean += _valuesList[i]
        mean /= self._N
        for i in range(self._N):
            standard_deviation += (_valuesList[i] - mean)**2
        standard_deviation /= self._N
        standard_deviation = math.sqrt(standard_deviation)
        return standard_deviation

    def __init__(self) -> None:
        self._xValues = []
        self._uValues = []
        self._yValues = []
        self._vValues = []
        self._uvValues = []
        self._coVarianceXY = 0.0
        self._karlPCoefficient = 0.0
        self._sigmaX = 0.0  # standard deviation for X
        self._sigmaY = 0.0  # standard deviation for Y
        self._N = 0
        self._A = 0  # assumed mean for X
        self._B = 0  # assumed mean for Y
        self._maxX = float('-inf')
        self._minX = float('inf')
        self._sumX = 0
        self._sumY = 0
        self._sumXY = 0
        self._bYX = 0
        self._bXY = 0

obj = RegressionLine()
obj.accept()
obj.calculateCovariance()
obj.calculateKarlPearson()
obj.plotScatterDiagram()
Posted by at No comments:
Labels: ,

Thursday, January 12, 2023

ICSE Java Programming Switch Case 2017 Q6 Solved

ICSE Java Programming Switch Case  2017 Q6  Solved Computer Application



import java.util.Scanner;

public class ICSEJava {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int choice;
        double sum = 0;
        System.out.println("Enter 1 to calculate the sum.");
        System.out.println("Enter 2 to print the series.");
        System.out.println("Enter your choice:");
        choice = in.nextInt();
        switch (choice) {
            case 1:
                for (int i = 1; i <= 5; i++) {
                    sum += Math.pow(2, i) * Math.pow(-1, (double) (i + 1));
                }
                sum -= Math.pow(2, 20);
                System.out.println("The sum is: " + sum);
                break;
            case 2:
                int n;
                System.out.println("Enter the number of terms:");
                n = in.nextInt();
                for (int j = 1; j <= n; j++) {
                    for (int k = 1; k <= j; k++)
                        System.out.print("1");
                    System.out.print("  ");
                }
                break;
            default:
                System.out.println("Wrong choice.");
                break;
        }
        in.close();

    }
}
Posted by at No comments:
Labels: , ,

Wednesday, January 11, 2023

ICSE Java Programming Electricity Bill 2017 Q4 Solved

ICSE Java Programming Electricity Bill  2017 Q4  Solved

Question 4.

Define a class Electricity Bill with the following specifications : [15]
class : ElectricBill
Instance variables /data member :
String n – to store the name of the customer
int units – to store the number of units consumed
double bill – to store the amount to be paid
Member methods :
void accept ( ) – to accept the name of the customer and number of units consumed
void calculate ( ) – to calculate the bill as per the following tariff :

ICSE Computer Applications Question Paper 2017 Solved for Class 10 - 1
A surcharge of 2.5% charged if the number of units consumed is above 300 units.
ICSE Computer Applications Question Paper 2017 Solved for Class 10 - 2
Write a main method to create an object of the class and call the above member methods.

Python Code


class ElectricityBill:
    def accept(self):
        self.customer_Name = str(input("Enter the name of the customer:"))
        self.units_Consumed = int(input("Enter the units consumed:"))
    def calculate(self):
        if self.units_Consumed <= 100:
            self.bill_Amount = self.units_Consumed *2.0
        elif self.units_Consumed > 100 and self.units_Consumed <= 300:
            self.bill_Amount  = self.units_Consumed *3.0
        else:
            self.bill_Amount  = self.units_Consumed *5.0
self.bill_Amount  += self.bill_Amount*(2.5/100.0)
    def printBill(self):
        print("Name of the customer: ",self.customer_Name)
        print("Total units consumed: ",self.units_Consumed)
        print("Bill Amount: ",self.bill_Amount)
    def __init__(self) -> None:
        self.customer_Name = ""
        self.units_Consumed = 0
        self.bill_Amount =0.0
obj = ElectricityBill()
obj.accept()
obj.calculate()
obj.printBill()


JAVA Code 


import java.util.Scanner;

public class ICSEJava {
    public static void main(String[] args) {
        ElectricityBill obj = new ElectricityBill();
        obj.accept();
        obj.calculate();
        obj.print();

    }
}

class ElectricityBill {
    public void print() {
        System.out.println("Name of the customer: " + this.customer_Name);
        System.out.println("Total units consumed: " + this.units_Consumed);
        System.out.println("Bill Amount: " + this.bill_Amount);
    }

    public void calculate() {
        if (this.units_Consumed <= 100)
            this.bill_Amount = this.units_Consumed * 2.0;
        else if (this.units_Consumed > 100 && this.units_Consumed <= 300)
            this.bill_Amount = this.units_Consumed * 3.0;
        else {
            this.bill_Amount = this.units_Consumed * 5.0;
            this.bill_Amount += (this.bill_Amount)*(2.5/100);
        }
    }

    public void accept() {
        Scanner in = new Scanner(System.in);
        System.out.println("Enter the name of the customer.");
        this.customer_Name = in.nextLine();
        System.out.println("Enter the unit consumed.");
        this.units_Consumed = in.nextInt();
        in.close();
    }

    ElectricityBill() {
        this.bill_Amount = 0.0;
        this.units_Consumed = 0;
        this.customer_Name = "";
    }

    private int units_Consumed;
    private String customer_Name;
    private double bill_Amount;
}
Posted by at No comments:
Labels: , ,
Subscribe to: Posts (Atom)