Past puzzles

class Patch {
  constructor(bankLabel, patchName) {
    this.bankLabel = bankLabel;   // e.g. 'Bank A'
    this.patchName = patchName;   // e.g. 'Lush Pad'
    this._displayName = undefined;
  }

  // Lazily builds 'Bank A · Lush Pad' and caches it on first read.
  get displayName() {
    if (this._displayName === undefined) {
      this._displayName = `${this.bankLabel} · ${this.patchName}`;
    }
    return this._displayName;
  }
}

function renderPatchList(patches) {
  return patches.map((patch) => patch.displayName).join('\n');
}

function renameBank(patches, oldLabel, newLabel) {
  for (const patch of patches) {
    if (patch.bankLabel === oldLabel) {
      patch.bankLabel = newLabel;
    }
  }
}

const bank = [
  new Patch('Bank A', 'Lush Pad'),
  new Patch('Bank A', 'Acid Bass'),
];

// UI renders the list first...
console.log(renderPatchList(bank));
// 'Bank A · Lush Pad\nBank A · Acid Bass'

// ...then the user renames the bank and we re-render.
renameBank(bank, 'Bank A', 'Bank B');
console.log(renderPatchList(bank));
// Expected: 'Bank B · Lush Pad\nBank B · Acid Bass'
// Actual:   still shows 'Bank A · ...'

// Aurora borealis sighting logger — nightly Kp summary for Reykjavik report
function summarizeNightlyKp(sightings) {
  const dailyKpTotals = {};

  for (const sighting of sightings) {
    // Bucket each sighting into its 'night' by calendar date
    const nightKey = new Date(sighting.timestamp).toLocaleDateString();
    dailyKpTotals[nightKey] = (dailyKpTotals[nightKey] || 0) + sighting.kpIndex;
  }

  return dailyKpTotals;
}

const auroraSightings = [
  { timestamp: '2024-01-15T21:05:00Z', kpIndex: 4 },
  { timestamp: '2024-01-15T23:30:00Z', kpIndex: 5 },
  { timestamp: '2024-01-16T00:45:00Z', kpIndex: 6 },
  { timestamp: '2024-01-16T22:10:00Z', kpIndex: 3 },
];

const report = summarizeNightlyKp(auroraSightings);
console.log('Nightly Kp totals for Reykjavik:', report);

-- Monthly report: count inspections per hive where the queen was NOT confirmed sighted.
-- These flag neglected hives that may need a beekeeper's attention.

SELECT hive_id,
       COUNT(*) AS queen_not_sighted_count
FROM inspections
WHERE queen_sighted <> TRUE
GROUP BY hive_id
ORDER BY queen_not_sighted_count DESC;

#!/usr/bin/env bash
# Reconcile seismograph station calibration from sensors.cfg
# Each line: <SENSOR> <GAIN_CORRECTION>, e.g. "BHZ-04 1.02"

total_gain=0

while read -r sensor gain; do
  [[ -z "$sensor" ]] && continue
  total_gain=$(echo "$total_gain + $gain" | bc -l)
  echo "Applied $sensor gain correction: $gain"
done < sensors.cfg

echo "Total accumulated gain correction: $total_gain"

# sensors.cfg (hand-edited by field techs, last line often lacks newline):
#   BHZ-04 1.02
#   BHN-04 0.99
#   HHN-12 0.97   <-- saved with no trailing newline

// Builds a 30-night observation schedule.
// Each slot is set to an observation timestamp when the user logs a session,
// or left empty (deleted) when a night is cleared.
function buildSchedule() {
  const schedule = new Array(30);
  // Simulate some logged nights
  schedule[0]  = '2024-11-01T21:00:00Z';
  schedule[2]  = '2024-11-03T22:15:00Z';
  schedule[5]  = '2024-11-06T20:45:00Z';
  schedule[10] = '2024-11-11T23:00:00Z';

  // User later clears night index 2 (clouds rolled in)
  delete schedule[2];

  return schedule;
}

// Counts how many nights in the 30-night window were NOT observed.
function countMissedNights(schedule) {
  let missedNights = 0;

  schedule.forEach((slot, index) => {
    if (slot === undefined) {
      // This night has no observation logged
      missedNights++;
    }
  });

  return missedNights;
}

const schedule = buildSchedule();
const missed   = countMissedNights(schedule);
console.log(`Missed nights: ${missed}`);
// Expected: 27  (30 total − 3 observed: indices 0, 5, 10)
// Actual:   26  (the hole at index 2 is silently skipped by forEach)

import csv
import io

def validate_submission(csv_upload: str, master_word_bank: set) -> dict:
    reader = csv.reader(io.StringIO(csv_upload))
    submitted_words = [row[0].strip().lower() for row in reader if row]

    # Generator that lazily filters words found in the master word bank
    valid_words_gen = (w for w in submitted_words if w in master_word_bank)

    # First pass: count how many valid words the contestant submitted
    valid_count = sum(1 for _ in valid_words_gen)

    # Second pass: collect the actual matched words for the score report
    matched_words = [w for w in valid_words_gen]

    return {
        "valid_count": valid_count,
        "matched_words": matched_words,
    }


if __name__ == "__main__":
    word_bank = {"apple", "brave", "crane", "dwell", "ember"}

    csv_data = "Apple\nBrave\nCrane\nzebra\nDwell\nflight\nEmber\n"

    result = validate_submission(csv_data, word_bank)
    print(f"Valid word count : {result['valid_count']}")
    print(f"Matched words    : {result['matched_words']}")
    # Expected: count=5, matched_words=['apple','brave','crane','dwell','ember']
    # Actual  : count=5, matched_words=[]  <-- bug!

#!/usr/bin/env bash

READING_FILE="/data/tremorvault/raw/reading_$(date +%Y%m%d).dat"
ARCHIVE_FILE="/data/tremorvault/archive/tremor_archive_$(date +%Y%m%d).gz"
CHECKSUM_FILE="/data/tremorvault/archive/tremor_checksum_$(date +%Y%m%d).txt"

# Compress the night's raw sensor readings, mirror to the archive, and
# record a checksum so we can verify integrity later.
gzip -c "$READING_FILE" | tee "$ARCHIVE_FILE" | md5sum > "$CHECKSUM_FILE"

if [[ $? -eq 0 ]]; then
  echo "TremorVault: archive verified, removing raw reading."
  rm "$READING_FILE"
else
  echo "TremorVault: archiving failed, keeping raw reading $READING_FILE" >&2
  exit 1
fi

using System.Collections.Generic;

public class InventoryManager
{
    private List<string> items = new List<string>();

    public void AddItem(string item)
    {
        items.Add(item);
    }

    public void RemoveItem(string item)
    {
        for (int i = 0; i < items.Count; i++)
        {
            if (items[i] == item)
            {
                items.Remove(items[i]);
            }
        }
    }

    public int GetCount() => items.Count;
}

-- Sailing club: compute each skipper's season score after dropping their worst race
WITH scored AS (
    SELECT
        skipper_name,
        race_number,
        points,
        RANK() OVER (PARTITION BY skipper_name ORDER BY points DESC) AS finish_rank
    FROM race_results
    WHERE season = 2024
      AND finish_rank > 1  -- intended to drop the worst (highest-point) finish
)
SELECT
    skipper_name,
    SUM(points) AS discarded_score
FROM scored
GROUP BY skipper_name
ORDER BY discarded_score;

-- Sample data for reference:
-- skipper_name | race_number | points
-- Hargreaves   |      1      |   3
-- Hargreaves   |      2      |   7    <-- worst, should be discarded
-- Hargreaves   |      3      |   1
-- Hargreaves   |      4      |   4
-- Hargreaves   |      5      |   6
-- Nakamura     |      1      |   5
-- Nakamura     |      2      |   2
-- Nakamura     |      3      |   8    <-- worst, should be discarded
-- Nakamura     |      4      |   3
-- Nakamura     |      5      |   6

-- Sailing club: compute each skipper's season score after dropping their worst race
WITH scored AS (
    SELECT
        skipper_name,
        race_number,
        points,
        RANK() OVER (PARTITION BY skipper_name ORDER BY points DESC) AS finish_rank
    FROM race_results
    WHERE season = 2024
      AND finish_rank > 1  -- intended to drop the worst (highest-point) finish
)
SELECT
    skipper_name,
    SUM(points) AS discarded_score
FROM scored
GROUP BY skipper_name
ORDER BY discarded_score;

-- Sample data for reference:
-- skipper_name | race_number | points
-- Hargreaves   |      1      |   3
-- Hargreaves   |      2      |   7    <-- worst, should be discarded
-- Hargreaves   |      3      |   1
-- Hargreaves   |      4      |   4
-- Hargreaves   |      5      |   6
-- Nakamura     |      1      |   5
-- Nakamura     |      2      |   2
-- Nakamura     |      3      |   8    <-- worst, should be discarded
-- Nakamura     |      4      |   3
-- Nakamura     |      5      |   6

using System;

public class Program
{
    public static int CountBusinessDays(DateTime start, DateTime end)
    {
        if (end < start) return 0;

        int count = 0;
        DateTime current = start.Date;

        while (current <= end.Date)
        {
            if (current.DayOfWeek != DayOfWeek.Saturday &&
                current.DayOfWeek != DayOfWeek.Sunday)
            {
                count++;
            }

            current.AddDays(1);
        }

        return count;
    }

    public static void Main()
    {
        var start = new DateTime(2026, 3, 1);
        var end = new DateTime(2026, 3, 10);
        Console.WriteLine($"Business days: {CountBusinessDays(start, end)}");
    }
}

type User = { id: number; name: string };

const fakeDb: Record<number, User> = {
  1: { id: 1, name: "Ada" },
  2: { id: 2, name: "Linus" },
  3: { id: 3, name: "Grace" }
};

function delay(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function getUserName(id: number): Promise<string> {
  await delay(20);
  return fakeDb[id]?.name ?? "Unknown";
}

async function loadNames(ids: number[]): Promise<string[]> {
  const names: string[] = [];

  ids.forEach(async (id) => {
    const name = await getUserName(id);
    names.push(name);
  });

  return names;
}

(async () => {
  const result = await loadNames([1, 2, 3]);
  console.log(result); // Expected: ["Ada", "Linus", "Grace"]
})();

using System;

class Program
{
    static void Main()
    {
        int completedTasks = 3;
        int totalTasks = 10;

        int percent = GetCompletionPercent(completedTasks, totalTasks);
        Console.WriteLine($"Completed: {percent}%");
    }

    static int GetCompletionPercent(int completed, int total)
    {
        if (total == 0)
            return 0;

        return (completed / total) * 100;
    }
}

-- Customers who have not placed any order in the last 30 days
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.order_date >= CURRENT_DATE - INTERVAL '30 days'
   OR o.id IS NULL
ORDER BY c.name;

<?php

$codes = [
    'VIP-123',
    'SUMMER-VIP-50',
    'VIP-999',
    'BASIC-10'
];

function isVipCode(string $code): bool
{
    // VIP codes must start with "VIP-"
    if (!strpos($code, 'VIP-')) {
        return false;
    }

    return true;
}

foreach ($codes as $code) {
    echo $code . ' => ' . (isVipCode($code) ? 'valid' : 'invalid') . PHP_EOL;
}

def add_tag(tag, tags=[]):
    tags.append(tag)
    return tags

print(add_tag("python"))      # ['python']
print(add_tag("bugs"))        # expected ['bugs']
print(add_tag("spot", ["daily"]))  # ['daily', 'spot']

interface Service {
  id: number;
  name: string;
  enabled: boolean;
}

// Build an index of services to quickly retrieve their names.
const services: Service[] = [
  { id: 101, name: "Billing", enabled: true },
  { id: 202, name: "Analytics", enabled: false },
  { id: 303, name: "Support", enabled: true }
];

const serviceIndex: Map<number, Service> = new Map();
services.forEach(service => serviceIndex.set(service.id, service));

function getEnabledServiceName(serviceId: string): string {
  const service = serviceIndex.get(serviceId);
  if (!service) throw new Error(`Service ${serviceId} is missing.`);
  if (!service.enabled) throw new Error(`Service ${serviceId} is disabled.`);
  return service.name;
}

console.log(getEnabledServiceName("101"));

type Notification = { userId: string; message: string };

async function fetchNotificationQueue(): Promise<Notification[]> {
  const response = await fetch("https://example.com/api/notifications");
  if (!response.ok) throw new Error(`Failed to load queue (${response.status})`);
  return response.json();
}

async function sendNotification(notification: Notification) {
  await new Promise(resolve => setTimeout(resolve, 50));
  console.log(`Sent to ${notification.userId}: ${notification.message}`);
}

// Process the pending notifications sequentially and report when finished
async function processQueue() {
  const notifications = await fetchNotificationQueue();
  notifications.forEach(async notification => {
    await sendNotification(notification);
  });
  console.log("All notifications processed");
}

processQueue().catch(console.error);

#!/bin/bash

# Script to monitor disk usage and alert if any partition exceeds threshold
THRESHOLD=80
ALERT_FILE="/tmp/disk_alerts.log"

# Clear previous alerts
> "$ALERT_FILE"

# Check disk usage for all mounted filesystems
df -h | tail -n +2 | while read filesystem size used avail percent mountpoint; do
    # Extract numeric percentage value
    usage=${percent%?}
    
    if [ $usage -gt $THRESHOLD ]; then
        echo "WARNING: $mountpoint is at ${percent} capacity" >> "$ALERT_FILE"
    fi
done

# Report findings
if [ -s "$ALERT_FILE" ]; then
    echo "Disk usage alerts found:"
    cat "$ALERT_FILE"
else
    echo "All partitions are within safe limits"
fi

class InventoryManager:
    """Manages product inventory with automatic reordering"""
    
    def __init__(self):
        self.inventory = {}
        self.reorder_threshold = 10
        self.reorder_quantity = 50
    
    def add_product(self, product_id, quantity):
        """Add or update product quantity in inventory"""
        if product_id in self.inventory:
            self.inventory[product_id] += quantity
        else:
            self.inventory[product_id] = quantity
    
    def sell_product(self, product_id, quantity):
        """Sell product and automatically reorder if below threshold"""
        if product_id not in self.inventory:
            raise ValueError(f"Product {product_id} not in inventory")
        
        if self.inventory[product_id] < quantity:
            raise ValueError(f"Insufficient stock for product {product_id}")
        
        self.inventory[product_id] -= quantity
        
        # Auto-reorder if stock falls below threshold
        if self.inventory[product_id] < self.reorder_threshold:
            self.reorder(product_id)
        
        return self.inventory[product_id]
    
    def reorder(self, product_id):
        """Reorder product to replenish stock"""
        self.inventory[product_id] += self.reorder_quantity
        print(f"Reordered {self.reorder_quantity} units of {product_id}")

# Test the inventory system
manager = InventoryManager()
manager.add_product("WIDGET-001", 15)

# Sell products in batches
for i in range(3):
    remaining = manager.sell_product("WIDGET-001", 3)
    print(f"Sale {i+1}: {remaining} units remaining")

print(f"Final inventory: {manager.inventory['WIDGET-001']}")

// Shopping cart discount calculator with tiered pricing
// Apply volume discounts and promotional codes

interface CartItem {
  id: string;
  price: number;
  quantity: number;
}

interface PromoCode {
  code: string;
  discount: number;
  minPurchase: number;
}

class ShoppingCart {
  private items: CartItem[] = [];
  private promoCodes: Map<string, PromoCode> = new Map();

  constructor() {
    this.promoCodes.set('SAVE10', { code: 'SAVE10', discount: 0.10, minPurchase: 50 });
    this.promoCodes.set('SAVE20', { code: 'SAVE20', discount: 0.20, minPurchase: 100 });
  }

  addItem(item: CartItem): void {
    const existing = this.items.find(i => i.id === item.id);
    if (existing) {
      existing.quantity += item.quantity;
    } else {
      this.items.push(item);
    }
  }

  calculateTotal(promoCode?: string): number {
    let subtotal = this.items.reduce((sum, item) => {
      let itemPrice = item.price * item.quantity;
      // Apply volume discount: 5% off if buying 10+ of same item
      if (item.quantity >= 10) {
        itemPrice *= 0.95;
      }
      return sum + itemPrice;
    }, 0);

    if (promoCode) {
      const promo = this.promoCodes.get(promoCode);
      if (promo && subtotal > promo.minPurchase) {
        subtotal -= subtotal * promo.discount;
      }
    }

    return Math.round(subtotal * 100) / 100;
  }
}

<?php

$workflowSteps = ['draft', 'submitted', 'approved', 'invoiced'];
$orders = [
    ['id' => 301, 'status' => 'draft', 'customer_tier' => 'gold', 'total' => 980],
    ['id' => 302, 'status' => 'submitted', 'customer_tier' => 'standard', 'total' => 120],
];

function determineNextAction(array $order, array $workflowSteps): string
{
    // Business rule: escalate gold customers with high-value orders to manual approval.
    $currentStep = array_search($order['status'], $workflowSteps, true);
    if (!$currentStep) {
        throw new RuntimeException("Workflow status '{$order['status']}' is not recognized.");
    }

    if ($order['customer_tier'] === 'gold' && $order['total'] > 500) {
        return 'manual_review';
    }

    $nextStep = $workflowSteps[$currentStep + 1] ?? 'completed';

    return $nextStep === 'approved' && $order['total'] < 200
        ? 'auto_approve_discount'
        : $nextStep;
}

foreach ($orders as $order) {
    try {
        $nextAction = determineNextAction($order, $workflowSteps);
        echo "Order {$order['id']} next action: {$nextAction}\n";
    } catch (RuntimeException $exception) {
        echo "Order {$order['id']} failed: {$exception->getMessage()}\n";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var orders = new List<Order>
        {
            new Order { Id = "A102", PlacedAt = DateTime.UtcNow.AddHours(-5) },
            new Order { Id = "B204", PlacedAt = DateTime.UtcNow.AddHours(-1) },
            new Order { Id = "C309", PlacedAt = DateTime.UtcNow.AddHours(-3) }
        };

        var reporter = new OrderReporter();
        // Prints the most recent order to review shipping priority.
        var latest = reporter.GetMostRecentOrder(orders);
        Console.WriteLine($"Most recent order: {latest.Id} at {latest.PlacedAt:O}");
    }
}

class Order
{
    public string Id { get; set; }
    public DateTime PlacedAt { get; set; }
}

class OrderReporter
{
    public Order GetMostRecentOrder(List<Order> orders)
    {
        if (orders == null || orders.Count == 0)
        {
            throw new ArgumentException("Orders collection cannot be empty.");
        }

        return orders
            .OrderBy(o => o.PlacedAt)
            .First();
    }
}

public class InventoryManager
{
    private List<(string itemId, int quantity)> inventory = new();

    // Applies a bulk discount and updates inventory when order is placed
    public decimal ProcessOrder(string itemId, int quantity, decimal pricePerUnit)
    {
        var existingItem = inventory.FirstOrDefault(x => x.itemId == itemId);
        
        if (existingItem.itemId != null)
        {
            inventory.Remove(existingItem);
            inventory.Add((itemId, existingItem.quantity - quantity));
        }

        decimal totalPrice = quantity * pricePerUnit;
        
        // Apply bulk discount: 10% off for orders >= 100 units
        if (quantity >= 100)
        {
            totalPrice *= 0.9m;
        }
        
        return totalPrice;
    }

    public void AddStock(string itemId, int quantity)
    {
        var existing = inventory.FirstOrDefault(x => x.itemId == itemId);
        
        if (existing.itemId != null)
        {
            inventory.Remove(existing);
            inventory.Add((itemId, existing.quantity + quantity));
        }
        else
        {
            inventory.Add((itemId, quantity));
        }
    }
}

// Product inventory management system that applies discounts based on quantity
interface Product {
  id: string;
  name: string;
  price: number;
  stock: number;
}

class InventoryManager {
  private products: Map<string, Product> = new Map();

  addProduct(product: Product): void {
    this.products.set(product.id, product);
  }

  // Calculate total price with bulk discount: 10% off for 5+ items, 20% off for 10+ items
  calculateOrderTotal(productId: string, quantity: number): number | null {
    const product = this.products.get(productId);
    
    if (!product || product.stock < quantity) {
      return null;
    }

    let total = product.price * quantity;
    let discount = 0;

    if (quantity >= 10) {
      discount = 0.20;
    } else if (quantity >= 5) {
      discount = 0.10;
    }

    total -= total * discount;
    product.stock -= quantity;
    
    return total;
  }
}

// Test the inventory system
const manager = new InventoryManager();
manager.addProduct({ id: 'A1', name: 'Widget', price: 100, stock: 50 });

console.log(manager.calculateOrderTotal('A1', 8));  // Should be 720 (800 - 10%)
console.log(manager.calculateOrderTotal('A1', 12)); // Should be 960 (1200 - 20%)
console.log(manager.calculateOrderTotal('A1', 5));  // Should be 450 (500 - 10%)

const tasks = [
  { name: 'Sync DB', priority: 2 },
  { name: 'Deploy hotfix', priority: 1 },
  { name: 'Write report', priority: 3 }
];

function sortTasksByPriority(list) {
  // Sort tasks so the lowest priority number is handled first
  return [...list].sort((a, b) => a.priority > b.priority);
}

function getNextTaskName(taskList) {
  const sorted = sortTasksByPriority(taskList);
  if (sorted.length === 0) return 'No tasks pending';
  return sorted[0].name;
}

console.log('Next up:', getNextTaskName(tasks));

#!/usr/bin/env bash
set -euo pipefail

# Validate the database connection string from .env and try a simple query.
env_file=".env"
if [[ ! -f "$env_file" ]]; then
  echo "Configuration file $env_file not found." >&2
  exit 1
fi

db_url=$(grep -E '^DATABASE_URL=' "$env_file" | head -n1 | cut -d '=' -f2)
if [[ -z "$db_url" ]]; then
  echo "DATABASE_URL missing in $env_file" >&2
  exit 1
fi

echo "Testing database connectivity..."
psql "$db_url" -c 'SELECT NOW();'

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // This code processes user data and removes inactive accounts
        List<User> users = new List<User>
        {
            new User { Id = 1, Name = "Alice", IsActive = true },
            new User { Id = 2, Name = "Bob", IsActive = false },
            new User { Id = 3, Name = "Charlie", IsActive = true }
        };

        foreach (var user in users)
        {
            if (!user.IsActive)
            {
                users.Remove(user);
            }
        }

        Console.WriteLine($"Remaining users: {users.Count}");
    }
}

class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsActive { get; set; }
}

DECLARE @StartOfLastMonth DATE;
DECLARE @EndOfLastMonth DATE;

-- Calculate the total sales for the previous month
SET @StartOfLastMonth = DATEFROMPARTS(YEAR(GETDATE()), MONTH(GETDATE()) - 1, 1);
SET @EndOfLastMonth = EOMONTH(@StartOfLastMonth);

SELECT
    CustomerID,
    SUM(TotalAmount) AS MonthlySales
FROM dbo.SalesOrders
WHERE OrderDate BETWEEN @StartOfLastMonth AND @EndOfLastMonth
  AND IsCancelled = 0
GROUP BY CustomerID
ORDER BY MonthlySales DESC;

# Script to check if a given filename exists and is a non-empty regular file
filename="data.txt"
# Check if file exists and is not empty
if [[ -e $filename && -s $filename ]]; then
    echo "$filename exists and is not empty."
else
    echo "$filename does not exist or is empty."
fi

using System;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program
{
    static async Task Main(string[] args)
    {
        var processor = new DataProcessor();
        await processor.ProcessMultipleItems();
    }
}

class DataProcessor
{
    // Process multiple data items concurrently and aggregate results
    public async Task ProcessMultipleItems()
    {
        var items = new List<int> { 1, 2, 3, 4, 5 };
        var tasks = new List<Task<string>>();
        
        foreach (var item in items)
        {
            tasks.Add(ProcessItemAsync(item));
        }
        
        // Wait for all tasks to complete
        await Task.WhenAll(tasks);
        
        Console.WriteLine("Processing complete. Results:");
        foreach (var task in tasks)
        {
            Console.WriteLine(task.Result);
        }
    }
    
    private async Task<string> ProcessItemAsync(int itemId)
    {
        // Simulate async operation
        await Task.Delay(100);
        return $"Processed item {itemId}";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var orderProcessor = new OrderProcessor();
        orderProcessor.ProcessOrders();
    }
}

class OrderProcessor
{
    private List<Order> orders = new List<Order>();

    public OrderProcessor()
    {
        // Initialize with sample orders
        orders.Add(new Order { Id = 1, Amount = 100.50m, Status = "Pending" });
        orders.Add(new Order { Id = 2, Amount = 250.75m, Status = "Completed" });
        orders.Add(new Order { Id = 3, Amount = 75.25m, Status = "Pending" });
    }

    // Process all pending orders and calculate total
    public void ProcessOrders()
    {
        decimal total = 0;
        var pendingOrders = orders.Where(o => o.Status == "Pending").ToList();
        
        foreach (var order in pendingOrders)
        {
            Console.WriteLine($"Processing order {order.Id} with amount {order.Amount}");
            order.Status = "Completed";
            total += order.Amount;
        }
        
        Console.WriteLine($"Total processed: {total}");
        Console.WriteLine($"Remaining pending orders: {orders.Count(o => o.Status == "Pending")}");
    }
}

class Order
{
    public int Id { get; set; }
    public decimal Amount { get; set; }
    public string Status { get; set; }
}

// Function to check if a user has permission to delete a resource
// Users can delete if they are the owner OR if they are an admin
function canDeleteResource(user, resource) {
  const isOwner = user.id === resource.ownerId;
  const isAdmin = user.role === 'admin';
  const isResourceLocked = resource.locked === true;
  
  // Allow deletion if user is owner or admin, but not if resource is locked
  if (isOwner || isAdmin && !isResourceLocked) {
    return true;
  }
  
  return false;
}

// Test cases
const admin = { id: 1, role: 'admin' };
const owner = { id: 2, role: 'user' };
const otherUser = { id: 3, role: 'user' };
const lockedResource = { ownerId: 2, locked: true };
const unlockedResource = { ownerId: 2, locked: false };

console.log('Admin can delete unlocked:', canDeleteResource(admin, unlockedResource)); // Expected: true
console.log('Owner can delete locked:', canDeleteResource(owner, lockedResource)); // Expected: false, Actual: true (BUG!)
console.log('Other user cannot delete:', canDeleteResource(otherUser, unlockedResource)); // Expected: false

<?php
// Process user registration with email verification
function validateUserRegistration($email, $password, $isEmailVerified, $accountAge) {
    $isValidEmail = filter_var($email, FILTER_VALIDATE_EMAIL);
    $isStrongPassword = strlen($password) >= 8;
    $isAccountOldEnough = $accountAge >= 30; // Account must be at least 30 days old
    
    // Check if user meets all registration requirements
    if ($isValidEmail && $isStrongPassword && ($isEmailVerified || $isAccountOldEnough)) {
        return true;
    }
    return false;
}

$result = validateUserRegistration('user@example.com', 'password123', false, 20);
echo $result ? 'Registration approved' : 'Registration denied';
?>

#!/bin/bash

# Script to validate user age and grant access to premium features
user_age=25
min_age_required=18
access_granted=false

# Check if user meets minimum age requirement
if [ $user_age -ge $min_age_required ]; then
  access_granted=true
fi

# Display access status
if [ "$access_granted" = true ]; then
  echo "Access granted to premium features"
else
  echo "Access denied - user too young"
fi

interface User {
  id: number;
  name: string;
}

// Adds a new user to the provided array if not present
function addUser(users: User[], newUser: User): User[] {
  if (!users.includes(newUser)) {
    users.push(newUser);
  }
  return users;
}

// Usage example:
const usersList = [ { id: 1, name: 'Alice' } ];
const updatedList = addUser(usersList, { id: 1, name: 'Alice' });
console.log(updatedList.length); // Supposed to print 1 if no duplicate

<?php

class UserPermissionManager {
    private $users = [];
    private $roles = ['admin', 'editor', 'viewer'];
    private $permissions = [];

    public function addUser($userId, $role, $isActive = true) {
        $this->users[$userId] = [
            'role' => $role,
            'active' => $isActive,
            'createdAt' => time()
        ];
    }

    // Determines if a user can perform an action based on role and active status
    public function canPerformAction($userId, $action) {
        if (!isset($this->users[$userId])) {
            return false;
        }

        $user = $this->users[$userId];
        
        // Check if user is active AND has appropriate role for the action
        $isActive = $user['active'];
        $hasPermission = $this->hasRolePermission($user['role'], $action);
        
        return $isActive && $hasPermission || $user['role'] === 'admin';
    }

    private function hasRolePermission($role, $action) {
        $permissions = [
            'admin' => ['read', 'write', 'delete', 'manage'],
            'editor' => ['read', 'write'],
            'viewer' => ['read']
        ];
        
        return isset($permissions[$role]) && in_array($action, $permissions[$role]);
    }

    public function revokeUserAccess($userId) {
        if (isset($this->users[$userId])) {
            $this->users[$userId]['active'] = false;
        }
    }
}

// Test the class
$manager = new UserPermissionManager();
$manager->addUser('user1', 'editor', true);
$manager->addUser('user2', 'viewer', false);
$manager->addUser('user3', 'admin', true);

// Expected: user1 (editor, active) can write = true
var_dump($manager->canPerformAction('user1', 'write'));

// Expected: user2 (viewer, inactive) cannot read even if viewer can = false
var_dump($manager->canPerformAction('user2', 'read'));

// Expected: user3 (admin, active) can delete = true
var_dump($manager->canPerformAction('user3', 'delete'));

// This should be false but will return true due to the bug
$manager->revokeUserAccess('user1');
var_dump($manager->canPerformAction('user1', 'write'));

?>

<?php

// Function to validate and sanitize user input before database insertion
function sanitizeUserData($userData) {
    $sanitized = [];
    
    foreach ($userData as $key => $value) {
        // Remove any HTML tags and trim whitespace
        $sanitized[$key] = trim(strip_tags($value));
    }
    
    return $sanitized;
}

// Simulate user registration data
$userInput = [
    'username' => 'john_doe',
    'email' => 'john@example.com',
    'bio' => 'Software developer from NYC',
    'is_active' => true,
    'age' => 25
];

// Sanitize the user data
$cleanData = sanitizeUserData($userInput);

// Display the sanitized data
echo "Sanitized Data:\n";
print_r($cleanData);

// Check if user is active
if ($cleanData['is_active']) {
    echo "\nUser account is active\n";
} else {
    echo "\nUser account is inactive\n";
}

?>

#!/bin/bash
# Check if user has valid permissions based on role hierarchy
declare -a roles=("guest" "user" "moderator" "admin" "superadmin")
declare -a user_perms=("read" "write" "delete" "manage" "full")

function check_auth() {
    local user_role="$1"
    local required_role="$2"
    local user_idx=-1
    local req_idx=-1
    
    for i in "${!roles[@]}"; do
        [[ "${roles[$i]}" == "$user_role" ]] && user_idx=$i
        [[ "${roles[$i]}" == "$required_role" ]] && req_idx=$i
    done
    
    [[ $user_idx -ge 0 && $req_idx -ge 0 && $user_idx -gt $req_idx ]] && echo "Access granted: ${user_perms[$user_idx]}" || echo "Access denied"
}

check_auth "admin" "moderator"

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Button demo</title>
<style>
:root {
  --primary-color: #1e90ff;
  --btn-radius: 8px;
}

body {
  font-family: system-ui, sans-serif;
  background: #f7f7f7;
  display: flex;
  align-items: center;
  justify-content: center;
  height: 100vh;
  margin: 0;
}

.button {
  background: var(--primray-color);
  color: white;
  padding: 12px 20px;
  border: none;
  border-radius: var(--btn-radius);
  cursor: pointer;
  box-shadow: 0 2px 6px rgba(0,0,0,0.15);
  font-size: 16px;
}
</style>
</head>
<body>
<button class="button">Click me</button>
</body>
</html>

def make_squares(n):
    funcs = []
    for i in range(n):
        # bug: lambda closes over loop variable i
        funcs.append(lambda: i * i)
    return funcs

funcs = make_squares(5)
for f in funcs:
    print(f())

SELECT customer_id, order_date, total_amount
FROM orders
WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31'
ORDER BY order_date;

function addNumbers(a, b) {
  return a + b;
}

const result = addNumbers('5', 10);
console.log(result);

<?php
function calculateDiscount($price, $percentage) {
    $discount = $price * $percentage / 100;
    return $price - $discount;
}

$originalPrice = 100;
$discountRate = '15%';
$finalPrice = calculateDiscount($originalPrice, $discountRate);
echo "Final price: $" . $finalPrice;
?>

SELECT employee_id, CONCAT(first_name, last_name) AS full_name FROM employees WHERE department = 'Sales';

<?php
function calculateTotal($items) {
    $total = 0;
    foreach ($items as $item) {
        $total += $item['price'] * $item['quantity'];
    }
    return $total;
}

$products = [
    ['name' => 'Apple', 'price' => '2.50', 'quantity' => 3],
    ['name' => 'Banana', 'price' => '1.20', 'quantity' => 5],
    ['name' => 'Orange', 'price' => '3.00', 'quantity' => 2]
];

echo "Total: $" . calculateTotal($products);
?>

function findMaxValue(numbers) {
  let max = 0;
  for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] > max) {
      max = numbers[i];
    }
  }
  return max;
}

console.log(findMaxValue([5, 3, 8, 1])); // Works fine
console.log(findMaxValue([-2, -5, -1, -8])); // Bug appears here

function findLargestNumber(numbers) {
  let largest = 0;
  for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] > largest) {
      largest = numbers[i];
    }
  }
  return largest;
}

console.log(findLargestNumber([5, 2, 8, 1]));
console.log(findLargestNumber([-3, -1, -7, -2]));

button {
  background-color: #4CAF50;
  color: white;
  padding: 10px 24px;
  border: none;
  border-radius: 12px 12px 12px 12px 12px;
  cursor: pointer;
  font-size: 16px;
}

<?php
function addToArray($arr) {
    $arr[] = 'new item';
}

$myArray = ['item1', 'item2'];
addToArray($myArray);
print_r($myArray);
?>

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        foreach (var num in numbers)
        {
            if (num % 2 == 0)
            {
                numbers.Remove(num);
            }
        }
        
        Console.WriteLine("Remaining numbers: " + string.Join(", ", numbers));
    }
}

<?php
function calculateDiscount($price, $discount) {
    if ($discount > 0 && $discount < 100) {
        return $price - ($price * $discount / 100);
    }
    return $price;
}

$originalPrice = 50.00;
$discountPercent = "10";
$finalPrice = calculateDiscount($originalPrice, $discountPercent);
echo "Final price: $" . $finalPrice;
?>

#!/bin/bash

files=$(ls *.txt)
for file in $files; do
    if [ -f $file ]; then
        echo "Processing: $file"
        wc -l $file
    fi
done

def calculate_total(items, discount_rate=0.1):
    total = sum(item['price'] for item in items)
    return total * (1 - discount_rate)

class Calculator {
  private history: number[] = [];

  add(a: number, b: number): number {
    const result = a + b;
    this.history.push(result);
    return result;
  }

  getAverage(): number {
    const sum = this.history.reduce((acc, val) => acc + val, 0);
    return sum / this.history.length;
  }

  clear(): void {
    this.history = [];
  }
}

const calc = new Calculator();
console.log(calc.add(5, 3));
console.log(calc.add(10, 2));
console.log('Average:', calc.getAverage());
calc.clear();
console.log('Average after clear:', calc.getAverage());

SELECT customer_name, order_date, total_amount FROM orders WHERE order_date >= '2023-01-01' AND order_date < '2024-01-01' ORDER BY order_date GROUP BY customer_name;

#!/bin/bash

read -p "Enter a number: " num
if [ $num -gt 10 ]; then
    echo "Number is greater than 10"
elif [ $num -eq 10 ]; then
    echo "Number equals 10"
else
    echo "Number is less than 10"
fi

public class UserManager {
    private static List<string> _users = new List<string>();
    
    public void AddUser(string username) {
        if (_users.Contains(username)) {
            _users.Add(username);
        }
    }
    
    public bool UserExists(string username) {
        return _users.Contains(username);
    }
}

fdsqfdq

.container {
    display: flex;
    flex-wrap: nowrap;
    overflow-x: auto;
    width: 100%;
}

.item {
    flex-shrink: 0;
    min-width: 250px;
    margin-right: 10px;
}

<?php
function calculateTotal($items, $tax = 0.1) {
    $total = 0;
    foreach ($items as $item) {
        $total += $item['price'];
    }
    return $total * (1 + $tax);
}

$products = [
    ['name' => 'Laptop', 'price' => 1000],
    ['name' => 'Phone', 'price' => 500],
    ['name' => 'Tablet', 'price' => null]
];

echo calculateTotal($products);

public class NumberProcessor {
    public static int CalculateSum(int[] numbers) {
        int result = 0;
        foreach (int num in numbers) {
            result += num;
        }
        return result / numbers.Length;
    }

    public static void Main() {
        int[] data = { 10, 20, 30 };
        Console.WriteLine(CalculateSum(data));
    }
}

<?php
function calculateSum($a, $b) {
    return $a + $b;
}

$result = calculateSum('5 apples', 10);
echo "Sum is: $result";
?>

const numbers = [1, 2, 3, 4, 5];
const squared = numbers.map(num => {
  num * num;
});
console.log(squared);

function calculateTotal(items) {
    return items.reduce((total, item) => {
        return total + item.price * item.quantity;
    }, 0);
}

const cart = [
    { name: 'Laptop', price: 1000, quantity: 1 },
    { name: 'Mouse', price: 50 }
];

console.log(calculateTotal(cart));

public class UserManager {
    private List<string> userNames = new List<string>();

    public void AddUser(string name) {
        if (name != null && name.Length > 2) {
            userNames.Add(name.ToLower());
        }
    }

    public bool IsUserNameUnique(string name) {
        return !userNames.Contains(name);
    }
}

class Rectangle {
    width: number;
    height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    getArea(): number {
        return this.width * this.heigth;
    }
}

body {
    background-color: #GGG;
}

function greet(name) {
    return 'Hello, ' + name;
}
greet();

def divide_numbers(a, b):
    return a / b

.modal-backdrop {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background-color: rgba(0, 0, 0, 0.5);
  z-index: 100;
}

.modal {
  position: fixed;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  background-color: white;
  padding: 20px;
  z-index: 10;
}

#!/bin/bash

filename=$1

if [ -f $filename ]; then
  echo "Processing $filename"
  grep "ERROR" $filename > errors.log
else
  echo "File not found"
fi

public class UserManager {
  private List<User> users;
  
  public void AddUser(User user) {
    users.Add(user);
  }
  
  public User FindUser(string username) {
    return users.FirstOrDefault(u => u.Username == username);
  }
}

function createCounter() {
  let count = 0;
  
  function increment() {
    count++;
    return count;
  }
  
  return {
    increment: increment,
    reset: function() {
      count = 0;
    },
    getCount: function() {
      return Count;
    }
  };
}

function reverseString(str: string): string {
  let reversed = '';
  for (let i = 0; i <= str.length; i++) {
    reversed = str[i] + reversed;
  }
  return reversed;
}

async function fetchUserData(userId) {
    const response = await fetch(`/api/users/${userId}`);
    const data = response.json();
    return data;
}

public class User
{
    private string _name;
    private int _age;
    
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
    
    public int Age
    {
        get { return _age; }
        set { _age = value; }
    }
    
    public bool IsAdult()
    {
        return Age > 18;
    }
}

interface User {
  id: number;
  name: string;
  email: string;
  active: boolean;
}

function filterActiveUsers(users: User[]): User[] {
  return users.filter(user => user.active = true);
}

function incrementCounter() {
    static $counter = 0;
    counter++;
    return $counter;
}

echo incrementCounter();

function setupButton() {
    const button = document.getElementById('myButton');
    
    button.addEventListener('click', function() {
        button.textContent = 'Clicked!';
        setupButton();
    });
}

function getLastElement(array) {
    return array[array.length];
}

const arr = [1, 2, 3, 4, 5];
console.log(getLastElement(arr));

.container {
    width: 100;
    height: 200px;
    padding: 20px;
    margin: 10px;
}

#!/bin/bash
if [ $1 -eq "yes" ]; then
  echo "You said yes"
fi

function sanitizeInput($input)
{
    $clean = strip_tags($input);
    $clean = htmlspecialchars($clean);
    return $input;
}