****PGRM-1 CALCULATOR****
using System;
class Program
{
static void Main()
{
Console.WriteLine("Enter the first number:");
double num1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter the second number:");
double num2 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Choose an operation: +, -, *, /, %");
char op = Convert.ToChar(Console.ReadLine());
double result = 0;
switch (op)
{
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
case '%':
result = num1 % num2;
break;
default:
Console.WriteLine("Invalid operation.");
break;
}
Console.WriteLine("Result: " + result);
}
}
***************************************************
****PGRM-2 ARMSTRONG NUMBER****
using System;
class ArmstrongNumbers
{
static void Main()
{
int start = 1, end = 1000;
for (int num = start; num <= end; num++)
{
int originalNum, remainder, result = 0;
originalNum = num;
while (originalNum != 0)
{
remainder = originalNum % 10;
result += (int)Math.Pow(remainder, 3);
originalNum /= 10;
}
if (result == num)
{
Console.WriteLine(num);
}
}
}
}
*****************************************************
****PGRM-3 SUBSTRING****
using System;
class Program
{
static void Main()
{
string str = "hello";
for (int i = 0; i < str.Length; i++)
{
for (int j = i + 1; j <= str.Length; j++)
{
Console.WriteLine(str.Substring(i, j - i));
}
}
}
}
*******************************************************
****PGRM-4 EXCEPTION****
using System;
namespace ExceptionDemo
{
class Program
{
static void Main(string[] args)
{
int num1, num2, arrayIndex;
int[] myArray = { 10, 20, 30 };
Console.Write("Enter two numbers for division: ");
num1 = int.Parse(Console.ReadLine());
num2 = int.Parse(Console.ReadLine());
Console.Write("Enter an array index (0-2): ");
arrayIndex = int.Parse(Console.ReadLine());
try
{
// Potential divide by zero exception
int result = num1 / num2;
Console.WriteLine("Result: {0}", result);
// Potential index out of range exception
int arrayValue = myArray[arrayIndex];
Console.WriteLine("Array value: {0}", arrayValue);
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Error: Division by zero is not allowed.");
Console.WriteLine(ex.Message);
}
catch (IndexOutOfRangeException ex)
{
Console.WriteLine("Error: Array index out of range.");
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("An unexpected error occurred:");
Console.WriteLine(ex.Message);
}
finally
{
Console.WriteLine("Program execution completed.");
}
}
}
}
*******************************************************
****PGRM-5 PASCALS TRIANGLE****
using System;
public class PascalTriangle
{
static void Main(string[] args)
{
Console.Write("Enter the number of rows: ");
int rows = int.Parse(Console.ReadLine());
int[,] pascalTriangle = new int[rows, rows];
// Fill the first and last elements of each row with 1
for (int i = 0; i < rows; i++)
{
pascalTriangle[i, 0] = 1;
pascalTriangle[i, i] = 1;
}
// Fill the remaining elements using the formula C(n, r) = C(n-1, r-1) +
C(n-1, r)
for (int i = 2; i < rows; i++)
{
for (int j = 1; j < i; j++)
{
pascalTriangle[i, j] = pascalTriangle[i - 1, j - 1] +
pascalTriangle[i - 1, j];
}
}
// Print the Pascal's triangle in a triangular shape
for (int i = 0; i < rows; i++)
{
// Print leading spaces for alignment
for (int j = 0; j < rows - i - 1; j++)
{
Console.Write(" "); // Two spaces for better spacing
}
// Print elements of the current row
for (int j = 0; j <= i; j++)
{
Console.Write(pascalTriangle[i, j] + " "); // Two spaces for
better spacing
}
Console.WriteLine();
}
}
}
***********************************************************************************
***********
****PGRM-6 FLOYDS TRIANGLE****
using System;
class Program
{
static void Main(string[] args)
{
Console.Write("Enter the number of rows for Floyd's Triangle: ");
int rows = int.Parse(Console.ReadLine());
int[][] triangle = new int[rows][];
int count = 1;
for (int i = 0; i < rows; i++)
{
triangle[i] = new int[i + 1];
for (int j = 0; j <= i; j++)
{
triangle[i][j] = count;
count++;
}
}
Console.WriteLine("Floyd's Triangle:");
for (int i = 0; i < rows; i++)
{
for (int j = 0; j <= i; j++)
{
Console.Write(triangle[i][j] + " ");
}
Console.WriteLine();
}
}
}
**************PGRM-7******************
using System;
using System.IO;
class FileCopy
{
static void Main()
{
Console.WriteLine("Enter the path of the source text file:");
string sourceFilePath = Console.ReadLine();
Console.WriteLine("Enter the path of the destination text file:");
string destinationFilePath = Console.ReadLine();
try
{
// Ensure the destination directory exists
Directory.CreateDirectory(Path.GetDirectoryName(destinationFilePath));
// Read the contents of the source file
string fileContents = File.ReadAllText(sourceFilePath);
// Write the contents to the destination file
File.WriteAllText(destinationFilePath, fileContents);
Console.WriteLine("File copy successful!");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
}
*************************PGRM-8*************************
using System;
class StackImplementation
{
static void Main()
{
// Create a stack instance
Stack stack = new Stack();
while (true)
{
Console.WriteLine("Choose an option:");
Console.WriteLine("1. Push");
Console.WriteLine("2. Pop");
Console.WriteLine("3. Display");
Console.WriteLine("4. Exit");
int choice = GetChoice();
switch (choice)
{
case 1:
Console.WriteLine("Enter the value to push:");
int valueToPush = GetValue();
stack.Push(valueToPush);
break;
case 2:
int poppedValue = stack.Pop();
if (poppedValue != -1)
Console.WriteLine($"Popped element: {poppedValue}");
break;
case 3:
stack.Display();
break;
case 4:
Console.WriteLine("Exiting the program.");
Environment.Exit(0);
break;
default:
Console.WriteLine("Invalid choice. Please choose a valid
option.");
break;
}
}
}
static int GetChoice()
{
int choice;
while (!int.TryParse(Console.ReadLine(), out choice))
{
Console.WriteLine("Invalid input. Please enter a number.");
}
return choice;
}
static int GetValue()
{
int value;
while (!int.TryParse(Console.ReadLine(), out value))
{
Console.WriteLine("Invalid input. Please enter a number.");
}
return value;
}
}
class Stack
{
private const int MaxSize = 10;
private int[] items;
private int top;
public Stack()
{
items = new int[MaxSize];
top = -1;
}
public void Push(int value)
{
if (top == MaxSize - 1)
{
Console.WriteLine("Stack overflow! Cannot push more elements.");
return;
}
items[++top] = value;
Console.WriteLine($"Pushed element: {value}");
}
public int Pop()
{
if (top == -1)
{
Console.WriteLine("Stack underflow! Cannot pop from an empty stack.");
return -1; // Return a sentinel value indicating underflow
}
int poppedValue = items[top--];
return poppedValue;
}
public void Display()
{
if (top == -1)
{
Console.WriteLine("Stack is empty.");
return;
}
Console.WriteLine("Stack elements:");
for (int i = top; i >= 0; i--)
{
Console.WriteLine(items[i]);
}
}
}
**************************PGM-9******************************
using System;
class Complex
{
private double real;
private double imaginary;
// Constructor
public Complex(double real, double imaginary)
{
this.real = real;
this.imaginary = imaginary;
}
// Overloaded addition operator
public static Complex operator +(Complex c1, Complex c2)
{
double realSum = c1.real + c2.real;
double imaginarySum = c1.imaginary + c2.imaginary;
return new Complex(realSum, imaginarySum);
}
// Display the complex number
public void Display()
{
Console.WriteLine($"Result: {real} + {imaginary}i");
}
}
class Program
{
static void Main()
{
Console.WriteLine("Enter the first complex number:");
Console.Write("Real part: ");
double real1 = Convert.ToDouble(Console.ReadLine());
Console.Write("Imaginary part: ");
double imaginary1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("\nEnter the second complex number:");
Console.Write("Real part: ");
double real2 = Convert.ToDouble(Console.ReadLine());
Console.Write("Imaginary part: ");
double imaginary2 = Convert.ToDouble(Console.ReadLine());
// Create Complex objects
Complex complex1 = new Complex(real1, imaginary1);
Complex complex2 = new Complex(real2, imaginary2);
// Use the overloaded addition operator
Complex result = complex1 + complex2;
// Display the result
Console.WriteLine("\nFirst complex number:");
complex1.Display();
Console.WriteLine("\nSecond complex number:");
complex2.Display();
Console.WriteLine("\nResult of addition:");
result.Display();
}
}
**************PGRM-10*********************************************
using System;
class Shape
{
public virtual void Draw()
{
Console.WriteLine("Drawing a generic shape.");
}
public virtual void Erase()
{
Console.WriteLine("Erasing a generic shape.");
}
}
class Circle : Shape
{
public override void Draw()
{
Console.WriteLine("Drawing a circle.");
}
public override void Erase()
{
Console.WriteLine("Erasing a circle.");
}
}
class Triangle : Shape
{
public override void Draw()
{
Console.WriteLine("Drawing a triangle.");
}
public override void Erase()
{
Console.WriteLine("Erasing a triangle.");
}
}
class Square : Shape
{
public override void Draw()
{
Console.WriteLine("Drawing a square.");
}
public override void Erase()
{
Console.WriteLine("Erasing a square.");
}
}
class Program
{
static void Main()
{
// Create instances of the derived classes
Shape circle = new Circle();
Shape triangle = new Triangle();
Shape square = new Square();
// Demonstrate polymorphism through the Draw and Erase methods
Console.WriteLine("Demonstrating polymorphism:");
DrawAndErase(circle);
DrawAndErase(triangle);
DrawAndErase(square);
}
static void DrawAndErase(Shape shape)
{
shape.Draw();
shape.Erase();
Console.WriteLine();
}
}
*****************************PGRM-11**********************
using System;
abstract class Shape
{
public abstract double CalculateArea();
public abstract double CalculatePerimeter();
}
class Circle : Shape
{
private double radius;
public Circle(double radius)
{
this.radius = radius;
}
public override double CalculateArea()
{
return Math.PI * radius * radius;
}
public override double CalculatePerimeter()
{
return 2 * Math.PI * radius;
}
}
class Triangle : Shape
{
private double side1, side2, side3;
public Triangle(double side1, double side2, double side3)
{
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public override double CalculateArea()
{
// Using Heron's formula to calculate the area of a triangle
double s = (side1 + side2 + side3) / 2;
return Math.Sqrt(s * (s - side1) * (s - side2) * (s - side3));
}
public override double CalculatePerimeter()
{
return side1 + side2 + side3;
}
}
class Program
{
static void Main()
{
// Input for Circle
Console.WriteLine("Enter the radius of the circle:");
double circleRadius = Convert.ToDouble(Console.ReadLine());
Circle circle = new Circle(circleRadius);
// Input for Triangle
Console.WriteLine("Enter the side lengths of the triangle (separated by
spaces):");
string[] triangleSides = Console.ReadLine().Split(' ');
double side1 = Convert.ToDouble(triangleSides[0]);
double side2 = Convert.ToDouble(triangleSides[1]);
double side3 = Convert.ToDouble(triangleSides[2]);
Triangle triangle = new Triangle(side1, side2, side3);
// Calculate and display the area and perimeter of each shape
Console.WriteLine("\nCircle - Area: " + circle.CalculateArea() + ",
Perimeter: " + circle.CalculatePerimeter());
Console.WriteLine("Triangle - Area: " + triangle.CalculateArea() + ",
Perimeter: " + triangle.CalculatePerimeter());
}
}
*********************PGRM-12*****************************
using System;
// Define the Resizable interface
interface Resizable
{
void ResizeWidth(int width);
void ResizeHeight(int height);
}
// Implement the Resizable interface in the Rectangle class
class Rectangle : Resizable
{
private int width;
private int height;
public Rectangle(int width, int height)
{
this.width = width;
this.height = height;
}
public void Display()
{
Console.WriteLine($"Rectangle - Width: {width}, Height: {height}");
}
public void ResizeWidth(int newWidth)
{
width = newWidth;
Console.WriteLine($"Resized width to {newWidth}");
}
public void ResizeHeight(int newHeight)
{
height = newHeight;
Console.WriteLine($"Resized height to {newHeight}");
}
}
class Program
{
static void Main()
{
// Input for initial values
Console.WriteLine("Enter the initial width of the rectangle:");
int initialWidth = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Enter the initial height of the rectangle:");
int initialHeight = Convert.ToInt32(Console.ReadLine());
// Create an instance of Rectangle
Rectangle rectangle = new Rectangle(initialWidth, initialHeight);
// Display the original size of the rectangle
Console.WriteLine("\nOriginal Size:");
rectangle.Display();
// Input for resized values
Console.WriteLine("\nEnter the new width for resizing:");
int newWidth = Convert.ToInt32(Console.ReadLine());
rectangle.ResizeWidth(newWidth);
Console.WriteLine("Enter the new height for resizing:");
int newHeight = Convert.ToInt32(Console.ReadLine());
rectangle.ResizeHeight(newHeight);
// Display the updated size of the rectangle
Console.WriteLine("\nUpdated Size:");
rectangle.Display();
}
}
