void Processor::_remove_to(SortedLimitedList<double> &must_be_equal_to,SortedLimitedList<double>::iterator &it) { while(must_be_equal_to.first() != it) { must_be_equal_to.remove(must_be_equal_to.first()); } }
SortedLimitedList<double>::iterator Processor::_remove_if_greate(SortedLimitedList<double> &must_be_equal_to,SortedLimitedList<double>::iterator it, double value) { while(it != must_be_equal_to.end()) { auto temp = it; --temp; if(*it > value) { must_be_equal_to.remove(it); } else { return it; } it = temp; } return it; }
SortedLimitedList<double>::iterator Processor::_clear_place(SortedLimitedList<double> &must_be_equal_to,SortedLimitedList<double>::iterator m_it,const SortedLimitedList<double> &expected_output, SortedLimitedList<double>::const_iterator e_it) { auto reserve = m_it; while(m_it != must_be_equal_to.end()) { while(e_it != expected_output.end()) { if(*m_it>*e_it) { bool first = reserve == m_it ; auto temp = m_it; --temp; must_be_equal_to.remove(m_it); if(first) return temp; else return reserve; } else if (*m_it == *e_it) { --e_it; break; } else { --e_it; } } --m_it; } auto temp = reserve; --temp; must_be_equal_to.remove(reserve); return temp; }
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. assert(expected_output.count() <= mLimit); bool need_iterate = true; while (need_iterate) { need_iterate = false; SortedLimitedList<double>::iterator lhs = must_be_equal_to.first(); SortedLimitedList<double>::const_iterator rhs = expected_output.first(); while (lhs != must_be_equal_to.end() || rhs != expected_output.end()) { if (lhs == must_be_equal_to.end()) { must_be_equal_to.add_last(*rhs); ++rhs; } else if (rhs == expected_output.end()) { SortedLimitedList<double>::iterator tmp = lhs; ++tmp; must_be_equal_to.remove(lhs); lhs = tmp; } else if (*lhs < *rhs) { SortedLimitedList<double>::iterator tmp = lhs; ++tmp; must_be_equal_to.remove(lhs); lhs = tmp; } else if (*lhs > *rhs) { if (must_be_equal_to.count() < mLimit) { must_be_equal_to.add_before(lhs, *rhs); } else { need_iterate = true; } ++rhs; } else { ++lhs; ++rhs; } } } }
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; } }