Code Snippets on Cacher

VoileNoir

Un script Godot pour faire un effet de transition Avoir deux scene : Main + menu - Ajouter un colorRect (Mettre couleur noir) le Color A a transparent ==> 0 - Le mettre en bas de la scene - Option moins brusque en bas du script pour le script retour (game scene)

extends Control
@onready var voile_noir: ColorRect = $VoileNoir

var game_scene: PackedScene = preload("res://scenes/main.tscn")

func _process(delta: float) -> void:
	if Input.is_action_just_pressed("confirm"):
		changer_scene()



func changer_scene():
	var tween := create_tween()
	tween.tween_property(voile_noir, "color:a", 1.0, 0.8)
	await tween.finished
	
	get_tree().change_scene_to_packed(game_scene)
	
	#Option moins brusque:
    #var tween := create_tween()
    #tween.

3310. Remove Methods From Project

You are maintaining a project that has n methods numbered from 0 to n - 1. You are given two integers n and k, and a 2D integer array invocations, where invocations[i] = [ai, bi] indicates that method ai invokes method bi. There is a known bug in method k. Method k, along with any method invoked by it, either directly or indirectly, are considered suspicious and we aim to remove them. A group of methods can only be removed if no method outside the group invokes any methods within it. Return an array containing all the remaining methods after removing all the suspicious methods. You may return the answer in any order. If it is not possible to remove all the suspicious methods, none should be removed.

/**
 * @param {number} n
 * @param {number} k
 * @param {number[][]} invocations
 * @return {number[]}
 */
var remainingMethods = function(n, k, invocations) {
    const adj = Array.from({ length: n }, () => []);
    const rev = Array.from({ length: n }, () => []);

    for (const [a, b] of invocations) {
        adj[a].push(b);
        rev[b].push(a);
    }

    // Step 1: find suspicious nodes
    const suspicious = new Array(n).fill(false);
    const stack = [k];
    suspicious[k] = true;

qwen

sk-ws-H.DMDRYPP.vl9R.MEUCIBLPjK81_F8ggRU85KvznonJKbj1B6VbsG0WLPx5TE-xAiEAqjWvH6KJHTITicb9msrt_cXgKKwsHbYQAIBScFzN7H8

https://ws-572c0f0lftimh5ph.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1

Svg mask - sprite via css target


<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" fill-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2" clip-rule="evenodd" viewBox="0 0 1920 300" preserveAspectRatio="none"><style>:is(path,g){display:none}:is(path,g):target,#image path{display:initial}</style><path id="section2-bottom" fill-rule="nonzero" d="m354 132 4 2v1l-5-1 1-2Zm-4-32v1h1v-1h-1Zm-1 8-3 2c-3 2-2 4 0 6l4-5-1-3Zm0 22h1-1Zm-3 11h1-1Zm30-10 1-1h-2l1 1Zm-14 16 1 1v-1h-1Zm12-24-1 1 1 2 1-2-1-1Zm4 6h1v-1l-1

3731. Find Missing Elements

You are given an integer array nums consisting of unique integers. Originally, nums contained every integer within a certain range. However, some integers might have gone missing from the array. The smallest and largest integers of the original range are still present in nums. Return a sorted list of all the missing integers in this range. If no integers are missing, return an empty list.

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var findMissingElements = function(nums) {
    const mn = Math.min(...nums);
    const mx = Math.max(...nums);

    // Boolean presence array
    const seen = new Array(mx - mn + 1).fill(false);

    for (const num of nums) {
        seen[num - mn] = true;
    }

    const missing = [];
    for (let i = mn; i <= mx; i++) {
        if (!seen[i - mn]) missing.push(i);
    }

    return missing;
};

1406. Stone Game III

Alice and Bob continue their games with piles of stones. There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue. Alice and Bob take turns, with Alice starting first. On each player's turn, that player can take 1, 2, or 3 stones from the first remaining stones in the row. The score of each player is the sum of the values of the stones taken. The score of each player is 0 initially. The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken. Assume Alice and Bob play optimally. Return "Alice" if Alice will win, "Bob" if Bob will win, or "Tie" if they will end the game with the same score.

/**
 * @param {number[]} stoneValue
 * @return {string}
 */
var stoneGameIII = function(stoneValue) {
    const n = stoneValue.length;

    // dp[i] = maximum score difference Alice can achieve starting at index i
    // Positive dp[i] means Alice is ahead; negative means Bob is ahead.
    const dp = new Array(n + 1).fill(0);

    // Fill dp from the back because future states depend on later indices
    for (let i = n - 1; i >= 0; i--) {
        let best = -Infinity;   // Best score difference

🔗 DBT - dbt-utils VS dbt-expectations

# `dbt-utils` et `dbt-expectations` — fiche de comparaison

| | |
|---|---|
| **Genre** | ⚠️ **Hors corpus.** Document de travail personnel, pas un artefact de la version de vérité |
| **Pourquoi hors corpus** | Il décrit deux catalogues tiers qui évoluent indépendamment de la doctrine dbt. Le corpus ne fixe que ce que *nous* décidons ; le catalogue se lit sur GitHub |
| **Sources** | READMEs des dépôts, consultés le 3 août 2026 |
| **Versions décrites** | `dbt-utils` 1.3.3 (déc. 2025) · `dbt-ex

🔗 DBT - 03 - ECART - Marts réduits à une couche d'exposition

# Écart 03 — Les marts réduits à une couche d'exposition

| | |
|---|---|
| **Type** | Décalage de vocabulaire et d'architecture |
| **Doctrine de référence** | *Les trois couches d'un projet dbt*, §5.1 et §5.8 |
| **Statut** | À instruire |
| **Dernière révision** | Juillet 2026 |

> **En une phrase :** l'architecture est probablement correcte et seuls les noms sont faux — mais tant qu'ils le sont, la gouvernance se pose sur des projections plutôt que sur les définitions.

---

## 1. La pratiqu

🔗 DBT - 02 - ECART - Décomposition de l'intermediate en étapes techniques

# Écart 02 — Décomposition de l'intermediate en étapes techniques

| | |
|---|---|
| **Type** | Écart à un principe de découpage dbt |
| **Doctrine de référence** | *Les trois couches d'un projet dbt*, §4.4 et §6.5 |
| **Statut** | À instruire |
| **Dernière révision** | Juillet 2026 |

> **En une phrase :** dbt découpe l'intermediate selon le **concept métier préparé**, jamais selon l'**opération SQL effectuée** ; et le critère qui promeut une étape en modèle est la réutilisation, pas la nature

🔗 DBT - 01 - ECART - Ephemeral comme matérialisation au staging

# Écart 01 — `ephemeral` comme matérialisation du staging

| | |
|---|---|
| **Type** | Écart à une recommandation dbt explicite |
| **Doctrine de référence** | *Les trois couches d'un projet dbt*, §3.7 |
| **Statut** | À instruire |
| **Dernière révision** | Juillet 2026 |

> **En une phrase :** dbt recommande `view` au staging et énonce pour `ephemeral` trois conditions d'usage cumulatives dont l'une est incompatible par construction avec la fonction de la couche.

---

## 1. La pratique

La c

🔗 DBT - Semantic Layer et Modélisation Kimball

# Le dbt Semantic Layer — et pourquoi il réconcilie dbt avec Kimball

> Note de synthèse construite à partir de la documentation dbt Labs (pages *About MetricFlow*, *Joins*, *Semantic models*, *Measures*, *Creating metrics*, guide *How we build our metrics*, FAQ Semantic Layer) et de la page d'intégration Power BI. Sources consultées fin juillet 2026.

---

## 0. La réponse en cinq lignes

Le Semantic Layer déplace la définition des **métriques** hors de l'outil de BI et hors des tables figées,

🔗 DBT - Best Practises Couches

# Les trois couches d'un projet dbt : préconisations, recommandations et interdits

> Note de synthèse construite à partir des sources primaires dbt Labs (guides *How we structure our dbt projects*, *How we style our dbt projects*, *Materialization best practices*) et du package d'audit `dbt_project_evaluator`. État des pages consultées : mise à jour juin–juillet 2026.
>
> **Révision 5** — ajouts : sélection des colonnes en staging (§3.4), `ephemeral` au staging (§3.7), critère identité/préparat

🔗 DBT - 00 - Index

# Corpus dbt — index

Dernière mise à jour : août 2026

---

## Les trois genres

Le corpus distingue trois types de documents. Confondre les genres est la principale cause de dérive documentaire : une référence qui juge cesse d'être une référence, une note d'écart qui recopie la doctrine se périme à la première révision.

| Genre | Répond à | Longueur | Se met à jour |
|---|---|---|---|
| **Référence** | Que dit dbt ? | Long, exhaustif | Quand dbt évolue |
| **Note thématique** | Comment foncti

🔗 DBT - Choix d'une matérialisation

# Choix d'une matérialisation dbt — arbre de décision

| | |
|---|---|
| **Type** | Doctrine — synthèse des conseils officiels |
| **Doctrine de référence** | *Les trois couches d'un projet dbt*, §3.7, §4.6, §5.4 |
| **Dernière révision** | Juillet 2026 |

> ⚠️ **dbt ne publie aucun arbre de décision de ce type.** Ce diagramme est une synthèse des blocs « Advice » de la page *Materializations* croisés avec les matérialisations par défaut de chaque couche. Chaque nœud est traçable à une recommand

877. Stone Game

Alice and Bob play a game with piles of stones. There are an even number of piles arranged in a row, and each pile has a positive integer number of stones piles[i]. The objective of the game is to end with the most stones. The total number of stones across all the piles is odd, so there are no ties. Alice and Bob take turns, with Alice starting first. Each turn, a player takes the entire pile of stones either from the beginning or from the end of the row. This continues until there are no more piles left, at which point the person with the most stones wins. Assuming Alice and Bob play optimally, return true if Alice wins the game, or false if Bob wins.

/**
 * @param {number[]} piles
 * @return {boolean}
 */
var stoneGame = function(piles) {
    const n = piles.length;

    // dp[i][j] = max score difference current player can achieve
    const dp = Array.from({ length: n }, () => Array(n).fill(0));

    // Base case: when i == j, only one pile is available
    // The current player takes it, so the difference is piles[i]
    for (let i = 0; i < n; i++) {
        dp[i][i] = piles[i];
    }

    // Fill DP table for increasing lengths of subarra

Simu alpha 28 rue du Foix p9syzn8r6s 2 PAC

{
    "custom_renovation_plan": [
        {
            "category_technical_id": "heating",
            "gesture_technical_id": "air_air_heat_pump_with_external_unit_complete",
            "quantity": {
                "default_value": null,
                "error_margin": 0,
                "unit": "unit",
                "value": 1
            },
            "pricing": {
                "price_per_unit": "100.0"
            },
            "spec": {
                "service_technical_id": "air_

Cacher is the code snippet organizer for pro developers

We empower you and your team to get more done, faster