nice logic. +1

I used a sliding window, just like you, but there was no need to build a sum array.
https://www.hackerrank.com/challenges/the-birthday-bar/submissions/code/43358272

how is the logic working?

how did u get dat kinda logic

please explain the logic

Why is sum an array of 105 integers? Isn't 101 enough?

def solve(n, s, d, m):
    # Complete this function
    count = 0
    for i in range(0,n):
        total = sum(s[i:m+i])
        if total == d:
            count+=1
    return count

This function uses a sliding window too :) If any corrections please comment :)

My solution in Java:

static int solve(int n, int[] s, int d, int m){
    int sum = 0;
    int r = 0;
    for (int i = 0; i < s.length; i++) {
        sum += s[i];
        // M is never less than 1
        if (i > m - 1) sum -= s[i - m];
        if (i >= m - 1 && sum == d) r++;
    }
    return r;
}

why not O(n) like below

def solve(n, s, d, m):
    if(n==1 and s[0]==d):
        return 1
    elif(n==1):
        return 0
    count = 0
    for i in range(len(s)-1):
        if(sum(s[i:m+i])==d):
            count = count + 1
    return count
    # Complete this function

can anyone pls explain how does this code work?

will you please explain why did you write this:sum[i+m]-sum[i]==d

nice logic broo!!!

change getWays function into birthday function.. Answer is right.. Could you please explain the logic behind declaring sum[105] ?

nice logic. However can you reduce the time complexity a little?

Ruby!

def birthday(bar, day, month)
  possible = 0
  (0..bar.length - month).each do |i|
    possible += 1 if (bar[i...i + month].inject(0, :+) === day)
  end
  possible
end

Can you explain me the question in easy language ,i mean what we have to do.

please explain the logic

nice pal

could you explain the second for loop

static int birthday(List<Integer> s, int d, int m) {
    int count = 0;

    for(int i=0; i<= s.size() - m; i++) {
        if( s.subList(i, i+m).stream().mapToInt(n -> n).sum() == d) {
            count++;
        }
    }

    return count;
}

I know this is an old comment but I want to understand the logic behind this

squares.Length - (m - 1)

Can you help me?

Cool LINQ! Thanks for sharing!

Solid as a rock, thanks for sharing

Hello, I'm confused. Why did you have to subtract (m - 1) from the length of the array

It could be simplified even more

static int birthday(List<int> s, int d, int m) {
    return Enumerable.Range(0, s.Count - m + 1)
        .Select(x => s.Skip(x).Take(m).Sum())
        .Count(x => x == d);
}

but this is not optimal solution performance vice - it do too much redundant sum calculations (see discussion above for details)

static int birthday(List s, int d, int m) { int sum = 0; int count = 0; int res = 0;

        for(int x = 0; x < s.Count-m+1; x++)
        {
            for(int y = x; y < s.Count; y++)
            {
                sum += s[y];
                count++;
                if (sum == d && count==m)
                {
                    sum = 0;
                    count = 0;
                    res++;
                    break;
                }
                else if (sum > d)
                {
                    sum = 0;
                    count = 0;
                    break;
                }
            }
        }
        return res;
    }

Great C# solution!

I did the same think with multiple lines, but it's always refreshing to see oneliner solutions.

Beat this:

def getWays(squares, d, m):
    return sum([1 for i in range(n-m+1) if sum(s[i:i+m])==d])

Python people saw this, and now python people jealous. :p

Thanks for the approach! BTW we could have used segment trees as well, right?

Did similarly, but shorter

def solve(n, s, d, m):
    return sum([1 for i in range(n-m+1) if sum(s[i:i+m]) == d])

Ruby version:

def solve(squares, d, m)
    squares.each_cons(m).map(&:sum).select { |s| s == d }.count
end

how did u write tp?

In fact your solution is dumb, you solved it in O(n^2) instead of O(n)

Why does this work? In the case you have the list of squares [1,1, 3, 3, 2], m = 2 and d = 3, there are two positive cases of [2,1] and [1,2]. However, your code gives returns 0.

The only way this makes sense is the assumption the pieces must be consecutive to sum, but I didn't see that mentioned in the problem.

I started with the same approach, but there is a gotcha in there. [1,2,3,4].slice(2,6) will return [3,4]. So the length of a new array is only 2. Have no idea how to fix it so I decided to use the inner cycle.

If s was a sorted array this function would fail more than it would succeed

I did it pretty much the same way but slightly different. I like your chained functions in the evaluation!

function solve(s, d, m) {
  let vc = [];
  for (let i = 0; i < s.length; i++) {
    let c = s.slice(i, i + m);
    // if c the size of m and d equals c's sum then keep it
    if((c.length === m) && (d === c.reduce((a, p) => p + a, 0))){
      vc.push(c);
    }
  }
  return vc.length;
}

In your for loop, i should stop when i < = l - m ? Or would your if statement not run if the segment is less than m?

What do you think about recursive approach?

int solve(vector<int> s, int d, int m, int i)
{
    if(i < s.size() - m + 1)
    {
        int sum = 0;
        for(int j = i; j < i+m; ++j)
            sum += s[j];
        bool good_choco = sum == d;
        return good_choco + solve(s, d, m, i+1);
    }
    else
    	return 0;
}

love your code.

I was doing the same thing and my code was throwing array out of bounds exception. I don't know where I was wrong until I saw your code. It happens to me all the time.

Thank you for your advice.

I have pressed dislike accidentally, sorry!

Really awesome. Superb Logic

Please explain the logic behind it.

static int birthday(List<Integer> s, int d, int m) {
    int count = 0;

    for(int i=0; i<= s.size() - m; i++) {
        if( s.subList(i, i+m).stream().mapToInt(n -> n).sum() == d) {
            count++;
        }
    }

    return count;
}

why is the range subtracted from len()+1?

can you explain that please :-(

This is what i was looking for! thanks!

It's O(n*m), can be done faster with O(n). One-liner doesn't make it good solution.

sum(a[i:i+m]) would you please explain this condition?

Clever, took me a minute to understand what you did. More efficient than re-adding each series of ints in embedded loops.

Quick Summary of what was done: 1) The first loops adds the first m ints together to see if they equal d. 2) The second loop removes the first digit from the last calculation, and adds a later one to replace it.