Test results - Codility

Code: 17:04:21 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A, int[] B) {
        // write your code in Java SE 8
    }
}

Code: 17:09:03 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {
    // write your code in C++14 (g++ 6.2.0)
}

Code: 17:34:59 UTC, cpp, autosave

1 2 3 4 5 6 7 8

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {
}

Code: 17:35:13 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare
}

Code: 17:35:25 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare se
}

Code: 17:35:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles
}

Code: 17:36:10 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so that
}

Code: 17:36:32 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so that smaller side trap int A
}

Code: 17:36:53 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
}

Code: 17:37:23 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for 
}

Code: 17:37:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (auto index = 0; i <)
}

Code: 17:38:49 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (auto index = 0; i < )
}

Code: 17:38:59 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (auto index = 0; i < A.size())
}

Code: 17:39:10 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (auto index = 0; index < A.size();)
}

Code: 17:39:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (auto index = 0; index < A.size(); ++index)
}

Code: 17:39:48 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t index = 0; index < A.size(); ++index)
    {
        if (A)
    }
}

Code: 17:40:03 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i])
    }
}

Code: 17:40:14 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
    }
}

Code: 17:40:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
}

Code: 17:41:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A:" << A << endl;
}

Code: 17:41:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:41:41 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    
    return A.size();
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:20:18: error: no match for 'operator<<' (operand types are 'std::basic_ostream<char>' and 'std::vector<int>')
     cout << "A:" << A << endl;
     ~~~~~~~~~~~~~^~~~
In file included from /opt/lang/gcc/include/c++/6.2.0/iostream:39:0,
                 from solution.cpp:4:
/opt/lang/gcc/include/c++/6.2.0/ostream:108:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ostream_type& (*)(std::basic_ostream<_CharT, _Traits>::__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(__ostream_type& (*__pf)(__ostream_type&))
       ^~~~~~~~
/opt/lang/gcc/include/c++/6.2.0/ostream:108:7: note:   no known conversion for argument 1 from 'std::vector<int>' to 'std::basic_ostream<char>::__ostream_type& (*)(std::basic_ostream<char>::__ostream_type&) {aka std::basic_ostream<char>& (*)(std::basic_ostream<char>&)}'
/opt/lang/gcc/include/c++/6.2.0/ostream:117:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ios_type& (*)(std::basic_ostream<_CharT, _Traits>::__ios_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>; std::basic_ostream<_CharT, _Traits>::__ios_type = std::basic_ios<char>]
       operator<<(__ios_type& (*__pf)(__ios_type&))
       ^~~~~~~~
/opt/lang/gcc/include/c++/6.2.0/ostream:117:7: note:   no known conversion for argument 1 from 'std::vector<int>' to 'std::basic_ostream<char>::__ios_type& (*)(std::basic_ostream<char>::__ios_type&) {aka std::basic_ios<char>& (*)(std::basic_ios<char>&)}'
/opt/lang/gcc/include/c++/6.2.0/ostream:127:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostre

Code: 17:42:22 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    for (size_t i = 0; i < A.size(); ++i)
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:42:43 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    for each (size_t i = 0; i < A.size(); ++i)
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:42:58 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    for each (auto e: A.size(); ++i)
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:43:14 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    for each (auto e: A)
    cout << "A:" << A << endl;

    for each (auto e: A)
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:43:26 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A:" << A << endl;
    for each (auto e: A)
    cout << "A:" << A << endl;

    cout << "B:" << B << endl;
    for each (auto e: A)
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:43:37 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [" << A << endl;
    for each (auto e: A)
    cout << "A:" << A << endl;

    cout << "B: ";
    for each (auto e: A)
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:43:49 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for each (auto e: A)
        cout << "A:" << A << endl;

    cout << "B: ";
    for each (auto e: A)
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:44:00 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for each (auto e: A)
        cout << e << " ";

    cout << "B: ";
    for each (auto e: A)
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:44:12 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for each (auto e: A)
        cout << e << " ";

    cout << "B: [";
    for each (auto e: A)
        cout << e << " ";
    cout << "B:" << B << endl;
    
    return A.size();
}

Code: 17:44:25 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for each (auto e: A)
        cout << e << " ";

    cout << "B: [";
    for each (auto e: A)
        cout << e << " ";
    cout << "]" << B << endl;
    
    return A.size();
}

Code: 17:44:35 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for each (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for each (auto e: A)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:21:9: error: expected '(' before 'each'
     for each (auto e: A)
         ^~~~
func.cpp:21:15: error: expected primary-expression before 'auto'
     for each (auto e: A)
               ^~~~
func.cpp:21:24: error: 'each' was not declared in this scope
     for each (auto e: A)
                        ^
func.cpp:25:19: error: expected ')' before ';' token
     cout << "B: [";
                   ^
func.cpp:26:9: error: expected '(' before 'each'
     for each (auto e: A)
         ^~~~
func.cpp:26:15: error: expected primary-expression before 'auto'
     for each (auto e: A)
               ^~~~
func.cpp:26:24: error: 'each' was not declared in this scope
     for each (auto e: A)
                        ^
func.cpp:30:5: error: expected primary-expression before 'return'
     return A.size();
     ^~~~~~
func.cpp:30:5: error: expected ')' before 'return'
func.cpp:31:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^

Code: 17:44:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for each (auto e: A)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:44:56 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

▶

example1
First example test.

✘

WRONG ANSWER
got 5 expected 3

▶

example2
Second example test.

✘

WRONG ANSWER
got 4 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 5 expected 3

Code: 17:45:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:45:29 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

▶

example1
First example test.

✘

WRONG ANSWER
got 5 expected 3

▶

example2
Second example test.

✘

WRONG ANSWER
got 4 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 5 expected 3

Code: 17:45:48 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;

    
    return A.size();
}

Code: 17:46:33 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    
    return A.size();
}

Code: 17:46:52 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;

    // sort each array to find
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    
    return A.size();
}

Code: 17:47:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;

    // sort each array to find longest sequence
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    
    return A.size();
}

Code: 17:47:34 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;

    // sort each array to find longest sequence
    std::sort(A);
    std::sort(B);
    
    return A.size();
}

Code: 17:48:00 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A);
    std::sort(B);
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:48:02 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A);
    std::sort(B);
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:21:5: error: 'sort' is not a member of 'std'
     std::sort(A);
     ^~~
func.cpp:22:5: error: 'sort' is not a member of 'std'
     std::sort(B);
     ^~~

Code: 17:48:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A);
    std::sort(B);
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:48:28 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A);
    std::sort(B);
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:20:16: error: no matching function for call to 'sort(std::vector<int>&)'
     std::sort(A);
                ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4697:5: note: candidate: template<class _RAIter> void std::sort(_RAIter, _RAIter)
     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     ^~~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4697:5: note:   template argument deduction/substitution failed:
func.cpp:20:16: note:   candidate expects 2 arguments, 1 provided
     std::sort(A);
                ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4727:5: note: candidate: template<class _RAIter, class _Compare> void std::sort(_RAIter, _RAIter, _Compare)
     sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
     ^~~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4727:5: note:   template argument deduction/substitution failed:
func.cpp:20:16: note:   candidate expects 3 arguments, 1 provided
     std::sort(A);
                ^
func.cpp:21:16: error: no matching function for call to 'sort(std::vector<int>&)'
     std::sort(B);
                ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4697:5: note: candidate: template<class _RAIter> void std::sort(_RAIter, _RAIter)
     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     ^~~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:4697:5: note:   template argument deduction/substitution failed:
func.cpp:21:16: note:   candidate expects 2 arguments, 1 provided
     std::sort(B);
                ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/g

Code: 17:48:57 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B);
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:49:09 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Code: 17:49:10 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    return A.size();
}

Analysis

▶

example1
First example test.

✘

WRONG ANSWER
got 5 expected 3

▶

example2
Second example test.

✘

WRONG ANSWER
got 4 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 5 expected 3

Code: 17:53:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    
    return A.size();
}

Code: 17:53:55 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto 
    return A.size();
}

Code: 17:54:06 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    
    return A.size();
}

Code: 17:54:32 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    for (auto e: A)
        cout << e << " ";
    
    return A.size();
}

Code: 17:54:42 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;

    for (auto e: A)
    {
        cout << e << " ";
    
    return A.size();
}

Code: 17:54:52 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 17:59:22 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 17:59:53 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid 
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:00:09 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:00:39 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:01:01 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto check = A[0];

    for (auto e: A)
    {
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:01:29 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto check = A[0];

    for (auto e: A)
    {
        if ()
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:01:42 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto max_count = 0;
    auto check = A[0];

    for (auto e: A)
    {
        if ()
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:02:03 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    for (auto e: A)
    {
        if (e == check)
        cout << e << " ";
    }
    
    return A.size();
}

Code: 18:02:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    for (auto e: A)
    {
        if (e == check)
    }
    
    return A.size();
}

Code: 18:02:33 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
    }
    
    return A.size();
}

Code: 18:05:40 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];


    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
    }
    
    return A.size();
}

Code: 18:05:54 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
    }
    
    return A.size();
}

Code: 18:06:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            
        }
    }
    
    return A.size();
}

Code: 18:06:30 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            
        }
    }
    
    return A.size();
}

Code: 18:06:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
        }
    }
    
    return A.size();
}

Code: 18:07:03 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:07:22 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }

    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:07:32 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }

    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:07:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }

    auto chunk_size = 1;
    auto check = A[0];
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:08:14 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_cou)
        }
    }

    auto chunk_size = 1;
    auto check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:08:24 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    auto chunk_size = 1;
    auto check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
        }
    }
    
    return A.size();
}

Code: 18:08:39 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    auto chunk_size = 1;
    auto check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:08:39 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    auto chunk_size = 1;
    auto check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:51:13: error: 'chunck_size' was not declared in this scope
             chunck_size = 1;
             ^~~~~~~~~~~
func.cpp:56:10: error: conflicting declaration 'auto chunk_size'
     auto chunk_size = 1;
          ^~~~~~~~~~
func.cpp:38:10: note: previous declaration as 'int chunk_size'
     auto chunk_size = 1;
          ^~~~~~~~~~
func.cpp:57:10: error: conflicting declaration 'auto check'
     auto check = B[0];
          ^~~~~
func.cpp:39:10: note: previous declaration as 'int check'
     auto check = A[0];
          ^~~~~
func.cpp:68:13: error: 'chunck_size' was not declared in this scope
             chunck_size = 1;
             ^~~~~~~~~~~

Code: 18:09:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    size_t chunk_size = 1;
    auto check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:09:14 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:51:13: error: 'chunck_size' was not declared in this scope
             chunck_size = 1;
             ^~~~~~~~~~~
func.cpp:68:13: error: 'chunck_size' was not declared in this scope
             chunck_size = 1;
             ^~~~~~~~~~~

Code: 18:09:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:09:51 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunck_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:10:08 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunck_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:10:10 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 1;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Analysis

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 3

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 3

Code: 18:11:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:11:31 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 0;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:11:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:12:01 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    chunk_size = 1;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:12:11 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            check = e;
            chunk_size = 1;
            max_count = std::max(chunk_size, max_count);
        }
    }
    
    return max_count;
}

Code: 18:12:17 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 2 expected 3

Code: 18:13:31 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

            max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    return max_count;
}

Code: 18:13:46 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✘

WRONG ANSWER
got 2 expected 3

Code: 18:20:34 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
//
int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Code: 18:20:47 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
// commented code v1
int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Code: 18:21:00 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Code: 18:21:11 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    
int solution(vector<int> &A, vector<int> &B) {

    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Code: 18:21:23 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    
int solution(vector<int> &A, vector<int> &B) {

    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    return max_count;
}

Code: 18:21:34 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    
int solution(vector<int> &A, vector<int> &B) {

    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:22:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
    
    
int solution(vector<int> &A, vector<int> &B) {

    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:22:34 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, >
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:22:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> 
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:23:13 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> dimension_count_by
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:23:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_dimension_count_by
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:23:38 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:24:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:24:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] == B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:24:40 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        
        if (A[i] == B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:25:09 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:25:22 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:25:32 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:25:43 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:25:56 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:26:09 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " = " << e.second;
    cout << "]" << endl;


    return max_count;
}

Code: 18:26:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " = " << e.second << " ";
    cout << "]" << endl;


    return max_count;
}

Code: 18:26:37 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " = " << e.second << " ";
    cout << "]" << endl;

    auto max_count = 1;
    return max_count;
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:79:5: error: 'map' is not a member of 'std'
     std::map<int, int> element_count_by_dimension;
     ^~~
func.cpp:79:14: error: expected primary-expression before 'int'
     std::map<int, int> element_count_by_dimension;
              ^~~
func.cpp:83:9: error: 'element_count_by_dimension' was not declared in this scope
         element_count_by_dimension[A[i]]++;
         ^~~~~~~~~~~~~~~~~~~~~~~~~~
func.cpp:92:18: error: 'element_count_by_dimension' was not declared in this scope
     for (auto e: element_count_by_dimension)
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~

Code: 18:26:51 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

#include <algorithm>
#include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " = " << e.second << " ";
    cout << "]" << endl;

    auto max_count = 1;
    return max_count;
}

Code: 18:26:58 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
        cout << e.first << " = " << e.second << " ";
    cout << "]" << endl;

    auto max_count = 1;
    return max_count;
}

Analysis

▶

example1
First example test.

✘

WRONG ANSWER
got 1 expected 3

▶

example2
Second example test.

✘

WRONG ANSWER
got 1 expected 2

▶

example3
Third example test.

✘

WRONG ANSWER
got 1 expected 3

Code: 18:28:08 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
    
        cout << e.first << " = " << e.second << " ";
    cout << "]" << endl;

    auto max_count = 1;
    return max_count;
}

Code: 18:28:18 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
    }
    cout << "]" << endl;

    auto max_count = 1;
    return max_count;
}

Code: 18:28:32 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    auto max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
    }
    cout << "]" << endl;

    return max_count;
}

Code: 18:29:40 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    auto max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
    max_count = std::max(chunk_size, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Code: 18:29:52 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    auto max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Code: 18:29:53 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    auto max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:98:42: error: no matching function for call to 'max(std::pair<const int, int>&, int&)'
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/bits/char_traits.h:39:0,
                 from /opt/lang/gcc/include/c++/6.2.0/string:40,
                 from solution.cpp:3:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:219:5: note: candidate: template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)
     max(const _Tp& __a, const _Tp& __b)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:219:5: note:   template argument deduction/substitution failed:
func.cpp:98:42: note:   deduced conflicting types for parameter 'const _Tp' ('std::pair<const int, int>' and 'int')
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/bits/char_traits.h:39:0,
                 from /opt/lang/gcc/include/c++/6.2.0/string:40,
                 from solution.cpp:3:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:265:5: note: candidate: template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)
     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:265:5: note:   template argument deduction/substitution failed:
func.cpp:98:42: note:   deduced conflicting types for parameter 'const _Tp' ('std::pair<const int, int>' and 'int')
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:3459:5: note: candidate: template<class _Tp> constexpr _Tp std::max(std::initializer_list<_Tp>)
     max(initializer_list<_Tp> __l)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo

Code: 18:30:15 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Analysis

Compile error

func.cpp: In function 'int solution(std::vector<int>&, std::vector<int>&)':
func.cpp:98:42: error: no matching function for call to 'max(std::pair<const int, int>&, int&)'
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/bits/char_traits.h:39:0,
                 from /opt/lang/gcc/include/c++/6.2.0/string:40,
                 from solution.cpp:3:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:219:5: note: candidate: template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)
     max(const _Tp& __a, const _Tp& __b)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:219:5: note:   template argument deduction/substitution failed:
func.cpp:98:42: note:   deduced conflicting types for parameter 'const _Tp' ('std::pair<const int, int>' and 'int')
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/bits/char_traits.h:39:0,
                 from /opt/lang/gcc/include/c++/6.2.0/string:40,
                 from solution.cpp:3:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:265:5: note: candidate: template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)
     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algobase.h:265:5: note:   template argument deduction/substitution failed:
func.cpp:98:42: note:   deduced conflicting types for parameter 'const _Tp' ('std::pair<const int, int>' and 'int')
         max_count = std::max(e, max_count);
                                          ^
In file included from /opt/lang/gcc/include/c++/6.2.0/algorithm:62:0,
                 from func.cpp:1:
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo.h:3459:5: note: candidate: template<class _Tp> constexpr _Tp std::max(std::initializer_list<_Tp>)
     max(initializer_list<_Tp> __l)
     ^~~
/opt/lang/gcc/include/c++/6.2.0/bits/stl_algo

Code: 18:30:23 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e., max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Code: 18:30:48 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

Code: 18:31:16 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    cout << "]" << endl;

    return max_count;
}

Code: 18:31:26 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Code: 18:31:26 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

Code: 18:36:02 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Code: 18:36:18 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Code: 18:36:18 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

test_data1

✘

RUNTIME ERROR
invalid input, unexpected token at the end of input: '['

Code: 18:36:39 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Code: 18:36:47 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

test_data1

✔

OK

Code: 18:37:04 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

test_data1

✔

OK

Code: 18:37:29 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

test_data1

✔

OK

Code: 18:37:36 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

test_data1

✔

OK

Code: 18:37:40 UTC, cpp, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

#include <algorithm>
#include <map>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

// commented code v1
/*
    // avoid complexify code below
    if (A.size() == 0)
        return 0;
        
    // prepare arrays, transform rectangles so
    // that smaller side trap int A and bigger side trap into B
    
    for (size_t i = 0; i < A.size(); ++i)
    {
        if (A[i] > B[i])
        {
            std::swap(A[i], B[i]);
        }
    }
    
    // sort each array to find longest sequence
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    cout << "A: [";
    for (auto e: A)
        cout << e << " ";
    cout << "]" << endl;

    cout << "B: [";
    for (auto e: B)
        cout << e << " ";
    cout << "]" << endl;
    
    auto max_count = 0;
    auto chunk_size = 0;
    auto check = A[0];

    // todo use adjucent_find()
    for (auto e: A)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }

    max_count = std::max(chunk_size, max_count);
    chunk_size = 0;
    check = B[0];
    
    for (auto e: B)
    {
        if (e == check)
        {
            chunk_size++;
        }
        else
        {
            max_count = std::max(chunk_size, max_count);
            check = e;
            chunk_size = 1;
        }
    }
    
    max_count = std::max(chunk_size, max_count);
*/    
    
int solution(vector<int> &A, vector<int> &B) {

    std::map<int, int> element_count_by_dimension;

    for (size_t i = 0; i < A.size(); ++i)
    {
        element_count_by_dimension[A[i]]++;
        
        if (A[i] != B[i])
        {
            element_count_by_dimension[B[i]]++;
        }
    }
    
    int max_count = 0;

    //cout << "D: [";
    for (auto e: element_count_by_dimension)
    {
        //cout << e.first << " = " << e.second << " ";
        max_count = std::max(e.second, max_count);
    }
    //cout << "]" << endl;

    return max_count;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N*log(N)) or O(N)

▶

example1
First example test.

✔

OK

▶

example2
Second example test.

✔

OK

▶

example3
Third example test.

✔

OK

▶

common_side_from_A
No rotations needed. Common side can be chosen from A. N = 15.

✔

OK

▶

common_side_from_B
No rotations needed. Common side can be chosen from B. N = 15.

✔

OK

▶

A_less_than_B
Array A contains shorter sides. N = 15.

✔

OK

▶

A_greater_than_B
Array A contains longer sides. N = 15.

✔

OK

▶

only_squares
All rectangles are squares. N = 15.

✔

OK

▶

no_squares
Rectangles are not squares. N = 15.

✔

OK

▶

corners
N <= 2.

✔

OK

1.

0.001 s

OK

2.

0.001 s

OK

3.

0.001 s

OK

4.

0.001 s

OK

5.

0.001 s

OK

6.

0.001 s

OK

▶

medium_common_side_from_A
No rotations needed. Common side can be chosen from A. N = 200.

✔

OK

▶

medium_common_side_from_B
No rotations needed. Common side can be chosen from B. N = 200.

✔

OK

▶

medium_A_less_than_B
"Array A contains shorter sides. N = 200.

✔

OK

▶

medium_A_greater_than_B
Array A contains longer sides. N = 200.

✔

OK

▶

medium_only_squares
All rectangles are squares. N = 200.

✔

OK

▶

large_common_side_from_A
No rotations needed. Common side can be chosen from A. N = 100,000.

✔

OK

▶

large_common_side_from_B
No rotations needed. Common side can be chosen from B. N = 100,000.

✔

OK

▶

large_A_less_than_B
Array A contains shorter sides. N = 100,000. Points x 2.

✔

OK

▶

large_A_greater_than_B
Array A contains longer sides. N = 100,000. Points x 2.

✔

OK

▶

large_only_squares
All rectangles are squares. N = 100,000. Points x 2.

✔

OK