Backpropagation in a Two-Layer Network

Backpropagation applies the chain rule layer by layer, from the output back to the inputs. The network has n inputs, h hidden neurons and one output, all with sigmoid activation (σ(z) = 1 / (1 + e^(-z))):

hidden: a_j = σ(inputs · hidden_weights[j] + hidden_biases[j])
output: y = σ(a · output_weights + output_bias)
loss: L = (y - target)²

Gradients:

delta_out = 2 × (y - target) × y × (1 - y)
Output layer: dL/doutput_weights[j] = delta_out × a_j and dL/doutput_bias = delta_out
delta_j = delta_out × output_weights[j] × a_j × (1 - a_j)
Hidden layer: dL/dhidden_weights[j][i] = delta_j × inputs[i] and dL/dhidden_biases[j] = delta_j

Implement backprop_gradients(inputs, hidden_weights, hidden_biases, output_weights, output_bias, target).

Output

Return a matrix with h + 1 rows:

Row j (for each hidden neuron j, in order): the n gradients of hidden_weights[j], then the gradient of hidden_biases[j].
Last row: the h gradients of output_weights, then the gradient of output_bias.

Constraints

1 ≤ n, h ≤ 20

-5 ≤ each input, weight and bias ≤ 5

0 ≤ target ≤ 1

Examples

Example 1

Input:
inputs = [1.0]
target = 1.0
output_bias = 0.0
hidden_biases = [0.0]
hidden_weights = [
    [0.0]
]
output_weights = [0.0]

Expected output:
[
    [0.0, 0.0],
    [-0.125, -0.25]
]

Explanation

a = σ(0) = 0.5 and y = σ(0) = 0.5. delta_out = 2 × (0.5 - 1) × 0.25 = -0.25. Output row: [-0.25 × 0.5, -0.25] = [-0.125, -0.25]. delta_1 = -0.25 × 0 × 0.25 = 0, so the hidden row is [0, 0]: a zero output weight blocks the gradient.

Example 2

Input:
inputs = [1.0, 0.0]
target = 0.0
output_bias = -1.0
hidden_biases = [0.0, 0.0]
hidden_weights = [
    [0.0, 1.0],
    [0.0, -1.0]
]
output_weights = [1.0, 1.0]

Expected output:
[
    [0.0625, 0.0, 0.0625],
    [0.0625, 0.0, 0.0625],
    [0.125, 0.125, 0.25]
]

Explanation

Both hidden values are σ(0) = 0.5, so y = σ(0.5 + 0.5 - 1) = 0.5 and delta_out = 2 × 0.5 × 0.25 = 0.25. Output row: [0.125, 0.125, 0.25]. Each delta_j = 0.25 × 1 × 0.25 = 0.0625, giving hidden rows [0.0625, 0, 0.0625] (the second input is 0).

References

Run the sample tests to check your code without submitting.

Example 1 Not run

Input:

inputs = [1.0]
target = 1.0
output_bias = 0.0
hidden_biases = [0.0]
hidden_weights = [
    [0.0]
]
output_weights = [0.0]

Expected output:

[
    [0.0, 0.0],
    [-0.125, -0.25]
]

Your output

Example 2 Not run

Input:

inputs = [1.0, 0.0]
target = 0.0
output_bias = -1.0
hidden_biases = [0.0, 0.0]
hidden_weights = [
    [0.0, 1.0],
    [0.0, -1.0]
]
output_weights = [1.0, 1.0]

Expected output:

[
    [0.0625, 0.0, 0.0625],
    [0.0625, 0.0, 0.0625],
    [0.125, 0.125, 0.25]
]

Your output

4 hidden tests also run when you submit.

Online C++ Compiler & Debugger

Write, compile, run, and debug C++ online. Set breakpoints, inspect variables, and step through code with GDB in Server mode - no setup required.

Version

Pre-installed Libs

🚀 2,393,936 total executions (1,562 this month)

Output

Practice C++ with coding challenges

Solve hands-on problems right in this editor: run the sample tests, submit, and get an AI code review.

All C++ challenges

Easy

Average of Three

Average three whole numbers.

You'll learn ArithmeticDivision

BeginnerLearning-pathVariables

View solutions (1)

Easy

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

You'll learn ArithmeticReturn values

BeginnerLearning-pathVariables

View solutions (1)

Easy

Join Customers and Orders

Join customers with their orders like a LINQ Join and report each customer's total spend.

You'll learn LINQ JoinGrouping

ArraysSorting

No solutions yet

Easy

To-Do List

Keep a list of tasks: add them, mark them done, remove them and report what is still pending.

You'll learn Typed collectionsRecords

BeginnerSimulationStrings

No solutions yet

Easy

Linked List Operations

Simulate a linked list: add at either end, remove from the front or by value, and reverse it.

You'll learn Linked listsSimulation

Data-structuresSimulation

No solutions yet

Easy

Sum a Flat JSON Object

Parse a flat JSON object whose values are integers and add up the values.

You'll learn JSON parsingString splitting

ParsingStrings

No solutions yet

Easy

WhenAll Total Time

Find how long a program takes when each group of tasks runs together with Task.WhenAll and groups run one after another.

You'll learn Async/awaitTask.WhenAll

ArraysBeginner

No solutions yet

Medium

Parallel Task Completion Order

Run tasks concurrently with at most k at a time and report the order in which they finish.

You'll learn ConcurrencyPriority queues

SimulationSorting

No solutions yet

Medium

Min Stack

Build a stack that reports its smallest element instantly after any push or pop.

You'll learn StacksRunning minimum

Data-structuresStacks

No solutions yet

Easy

Unique Records

Remove duplicate records that are equal by value, keeping the first of each in order.

You'll learn RecordsValue equality

BeginnerStrings

No solutions yet

Easy

Sort by a Chosen Key

Sort people by name or by age with a comparer chosen at run time, breaking ties consistently.

You'll learn ComparersSorting

ArraysSorting

No solutions yet

Medium

Weekly Payroll

Total a week's pay for salaried, hourly and commission employees, each paid by its own rule.

You'll learn PolymorphismOvertime math

ParsingSimulationmath

No solutions yet

Learn and practise C/C++

Follow a learning path with runnable lessons, then test yourself with coding challenges.

C/C++ Examples →

💻 About This C++ Online Executor

The CodeUtility C++ Executor lets you write and run C++ code directly in your browser - no installation or compiler setup needed. It’s powered by a secure sandbox that supports real C++ standards from C++11, C++14, C++17, up to the latest version.

This tool uses a real C++ compiler running in the cloud to compile and execute your code, ensuring accurate and consistent behavior across versions. You can freely experiment with core C++ concepts like variables, functions, loops, conditionals, and object-oriented programming.

Whether you’re preparing for interviews, learning modern C++ features, or verifying algorithm logic, the CodeUtility C++ Executor provides a simple yet powerful environment to run code instantly from any device.

More than a code runner

Use a multi-file editor, an isolated execution terminal, runtime-specific libraries, persistent workspaces, sharing, and real-time collaboration from the same executor.

How to use this executor?

Choose a runtime, open or create a file, write your code, and select Run. Output appears in the terminal, while signed-in users can keep files in a workspace, install libraries, and collaborate through shares.

Select a version and edit the current file or open another workspace file.
Run the code, provide input in the terminal when requested, and review saved run history.
Use libraries, workspace tools, sharing, and chat when your task needs more than one snippet.

Start coding

VersionSelect a runtime before running. Installed libraries belong to the selected language version.
Open files lists unopened text files. Select one to open it in an available editor tab.
Run executes the active file with its workspace available to the program.
Stop ends the current execution before its time limit.
Advanced Mode opens the IDE layout with a file explorer and movable, resizable terminal.

Workspace and libraries

New file creates a file in the selected parent directory and opens it in the editor.
New folder creates a directory, up to the supported nesting depth.
Upload files adds one or more safe files to a directory.
Download saves a file or a zipped directory to your device.
Copy duplicates a workspace file or directory.
Rename changes a file name and updates its open tab and history.
Move relocates an item; files and directories can also be dragged.
Delete removes an item after confirmation and closes its open editor tab.
Pre-installed Libs shows packages already included in this runtime.
Add Lib installs a private package for your account and selected runtime.

Terminal and assistance

Run history opens previous and next saved outputs.
Run with switches C++ between the execution server and Browser C++. Browser C++ synchronizes workspace files, while account-installed libraries and interactive terminal input require the execution server.
Copy output copies the current terminal text.
Clear output removes all saved run outputs after confirmation.
Explain summarizes the active code.
Recents opens recent explanations and results.
Settings changes fonts, themes, and visible toolbar buttons.

Sharing and collaboration

Share publishes the current file, a directory, or the whole workspace as a snapshot or live workspace. You control link access and who may save changes.
Logs records saved collaborator actions in a shared workspace.
Share chat lets signed-in participants message, mention people, share code blocks, and see online or typing members.
Live collaboration shows collaborator cursors and saved file updates. View-only users can load the latest version or keep temporary edits.

Quotas and limits

Execution time is limited to 20 seconds per server run. Use Stop when you want to end it sooner.
Workspace storage allows 100 files, 100 directories, and 10 MiB total for each signed-in user workspace and language.
Files and folders are limited to 1 MiB per file and 5 nested directory levels. Files generated by your code follow the same quota.
Private libraries are limited to 10 installed packages for each account and runtime.
Share snapshots can contain up to 100 files, 1 MiB per file, and 2 MiB total.
Share invitations support up to 25 people per share, with access and saving permissions managed separately.
Share chat allows 2,000 characters per message and 10,000 messages per share.
Quota enforcement also applies while code is running. A write that exceeds file count, size, storage, or nesting limits is rejected safely.

Good to know Only run code and install packages you trust. Execution is isolated and limited, but your program can still modify files inside a writable workspace up to its enforced quota.

💡 C++ Basics & Examples You Can Try Above

1. Declaring Variables and Constants

C++ requires you to declare the type of each variable. Use const to define read-only values that cannot be changed after initialization.

int age = 30;
double pi = 3.14159;
char grade = 'A';
std::string name = "Alice";
bool isActive = true;

// Constants
const int MAX_USERS = 100;
const std::string COMPANY = "CodeUtility";

// Attempting to modify a const will cause a compile-time error
// MAX_USERS = 200; // ❌ error

2. Conditionals (if / switch)

Use if, else if, else for branching. Use switch for multiple values.

int x = 2;
if (x == 1) {
    std::cout << "One\n";
} else if (x == 2) {
    std::cout << "Two\n";
} else {
    std::cout << "Other\n";
}

// Switch-case
switch (x) {
    case 1:
        std::cout << "One\n";
        break;
    case 2:
        std::cout << "Two\n";
        break;
    default:
        std::cout << "Other\n";
}

3. Loops

Use for, while, and do-while to repeat code blocks.

for (int i = 0; i < 3; i++) {
    std::cout << i << "\n";
}

int n = 3;
while (n > 0) {
    std::cout << n << "\n";
    n--;
}

4. Arrays

Arrays store multiple elements of the same type.

int numbers[3] = {10, 20, 30};
std::cout << numbers[1] << "\n";

5. Array/Vector Manipulation

Use std::vector for dynamic arrays.

#include <vector>

std::vector nums = {1, 2, 3};
nums.push_back(4);
nums.pop_back();

for (int n : nums) {
    std::cout << n << " ";
}

6. Console Input/Output

Use std::cin for input and std::cout for output.

std::string name;
std::cout << "Enter your name: ";
std::cin >> name;
std::cout << "Hello, " << name << "\n";

7. Functions

Functions group reusable logic. Use parameters and return types.

int add(int a, int b) {
    return a + b;
}

std::cout << add(3, 4);

8. Maps

std::map stores key-value pairs like dictionaries.

#include <map>

std::map ages;
ages["Alice"] = 30;
std::cout << ages["Alice"];

9. Exception Handling

Use try and catch to handle runtime errors.

try {
    throw std::runtime_error("Error occurred");
} catch (const std::exception& e) {
    std::cout << e.what();
}

10. File I/O

Use fstream to read from and write to files.

#include <fstream>

std::ofstream out("file.txt");
out << "Hello File";
out.close();

std::ifstream in("file.txt");
std::string line;
getline(in, line);
std::cout << line;
in.close();

11. String Manipulation

C++ strings support methods like length(), substr(), and find().

std::string text = "Hello World";
std::cout << text.length();
std::cout << text.substr(0, 5);
std::cout << text.find("World");

12. Classes & Objects

C++ supports object-oriented programming using classes.

class Person {
  public:
    std::string name;
    Person(std::string n) : name(n) {}
    void greet() { std::cout << "Hi, I'm " << name; }
};

Person p("Alice");
p.greet();

13. Pointers

A pointer stores the memory address of another variable. Use & to get an address, and * to dereference (access the value at the address).

int x = 10;
int* ptr = &x;

std::cout << "Value of x: " << x << "\n";
std::cout << "Address of x: " << ptr << "\n";
std::cout << "Value from pointer: " << *ptr << "\n";

// Modify x through pointer
*ptr = 20;
std::cout << "Updated x: " << x << "\n";

🐞 How to Debug %{language} Code Online

Use the online %{language} debugger to find runtime and logic errors without installing a compiler or desktop IDE. Server mode compiles with debug symbols and runs the program under GDB.

Set one or more breakpoints beside the line numbers.
Select Debug to compile and pause at the first matching breakpoint.
Inspect the current line, call stack, and variables.
Use Continue, Step Over, Step Into, or Step Out to control execution.
Select Stop to end the debugging session.

Start with a small reproducible example and place a breakpoint just before the value or control flow becomes unexpected.