2904. Shortest and Lexicographically Smallest Beautiful String

You are given a binary string s and a positive integer k. A substring of s is beautiful if the number of 1's in it is exactly k. Let len be the length of the shortest beautiful substring. Return the lexicographically smallest beautiful substring of string s with length equal to len. If s doesn't contain a beautiful substring, return an empty string. A string a is lexicographically larger than a string b (of the same length) if in the first position where a and b differ, a has a character strictly larger than the corresponding character in b. For example, "abcd" is lexicographically larger than "abcc" because the first position they differ is at the fourth character, and d is greater than c.
/**
 * @param {string} s
 * @param {number} k
 * @return {string}
 */
var shortestBeautifulSubstring = function(s, k) {
    let n = s.length;
    let left = 0;
    let count1 = 0;
    let best = "";  // store lexicographically smallest among shortest

    for (let right = 0; right < n; right++) {
        if (s[right] === '1') count1++;

        // When we have exactly k ones, try shrinking from the left
        while (count1 === k) {
            let candidate = s.slice(left, right + 1);

JWT dependencies 

    implementation("io.jsonwebtoken:jjwt-api:0.12.5")
    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.5")
    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.5")

3718. Smallest Missing Multiple of K

Given an integer array nums and an integer k, return the smallest positive multiple of k that is missing from nums. A multiple of k is any positive integer divisible by k.
/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var missingMultiple = function(nums, k) {
    // Use a Set for O(1) membership checks
    const seen = new Set(nums);

    // Start from the first positive multiple of k
    let m = k;

    // Keep checking multiples of k until one is not in nums
    while (seen.has(m)) {
        m += k;   // Move to the next multiple
    }

    // This is the smallest missing multiple
    return m;
};

genspark skils 

<skill_content name="app-development-dashboard">
# Skill: app-development-dashboard

# Dashboard Development Guide

Build multi-chart dashboards with KPI cards on the **B-Suite design system**.
Assumes you have already activated the base `app-development` skill.

## Inherit the design system (do NOT inline CSS)

Declare a palette on `<html>` and the platform injects the whole B-Suite design
system at serve time — design tokens, 9 palettes (light + dark), the component
CSS, and a JS r

1872. Stone Game VIII

Alice and Bob take turns playing a game, with Alice starting first. There are n stones arranged in a row. On each player's turn, while the number of stones is more than one, they will do the following: Choose an integer x > 1, and remove the leftmost x stones from the row. Add the sum of the removed stones' values to the player's score. Place a new stone, whose value is equal to that sum, on the left side of the row. The game stops when only one stone is left in the row. The score difference between Alice and Bob is (Alice's score - Bob's score). Alice's goal is to maximize the score difference, and Bob's goal is the minimize the score difference. Given an integer array stones of length n where stones[i] represents the value of the ith stone from the left, return the score difference between Alice and Bob if they both play optimally.
/**
 * @param {number[]} stones
 * @return {number}
 */
var stoneGameVIII = function(stones) {
    const n = stones.length;

    // Build prefix sums: pref[i] = sum of stones[0..i]
    // These represent the score Alice would gain if she removes up to index i.
    const pref = new Array(n);
    pref[0] = stones[0];
    for (let i = 1; i < n; i++) {
        pref[i] = pref[i - 1] + stones[i];
    }

    // dp[i] = best score difference Alice can guarantee
    // starting from the state where she h

view transition apiを利用する

遷移前、遷移後でトランジションさせたい同一要素に対して<br> 「view-transition-name」プロパティで固有の名前を合わせて付与させる。<br> ※このとき、値が一意じゃないと動作しないので注意
@view-transition {
	navigation: auto;
}

usefull houdini hip 

https://codercat.xyz/cookbook/recipes/

1927. Sum Game

Alice and Bob take turns playing a game, with Alice starting first. You are given a string num of even length consisting of digits and '?' characters. On each turn, a player will do the following if there is still at least one '?' in num: Choose an index i where num[i] == '?'. Replace num[i] with any digit between '0' and '9'. The game ends when there are no more '?' characters in num. For Bob to win, the sum of the digits in the first half of num must be equal to the sum of the digits in the second half. For Alice to win, the sums must not be equal. For example, if the game ended with num = "243801", then Bob wins because 2+4+3 = 8+0+1. If the game ended with num = "243803", then Alice wins because 2+4+3 != 8+0+3. Assuming Alice and Bob play optimally, return true if Alice will win and false if Bob will win.
/**
 * @param {string} num
 * @return {boolean}
 */
var sumGame = function(num) {
    const n = num.length;
    const half = n / 2;

    let Lsum = 0, Rsum = 0;
    let Lq = 0, Rq = 0;

    for (let i = 0; i < half; i++) {
        if (num[i] === '?') Lq++;
        else Lsum += num.charCodeAt(i) - 48;
    }

    for (let i = half; i < n; i++) {
        if (num[i] === '?') Rq++;
        else Rsum += num.charCodeAt(i) - 48;
    }

    // If odd number of question marks, Alice wins automatically

Activate Django in Python script 


# ================================================================
# ======  For local testing purposes only- activate Django  ======
# ================================================================

import os
import django

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_name.settings")
django.setup()

# ================================================================
# ======          End of Django activaion setup             ====== 
# =================================

3622. Check Divisibility by Digit Sum and Product

You are given a positive integer n. Determine whether n is divisible by the sum of the following two values: The digit sum of n (the sum of its digits). The digit product of n (the product of its digits). Return true if n is divisible by this sum; otherwise, return false.
/**
 * @param {number} n
 * @return {boolean}
 */
var checkDivisibility = function(n) {
    // Convert the number to a string so we can iterate through each digit
    let sum = 0;
    let prod = 1;

    // Loop through each character (digit) in the number
    for (const ch of String(n)) {
        const d = ch - '0';   // Convert character to actual digit
        sum += d;             // Add digit to the running sum
        prod *= d;            // Multiply digit into the running product
    }

Check user password / Django 

import os
import django
from django.contrib.auth import get_user_model

# Start Django setup
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Django_project_4.settings")
django.setup()
# End of djang o setup


User = get_user_model()

# Find user by username or email
user = User.objects.get(username="username")
# user = User.objects.get(email="email@email.com")
password = "password"

if user.check_password(password):
    print("Password match!")
else:
    print("Wrong passwor

Deacom Linked Docs Installer Script 

# =============================================================================
# Single Deployment Script (PRODUCTION)
# - Password is hardcoded below
# - Encrypts it on the jump box
# - Writes the processing script (with encrypted password only) to C:\Scripts
# - Creates a reboot-resistant scheduled task (Daily + every 5 minutes)
# - FTPS (Explicit TLS) + Passive + Hostname
# - Gracefully handles 425 on close (known FileZilla quirk)
# - Archives files LOCALLY on C: drive
# ===========

3116. Kth Smallest Amount With Single Denomination Combination

You are given an integer array coins representing coins of different denominations and an integer k. You have an infinite number of coins of each denomination. However, you are not allowed to combine coins of different denominations. Return the kth smallest amount that can be made using these coins.
/**
 * @param {number[]} coins
 * @param {number} k
 * @return {number}
 */
var findKthSmallest = function(coins, k) {
    const n = coins.length;

    // Precompute all subset LCMs
    const lcms = [];
    const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
    const lcm = (a, b) => a / gcd(a, b) * b;

    for (let mask = 1; mask < (1 << n); mask++) {
        let L = 1;
        for (let i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                L = lcm(L, coins[i]);

Data validator 

https://www.npmjs.com/package/validatorjs

3069. Distribute Elements Into Two Arrays I

You are given a 1-indexed array of distinct integers nums of length n. You need to distribute all the elements of nums between two arrays arr1 and arr2 using n operations. In the first operation, append nums[1] to arr1. In the second operation, append nums[2] to arr2. Afterwards, in the ith operation: If the last element of arr1 is greater than the last element of arr2, append nums[i] to arr1. Otherwise, append nums[i] to arr2. The array result is formed by concatenating the arrays arr1 and arr2. For example, if arr1 == [1,2,3] and arr2 == [4,5,6], then result = [1,2,3,4,5,6]. Return the array result.
/**
 * @param {number[]} nums
 * @return {number[]}
 */
var resultArray = function(nums) {

    // arr1 starts with the first element
    const arr1 = [nums[0]];

    // arr2 starts with the second element
    const arr2 = [nums[1]];

    // Process the rest of the array starting from index 2
    for (let i = 2; i < nums.length; i++) {

        // Compare the last elements of arr1 and arr2
        // If arr1's last element is greater, append to arr1
        if (arr1[arr1.length - 1] > arr2[arr2.