Past puzzles

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;
}