Build a **Precision–Recall (PR) curve** for a binary classifier so you can visualize the trade-off between precision and recall across different decision thresholds. You’ll compute precision/recall points by sweeping thresholds over predicted probabilities and return the curve data for evaluation.

## Requirements

Implement the function
```python
def precision_recall_curve(y_true, y_score):
    \"""
    Computes the Precision-Recall curve points for binary classification.

    Args:
        y_true (np.ndarray): Ground-truth binary labels (0 or 1).
        y_score (np.ndarray): Predicted probabilities/scores for the positive class.

    Returns:
        tuple[np.ndarray, np.ndarray, np.ndarray]:
            precisions: Precision values at each threshold.
            recalls: Recall values at each threshold.
            thresholds: Thresholds used to compute the points (sorted descending).
    \"""
    # Your solution below
```

**Rules:**
- Use thresholds equal to the **unique values** in `y_score`, sorted in **descending** order.
- For each threshold $t$, predict $\hat{y}=1$ if $y\_score \ge t$ else $0$, then compute:
  $$
  \text{precision}=\frac{TP}{TP+FP}, \quad \text{recall}=\frac{TP}{TP+FN}
  $$
- Return three NumPy arrays: `precisions`, `recalls`, and `thresholds`.
- Do not use any prebuilt PR-curve utilities (e.g., from scikit-learn).
- Use NumPy vectorized operations for efficiency.

## Example

```python
y_true = np.array([0, 1, 1, 0])
y_score = np.array([0.1, 0.4, 0.8, 0.35])

precision_recall_curve(y_true, y_score)
```

Output:
```python
(
  array([1.0, 1.0, 0.66666667, 0.5]),
  array([0.5, 1.0, 1.0, 1.0]),
  array([0.8, 0.4, 0.35, 0.1])
)
```


Recall Score

Binary Tree Zigzag Level Order Traversal

Precision recall curve

Solve this medium level ML coding question from General. The premier LeetCode for ML platform to master Python, SQL, and Machine Learning algorithms.

1073. Precision recall curve

Examples

Constraints

Similar Questions

Argument	Type
y_true	np.ndarray
y_score	np.ndarray