Ricetta pancake
Porti una ricetta da 8 pancake a 12: ogni riga viene moltiplicata per 1,5, quindi 190 g di farina diventano 285 g e 350 ml di latte diventano 525 ml. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Quantità
- 190, 350, 1, 3,5
- Porzioni
- 12
- Porzioni di base
- 8
- Nomi
- flour (g), milk (ml), eggs, baking powder (tsp)
- Scalato
- 285, 525, 1,5, 5,25
- Fattore
- 1,5
- Quantità
- 4
Uno scalatore di ricetta pancake trasforma una scheda di impasto da cucina casalinga nell'elenco esatto di ingredienti di cui Lei ha bisogno per un'altra dimensione di pila. Inserisca ogni quantità numerica della ricetta base—farina, latte, uova, lievito in polvere, zucchero, sale, burro fuso—più il rendimento per cui quella ricetta è stata scritta e il numero di porzioni o pancake che desidera sulla piastra. Le etichette opzionali degli ingredienti viaggiano con ogni quantità affinché la risposta possa mostrare grammi di farina accanto a millilitri di latte e cucchiaini di lievito.
Che cosa significa scalare una ricetta pancake e perché i rapporti dell'impasto restano fissi
I cuochi del fine settimana, gli ospitanti del brunch e le cucine al banco affrontano lo stesso problema aritmetico: una ricetta di pancake pubblicata elenca grammi o millilitri fissi per otto pezzi, ma la tavola serve un'altra pila.
Lo scaling di una ricetta pancake moltiplica ogni quantità scalabile per un unico fattore condiviso così i rapporti relativi restano costanti—una volta e mezza la farina incontra ancora una volta e mezza il latte alla stessa idratazione, e il lievito in polvere scala con lo stesso coefficiente anche quando l'unità è il cucchiaino anziché il grammo. Le unità non vengono convertite qui; centonovanta resta centonovanta finché Lei non decide se sono grammi o millilitri, e il risultato scalato conserva la convenzione di unità già usata sulla scheda.
Quella separazione è intenzionale: i convertitori tazza-grammi e i sostituti del latticello risolvono altre domande, mentre questa capacità risponde solo quanto di ogni riga elencata serve dopo il cambio del numero di pancake. L'intento di ricerca di uno scalatore di ricetta pancake è distinto da uno scalatore generico di ricette di cucina: chi cerca rendimento di impasto, pile da brunch e conversione da otto a dodici pezzi vuole linguaggio pancake, rendimenti di piastra ed esempi farina-latte-uovo nella pagina di atterraggio.
Domande frequenti
Come funziona lo scalatore di ricetta pancake?
Fornisca un conteggio positivo di porzioni o pancake desiderati, le quantità numeriche degli ingredienti e, in opzione, il rendimento della ricetta base (valore 1).
Che cosa succede se servings è zero o negativo?
Una ricetta pancake non può scalare verso un rendimento non positivo; le porzioni desiderate devono essere un numero finito maggiore di zero.
Posso scalare una ricetta scritta per otto pancake fino a ventiquattro?
Il fattore diventa 3 e ogni ingrediente si moltiplica per tre.
Questo converte le tazze di farina in grammi?
No. Scala soltanto i numeri. Mantenga Lei le unità coerenti, oppure converta prima le unità con uno strumento tazze-grammi e poi scali le quantità risultanti.
Il calcolatore di ricetta pancake è gratis?
Lo strumento nel browser è gratis e gira in locale.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/cook/pancake-recipe \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"servings":12,"amounts":[190,350,1,3.5]}'const res = await fetch("https://api.kit.forhosting.com/cook/pancake-recipe", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"servings": 12,
"amounts": [
190,
350,
1,
3.5
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/pancake-recipe",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"servings": 12,
"amounts": [
190,
350,
1,
3.5
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/pancake-recipe", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"servings":12,"amounts":[190,350,1,3.5]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"servings":12,"amounts":[190,350,1,3.5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/pancake-recipe", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"servings": 12,
"amounts": [
190,
350,
1,
3.5
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.pancake_recipe",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_abs | 1000000000000 |
max_n | 10000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Lo strumento calcola factor uguale a servings diviso per base_servings e moltiplica ogni riga per quel fattore condiviso, così il rapporto dell'impasto resta identico passando da otto pancake a dodici, o da un pancake di prova a un brunch di venti pezzi. Porzioni desiderate non positive falliscono con invalid_input perché un conteggio di pancake zero o negativo non definisce una scala significativa. Il percorso è aritmetica pura e deterministica—senza rete, senza semi casuali, senza dipendenza dall'orologio—così l'esecutore gratuito del browser e l'API prepagata restituiscono lo stesso JSON dopo l'arrotondamento decimale fisso ogni volta che Lei la invoca.
Che cosa significa scalare una ricetta pancake e perché i rapporti dell'impasto restano fissi
Questo calcolatore di ricetta pancake accetta un elenco non vuoto di numeri finiti come amounts, un conteggio desiderato di porzioni o pancake strettamente positivo, e un valore opzionale positivo di base_servings che vale uno se omesso, così una scheda per pancake scala con il solo rendimento desiderato. Fissa factor uguale a servings diviso per base_servings e restituisce sia un array scaled piatto sia un array ingredients che accoppia ogni quantità originale al valore scalato. I fogli di classe, i fogli di meal-prep e i kata di programmazione possono affermare lo stesso JSON arrotondato perché l'aritmetica non dipende mai dall'orologio né da dati esterni.
Come chiamare l'API: ingressi, forma della risposta e convalida
I names opzionali compaiono al livello superiore solo quando è stata fornita almeno un'etichetta; i campi opzionali sono omessi anziché impostati a null. Invii un corpo JSON con amounts come array obbligatorio di numeri finiti—oppure una stringa separata da virgole nei moduli di testo—più servings per il conteggio desiderato di pancake o porzioni. servings (alias pancakes, desired, desired_servings, pancake_count) deve essere finito e strettamente maggiore di zero; valori zero, negativi e non numerici falliscono con invalid_input e non vengono mai addebitati. Il base_servings opzionale (alias original, original_servings, from_servings, yield, recipe_servings, base) è il rendimento per cui sono state scritte le quantità elencate; vale uno se omesso e deve essere strettamente positivo quando fornito, perché dividere per una base non positiva non può definire una scala pancake. I names opzionali (alias labels, ingredients) allineano etichette di testo a ogni quantità nello stesso ordine; etichette in eccesso o mancanti vengono riempite o troncate così il numero di righe coincide sempre. I valori assoluti devono restare entro un bilione, e la lunghezza dell'elenco è limitata affinché un Worker termini in fretta. In caso di successo la risposta ripete amounts arrotondati, valori scaled, factor, count, servings, base_servings, righe ingredients con index amount e scaled più name quando presente, formula, message e steps ordinati. La convalida fallita—amounts vuoti, numeri non finiti, servings assente o porzioni non positive—restituisce invalid_input. Il prezzo è un fisso $0.002 per richiesta riuscita con unità item. Preferisca numeri anziché stringhe con unità preformattate dentro amounts; metta le unità nel campo opzionale names così centonovanta e flour (g) restano separati e leggibili dalla macchina.
Consigli pratici per lotti da brunch, limiti e strumenti correlati
Mantenga le unità coerenti nell'elenco: se la farina è in grammi, tenga anche zucchero e burro fuso in grammi, e riservi cucchiaini o uova solo alle righe che usano davvero quelle unità. Valori positivi vicini a zero sono ammessi per minuscole righe di sale o vaniglia se la Sua scheda li usa, ma le porzioni desiderate a zero sono sempre rifiutate. Questa pagina si rivolge a chi cerca una ricetta pancake, scalare gli ingredienti dei pancake o un calcolatore di porzioni di pancake; non è un convertitore di unità, né un sostituto del latticello, né un sistema completo di menu. I controlli andata e ritorno sono semplici: ricalcoli a mano ogni amount per factor e confermi che coincide con la voce scaled pubblicata con lo stesso arrotondamento a dodici decimali, e confermi che cambiando solo le porzioni desiderate si scalano tutte le righe in proporzione senza riscrivere la scheda originale. Rifiuti sempre le porzioni non positive nei moduli del cliente prima dell'invio quando può; l'API lancerà comunque un messaggio chiaro di invalid_input se filtra uno zero o un conteggio negativo di pancake, perché puntare a zero pezzi non è un lotto significativo. Nel scalare una scheda classica da otto pancake, imposti base_servings a otto e servings al numero di pezzi che prevede di versare—dodici per una colazione in famiglia, ventiquattro per un brunch piccolo. Per una ricetta già scritta come un pancake, ometta base_servings (vale uno) e imposti servings alla pila completa così il fattore è il conteggio stesso dei pancake. Preferisca gli strumenti cook fratelli quando Le serve uno scaling generico di ricette di cucina o rendimenti di lotto cocktail, e usi questo endpoint quando l'intento è l'impasto per pancake. Le attività fallite che restituiscono invalid_input non consumano il saldo prepagato, il che mantiene economici gli script esplorativi quando si invia di proposito servings zero.
Casi di integrazione
Colazione in famiglia da una scheda di otto pancake
Incolli farina, latte, uovo e lievito di una ricetta per 8 pancake, imposti base_servings a 8 e servings a 12, e mescoli l'impasto scalato per una pila più grande.
Catering da brunch da una prova per pancake
Converta un impasto di prova di un pancake in un servizio di venti pezzi omettendo base_servings (valore 1) e inviando servings 20 così ogni riga si moltiplica per venti.
Test unitari per app di ricette e meal-prep
Generi array pancake scalati di riferimento e rifiuti deliberati di porzioni non positive per i valori attesi dei kata di programmazione e i test di contratto API.