Cacher is the code snippet organizer for pro developers

/**
 * Calculates the maximum number of partitions after performing operations
 * that allow up to `k` distinct characters per partition.
 *
 * @param {string} s - Input string consisting of lowercase letters.
 * @param {number} k - Maximum number of distinct characters allowed per partition.
 * @return {number} - Maximum number of partitions achievable.
 */
var maxPartitionsAfterOperations = function(s, k) {
    const n = s.length;

    // L[i] stores [leftPartitions, leftMask, leftCount] for p

-Xms12G
-Xmx12G
-XX:+UnlockExperimentalVMOptions
-XX:+UseG1GC
-XX:+ParallelRefProcEnabled
-XX:MaxGCPauseMillis=50
-XX:+DisableExplicitGC
-XX:+AlwaysPreTouch
-XX:G1NewSizePercent=30
-XX:G1MaxNewSizePercent=40
-XX:G1HeapRegionSize=16M
-XX:G1ReservePercent=20
-XX:InitiatingHeapOccupancyPercent=15
-XX:G1MixedGCCountTarget=4
-XX:G1MixedGCLiveThresholdPercent=90
-XX:G1RSetUpdatingPauseTimePercent=5
-XX:SurvivorRatio=8
-XX:MaxTenuringThreshold=15
-XX:SoftRefLRUPolicyMSPerMB=10000
-XX

{% comment %}
  Helper: retrieves all values for a given query key from the current URL.

  Usage:
  {% render 'get-parameter-from-url', key: 'filter.p.m.attributes.apparel_size' %}
{% endcomment %}

{%- liquid
  # Capture page URL from header
  capture content_for_query_string
    echo content_for_header
  endcapture

  # Extract path after shop domain
  assign page_url = content_for_query_string | split: '"pageurl":"' | last | split: '"' | first | split: '.myshopify.com' | last | replace: '\/'

// backend/b2bCheckoutTest.web.js
import { Permissions, webMethod } from 'wix-web-module';
import wixStores from 'wix-stores-backend';
import { contacts } from 'wix-crm-backend';
import wixFetch from 'wix-fetch';
import { getSecret } from 'wix-secrets-backend';

/* ---------------------------------- Helpers ---------------------------------- */

function pseudoUuid() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    const r = (Math.random() * 16) | 0; // es

select
	[Superseded].Title [Superseded Title]
	, [Superseded].CI_ID [Superseded CI_ID]
	, [Superseded].CI_UniqueID [Superseded CI_UniqueID]
	, [Superseded].ArticleID [Superseded ArticleID]
	, [Superseded].InfoURL [Superseded InfoURL]

	, [Superseding].Title [Superseding Title]
	, [Superseding].CI_ID [Superseding CI_ID]
	, [Superseding].CI_UniqueID [Superseding CI_UniqueID]
	, [Superseding].ArticleID [Superseding ArticleID]
	, [Superseding].InfoURL [Superseding InfoURL]

	, [PSCmd] =

import { session } from 'wix-storage-frontend';
import { currentMember } from 'wix-members-frontend';
import wixLocation from 'wix-location';
import { computeDiscount } from 'backend/utils/discount';
import { shippingNet } from 'backend/utils/shipping';
import {
  createDealerOrderFromProfile,
  fetchMemberDefaultAddress
} from 'backend/b2bCheckout.web';

const CART_KEY = 'b2bCart';
const LAST_ORDER_KEY = 'b2bLastOrder';

function getCart() {
  try {
    return JSON.parse(session.

ALGORITHM DijkstraNFLStadiums(stadiums, distances, startStadium, endStadium)
INPUT:
    - stadiums: list of all stadium names
    - distances: matrix of distances between stadiums
    - startStadium: starting stadium name
    - endStadium: destination stadium name
OUTPUT:
    - shortest path as list of stadium names
    - total distance in miles

BEGIN
    // Initialize data structures
    distanceMap = empty map
    previousStadium = empty map
    unvisitedStadiums = set of all stadiums
    vis

This script conditionally loads an external JavaScript file only when certain UI elements (header/footer) are missing, helping avoid duplicate or conflicting scripts on pages that already include them.

```// Creates and injects a script tag into the page
const initialize = () => {
  const script = document.createElement("script");
  script.id = "footer-header-script";           // Unique ID to prevent duplicate injection
  script.type = "text/javascript";
  script.src = "https://www.example.com

function ConvertFrom-ByteArray {
    [CmdletBinding()]
    param (
        [Alias('appid')]
        [Parameter(Mandatory = $true, Position = 0, ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true)]
        [byte[]]
        $byteArray
    )
    
    begin {}

    process {
        try {
            [System.Text.Encoding]::UTF8.GetString($byteArray)
        }
        catch {
            throw $_
        }
    }

    end {}
}

/**
 * @param {number[]} nums
 * @param {number} value
 * @return {number}
 */
var findSmallestInteger = function(nums, value) {
    // Step 1: Create a frequency map to count how many times each remainder appears
    const freq = new Map();

    for (let num of nums) {
        // Normalize the remainder to always be non-negative
        let mod = ((num % value) + value) % value;

        // Count how many times each remainder appears
        freq.set(mod, (freq.get(mod) || 0) + 1);
    }

    /

PLUGINS

• https://www.kadencewp.com/kadence-blocks/
• https://www.kadencewp.com/kadence-blocks/

# model.py
# ChildLangNet: Interaction Pattern Recognition for Early Childhood Language
# PyTorch >= 1.10

from typing import Optional, Tuple, Dict
import torch
import torch.nn as nn
import torch.nn.functional as F


# ---------------------------
# Small building blocks
# ---------------------------

class MLP(nn.Module):
    def __init__(self, in_dim: int, hidden: int, out_dim: int, p: float = 0.1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Li

import torch
import torch.nn as nn
import torch.nn.functional as F

# Define the Vocational Curriculum Alignment Network (VCAN)
class VCAN(nn.Module):
    def __init__(self, curriculum_dim, enterprise_dim, hidden_dim, output_dim):
        super(VCAN, self).__init__()

        # Convolutional layer to process curriculum and enterprise data
        self.curriculum_conv = nn.Conv1d(curriculum_dim, hidden_dim, kernel_size=3, padding=1)
        self.enterprise_conv = nn.Conv1d(enterprise_d

import torch
import torch.nn as nn
import torch.nn.functional as F

# Define the Temporal Skill Progression Network (TSPNet)
class TSPNet(nn.Module):
    def __init__(self, skill_dim, hidden_dim, output_dim):
        super(TSPNet, self).__init__()
        
        # Recurrent neural network (LSTM) to model temporal dependencies in skill progression
        self.lstm = nn.LSTM(skill_dim, hidden_dim, batch_first=True)
        
        # Attention mechanism to focus on the most relevant

# model.py
# TourFusionNet: Multi-Source Data Fusion for Sports Tourism Preference Prediction
# Implements: modality encoders, hierarchical fusion (self & cross attention),
#             graph propagation, and Adaptive Preference Integration Strategy (APIS).
# PyTorch >= 1.10 recommended.

from typing import Dict, Optional, List, Tuple
import torch
import torch.nn as nn
import torch.nn.functional as F


# -----------------------------
# Utility blocks
# ----------------------------

import torch
import torch.nn as nn
import torch.nn.functional as F

# Define the Harmonic Scene Integration Network (HSIN)
class HSIN(nn.Module):
    def __init__(self, music_dim, scene_dim, embedding_dim, output_dim):
        super(HSIN, self).__init__()
        
        # Define the multi-modal encoder for music and scene data
        self.music_encoder = nn.Sequential(
            nn.Linear(music_dim, embedding_dim),
            nn.ReLU(),
            nn.Dropout(0.5)
        )