****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();
}
}