omg...this is wonderful! I didn't know we could add 1 to a comprehension this way.

Here's another one ;)

print([d+a>=s and d+a<=t for d in apple].count(True))

print([b+d>=s and b+d<=t for d in orange].count(True))

Nice... The Java 8 is not bad too :) a bit longer, but easy to understand.

Arrays.stream(apple)
    .filter(x -> x + a  >= s && x + a <= t)
    .count();

Arrays.stream(orange)
    .filter(x -> x + b  >= s && x + b <= t)
    .count();

this is amazing! thanks for sharing

We are potentially dealing with a large number of large numbers. I don't want hold those big arrays in memory. I just want to evaulate each number and keep track of the count. Does this code accomplish that? Feedback please.

Python 3:

import sys

def countHits(lHouse, rHouse, treeLoc):
    lDist = lHouse - treeLoc
    rDist = rHouse - treeLoc
    return sum(1 for spot in input().strip().split(' ') if hitHouse(int(spot), lDist, rDist))

def hitHouse(spot, lDist, rDist):
    if spot >= lDist and spot <= rDist:
        return True

lHouse, rHouse = [int(x) for x in input().strip().split(' ')]
aTree, oTree = [int(x) for x in input().strip().split(' ')]
aCount, oCount = [int(x) for x in input().strip().split(' ')]

print (countHits(lHouse, rHouse, aTree))
print (countHits(lHouse, rHouse, oTree))

more pythonic

print(sum([1 for each in apple if s <= (each + a) <=t]))
print(sum([1 for each in orange if s <= (each + b) <=t]))

Swift way:

print(apples.filter{$0 + a >= s && $0 + a <= t}.count)
print(oranges.filter{$0 + b >= s && $0 + b <= t}.count)

We can also use range function here :

print(sum([ 1 for app in apple if a+(app) in range(s,t+1)]))
print(sum([ 1 for org in orange if b+(org) in range(s,t+1)]))

OMG!! this is simply awesome dude.... i never thought that python could be this much flexible

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

using namespace std;

int main(){ int s; int t; cin >> s >> t; int a; int b; cin >> a >> b; int m; int n;

cin >> m >> n;
int ctr1=0,ctr2=0;
vector<int> apple(m);
for(int apple_i = 0;apple_i < m;apple_i++){
   cin >> apple[apple_i];
    if(apple[apple_i]>0 && (s<=a+apple[apple_i] && a+apple[apple_i]<=t))
        ctr1++;
}
vector<int> orange(n);
for(int orange_i = 0;orange_i < n;orange_i++){
   cin >> orange[orange_i];
    if(orange[orange_i]<0 && (s<=b-abs(orange[orange_i]) && b-abs(orange[orange_i])<=t))
        ctr2++;
}

    cout<<ctr1<<"\n"<<ctr2;


return 0;

}

Did nearly the same

print(len([1 for app in apple if app >= s-a and app <= t-a]))
print(len([1 for ora in orange if ora <= t-b and ora >= s-b]))

can someone explain the sum function and for function please

That is beautiful, I feel like such a barbarian...

app_cnt = 0
org_cnt = 0

for ap in apple:
    if ap > 0:
        if t >= a+ap >= s:
            app_cnt += 1
for og in orange:
    if og < 0:
        if t >= b+og >= s:
            org_cnt += 1

print(app_cnt)
print(org_cnt)

can you explain what is the use of "1" here

print(len([x for x in apple if x>0 and a+x>=s and a+x<=t]))
print(len([y for y in orange if y<0 and b+y<=t and b+y>=s]))

I know that the savings are miniscule, but discarding the distances are to the left of the apple tree or to the right of the orange tree reduces the number of values to check.

You can also get rid of (x + a) >= s and (x + a) <= t and replace it with s <= a + d <= t or a + d in range(s, t+1)

c = list(filter(lambda x: x==True, map(lambda x: a+x in range(s,t+1),apples)))
d = list(filter(lambda x: x==True, map(lambda x: b+x in range(s,t+1),oranges)))
print(str(len(c))+"\n"+str(len(d)))

Is this code worthy?

Python rocks!

The solution is very elegant, but the complexity of the algorithm is being affected as a consequence.

another way:) print(len([i for i in apples if i+a in range(s,t+1)])) print(len([i for i in oranges if i+b in range(s,t+1)]))

similarly, you could:

apples = map(lambda x: 1 if s <= a+x <= t else 0, apples)
oranges = map(lambda x: 1 if s <= b+x <= t else 0, oranges)
print(sum(apples), sum(oranges))

they're both pretty pythonic. but list comprehensions are bae

    int ax = apples.Where(x=>s<=(x+a)&&(x+a)<=t).Count();
    int ox = oranges.Where(x=>s<=(x+b)&&(x+b)<=t).Count();

            c# style ;)

I love python man!

I used your method but im getting 12 test cases failed.Can u explain why??

In a functional way: (using Python3)

filter(lambda x: x+a in range(s,t+1), apples))

Exploiting the fact that checking on a range has O(1) complexity when checking integers against integer bounds and using the built-in filter function. What filter does is basically "let through" only those elements of the iterable (apples) that satisfy the predicate (in this case the lambda function). The resulting filter object will result in a list that has only the apples fallen on the house, whose lenght is the answer. Therefore,

result = len(list(filter(lambda x: x+a in range(s,t+1), apples))))

GREAT WAY!!!!! python way@@@@@

print(sum([1 for x in apple if (x+a) in range(s,t+1)])) print(sum([1 for x in orange if (x+b) in range (a,t+1)])) even simpler

inclusiverange = range(s,t+1)

ap = sum(1 for apple in apples if apple + a in inclusiverange)

on = sum(1 for orange in oranges if orange + b in inclusiverange)

print(ap)

print(on)

C++ way

auto count_fruits = []
(vector<int>& fruits, int s, int t) -> int
{
    return std::accumulate(
        fruits.begin(), fruits.end(), 0,
        [&] (int v, int f)
        {
            return v + (s <= f && f <= t ? 1 : 0);
        });
};

std::cout
        << count_fruits(apples, s - a, t - a)
        << std::endl
        << count_fruits(oranges, s - b, t - b);

}

why 1 is return before for

not very efficient though... worst case if there are 10^5 apples and oranges that all fall within the house, then you are just creating and recreating (twice- once for each fruit) an array that is being extended by one cell one at a time (or by some random buffer decided on by the python sdk) 10^5 times instead of just immediately incrementing a single value without any memory allocations. I would expect this to ime out on longer inputs.

If you are a beginner and don't know much about comprehensions, here's the basic code without the use of comperhensions. It's basically the same thing! :p

    ain=oin=0
    for i in range (len(apples)):
        apples[i]=apples[i]+a
        if apples[i]<=t and apples[i]>=s:
            ain=ain+1
        else:
            ain=ain
    for i in range (len(oranges)):
        oranges[i]=oranges[i]+b
        if oranges[i]<=t and oranges[i]>=s:
            oin=oin+1
        else:
            oin=oin
    print(ain)
    print(oin)

Great....

def countApplesAndOranges(s, t, a, b, apples, oranges):
        house_range = range(s,t+1)
        valid_apples, valid_oranges = 0,0

for i in apples:
    if i + a in house_range:
        valid_apples += 1

for j in oranges:
    if j + b in house_range:
        valid_oranges += 1 

print valid_apples
print valid_oranges 

Why is using for loop like this so much slower than the solution presented by @navjotahuja92? It is also using for loop and an if condition within it.

print(len([e for e in list(map(lambda dis: dis + a, apples)) if e >= s and e <= t]))

mine is a bit longer I guess.

Good but you don't really need to print it as a list Check this:

#!/bin/python3

def countApplesAndOranges(s, t, a, b, apples, oranges):
print (sum(1 for fruit in apples if (fruit + a) >= s and (fruit + a) <= t))
print (sum(1 for fruit in oranges if (fruit + b) >= s and (fruit + b) <= t))

Or simply count of the True and false doing this:

print(sum(s <= a + fruit <= t for fruit in apples)) print(sum(s <= b + fruit <= t for fruit in oranges))

typo: apple->apples, orange->oranges. still best solution. gud goin.

Faster way would be to use the len() function instead of sum()

great!! wonderful solution

Lol I actually dont understand whats going on here, could anyone explain

This is really great ... I was first adding and then checking on other line.But this can be done in one line.So thanks!!

Nice... I was using arrays and test results were failing for a few use cases. Thank you

Liked your variable name conventions!

Done in the same way but it is not passing some of the test cases

after seeing your code ..i found the bug..why my memory stack was hitting the bar of 50 kb ...thanks

Can you explain why the code fails if it is done using arrays?

Hey!! Can you once explain why does some cases fail when using arrays?

can u plz explain this line?

int applePosition = a + scan.nextInt();
            if (applePosition >= s && applePosition <= t)

please can u explain this code: int orangePosition = b + scan.nextInt();

I did it the same way, however I left the arrays as getting rid of them didn't even cross my mind! -Thank You!

wow, this is gread solution. something to lern as well

I did it in the same way but I include more code for constraints. My code passes 100% test cases too. I saw that you does not include code for constraints. It is weird that your code passes 100% test cases, may be the test cases not include the constraints validation. Well congratulations your code is great.

Let me share my code, any comment is welcome:

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int s = in.nextInt();
        int t = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        int m = in.nextInt();
        int n = in.nextInt();
        int[] datas = {s,t,a,b,m,n};
        int apples = 0, oranges = 0;
        
        for(int data:datas){
            if( (data <=1) && (data >= Math.pow(10,5)) ){
                System.err.println("Data out of range.");
                System.exit(-1);
            }
        }
        
        if( (a > s) && (s > t) && (t > b )){
            System.err.println("the data does not meet the requirements.");
            System.exit(-1);
        }
        
        int[] apple = new int[m];
        for(int apple_i=0; apple_i < m; apple_i++){
            apple[apple_i] = in.nextInt();
            
            if( apple[apple_i] >= Math.pow(-10,5) && apple[apple_i] <= Math.pow(10,5)){
                if( ( (a + apple[apple_i]) >= s) && ( (a + apple[apple_i]) <= t) )
                apples++;
            }
            else{
                System.err.println("Apple: Distance out of the range."+apple[apple_i]);
                System.exit(-1);
            }
        }
        int[] orange = new int[n];
        for(int orange_i=0; orange_i < n; orange_i++){
            orange[orange_i] = in.nextInt();
            
            if( orange[orange_i] >= Math.pow(-10,5) && orange[orange_i] <= Math.pow(10,5)){
                if( ( (b + orange[orange_i]) >= s) && ( (b + orange[orange_i]) <= t) )
                oranges++;
            }
            else{
                System.err.println("Orange: Distance out of the range."+orange[orange_i]);
                System.exit(-1);
            }
        }
        System.out.println(apples);
        System.out.println(oranges);
    }

Nice! U r careful about space complexity. Go on your discussion.Thanks

This is a much better solution.. I tried to compare the distances and it took way too long for the program to compile... Can you tell how to think of a time efficient approach?

Just wanted to know, if this question were in competitive programming,which technique would have been better? the way you or I did it or the one using streams or others few solved cases?

thank u nice logic really mindblowing. i also use array.

good job sir.

That way might be quicker than mine but I think mine looks nicer

function appleAndOrange(s, t, a, b, apple, orange) {
    return [
        apple.map(p => p + a).filter(p => p >= s && p <= t).length,
        orange.map(p => p + b).filter(p => p >= s && p <= t).length
    ]
}

    var i;
var countApples = 0;
var countOranges = 0;
for (i = 0; i < apples.length; i++) {
    if (a + apples[i] >= s && a + apples[i] <= t) {
        countApples += 1;
    }
}
for (i = 0; i < oranges.length; i++) {
    if (b + oranges[i] >= s && b + oranges[i] <= t) {
        countOranges += 1;
    }
}
console.log(countApples);
console.log(countOranges);

What do you guys think?

console.log(apples.filter(apple => a + apple >= s && a + apple <= t).length);
console.log(oranges.filter(orange => b + orange >= s && b + orange <= t).length);

Exactly the same as mine :)

I think my solution is similar, but doesn't work for all input cases, any idea why?

//header files bla bla

int main() {
    unsigned int s, t, a, b, m, n;
    cin>>s>>t;
    long long int house = (t-s);
    cin>>a>>b;
    cin>>m>>n;
    long long int d;
    long long int i,j;
    int count=0, count1=0;
    for (i=0;i<m;i++)
    {
        cin>>d;
        long long int x=(a+d);
        if (x>=s&&x<=t)
            count++;
           
    }
    for(j=0;j<n;j++)
    {
        cin>>d;
        long long int y=(b-d);
        if (y>=s && y<=t)
            count1++;
    }
    cout<<count<<endl<<count1;
        
    
    
    return 0;
}

brilliant!!

Same for me