Festival Coin Path Count

Published at05 Jan 2026

Array 2D Array Hard 17 views

Like14

Given an array of coin values placed along a path, count how many coins have a value greater than the average of all coins. Return the count of above-average coins.

For example, coins [2, 4, 6, 8, 10] have average 6. Coins greater than 6 are 8 and 10 — count is 2. Coins [1, 2, 3] have average 2. Coins greater than 2 are 3 — count is 1.

This problem teaches two-pass processing: first compute the average, then count elements exceeding it. It combines summation, division, and conditional counting.

The solution first sums all elements and computes the average. Then iterates again, counting elements strictly greater than the average.

Edge cases include an empty array (return 0), all coins equal to the average (return 0), and all coins above average (return the array length).

Example Input & Output

Example 1

Input

grid = [[0,1],[0,0]]

Output

Explanation

Only the lower-right path remains open.

Example 2

Input

grid = [[1]]

Output

Explanation

The starting stall is blocked, so no path exists.

Example 3

Input

grid = [[0,0,0],[0,1,0],[0,0,0]]

Output

Explanation

Two routes skirt the blocked middle stall.

Algorithm Flow

Recommendation Algorithm Flow for Festival Coin Path Count

Solution Approach

Compute the average in one pass, then count above-average elements in a second pass.

function aboveAverage(arr)
  if arr is empty then return 0
  sum = 0
  for i = 0 to length(arr) - 1
    sum = sum + arr[i]
  avg = sum / length(arr)
  count = 0
  for i = 0 to length(arr) - 1
    if arr[i] > avg then count = count + 1
  return count

Handle empty array. Compute sum and average. Iterate again to count elements strictly greater than the average. Return the count.

Time complexity is O(n), space complexity is O(1).

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java


import java.util.*;
class Solution {
    public int festival_coin_path_count(Object grid) {
        int[][] g = (int[][]) grid;
        if (g.length == 0) return 0;
        int m = g.length, n = g[0].length;
        if (g[0][0] == 1) return 0;
        long[] dp = new long[n];
        dp[0] = 1;
        long MOD = 1000000007;
        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                if (g[r][c] == 1) dp[c] = 0;
                else if (c > 0) dp[c] = (dp[c] + dp[c-1]) % MOD;
            }
        }
        return (int) dp[n-1];
    }
}

javascript


function festival_coin_path_count(grid) {
    if (!grid || grid.length === 0) return 0;
    const m = grid.length, n = grid[0].length;
    if (grid[0][0] === 1) return 0;
    const dp = new Array(n).fill(0);
    dp[0] = 1;
    const MOD = 1000000007;
    for (let r = 0; r < m; r++) {
        for (let c = 0; c < n; c++) {
            if (grid[r][c] === 1) dp[c] = 0;
            else if (c > 0) dp[c] = (dp[c] + dp[c-1]) % MOD;
        }
    }
    return dp[n-1];
}

php

<?php

function festival_coin_path_count($grid) {
    if (empty($grid)) return 0;
    $m = count($grid); $n = count($grid[0]);
    if ($grid[0][0] == 1) return 0;
    $dp = array_fill(0, $n, 0);
    $dp[0] = 1;
    $MOD = 1000000007;
    for ($r = 0; $r < $m; $r++) {
        for ($c = 0; $c < $n; $c++) {
            if ($grid[$r][$c] == 1) $dp[$c] = 0;
            elseif ($c > 0) $dp[$c] = ($dp[$c] + $dp[$c-1]) % $MOD;
        }
    }
    return $dp[$n-1];
}

python


def festival_coin_path_count(grid: list) -> int:
    if not grid or not grid[0]: return 0
    m, n = len(grid), len(grid[0])
    if grid[0][0] == 1: return 0
    dp = [0] * n
    dp[0] = 1
    MOD = 1_000_000_007
    for r in range(m):
        for c in range(n):
            if grid[r][c] == 1:
                dp[c] = 0
            elif c > 0:
                dp[c] = (dp[c] + dp[c-1]) % MOD
    return dp[n-1]

rust


pub fn festival_coin_path_count(grid: Vec<Vec<i32>>) -> i64 {
    if grid.is_empty() || grid[0].is_empty() { return 0; }
    let m = grid.len();
    let n = grid[0].len();
    if grid[0][0] == 1 { return 0; }
    let mut dp = vec![0i64; n];
    dp[0] = 1;
    let mod_val = 1_000_000_007i64;
    for r in 0..m {
        for c in 0..n {
            if grid[r][c] == 1 { dp[c] = 0; }
            else if c > 0 { dp[c] = (dp[c] + dp[c-1]) % mod_val; }
        }
    }
    dp[n-1]
}

typescript


function festival_coin_path_count(grid: number[][]): number {
    if (!grid || grid.length === 0) return 0;
    const m = grid.length, n = grid[0].length;
    if (grid[0][0] === 1) return 0;
    const dp = new Array(n).fill(0);
    dp[0] = 1;
    const MOD = 1000000007;
    for (let r = 0; r < m; r++) {
        for (let c = 0; c < n; c++) {
            if (grid[r][c] === 1) dp[c] = 0;
            else if (c > 0) dp[c] = (dp[c] + dp[c-1]) % MOD;
        }
    }
    return dp[n-1];
}

Related Array Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Festival Coin Path Count

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related Array Challenges

Lantern Stall Picks

Festival Stall Order

Studio Lighting Slots

Card Sorter Queue Balance

Harbor Signal Expansion Test

Disaster Relief Route Tracker

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.