presudo 1.0.0

package/pods/sudo/react/TravelMap Application.txt

@@ -0,0 +1,212 @@
+src/data/destinations.js
+
+This file will hold the data for destinations.
+
+export const destinations = [
+  { id: 1, name: "Paris", country: "France", x: 100, y: 200, description: "City of light" },
+  { id: 2, name: "New York", country: "USA", x: 300, y: 100, description: "The Big Apple" },
+  { id: 3, name: "Tokyo", country: "Japan", x: 500, y: 300, description: "City of technology" },
+  // Add more destinations here
+];
+
+
+-----------------------------------------------------------------------------------------------------------------------------------
+
+src/components/FilterBar.jsx
+
+The filter bar to filter destinations based on selected country.
+
+import React from "react";
+
+const FilterBar = ({ countries, selectedCountry, onChange }) => {
+  return (
+    <div style={{ marginBottom: "10px" }}>
+      <select value={selectedCountry} onChange={onChange}>
+        <option value="">All Countries</option>
+        {countries.map((country) => (
+          <option key={country} value={country}>
+            {country}
+          </option>
+        ))}
+      </select>
+    </div>
+  );
+};
+
+export default FilterBar;
+
+-----------------------------------------------------------------------------------------------------------------------------------
+
+src/components/DestinationCard.jsx
+
+Card component to display individual destinations.
+
+import React from "react";
+
+const DestinationCard = ({ destination, isActive, onSelect }) => {
+  return (
+    <div
+      onClick={() => onSelect(destination)}
+      style={{
+        border: "1px solid #ccc",
+        padding: "10px",
+        marginBottom: "8px",
+        cursor: "pointer",
+        backgroundColor: isActive ? "#e0f7fa" : "#fff",
+      }}
+    >
+      <h4>{destination.name}</h4>
+      <p>{destination.country}</p>
+    </div>
+  );
+};
+
+export default DestinationCard;
+
+-----------------------------------------------------------------------------------------------------------------------------------
+
+src/components/DestinationList.jsx
+
+This component renders the list of destinations.
+
+import React from "react";
+import DestinationCard from "./DestinationCard";
+
+const DestinationList = ({ destinations, selected, onSelect }) => {
+  return (
+    <div>
+      {destinations.map((dest) => (
+        <DestinationCard
+          key={dest.id}
+          destination={dest}
+          isActive={selected?.id === dest.id}
+          onSelect={onSelect}
+        />
+      ))}
+    </div>
+  );
+};
+
+export default DestinationList;
+
+-----------------------------------------------------------------------------------------------------------------------------------
+
+
+src/components/MapView.jsx
+
+This component will display the map with destinations.
+
+import React from "react";
+
+const MapView = ({ destinations, selected, onSelect }) => {
+  return (
+    <div
+      style={{
+        position: "relative",
+        height: "400px",
+        backgroundColor: "#eef",
+        border: "1px solid #aaa",
+      }}
+    >
+      {destinations.map((dest) => (
+        <div
+          key={dest.id}
+          onClick={() => onSelect(dest)}
+          title={dest.name}
+          style={{
+            position: "absolute",
+            left: dest.x,
+            top: dest.y,
+            width: "12px",
+            height: "12px",
+            borderRadius: "50%",
+            backgroundColor: selected?.id === dest.id ? "red" : "blue",
+            cursor: "pointer",
+          }}
+        />
+      ))}
+
+      {selected && (
+        <div
+          style={{
+            position: "absolute",
+            bottom: "10px",
+            left: "10px",
+            background: "#fff",
+            padding: "10px",
+            border: "1px solid #ccc",
+          }}
+        >
+          <strong>{selected.name}</strong>
+          <p>{selected.description}</p>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default MapView;
+
+
+-----------------------------------------------------------------------------------------------------------------------------------
+
+src/App.js
+
+The main app component, handling state and rendering components.
+
+import React, { useState, useEffect, useMemo } from "react";
+import { destinations as data } from "./data/destinations";
+import DestinationList from "./components/DestinationList";
+import MapView from "./components/MapView";
+import FilterBar from "./components/FilterBar";
+
+const App = () => {
+  const [destinations, setDestinations] = useState([]);
+  const [selectedDestination, setSelectedDestination] = useState(null);
+  const [selectedCountry, setSelectedCountry] = useState("");
+
+  // Load data on mount
+  useEffect(() => {
+    setDestinations(data);
+  }, []);
+
+  // Extract unique countries
+  const countries = useMemo(() => {
+    return [...new Set(destinations.map((d) => d.country))];
+  }, [destinations]);
+
+  // Filter destinations
+  const filteredDestinations = useMemo(() => {
+    if (!selectedCountry) return destinations;
+    return destinations.filter((d) => d.country === selectedCountry);
+  }, [destinations, selectedCountry]);
+
+  return (
+    <div style={{ display: "flex", padding: "20px", gap: "20px" }}>
+      {/* Sidebar */}
+      <div style={{ width: "30%" }}>
+        <h2>Travel Destinations</h2>
+        <FilterBar
+          countries={countries}
+          selectedCountry={selectedCountry}
+          onChange={(e) => setSelectedCountry(e.target.value)}
+        />
+        <DestinationList
+          destinations={filteredDestinations}
+          selected={selectedDestination}
+          onSelect={setSelectedDestination}
+        />
+      </div>
+      {/* Map */}
+      <div style={{ width: "70%" }}>
+        <MapView
+          destinations={filteredDestinations}
+          selected={selectedDestination}
+          onSelect={setSelectedDestination}
+        />
+      </div>
+    </div>
+  );
+};
+
+export default App;

package/pods/sudo/sq.txt

@@ -0,0 +1,217 @@
+//(Returns all students with the highest score for each exam)
+ 
+SELECT exam_id, student_id, student_name, score
+FROM (
+  SELECT
+    s.*,
+    RANK() OVER (PARTITION BY exam_id ORDER BY score DESC) AS rnk
+  FROM scores AS s
+) AS ranked
+WHERE rnk = 1
+ORDER BY exam_id, student_name;
+ 
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+//(Top scorer per subject)
+ 
+SELECT subject_id, student_id, student_name, score
+FROM (
+  SELECT
+    subject_id, student_id, student_name, score,
+    RANK() OVER (PARTITION BY subject_id ORDER BY score DESC) AS rnk
+  FROM scores
+) AS ranked
+WHERE rnk = 1
+ORDER BY subject_id, student_name;
+
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+1. Basic Query with Sorting and LIMIT
+
+SQL Query: Top Scorer (Simple Sorting)
+
+SELECT name, marks
+FROM students
+ORDER BY marks DESC
+LIMIT 1;
+
+Explanation:
+
+Sorting: Sorts students by marks in descending order to get the highest scorer.
+
+Data Filtering: Filters for the top scorer.
+
+SQL Syntax: The query is simple, using basic SQL keywords.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+2. Top Scorer Using Subquery
+
+SQL Query: Top Scorer Using Subquery
+
+SELECT name, marks
+FROM students
+WHERE marks = (SELECT MAX(marks) FROM students);
+
+Explanation:
+
+Data Filtering: Filters students whose marks match the maximum marks in the dataset.
+
+Unique Values: Ensures the top scorer(s) are unique by selecting only those with the highest marks.
+
+SQL Syntax: Uses a subquery to identify the top marks.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+3. Sorting and Getting Multiple Top Scorers (Handling Ties)
+
+SQL Query: Top Scorers with Ties
+
+SELECT name, marks
+FROM students
+WHERE marks = (SELECT MAX(marks) FROM students)
+ORDER BY marks DESC;
+
+Explanation:
+
+Sorting: Sorts the students by marks in descending order.
+
+Data Filtering: Filters students who have the highest marks.
+
+Unique Values: If there are multiple top scorers with the same marks, all are returned.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+4. Using RANK() for Tied Top Scorers
+
+SQL Query: Top Scorer(s) with Ranking
+
+WITH RankedStudents AS (
+  SELECT name, marks, RANK() OVER (ORDER BY marks DESC) AS rank
+  FROM students
+)
+SELECT name, marks
+FROM RankedStudents
+WHERE rank = 1;
+
+Explanation:
+
+Sorting: The RANK() function sorts students by marks.
+
+Data Filtering: Filters the students with rank = 1 (the top scorers).
+
+Unique Values: Handles ties by ranking multiple students with the same marks.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+5. Using DENSE_RANK() for Continuous Ranking
+
+SQL Query: Top Scorer(s) with Continuous Rank
+
+WITH RankedStudents AS (
+  SELECT name, marks, DENSE_RANK() OVER (ORDER BY marks DESC) AS rank
+  FROM students
+)
+SELECT name, marks
+FROM RankedStudents
+WHERE rank = 1;
+
+Explanation:
+
+Sorting: DENSE_RANK() assigns a rank with no gaps between tied students.
+
+Data Filtering: Filters the top scorer(s) with rank = 1.
+
+SQL Syntax: DENSE_RANK() is used to handle ties by giving all students with the same marks the same rank.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+6. Using LIMIT to Get Only One Top Scorer
+
+SQL Query: Top Scorer with LIMIT
+
+SELECT name, marks
+FROM students
+ORDER BY marks DESC
+LIMIT 1;
+
+Explanation:
+
+Sorting: Sorts students by marks in descending order.
+
+SQL Syntax: LIMIT 1 ensures that only the top scorer is returned.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+7. Using HAVING with GROUP BY for Top Scorer by Department
+
+SQL Query: Top Scorer by Department
+
+SELECT department, name, marks
+FROM students
+GROUP BY department
+HAVING marks = (SELECT MAX(marks) FROM students WHERE department = students.department);
+
+Explanation:
+
+Data Filtering: Filters the top scorer in each department using a HAVING clause.
+
+Sorting: Implicitly sorted by the GROUP BY department.
+
+Unique Values: Filters to only include the top scorer from each department.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+8. Using DISTINCT to Ensure Unique Top Scorers
+
+SQL Query: Distinct Top Scorers
+
+SELECT DISTINCT name, marks
+FROM students
+WHERE marks = (SELECT MAX(marks) FROM students);
+
+Explanation:
+
+Unique Values: The DISTINCT keyword ensures only unique top scorers are returned.
+
+Data Filtering: Filters students with the highest marks from the dataset.
+
+Sorting: No explicit sorting needed, but ensures uniqueness.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+9. Top Scorer Identification with ROW_NUMBER()
+
+SQL Query: Top Scorer Using ROW_NUMBER()
+
+WITH RankedStudents AS (
+  SELECT name, marks, ROW_NUMBER() OVER (ORDER BY marks DESC) AS rank
+  FROM students
+)
+SELECT name, marks
+FROM RankedStudents
+WHERE rank = 1;
+
+Explanation:
+
+Sorting: ROW_NUMBER() sorts students by marks in descending order.
+
+Data Filtering: Filters the rank 1 student(s) (the top scorer).
+
+Unique Values: The function ROW_NUMBER() ensures each student is assigned a unique rank.
+---------------------------------------------------------------------------------------------------------------------------------------------
+
+10. Using MAX() with GROUP BY for Top Scorer Per City
+
+SQL Query: Top Scorer Per City
+
+SELECT city, name, marks
+FROM students s
+WHERE marks = (
+  SELECT MAX(marks) FROM students WHERE city = s.city
+)
+GROUP BY city;
+
+Explanation:
+
+Data Filtering: The subquery filters the top marks for each city.
+
+Sorting: The query does not explicitly sort, but GROUP BY is used to group results by city.
+
+Unique Values: Ensures each city has its top scorer listed uniquely.

package/pods/ts/Product Management System.txt

@@ -0,0 +1,135 @@
+1. Product.ts
+
+This file defines the Product class, which represents a product in the store. The Product class includes methods for updating stock and displaying product details.
+
+// Product.ts
+export class Product {
+  productId: string;
+  name: string;
+  price: number;
+  stock: number;
+
+  constructor(productId: string, name: string, price: number, stock: number) {
+    this.productId = productId;
+    this.name = name;
+    this.price = price;
+    this.stock = stock;
+  }
+
+  // Update product stock after a sale
+  updateStock(amountSold: number): void {
+    if (this.stock >= amountSold) {
+      this.stock -= amountSold;
+      console.log(`${this.name}: Sold ${amountSold} items. Remaining stock: ${this.stock}`);
+    } else {
+      console.log(`${this.name}: Not enough stock available.`);
+    }
+  }
+
+  // Display product details
+  displayProduct(): void {
+    console.log(`Product ID: ${this.productId}`);
+    console.log(`Name: ${this.name}`);
+    console.log(`Price: $${this.price}`);
+    console.log(`Stock: ${this.stock}`);
+  }
+
+  // Check if product is in stock
+  isInStock(amountSold: number): boolean {
+    return this.stock >= amountSold;
+  }
+}
+
+2. ProductManager.ts
+
+This file defines the ProductManager class, which handles product inventory operations such as adding products, updating stock, and displaying all products.
+
+// ProductManager.ts
+import { Product } from './Product';
+
+export class ProductManager {
+  private products: Product[] = [];
+
+  // Add a new product to the inventory
+  addProduct(product: Product): void {
+    this.products.push(product);
+    console.log(`${product.name} added to the inventory.`);
+  }
+
+  // Display all products in the inventory
+  displayAllProducts(): void {
+    if (this.products.length === 0) {
+      console.log("No products available.");
+    } else {
+      console.log("\n--- Available Products ---");
+      this.products.forEach((product) => product.displayProduct());
+    }
+  }
+
+  // Search for a product by its ID
+  findProductById(productId: string): Product | undefined {
+    return this.products.find((product) => product.productId === productId);
+  }
+
+  // Search for a product by its name
+  findProductByName(productName: string): Product | undefined {
+    return this.products.find((product) => product.name.toLowerCase() === productName.toLowerCase());
+  }
+
+  // Update stock after a sale
+  processSale(productId: string, quantity: number): void {
+    const product = this.findProductById(productId);
+    if (product) {
+      if (product.isInStock(quantity)) {
+        product.updateStock(quantity);
+      } else {
+        console.log(`Not enough stock of ${product.name}.`);
+      }
+    } else {
+      console.log("Product not found.");
+    }
+  }
+
+  // Generate inventory report
+  generateInventoryReport(): void {
+    console.log("\n--- Inventory Report ---");
+    this.products.forEach((product) => product.displayProduct());
+  }
+}
+
+3. Main.ts
+
+This file is the entry point where we interact with the ProductManager to manage products, process sales, and generate reports.
+
+// Main.ts
+import { Product } from './Product';
+import { ProductManager } from './ProductManager';
+
+// Create an instance of the ProductManager
+const manager = new ProductManager();
+
+// Create some products
+const product1 = new Product("P001", "Laptop", 1000, 50);
+const product2 = new Product("P002", "Smartphone", 700, 100);
+const product3 = new Product("P003", "Headphones", 150, 200);
+
+// Add products to the inventory
+manager.addProduct(product1);
+manager.addProduct(product2);
+manager.addProduct(product3);
+
+// Display all products in the inventory
+manager.displayAllProducts();
+
+// Process sales for the products
+manager.processSale("P001", 5);  // Selling 5 Laptops
+manager.processSale("P002", 3);  // Selling 3 Smartphones
+
+// Display updated product list after sales
+manager.displayAllProducts();
+
+// Generate an inventory report
+manager.generateInventoryReport();
+
+// Attempting to sell more than available stock
+manager.processSale("P003", 250);  // Trying to sell 250 Headphones (more than stock)

package/pods/ts/RetailStore.txt

@@ -0,0 +1,113 @@
+// RetailStore.ts
+
+class Product {
+  productId: string;
+  name: string;
+  price: number;
+  stock: number;
+
+  constructor(productId: string, name: string, price: number, stock: number) {
+    this.productId = productId;
+    this.name = name;
+    this.price = price;
+    this.stock = stock;
+  }
+
+  // Method to update the stock after a sale
+  updateStock(amountSold: number): void {
+    if (this.stock >= amountSold) {
+      this.stock -= amountSold;
+      console.log(`${this.name}: Sold ${amountSold} items. Remaining stock: ${this.stock}`);
+    } else {
+      console.log(`${this.name}: Not enough stock available.`);
+    }
+  }
+
+  // Method to display product details
+  displayProduct(): void {
+    console.log(`Product ID: ${this.productId}`);
+    console.log(`Name: ${this.name}`);
+    console.log(`Price: $${this.price}`);
+    console.log(`Stock: ${this.stock}`);
+  }
+
+  // Check if product is in stock
+  isInStock(amountSold: number): boolean {
+    return this.stock >= amountSold;
+  }
+}
+
+class RetailStore {
+  private products: Product[] = [];
+  private totalRevenue: number = 0;
+
+  // Method to add a new product to the store
+  addProduct(product: Product): void {
+    this.products.push(product);
+    console.log(`${product.name} added to the store.`);
+  }
+
+  // Method to display all products in the store
+  displayProducts(): void {
+    if (this.products.length === 0) {
+      console.log("No products available.");
+    } else {
+      console.log("\n--- Available Products ---");
+      this.products.forEach((product) => product.displayProduct());
+    }
+  }
+
+  // Method to process a sale
+  processSale(productId: string, quantity: number): void {
+    const product = this.products.find((p) => p.productId === productId);
+    if (product) {
+      if (product.isInStock(quantity)) {
+        product.updateStock(quantity);
+        const saleAmount = product.price * quantity;
+        this.totalRevenue += saleAmount;
+        console.log(`Sale processed: ${quantity} x ${product.name}. Total Sale: $${saleAmount}`);
+      } else {
+        console.log(`${product.name}: Not enough stock to sell ${quantity} items.`);
+      }
+    } else {
+      console.log("Product not found.");
+    }
+  }
+
+  // Method to generate sales report
+  generateSalesReport(): void {
+    console.log(`\n--- Sales Report ---`);
+    console.log(`Total Revenue: $${this.totalRevenue}`);
+  }
+}
+
+// Main.ts
+
+// Initialize the Retail Store
+const store = new RetailStore();
+
+// Create products
+const product1 = new Product("P001", "Laptop", 1000, 50);
+const product2 = new Product("P002", "Smartphone", 700, 100);
+const product3 = new Product("P003", "Headphones", 150, 200);
+
+// Add products to the store
+store.addProduct(product1);
+store.addProduct(product2);
+store.addProduct(product3);
+
+// Display all products in the store
+store.displayProducts();
+
+// Process sales
+store.processSale("P001", 5);  // Selling 5 Laptops
+store.processSale("P002", 3);  // Selling 3 Smartphones
+
+// Display updated product details
+store.displayProducts();
+
+// Generate sales report
+store.generateSalesReport();
+
+// Attempting to sell more than available stock
+store.processSale("P003", 250);  // Selling 250 Headphones (more than stock)