2095. Delete the Middle Node of a Linked List

You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list. The middle node of a linked list of size n is the ⌊n / 2⌋th node from the start using 0-based indexing, where ⌊x⌋ denotes the largest integer less than or equal to x. For n = 1, 2, 3, 4, and 5, the middle nodes are 0, 1, 1, 2, and 2, respectively.
/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var deleteMiddle = function(head) {
    // 1. Edge case: only one node
    if (!head.next) return null;

    // 2. Find the node BEFORE the middle
    let slow = head;
    let fast = head.next.next;

    while (fast && fast.next) {
        slow = slow.next;

Получение xml заказа 

/bitrix/admin/1c_exchange.php?type=sale&mode=checkauth
/bitrix/admin/1c_exchange.php?type=sale&mode=init&sessid=ID_Сессии
/bitrix/admin/1c_exchange.php?type=sale&mode=query&sessid=ID_Сессии

IELTS 5 -12 

B
B
C
C
A
hillls
bus
5
picnic
mark?
B
E
D ---
F
G
D
B
C
I
A
D
A
H
E
G
sand
lower part
?
?
mobile phones
personality
numerous?
verbal
psychological 
?
extremes
assessment?
brain damage
school
reliability

Vocabulary:
red tape
ears poped

image.md 

Here are five distinct iterations of the Chicano tattoo-style theme, each expanding the narrative and scenery while maintaining the fineline black-and-grey aesthetic on vintage parchment.

### 1. The Boulevard Cruise
This scene shifts focus to a late-night cruise down Whittier Boulevard. The **Chevrolet lowrider** is depicted in motion, its front end hopped high in a "three-wheel motion" stance, captured with dynamic motion lines and blurred stippling. The **two skeleton figures** are seated

2130. Maximum Twin Sum of a Linked List

In a linked list of size n, where n is even, the ith node (0-indexed) of the linked list is known as the twin of the (n-1-i)th node, if 0 <= i <= (n / 2) - 1. For example, if n = 4, then node 0 is the twin of node 3, and node 1 is the twin of node 2. These are the only nodes with twins for n = 4. The twin sum is defined as the sum of a node and its twin. Given the head of a linked list with even length, return the maximum twin sum of the linked list.
/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {number}
 */
var pairSum = function(head) {
    // 1. Find middle using slow/fast pointers
    let slow = head, fast = head;
    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
    }

    // 2. Reverse second half
    let prev = null, curr

Claude - Settings 

{
  "outputStyle": "Explanatory",
  "enableAllProjectMcpServers": true,
  "permissions": {
    "defaultMode": "acceptEdits",
    "allow": ["Read", "Skill", "Bash", "Ide*", "WebSearch", "WebFetch", "mcp__*"]
  }
}

RTK - Installation and Tuning 

# RTK — Rust Token Killer

## What is it?

RTK is a standalone Rust CLI that sits between your shell and Claude Code, intercepting verbose command output (git logs, test failures, build errors, `find`, `ls -la`, etc.) and filtering, grouping, deduping, and truncating it before the LLM ever sees it. Claimed savings: **60–90% tokens** across ~100 supported dev commands.

It is **not a Claude Code plugin** — there is no marketplace ID and it never appears in `enabledPlugins`. Integration happens vi

3838. Weighted Word Mapping

You are given an array of strings words, where each string represents a word containing lowercase English letters. You are also given an integer array weights of length 26, where weights[i] represents the weight of the ith lowercase English letter. The weight of a word is defined as the sum of the weights of its characters. For each word, take its weight modulo 26 and map the result to a lowercase English letter using reverse alphabetical order (0 -> 'z', 1 -> 'y', ..., 25 -> 'a'). Return a string formed by concatenating the mapped characters for all words in order.
/**
 * @param {string[]} words
 * @param {number[]} weights
 * @return {string}
 */
var mapWordWeights = function(words, weights) {
    let out = "";

    for (const w of words) {
        let sum = 0;

        // Sum weights of characters
        for (const ch of w) {
            sum += weights[ch.charCodeAt(0) - 97]; // 'a' = 97
        }

        // Modulo 26
        const v = sum % 26;

        // Reverse alphabetical mapping: 0→'z', 1→'y', ..., 25→'a'
        const mapped = String.fromCharCo

chatGPT 

Je veux comprendre Fabric en profondeur.

Mon niveau : développeur Python/Django.

Explique-moi d’abord le problème que cette technologie résout, 

Puis les concepts clés, puis un exemple simple, puis un cas réel professionnel. 

Pose-moi des questions pour vérifier ma compréhension.

Linux Custom - Basic Shell Prompt 

export PS1="\n\
\[\033[38;2;255;249;143m\] \w\n\
\[\033[38;2;255;90;91m\] ⏹\
\[\033[38;2;250;190;36m\]⏹\
\[\033[38;2;42;197;67m\]⏹\
\[\033[0m\] \
\[\033[38;2;120;150;255m\]ubuntu-clean \
\[\033[38;2;140;170;255m\]❱ \
\[\033[0m\] "

Linux Custom - Basic Alias 

SUDO() {
    if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then
        sudo "$@"
    else
        "$@"
    fi
}

cc() {
    if command -v tput >/dev/null 2>&1 && [ -n "${TERM:-}" ] && tput reset 2>/dev/null; then
        return
    fi

    clear
}

alias apti='SUDO apt install -y'
alias aptu='SUDO apt update'
alias aptcc='SUDO apt autoremove -y && SUDO apt-get autoclean'
alias aptc='SUDO apt clean'
alias aptup='SUDO apt update && SUDO apt upgrade -y'

alias mkdir='mkdir -p'

alias

3559. Number of Ways to Assign Edge Weights II

There is an undirected tree with n nodes labeled from 1 to n, rooted at node 1. The tree is represented by a 2D integer array edges of length n - 1, where edges[i] = [ui, vi] indicates that there is an edge between nodes ui and vi. Initially, all edges have a weight of 0. You must assign each edge a weight of either 1 or 2. The cost of a path between any two nodes u and v is the total weight of all edges in the path connecting them. You are given a 2D integer array queries. For each queries[i] = [ui, vi], determine the number of ways to assign weights to edges in the path such that the cost of the path between ui and vi is odd. Return an array answer, where answer[i] is the number of valid assignments for queries[i]. Since the answer may be large, apply modulo 109 + 7 to each answer[i]. Note: For each query, disregard all edges not in the path between node ui and vi.
/**
 * @param {number[][]} edges
 * @param {number[][]} queries
 * @return {number[]}
 */
var assignEdgeWeights = function(edges, queries) {
    const n = edges.length + 1;
    const g = Array.from({ length: n + 1 }, () => []);

    for (const [u, v] of edges) {
        g[u].push(v);
        g[v].push(u);
    }

    // --- 1) BFS to compute depth + parent[0] ---
    const LOG = 17; // since n <= 1e5, log2(1e5) < 17
    const parent = Array.from({ length: LOG }, () => Array(n + 1).fill(0));
    c

hide sticky elementor claude 

@media (min-width: 320px) and (max-width: 767px) {
  
  .e-con-full.e-flex.e-con.e-child {
    position: relative;
}
  
}

Settings Basiques VS Code 

{
  // ============================================================
  // Settings VS Code — poste corporate
  // Périmètre : core VS Code + GitHub Copilot uniquement.
  // Exclus : settings liés aux extensions tierces (Ruff, Pylance,
  // YAML, TOML, Terraform, Material Icons, Gemini) — à réintégrer
  // au fil des approbations du circuit d'allowlisting interne.
  // ============================================================

  // --- UI & Affichage (core) ---
  "window.zoomLevel": 0,
  "workb

3558. Number of Ways to Assign Edge Weights I

There is an undirected tree with n nodes labeled from 1 to n, rooted at node 1. The tree is represented by a 2D integer array edges of length n - 1, where edges[i] = [ui, vi] indicates that there is an edge between nodes ui and vi. Initially, all edges have a weight of 0. You must assign each edge a weight of either 1 or 2. The cost of a path between any two nodes u and v is the total weight of all edges in the path connecting them. Select any one node x at the maximum depth. Return the number of ways to assign edge weights in the path from node 1 to x such that its total cost is odd. Since the answer may be large, return it modulo 109 + 7. Note: Ignore all edges not in the path from node 1 to x.
/**
 * @param {number[][]} edges
 * @return {number}
 */
var assignEdgeWeights = function(edges) {
    const n = edges.length + 1;
    const g = Array.from({ length: n + 1 }, () => []);

    for (const [u, v] of edges) {
        g[u].push(v);
        g[v].push(u);
    }

    // BFS to compute depths from node 1
    const depth = Array(n + 1).fill(-1);
    const queue = [1];
    depth[1] = 0;

    while (queue.length) {
        const u = queue.shift();
        for (const v of g[u]) {

3691. Maximum Total Subarray Value II

You are given an integer array nums of length n and an integer k. You must select exactly k distinct subarrays nums[l..r] of nums. Subarrays may overlap, but the exact same subarray (same l and r) cannot be chosen more than once. The value of a subarray nums[l..r] is defined as: max(nums[l..r]) - min(nums[l..r]). The total value is the sum of the values of all chosen subarrays. Return the maximum possible total value you can achieve.
/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var maxTotalValue = function(nums, k) {
    const n = nums.length;

    // -----------------------------
    // 1. Build Sparse Tables for RMQ
    // -----------------------------
    const LOG = Math.floor(Math.log2(n)) + 1;
    const stMax = Array.from({ length: LOG }, () => Array(n).fill(0));
    const stMin = Array.from({ length: LOG }, () => Array(n).fill(0));

    // level 0 is the array itself
    for (let i = 0; i