Freestyle Sparring

from typing import Any


class Pet:
    def __init__(
        self,
        name: Any,
        species: Any,
        gender: Any = "not defined",
        age: Any = 0,
        n_legs: Any = 4,
    ) -> None:
        # Go through the setters so we reuse validation/conversion logic
        self.name = name
        self.species = species
        self.gender = gender
        self.age = age
        self.n_legs = n_legs

    # --- string-like fields -------------------------------------------------

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, value: Any) -> None:
        try:
            self._name = str(value)
        except Exception as exc:
            raise ValueError("name must be convertible to str") from exc

    @property
    def species(self) -> str:
        return self._species

    @species.setter
    def species(self, value: Any) -> None:
        try:
            self._species = str(value)
        except Exception as exc:
            raise ValueError("species must be convertible to str") from exc

    @property
    def gender(self) -> str:
        return self._gender

    @gender.setter
    def gender(self, value: Any) -> None:
        try:
            self._gender = str(value)
        except Exception as exc:
            raise ValueError("gender must be convertible to str") from exc

    # --- int-like fields ----------------------------------------------------

    @property
    def age(self) -> int:
        return self._age

    @age.setter
    def age(self, value: Any) -> None:
        try:
            self._age = int(value)
        except (TypeError, ValueError) as exc:
            raise ValueError("age must be convertible to int") from exc

    @property
    def n_legs(self) -> int:
        return self._n_legs

    @n_legs.setter
    def n_legs(self, value: Any) -> None:
        try:
            self._n_legs = int(value)
        except (TypeError, ValueError) as exc:
            raise ValueError("n_legs must be convertible to int") from exc

    # --- behaviour ----------------------------------------------------------

    def have_birthday(self, b_day: Any = 1) -> int:
        try:
            increment = int(b_day)
        except (TypeError, ValueError) as exc:
            raise ValueError("birthday increment must be convertible to int") from exc
        self.age += increment
        return self.age

    def __str__(self) -> str:
        return (
            f"{self.name} the {self.gender} {self.species}, "
            f"age {self.age} has {self.n_legs} legs!"
        )

from operator import add, sub, mul, truediv
OPS = dict(zip("+-*/", (add, sub, mul, truediv)))
calculator = lambda a, b, op: OPS[op](a, b)

export function findTheLongestWord(sentence?: string): string {
  if (typeof sentence !== "string") throw new Error("The sentence must end up being a string");
  const words = sentence.trim().split(/\s+/);
  if (!words[0]) throw new Error("The sentence cannot be empty");
  
  let longest = "", tie = false;
  for (const w of words)
    if (w.length > longest.length) { longest = w; tie = false; }
    else if (w.length === longest.length) tie = true;
  
  return tie ? "no longest word found" : `${longest}: ${longest.length} chars`;
}

def cursed_world():
    return (
        (ඞ := lambda ඞඞ: ඞඞ)
        ((སྐྱེས := [])or[(སྐྱེས := [*སྐྱེས, chr(c)])for c in 
        (0x68,0x65,0x6c,0x6c,0x6f,0x20,0x77,0x6f,0x72,0x6c,0x64)])
        and ඞ(''.join(སྐྱེས))
    )

import std/unittest

const text* = "Hello world!"

proc main*() =
  echo text

when isMainModule:
  main()

suite "greeting":
  test "text is \"Hello world!\"":
    check text == "Hello world!"

import java.util.*;

class WordChain {
    
    static boolean validate(String[] w, int n) {
        // Edge cases
        if (n <= 0 || w == null || w.length <= 1) return false;
        
        final int len = w.length;
        final int TABLE_SIZE = 65536;
        final int MASK = TABLE_SIZE - 1;
        
        // Pre-process: lowercase char arrays + hashes (single pass)
        char[][] chars = new char[len][];
        int[] hashes = new int[len];
        
        for (int i = 0; i < len; i++) {
            String s = w[i];
            if (s == null || s.length() < n) return false;
            
            char[] c = new char[s.length()];
            int h = 0;
            for (int j = 0; j < c.length; j++) {
                char ch = s.charAt(j);
                // Branchless lowercase for A-Z
                ch |= ((ch >= 'A' & ch <= 'Z') ? 0x20 : 0);
                c[j] = ch;
                h = 31 * h + ch;
            }
            chars[i] = c;
            hashes[i] = h;
        }
        
        // Hash table with chaining (faster than linear probing)
        int[] buckets = new int[TABLE_SIZE];
        int[] next = new int[len];
        Arrays.fill(buckets, -1);
        
        // Insert first word
        int idx = hashes[0] & MASK;
        next[0] = -1;
        buckets[idx] = 0;
        
        // Validate chain
        for (int i = 1; i < len; i++) {
            char[] prev = chars[i - 1];
            char[] curr = chars[i];
            
            // Suffix-prefix match (direct array access = no bounds check)
            int suffixStart = prev.length - n;
            for (int j = 0; j < n; j++) {
                if (prev[suffixStart + j] != curr[j]) return false;
            }
            
            // Duplicate detection with early hash rejection
            int hash = hashes[i];
            idx = hash & MASK;
            
            for (int slot = buckets[idx]; slot != -1; slot = next[slot]) {
                if (hashes[slot] == hash && arraysEqual(chars[slot], curr)) {
                    return false;
                }
            }
            
            // Insert into hash table
            next[i] = buckets[idx];
            buckets[idx] = i;
        }
        
        return true;
    }
    
    private static boolean arraysEqual(char[] a, char[] b) {
        if (a.length != b.length) return false;
        for (int i = 0; i < a.length; i++) {
            if (a[i] != b[i]) return false;
        }
        return true;
    }
}