All challenges
Easy 0 solved 0% acceptance

Logistic Regression Prediction

Classify samples as 0 or 1 by passing a weighted sum through the sigmoid and comparing it to a threshold.

What you'll learn

  • Turn a weighted sum into a probability
  • Classify with a decision threshold
  • Understand binary classifiers

Problem

Logistic regression is a linear model for yes/no questions. For each sample it computes a probability and turns it into a class:

  1. z = x₁×w₁ + … + xₙ×wₙ + bias
  2. p = 1 / (1 + e^(-z))
  3. class = 1 if p ≥ threshold, otherwise 0

Implement logistic_predict(samples, weights, bias, threshold).

Input

samples: One row of n features per sample.

weights: n weights.

bias: The bias.

threshold: The probability needed to predict class 1 (strictly between 0 and 1).

Output

Return the predicted class (0 or 1) of each sample, in order.

Constraints

1 ≤ samples ≤ 1,000, 1 ≤ n ≤ 50

-100 ≤ each feature, weight and bias ≤ 100

0 < threshold < 1

Examples

Example 1
Input:
bias = -1.0
samples = [
    [2.0, 1.0],
    [0.0, 0.0],
    [-1.0, -3.0]
]
weights = [1.5, -0.5]
threshold = 0.5

Expected output:
expected = [1, 0, 0]
Input:
double bias = -1.0;
std::vector<std::vector<double>> samples = {
    {2.0, 1.0},
    {0.0, 0.0},
    {-1.0, -3.0}
};
std::vector<double> weights = {1.5, -0.5};
double threshold = 0.5;

Expected output:
std::vector<long long> expected = {1, 0, 0};
Input:
double bias = -1.0;
double[][] samples = new double[][] {
    new double[] {2.0, 1.0},
    new double[] {0.0, 0.0},
    new double[] {-1.0, -3.0}
};
double[] weights = new double[] {1.5, -0.5};
double threshold = 0.5;

Expected output:
long[] expected = new long[] {1, 0, 0};

Explanation

Sample 1: z = 3 - 0.5 - 1 = 1.5, p ≈ 0.818 → 1. Sample 2: z = -1, p ≈ 0.269 → 0. Sample 3: z = -1.5 + 1.5 - 1 = -1, p ≈ 0.269 → 0. Result: [1, 0, 0].

Example 2
Input:
bias = -2.0
samples = [
    [1.0],
    [2.0],
    [3.0]
]
weights = [1.0]
threshold = 0.7

Expected output:
expected = [0, 0, 1]
Input:
double bias = -2.0;
std::vector<std::vector<double>> samples = {
    {1.0},
    {2.0},
    {3.0}
};
std::vector<double> weights = {1.0};
double threshold = 0.7;

Expected output:
std::vector<long long> expected = {0, 0, 1};
Input:
double bias = -2.0;
double[][] samples = new double[][] {
    new double[] {1.0},
    new double[] {2.0},
    new double[] {3.0}
};
double[] weights = new double[] {1.0};
double threshold = 0.7;

Expected output:
long[] expected = new long[] {0, 0, 1};

Explanation

The probabilities are σ(-1) ≈ 0.269, σ(0) = 0.5 and σ(1) ≈ 0.731. Only the last one reaches the 0.7 threshold, so the result is [0, 0, 1].

How to approach it

Try on your own first, then open one hint at a time.

Hint 1

For each sample, first compute the linear score from features, weights, and bias.

Hint 2

Convert that score into a probability with a sigmoid, then compare it to the threshold.

Hint 3

Very large positive or negative scores can saturate the sigmoid, but the class decision still comes from the threshold.

Expected complexity

O(m × n) time, O(1) extra space

References

This challenge is adapted for CodeUtility. Follow the statement and constraints above.

Learn from others

Community solutions

No published solutions yet. Solve this challenge to share the first one.