I used to get annoyed by that but I've learned that it's actually on purpose... if they explained a problem like this in a straightforward way, it would be way too easy. And remember, this is already categorized as an easy problem. In fact, you correctly solved the first piece of the puzzle, which is boiling down the problem to a simpler form. I think this is what the problem setter is looking for. Since some problems like this are not based on more complex algorithms, they want to find another way to get you to think hard and carefully. I do agree though that too many variables and subscripts in the problem statement can be a very cheap source of frustration.

It's one more of those problems you just want to forget having read it afterwards... I get it that they have to make it sound a bit more mysterious, but it is just phrased very badly, you get it right not because you really understand, but because you have some a priori knowledge of what they probably mean. Like some of the worst IQ tests like "complete the sequence", which has no logic at all.

for me also

Agreed, the "disjoint pair" discription is very confusing. I would recommed include an example right in the discription.

Thank you for that!!! I was having trouble understanding the problem. I agree with you 100%, phrasing, very confusing.

Keep in mind that you háve learned what pairwise disjoint sets are. The objective of a challenge like this is not just to test, but also to educate.

C++ solution :

int beautifulPairs(vector<int> A, vector<int> B) {
    map<int, int> m1, m2;
    bool flag=false;
    int pairs=0;
    for (int i=0;i<A.size();i++)
        m1[A[i]]++;
    for (int i=0;i<B.size();i++)
        m2[B[i]]++;

    map<int, int>::iterator it = m1.begin();
    while(it!=m1.end())
    {
        pairs+=min(it->second, m2[it->first]);
        if (it->second!=m2[it->first])
            flag=true;
        it++;
    }
    if (flag)   return pairs+1;
    return pairs-1;
}

Python Oneliner Code

def beautifulPairs(A, B):
    return len(A)-sum((Counter(A)-Counter(B)).values())+1 if sum((Counter(A)-Counter(B)).values()) else len(A)-1

Better Code

def beautifulPairs(A, B):
    diff = sum((Counter(A) - Counter(B)).values())
    return len(A) - diff +1 if diff else len(A) - 1

caught up on 4 and 5 too. but i don't understand why you said "optimal amount of beautiful pairs does not always mean the maximum amount" it clearly states in the problem that "resulting number of pairwise disjoint beautiful pairs is maximal" after changing 1 number in B

you are right thanks

Huh,You saved me."Know that the optimal amount of beautiful pairs does not always mean the maximum amount"

thx bro +1

I re-read the question after reading your comment, Thanks!

Thanks, I didn't read carefully that we must change one int in B but this advice helped!

Thank You!! Writing the code for this problem is easy, understanding the problem, hard. I'm not convinced the problem description is complete.

Wow, you're right, very good catch. That's dumb.

thanks, this hint helps! :)

"Your task is to change exactly element in so that the size of the pairwise disjoint beautiful set is maximum." In test case 5 changing one element does exactly opposite! So, if the statement is "to change to increase" it f@¢ing MUST mean increasing not decreasing. Or at least it must be said, if you cannot change for increasing you must change anyway. But its not said. It is said : "change ... so that the size ... is maximum". Ambiguity in wording. Even fifth grader can do better. Had to open both test cases (5 hackos each) to determine that BS. From first opening I still thought that there might be bug in my code. But no, there is bug in challenge wording.

Thank you! I was too frustrated with that cases!

This was what I missed. Thank you for suggestion.

Thanks buddy! you just saved my time.

thanks , that helped :)

well on analyzing , i got your logic , but will you please tell me for how you thought of making an array which will store 1 at the position of the element and not for an array which will store the values entered?

Only one question with this approach - how would it work if A and B upper limits would be pushed to, say, 10^12? And N would stay relatively small. Even less than 10. Then your approach would be at least not very economical.

Of course, the problem as it was defined is solved. But you could have mentioned to the less enlightened that they should think of other ways to compare arrays on account of change in conditions.

Thanks mate! It really helped in understanding the approach to the problem!

Just Awsome

Nice! The author should consider updating the editorial.

Sure, and it could be a more generic map instead of an array... It's another way to represent multisets when you don't have to actually keep the different equivalent objects.

I finished this in 15 minutes with a dictionary solution. Not sure what you find difficult (although the disjoint pair thingy was a bit confusing at first).

can u please tell the logic used here?

why have you declared a1 and b1

well on analyzing , i got your logic , but will you please tell me for how you thought of making an array which will store 1 at the position of the element and not for an array which will store the values entered?

can u please tell me the use of line c-1 in which case?

nice approach bro !

beautiful...........

hey, I was analysing your logic for the FOR LOOP, but couldn't get it. Say if A = 1,2,3,4 and B = 1,2,3,3. Then, after the for loop, c = 7. and finally, we subtract 1 and get 6.??? I know I'm wrong, can you please explain the if condition and the increment in c variable lines?

can you explain the logic?