474. Ones and Zeroes

You are given an array of binary strings strs and two integers m and n. Return the size of the largest subset of strs such that there are at most m 0's and n 1's in the subset. A set x is a subset of a set y if all elements of x are also elements of y.
/**
 * @param {string[]} strs
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var findMaxForm = function(strs, m, n) {
    // Step 1: Initialize a 2D DP array
    // dp[i][j] = max number of strings we can form with i zeros and j ones
    let dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));

    // Step 2: Process each string in strs
    for (let str of strs) {
        // Count zeros and ones in the current string
        let zeros = 0, ones = 0;
        for (let

How to deploy branch to staging 

go to settings/environments/staging
Activate branch tracking and set the branch
save it
got to /deployments and deploy it with the name of the branch set

Removing stars from a string

Given a string s, where * represents a star. We can remove a star along with its closest non-star character to its left in a single operation. The task is to perform as many such operations as possible until all stars have been removed and return the resultant string. Example: Input: "abc*de*f" Expected: "abdf" Complexity: - Time: O(N) - Space: O(N) 
function removeStars(s) {
    const array = s.split('')
    const n = array.length
    const stack = []

    for (let i = 0; i < n; i++) {
        if (array[i] === '*') {
            stack.pop()
        } else {
            stack.push(array[i])
        }
    }

    return stack.join('')
}

Remove duplicates

Give a string s, convert it into a valid string. A string is considered valid if it does not have any two adjacent duplicate characters. To make a string valid, we will perform a duplicate removal process. A duplicate removal consists of choosing two adjacent and equal letters and removing them. We repeatedly make duplicate removals on s until we no longer can. Return the final string after all such duplicate removals have been made. Example: Input: "abbaca" Output: "ca" Complexity: - Time: O(N) - Space: O(N) 
function removeDuplicates(s) {
    const array = s.split('')
    const n = array.length
    console.log(n)
    const stack = []

    for (let i = 0; i < n; i++) {
        if (stack.length && stack[stack.length - 1] === array[i]) {
            stack.pop()
        } else {
            stack.push(array[i])
        }
    }

    return stack.join('')
}

iOS开发：SnapKit使用 

# iOS开发：SnapKit使用

## 例子1
```swift
// make width = superview.width + 100, height = superview.height + 100
make.size.equalTo(superview).offset(100)
```
## 例子2
```swift
// 等价于make.left.equalToSuperview().offset(10)
make.left.equalTo(10)

// 等价于make.right.equalToSuperview().offset(-10)
make.right.equalTo(-10)
```

## 例子3
```swift
// make.leading.trailing.equalToSuperview().inset(10)等价于以下两行代码
make.leading.equalTo(10)
make.trailing.equalTo(-10)
```

## 例子4
```swift
// make centerX = superview.centerX

Simplify Path

Given an absolute file path in a Unix-style file system, simplify it by converting ".." to the previous directory and removing any "." or multiple slashes. The resulting string should represent the shortest absolute path. Example: Input: path = "/a//b////c/d//././/.." Expected Output: "/a/b/c" Complexity: - Time: O(N) - Space: O(N)
function simplifyPath(path) {
    const pathArr = path.split('/')
    const n = pathArr.length
    const simplifiedPath = []

    for(let i=0; i<n; i++) {
        if(pathArr[i]==='.' || pathArr[i]==='') {
            continue
        }
        if(pathArr[i]==='..') {
            simplifiedPath.pop()
            continue
        }
        simplifiedPath.push(pathArr[i])
    }

    return `/${simplifiedPath.join('/')}`
}

Image container edge breakout 

:root {
  --container-width: 700px;
  --columns: 12;
  --gap: 20px;
  --column-width: calc((var(--container-width) / var(--columns)) - var(--gap));
  --breakpoint: 46em;
}

img {
  max-width: 100%;
}


.image-edge-grid {
	margin-bottom: 2rem;
    display: grid;
    grid-gap: var(--gap);
    grid-template-columns: minmax(1em, 1fr) repeat(var(--columns), minmax(0, var(--column-width))) minmax(1em, 1fr);
    max-width: initial;
	
	
}




.image-edge-grid__img {
  grid-col

Sorting a stack

Given a stack, sort it using only stack operations (push and pop). You can use an additional temporary stack, but you may not copy the elements into any other data structure (such as an array). The values in the stack are to be sorted in descending order, with the largest elements on top. Example: Input: [34, 3, 31, 98, 92, 23] Complexity - Time: O(N2) - Space: O(N) Output: [3, 23, 31, 34, 92, 98]
function sortStack(stack) {
    let tempStack = [];

    while(stack.length) {
        const temp = stack.pop()
        while(tempStack.length && tempStack[tempStack.length - 1]>temp) {
            stack.push(tempStack.pop())
        }

        tempStack.push(temp)
        

    }

    return tempStack
}

画像を右クリックやドラッグで保存させない 

<img src="assets/images/1.jpg" alt="" class="img" draggable="false" oncontextmenu="return false;" />

webGLコンテキストを破棄するサンプル 

<button id="createContext">WebGLコンテキスト作成</button>
<input type="number" id="deleteNumber" min="1" value="1" />
<button id="deleteSpecific">番号を指定して削除</button>
<button id="deleteAll">全て削除</button>
<div id="canvasContainer"></div>

文字量によって自動で高さが変動するtextarea 

<textarea class="auto-resize"></textarea>

Simple AI [Patrol] 

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class SmartRandomMover : MonoBehaviour
{
    [Header("Movement Settings")]
    public Transform[] targets;          // Assign points in Inspector
    public float moveSpeed = 3f;         // Speed of movement
    public float rotationSpeed = 5f;     // How fast it rotates to face target
    public float stopDistance = 0.5f;    // Distance to consider "arrived"
    public float waitTime = 1f;

Player Continous Fire System 

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerShootingAuto : MonoBehaviour
{
    [Header("Setup")]
    public GameObject bulletPrefab;
    public Transform firePoint;
    public float bulletSpeed = 20f;
    public float fireDelay = 0.3f;  // seconds between shots

    private bool isFiring = false;
    private float nextFireTime = 0f;

    // Called via Unity Event
    public void OnFire(InputAction.CallbackContext context)
    {
        if (context.perfo

clientes 

inicio{
"host":"VB4/gmn8UE5J73Bg9vSbWyhnUA==",
"porta":"CbyZhQEGptRObG41",
"contador":"e1Num6WG25XoF58yuifZFiiwRYcv+914nDNI57ZYQX8opvtTgHKpfsUXX+lngKGuEWTZnB3RUS03WS/UlPEg",
"spammer":"xQAIzKqmHLR3sYGuiRV33LNMw+U="
}fim

cabanova novembro scp 

ainicio{
"host":"3IzsRS6EmresJXTLu6M3v2nSFP8f",
"porta":"Jn09o6kUgovD8E/5",
"contador":"JwGjvL6E4SV7tfVnDj/lXkOR1s4CTgoTrpoY1w4XMMWzgPG8N3xnAFGMvrHqNaustm3lm4c=",
"spammer":"XJHaHXkcmmEaxX4="
}fim

3542. Minimum Operations to Convert All Elements to Zero

You are given an array nums of size n, consisting of non-negative integers. Your task is to apply some (possibly zero) operations on the array so that all elements become 0. In one operation, you can select a subarray [i, j] (where 0 <= i <= j < n) and set all occurrences of the minimum non-negative integer in that subarray to 0. Return the minimum number of operations required to make all elements in the array 0.
/**
 * Calculates the minimum number of operations needed to build a strictly increasing stack
 * from the input array, ignoring zeros and removing elements that break the order.
 *
 * @param {number[]} nums - Array of integers to process.
 * @return {number} - Minimum number of operations performed.
 */
var minOperations = function(nums) {
    const stack = []; // Stack to maintain increasing sequence
    let operations = 0; // Counter for operations performed

    for (const num of nums) {