Cacher is the code snippet organizer for pro developers

/**
 * @param {number[][]} tasks
 * @return {number}
 */
var minimumEffort = function(tasks) {
    // Sort by (minimum - actual) descending
    tasks.sort((a, b) => (b[1] - b[0]) - (a[1] - a[0]));

    let totalActual = 0; // sum of actual costs of tasks done so far
    let answer = 0;      // minimal initial energy required

    for (let [actual, minimum] of tasks) {
        // For this task, we need: initial >= minimum + totalActualBefore
        answer = Math.max(answer, minimum + totalActual

# `dbt snapshot`

> Commande de capture d'historique. Construit et maintient une table SCD2 reflétant l'évolution d'une source dans le temps. **Seule commande dbt qui produit un effet stateful** : chaque exécution accumule de la donnée.

---

## Ce que ça fait

`dbt snapshot` capture des **photos successives** d'une table source dans le temps. Chaque ligne de la table snapshot représente l'état d'une entité métier **pendant une période donnée**.

```
CUSTOMER (source aujourd'hui)
───────────────

# `dbt seed`

> Commande de chargement. Importe des fichiers CSV depuis `seeds/` et les matérialise comme **tables** sur le warehouse. Mécanisme de versionnement de petites données de référence avec le code.

---

## Ce que ça fait

`dbt seed` lit les fichiers CSV présents dans le dossier `seeds/` du projet et les matérialise comme tables sur le warehouse :

```
seeds/countries_region.csv      ──►   <database>.<schema>.countries_region (TABLE)
seeds/mpaa_rating_mapping.csv   ──►   <database>.<sc

# `dbt compile`

> Commande d'inspection et de validation. Parse le projet, résout le Jinja en SQL physique, écrit le résultat dans `target/compiled/`. Aucune matérialisation envoyée au warehouse.

---

## Ce que ça fait

`dbt compile` exécute toute la chaîne de préparation **sauf** la matérialisation :

- Lit `dbt_project.yml`, les `.sql` et les `.yml`
- Construit le DAG et met à jour `manifest.json`
- Évalue le Jinja, résout les `ref()` et `source()` en noms physiques
- Évalue les macros, y co

# `dbt test`

> Commande de validation. Exécute des requêtes de contrôle qualité sur les modèles déjà matérialisés.

---

## Ce que ça fait

`dbt test` exécute des **requêtes de validation** sur les tables et vues déjà matérialisées. Chaque test cherche des **violations** :

```
0 ligne retournée = test réussi (aucune violation)
≥1 ligne retournée = test échoué (N violations détectées)
```

C'est une logique **par la négative** : un test ne prouve pas que les données sont bonnes, il prouve qu'au

El truco es el siguiente, la regla general:


Se hace un ping a qinnova.uned.es:
ping qinnova.uned.es
Se mira la IP

Se hace un ping a la web que queremos comprobar. 
  - Si la ip no es la misma, entonces es cluster (PRO-3)
  - Si la ip sí es la misma, entonces es PRO  (pro)

# `dbt run`

> Commande de développement quotidien. Matérialise les modèles sélectionnés sur le warehouse, sans exécuter les tests.

---

## Ce que ça fait

`dbt run` compile le Jinja, génère le SQL, et envoie au warehouse les ordres de matérialisation pour les modèles sélectionnés.

| Matérialisation | SQL effectivement exécuté |
|-----------------|---------------------------|
| `view` | `CREATE OR REPLACE VIEW <schema>.<modele> AS <ton SELECT>` |
| `table` | `CREATE OR REPLACE TABLE <schema>.<

# `dbt build`

> Commande de production. Exécute le DAG complet (modèles, tests, snapshots, seeds) dans l'ordre topologique, avec garantie d'arrêt en aval d'un échec.

---

## Ce que ça fait

Pour chaque ressource du DAG, dans l'ordre topologique :

1. Matérialise la ressource (modèle, snapshot, seed)
2. Exécute immédiatement les tests qui lui sont attachés
3. Si un test échoue → les descendants sont **skippés** (pas matérialisés)

C'est l'équivalent fonctionnel de :

```bash
dbt run && dbt test

document.addEventListener("DOMContentLoaded", function () {
  // Get the accordion container
  const accordionContainer = document.querySelector(".footer-acc");

  // Only proceed if the container exists
  if (accordionContainer) {
    const firstItem = accordionContainer.querySelector(".x-acc-item");

    if (firstItem) {
      const button = firstItem.querySelector("button[role='button']");
      const panel = firstItem.querySelector("div[role='tabpanel']");

      if (button && panel) {
     

Describe data
  .describe()
  .value_counts()
    ex.  drive_wheel_counts=df["drive-wheels"].value_counts()
    
    drive_wheel_counts.rename(columns={'drive-wheels':'value_counts'} inplace=True)
    drive_wheel_counts.index.name = 'drive-wheels'

Box Plot
  sns.boxplot (x= "" , y= "" , data=df)
  
Scatter Plot
  y=df[""]
  x=df[""]
  plt.scatter(x,y)
  
  plt.title("")
  plt.xlabel("")
  plt.ylabel("")
  
GroupBy data
  .groupby()
    ex. df_test = df[['drive-wheels', 'body-style', 'price']]
 

#optinal

sudo apt-get update -y

sudo apt-get upgrade

#required

curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh get-docker.sh

sudo usermod -aG docker ubuntu

newgrp docker

https://localsquash.com/

import { createTool } from '@mastra/core/tools';
import z from 'zod';
import { FilesystemEventType, FileType, Sandbox } from '@e2b/code-interpreter';

export const createSandbox = createTool({
  id: 'createSandbox',
  description: 'Create an e2b sandbox',
  inputSchema: z.object({
    metadata: z.record(z.string()).optional().describe('Custom metadata for the sandbox'),
    envs: z.record(z.string()).optional().describe(`
      Custom environment variables for the sandbox.
      Used 

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var separateDigits = function(nums) {
    const res = [];

    for (let n of nums) {
        // If the number is a single digit, just append it
        if (n < 10) {
            res.push(n);
            continue;
        }

        const stack = [];

        // Extract digits from right to left using modulo/division
        while (n > 0) {
            stack.push(n % 10);
            n = Math.floor(n / 10);
        }

        // Digits were 

Practical fix for local dev (Android emulator)
Use the same URL host as on iOS (e.g. http://localhost:3000/...) on the emulator as well, and make localhost on the emulator reach your Mac’s port 3000 with port reverse:

adb reverse tcp:3000 tcp:3000
Then set:

EXPO_PUBLIC_KYC_WEBVIEW_URL_FREE_ACTIVATION="http://localhost:3000/beacon-money-account/info/free-activation?beacon_flow=BMA"

(aligned with iOS). After reverse, localhost:3000 inside the emulator is forwarded to your host’s 3000, so you ge

npx playwright codegen --device="iPhone 13" playwright.dev