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;
}
}
