void Processor::do_process(SortedLimitedList<double> &must_be_equal_to, const SortedLimitedList<double> &expected_output) { // TODO: make "must_be_equal_to" list equal to "expected_output". // 0. Processor will be created once and then will be used billion times. // 1. Use methods: AddFirst, AddLast, AddBefore, AddAfter, Remove to modify list. // 2. Do not change expected_output list. // 3. At any time number of elements in list could not exceed the "Limit". // 4. "Limit" will be passed into Processor's constructor. All "must_be_equal_to" and "expected_output" lists will have the same "Limit" value. // 5. At any time list elements must be in non-descending order. // 6. Implementation must perform minimal possible number of actions (AddFirst, AddLast, AddBefore, AddAfter, Remove). // 7. Implementation must be fast and do not allocate excess memory. if(expected_output.count()<0) { return; } else { if(expected_output.count()==0) { must_be_equal_to.clear(); return; } } SortedLimitedList<double>::const_iterator iterator_1 = expected_output.first(); SortedLimitedList<double>::iterator iterator_2 = must_be_equal_to.first(); for(;iterator_1!=expected_output.end();) { for(;iterator_2!=must_be_equal_to.end();) { { SortedLimitedList<double>::const_iterator iterator_1_temp_2 = expected_output.first(); SortedLimitedList<double>::iterator iterator_2_temp_2 = must_be_equal_to.first(); if(iterator_1==expected_output.end()) { iterator_1 = iterator_1_temp_2; } if(iterator_2==must_be_equal_to.end()) { iterator_2 = iterator_2_temp_2; } for(;iterator_1_temp_2!=expected_output.end() && iterator_2_temp_2!=must_be_equal_to.end();) { if(iterator_1_temp_2==iterator_1) { break; } if(iterator_2_temp_2==iterator_2) { break; } iterator_1_temp_2++; iterator_2_temp_2++; } iterator_1 = iterator_1_temp_2; iterator_2 = iterator_2_temp_2; } if(iterator_1==expected_output.end()) { break; } if(iterator_2==must_be_equal_to.end()) { break; } for(;*iterator_1==*iterator_2;) { iterator_1++; iterator_2++; if(iterator_1==expected_output.end()) { break; } if(iterator_2==must_be_equal_to.end()) { break; } } if ( expected_output.count()==must_be_equal_to.count() && iterator_1==expected_output.end() && iterator_2==must_be_equal_to.end() ) { return; } if(iterator_1==expected_output.end()) { break; } if(iterator_2==must_be_equal_to.end()) { break; } if(*iterator_1<*iterator_2) { if(iterator_2!=must_be_equal_to.last()) { if(must_be_equal_to.count()>=limit_value) { must_be_equal_to.remove(must_be_equal_to.last()); } must_be_equal_to.add_before(iterator_2,*iterator_1); } else { if(must_be_equal_to.count()>=limit_value) { must_be_equal_to.remove(must_be_equal_to.last()); } must_be_equal_to.add_after(must_be_equal_to.last(),*iterator_1); } } else // if(*iterator_1>=*iterator_2) { if(iterator_2==must_be_equal_to.first()) { for(;*must_be_equal_to.first()<*iterator_1;) { must_be_equal_to.remove(must_be_equal_to.first()); if(must_be_equal_to.count()==0) { break; } } if(must_be_equal_to.count()>=limit_value) { must_be_equal_to.remove(must_be_equal_to.last()); } if(must_be_equal_to.count()!=0) { if(*must_be_equal_to.first()!=*iterator_1) { must_be_equal_to.add_first(*iterator_1); } } else { must_be_equal_to.add_first(*iterator_1); } } else // iterator_2!=must_be_equal_to.first() { for(;*iterator_2<*iterator_1;) { SortedLimitedList<double>::iterator iterator_2_temp_3 = iterator_2; iterator_2_temp_3--; must_be_equal_to.remove(iterator_2); iterator_2 = iterator_2_temp_3; iterator_2++; if(iterator_2==must_be_equal_to.end()) { break; } } if(must_be_equal_to.count()>=limit_value) { must_be_equal_to.remove(must_be_equal_to.last()); } if(iterator_2==must_be_equal_to.end()) { iterator_2=must_be_equal_to.last(); } if(*iterator_2<=*iterator_1) { must_be_equal_to.add_after(iterator_2,*iterator_1); } else { if(*iterator_2>*iterator_1) { must_be_equal_to.add_before(iterator_2,*iterator_1); } } } } if(iterator_1==expected_output.end()) { break; } else { iterator_1++; } if(iterator_2==must_be_equal_to.end()) { break; } else { iterator_2++; } } if(iterator_1==expected_output.end() || iterator_2==must_be_equal_to.end()) { if(expected_output.count()<must_be_equal_to.count()) { for(;expected_output.count()<must_be_equal_to.count();) { must_be_equal_to.remove(must_be_equal_to.last()); } return; } else { if(expected_output.count()>must_be_equal_to.count()) { for(;expected_output.count()>must_be_equal_to.count();) { if(*must_be_equal_to.last()<=*iterator_1) { must_be_equal_to.add_last(*iterator_1); } else { if(*must_be_equal_to.last()>*iterator_1) { must_be_equal_to.add_before(must_be_equal_to.last(),*iterator_1); } } if(iterator_1==expected_output.end()) { break; } else { iterator_1++; } } } else // if(expected_output.count()==must_be_equal_to.count()) { return; } if(iterator_1==expected_output.end()) { break; } else { iterator_1++; } if(iterator_2==must_be_equal_to.end()) { break; } else { iterator_2++; } continue; } } if(iterator_1==expected_output.end()) { break; } else { iterator_1++; } if(iterator_2==must_be_equal_to.end()) { break; } else { iterator_2++; } } }
void Processor::do_process(SortedLimitedList<double> &must_be_equal_to, const SortedLimitedList<double> &expected_output) { // TODO: make "must_be_equal_to" list equal to "expected_output". // 0. Processor will be created once and then will be used billion times. // 1. Use methods: AddFirst, AddLast, AddBefore, AddAfter, Remove to modify list. // 2. Do not change expected_output list. // 3. At any time number of elements in list could not exceed the "Limit". // 4. "Limit" will be passed into Processor's constructor. All "must_be_equal_to" and "expected_output" lists will have the same "Limit" value. // 5. At any time list elements must be in non-descending order. // 6. Implementation must perform minimal possible number of actions (AddFirst, AddLast, AddBefore, AddAfter, Remove). // 7. Implementation must be fast and do not allocate excess memory. if(expected_output.first() == expected_output.end()) { _remove_to(must_be_equal_to,must_be_equal_to.end()); return; } //TODO: revers iterator is more suitable. But I not sure that allowed modified SortedLimitedList in test task auto e = expected_output.last(); auto m = must_be_equal_to.last(); while(true) { if(m == must_be_equal_to.end()) { // tail already matched and head empty must_be_equal_to.add_first(*e); } else { //remove all value greaten than in expected_output list m = _remove_if_greate(must_be_equal_to, m, *e); // std::remove_if is not optimal in sorted list if(m == must_be_equal_to.end()) { // all head in must_be_equal_to list was deleted must_be_equal_to.add_first(*e); } else if(*m == *e) { //next element equivalent to expected_output element --m; } else { // need to add value in 'e' iterator from expected_output list if(must_be_equal_to.count() >= _limit) { //remove elements to avoid exceeding m = _clear_place(must_be_equal_to, m, expected_output, e); if(m == must_be_equal_to.end()) must_be_equal_to.add_first(*e); else must_be_equal_to.add_after(m,*e); } else must_be_equal_to.add_after(m,*e); } } if(e == expected_output.first()) { //remove all items from first to m iterator (including m) in must_be_equal_to if(m != must_be_equal_to.end()) { ++m; _remove_to(must_be_equal_to,m); } break; } --e; } }