Отправлено: 23.11.18 18:41. Заголовок: Переместить элементы массива вправо на заданное количество позиций.

На одном из сайтов для начинающих программистов встретил такое задание Элементы массива переместить вправо на заданное количество позиций

То есть, как следует из описания задания,

1) элементы массива а ( n ) необходимо перемещать вправо к позиции k .Элементы, покинувшие границы массива, исчезают.Заполнять пробелы массива нулями.

Это задание можно рассматривать как тренировку на использование стандартных алгоритмов в C++.

Для выполнения задания можно использовать два стандартных алгоритма. Это, во-первых, стандартный алгоритм std::copy_backward и, во-вторых, стандартный алгоритм std::fill_n.

Ниже представлена демонстрационная программа.

 
 #include <iostream> 
 #include <iterator> 
 #include <algorithm> 
  
 int main() 
 { 
     while ( true ) 
     { 
         int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
      
         std::cout << "a[] = "; 
         for ( int x : a ) std::cout << x << ' '; 
         std::cout << '\n'; 
      
         std::cout << "\nEnter the new initial position in the array less than "  
                   << std::size( a ) << " (0 - exit): ";  
                
         size_t k; 
      
         if ( not ( std::cin >> k ) or ( k == 0 ) ) break; 
  
         if ( not ( k < std::size( a ) ) ) k = std::size( a ); 
          
         std::copy_backward( std::begin( a ), std::next( std::begin( a ), std::size( a ) - k ), std::end( a ) ); 
         std::fill_n( std::begin( a ), k, int() );                             
  
         std::cout << "\na[] = "; 
         for ( int x : a ) std::cout << x << ' '; 
         std::cout << "\n---------------------------\n"; 
     }         
 } 
 

Вывод программы на консоль, к примеру, может выглядеть следующим образом

 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 1 
  
 a[] = 0 1 2 3 4 5 6 7 8 9  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 2 
  
 a[] = 0 0 1 2 3 4 5 6 7 8  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 3 
  
 a[] = 0 0 0 1 2 3 4 5 6 7  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 4 
  
 a[] = 0 0 0 0 1 2 3 4 5 6  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 5 
  
 a[] = 0 0 0 0 0 1 2 3 4 5  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 6 
  
 a[] = 0 0 0 0 0 0 1 2 3 4  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 7 
  
 a[] = 0 0 0 0 0 0 0 1 2 3  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 8 
  
 a[] = 0 0 0 0 0 0 0 0 1 2  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 9 
  
 a[] = 0 0 0 0 0 0 0 0 0 1  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 10 
  
 a[] = 0 0 0 0 0 0 0 0 0 0  
 --------------------------- 
 a[] = 1 2 3 4 5 6 7 8 9 10  
  
 Enter the new initial position in the array less than 10 (0 - exit): 0

Вместо двух вызовов алгоритмов как отдельных предложений, можно было вызов алгоритма std::copy_backward вложить в вызов алгоритма std::fill. Например,

 
 std::fill( std::begin( a ), 
            std::copy_backward( std::begin( a ), std::next( std::begin( a ), std::size( a ) - k ), std::end( a ) ), 
            0 ); 
 

Однако такое предложение может показаться более трудно-читаемым, чем два отдельных предложения вызовов алгоритмов, показанных в демонстрационной программе.

В общем случае можно было бы в алгоритме std::copy_backward использовать std::move_iterator. Например,

 
 std::copy_backward( std::move_iterator( std::begin( a ) ),  
                     std::move_iterator( std::next( std::begin( a ), std::size( a ) - k ) ),  
                     std::end( a ) );