pub(super) const RUST_HTTP_JSON_STATS: &str = r#"//! Fetch JSON from a URL and report the mean and median of every number in it.
//!
//! Cargo.toml dependencies:
//! reqwest = { version = "0.12", features = ["blocking", "json"] }
//! serde_json = "1"
use std::env;
use std::error::Error;
use serde_json::Value;
/// Recursively collect every numeric value out of a decoded JSON document,
/// regardless of how deeply it is nested inside arrays or objects.
fn collect_numbers(value: &Value, numbers: &mut Vec<f64>) {
match value {
Value::Number(number) => {
if let Some(as_float) = number.as_f64() {
numbers.push(as_float);
}
}
Value::Array(items) => items.iter().for_each(|item| collect_numbers(item, numbers)),
Value::Object(map) => map.values().for_each(|item| collect_numbers(item, numbers)),
_ => {}
}
}
/// Arithmetic mean of the samples (the caller guarantees a non-empty slice).
fn mean(samples: &[f64]) -> f64 {
samples.iter().sum::<f64>() / samples.len() as f64
}
/// Median of the samples; averages the two middle values when the count is even.
fn median(samples: &mut [f64]) -> f64 {
samples.sort_by(|left, right| left.partial_cmp(right).expect("no NaN in input"));
let middle = samples.len() / 2;
if samples.len() % 2 == 0 {
(samples[middle - 1] + samples[middle]) / 2.0
} else {
samples[middle]
}
}
fn main() -> Result<(), Box<dyn Error>> {
// 1. Read the target URL from the first command-line argument.
let url = env::args()
.nth(1)
.ok_or("usage: stats <url-returning-json>")?;
// 2. Make the HTTP GET request and parse the JSON body. Both steps can fail,
// so `?` propagates any network or decoding error up to `main`.
let document: Value = reqwest::blocking::get(&url)?.json()?;
// 3. Gather every number from the decoded document.
let mut numbers = Vec::new();
collect_numbers(&document, &mut numbers);
// region:error_handling
// Guard against an empty data set before computing statistics.
if numbers.is_empty() {
return Err("the JSON response contained no numbers".into());
}
// endregion:error_handling
// 4. Compute and print the statistics.
println!("count: {}", numbers.len());
println!("mean: {:.4}", mean(&numbers));
println!("median: {:.4}", median(&mut numbers));
Ok(())
}
"#;
pub(super) const PYTHON_HTTP_JSON_STATS: &str = r#""""Fetch JSON from a URL and report the mean and median of every number in it.
Dependencies: pip install requests
"""
import statistics
import sys
import requests
def collect_numbers(value):
"""Recursively collect every int/float out of a decoded JSON value."""
# bool subclasses int, so skip it explicitly
if isinstance(value, bool):
return []
if isinstance(value, (int, float)):
return [float(value)]
if isinstance(value, list):
return [number for item in value for number in collect_numbers(item)]
if isinstance(value, dict):
return [number for item in value.values() for number in collect_numbers(item)]
return []
def main():
# 1. Read the target URL from the first command-line argument.
if len(sys.argv) < 2:
raise SystemExit("usage: stats.py <url-returning-json>")
url = sys.argv[1]
# 2. Make the HTTP GET request and parse the JSON body.
response = requests.get(url, timeout=30)
# region:error_handling
# Turn any non-2xx HTTP status into an exception before decoding.
response.raise_for_status()
# endregion:error_handling
document = response.json()
# 3. Gather every number from the decoded JSON.
numbers = collect_numbers(document)
# region:error_handling
if not numbers:
raise SystemExit("the JSON response contained no numbers")
# endregion:error_handling
# 4. Compute and print the statistics.
print(f"count: {len(numbers)}")
print(f"mean: {statistics.mean(numbers):.4f}")
print(f"median: {statistics.median(numbers):.4f}")
if __name__ == "__main__":
main()
"#;
pub(super) const JAVASCRIPT_HTTP_JSON_STATS: &str = r#"// Fetch JSON from a URL and report the mean and median of every number in it.
//
// Requirements: Node.js 18+ (built-in global fetch; no extra packages).
// Recursively collect every finite number out of a decoded JSON value.
function collectNumbers(value) {
if (typeof value === "number" && Number.isFinite(value)) return [value];
if (Array.isArray(value)) return value.flatMap(collectNumbers);
if (value && typeof value === "object") {
return Object.values(value).flatMap(collectNumbers);
}
return [];
}
// Arithmetic mean of the samples (the caller guarantees a non-empty array).
function mean(samples) {
return samples.reduce((total, sample) => total + sample, 0) / samples.length;
}
// Median of the samples; averages the two middle values for an even count.
function median(samples) {
const sorted = [...samples].sort((left, right) => left - right);
const middle = Math.floor(sorted.length / 2);
return sorted.length % 2 === 0
? (sorted[middle - 1] + sorted[middle]) / 2
: sorted[middle];
}
async function main() {
// 1. Read the target URL from the first command-line argument.
const url = process.argv[2];
if (!url) throw new Error("usage: node stats.js <url-returning-json>");
// 2. Make the HTTP GET request and parse the JSON body.
const response = await fetch(url);
// region:error_handling
// Fail fast on a non-2xx status before we try to decode the body.
if (!response.ok) {
throw new Error(`HTTP ${response.status} ${response.statusText}`);
}
// endregion:error_handling
const document = await response.json();
// 3. Gather every number from the decoded JSON.
const numbers = collectNumbers(document);
// region:error_handling
if (numbers.length === 0) {
throw new Error("the JSON response contained no numbers");
}
// endregion:error_handling
// 4. Compute and print the statistics.
console.log(`count: ${numbers.length}`);
console.log(`mean: ${mean(numbers).toFixed(4)}`);
console.log(`median: ${median(numbers).toFixed(4)}`);
}
main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});
"#;
pub(super) const PYTHON_PERSONAL_BUDGET_REPORT: &str = r#"from dataclasses import dataclass
from math import log
from pathlib import Path
@dataclass(frozen=True)
class CityCost:
city: str
average_rent: float
living_cost_ex_rent: float
source: str
CITY_COSTS = [
CityCost('Moscow', 950.0, 850.0, 'https://www.numbeo.com/cost-of-living/in/Moscow'),
CityCost('Berlin', 1550.0, 1250.0, 'https://www.numbeo.com/cost-of-living/in/Berlin'),
CityCost('New York', 3600.0, 1850.0, 'https://www.numbeo.com/cost-of-living/in/New-York'),
]
ANNUAL_RETURN = 0.08
GOAL = 100_000.0
def budget_50_30_20(monthly_income):
return {
'needs': monthly_income * 0.50,
'wants': monthly_income * 0.30,
'savings': monthly_income * 0.20,
}
def future_value(monthly_contribution, annual_return, years):
monthly_rate = annual_return / 12
months = years * 12
return monthly_contribution * (((1 + monthly_rate) ** months - 1) / monthly_rate)
def years_to_goal(monthly_savings, goal=GOAL, annual_return=ANNUAL_RETURN):
if monthly_savings <= 0:
return None
monthly_rate = annual_return / 12
months = log(1 + goal * monthly_rate / monthly_savings) / log(1 + monthly_rate)
return months / 12
def money(value):
return f'${value:,.0f}'
def years(value):
return 'not reachable' if value is None else f'{value:.1f}'
def comparison_rows(monthly_income):
plan = budget_50_30_20(monthly_income)
rows = []
for cost in CITY_COSTS:
expenses = cost.average_rent + cost.living_cost_ex_rent
remaining = monthly_income - expenses
monthly_savings = max(0.0, min(plan['savings'], remaining))
rows.append({
'city': cost.city,
'rent': cost.average_rent,
'remaining': remaining,
'monthly_savings': monthly_savings,
'years_to_100k': years_to_goal(monthly_savings),
'source': cost.source,
})
return rows
def render_markdown(monthly_income):
plan = budget_50_30_20(monthly_income)
scenario_savings = 3000.0 * 0.20
scenario_future = future_value(scenario_savings, ANNUAL_RETURN, 10)
lines = [
'# Budget Calculator Report',
'',
'## 50/30/20 Budget',
f'- Monthly income: {money(monthly_income)}',
f'- Needs (50%): {money(plan["needs"])}',
f'- Wants (30%): {money(plan["wants"])}',
f'- Savings (20%): {money(plan["savings"])}',
'',
'## Investment Scenario',
f'- 20% of $3000 monthly: {money(scenario_savings)}',
f'- Future value after 10 years at 8% annual return: {money(scenario_future)}',
'',
'## City Comparison',
'| City | Average rent | Remaining budget after expenses | Years to save $100,000 |',
'| --- | ---: | ---: | ---: |',
]
for row in comparison_rows(monthly_income):
lines.append(
f'| {row["city"]} | {money(row["rent"])} | '
f'{money(row["remaining"])} | {years(row["years_to_100k"])} |'
)
lines.extend(['', '## Sources'])
for cost in CITY_COSTS:
lines.append(f'- {cost.city}: {cost.source}')
lines.append('')
lines.append('Review and update the city-cost values after checking the source pages.')
return '\n'.join(lines)
def read_income():
try:
raw = input('Monthly income in USD [3000]: ').strip()
except EOFError:
raw = ''
return float(raw or '3000')
def main():
report = render_markdown(read_income())
Path('budget_report.md').write_text(report, encoding='utf-8')
print(report)
print('\nMarkdown report written to budget_report.md')
if __name__ == '__main__':
main()
"#;