program ExgArr;

{$APPTYPE CONSOLE}

uses
  Windows, SysUtils;

const
   m =  10 ; // кол - во элементов в первом отрезке
   n =  1 ; // кол - во элементов во втором отрезке

var
  a: array[ 1 ..m + n] of Integer;
  i, l, k, t, q, r: Integer;

begin
{ инициализация массива             }
  for i :=  1  to  m + n do
      a[i] := i;
{-------------------------------------------------------------------------------
Первый вариант обмена отрезков - суть в последовательном наложении первого
 отрезка на второй, в случае некратности первого второму выполняется перестановка
 отрезков полученных путем разбиения первого отрезка и так далее вплоть до
 полной перестановки
-------------------------------------------------------------------------------}
  i :=  1 ;  // смещение в массиве
  k :=  1 ;  // ссылка на границу первого отрезка
  l := m;  // начальная граница отрезков
  repeat
{*********************************************************
 *  выполняет перестановку отрезка                       *
 *  элементов m+ 1 ..n на место элементов отрезка i..m     *
 *  в массиве i..n.                                      *
 *  На входе:                                            *
 *    i - индекс первого элемента отрезка  1 ..l           *
 *    m + n - индекс последнего элемента отрезка l+ 1 ..m+n*
 *    m + n - const используется как константа           *
 *********************************************************}
    repeat
      t := a[i];
      a[i] := a[(l - k +  1 ) + i];
      a[(l - k +  1 ) + i] := t;
      i := i +  1 
    until (((l - k +  1 ) + i) > (m + n));
{*********************************************************}
    {l := (m + n) - ((m + n) - l) mod (l - k +  1 );}// высчитывание границы по методу
    q := m + n - l;                  // числа перекрытий второго отрезка первым
    r := l - k +  1 ;
    while (q >= r) do q := q - r;   // остаток будет смщением от конца масива
    l := m + n - q;
    k := i  // сохранение начала первого  отрезка в дальнейшем используется для
            // вычисления длины смещения перестановки эл-тов первого отрезка
  until (l = (m + n));

  for i :=  1  to m + n do
    Write(a[i], ' ');
	  
{ инициализация массива             }
  for i :=  1  to  m + n do
      a[i] := i;

{-------------------------------------------------------------------------------
Второй вариант  суть метода заключается в том что нужную перестановку двух
отрезков массива можно получить с помощью обратной перестановки всех эелементов
массива с последующей обратной перстановкой элементов отрезков
-------------------------------------------------------------------------------}
// перестановка элементов всего массива  1 ..m+n
  for i :=  1  to ((m + n) div  2 ) do
    begin      
      t := a[i];
      a[i] := a[(m + n) - i +  1 ];
      a[(m + n) - i +  1 ] := t
    end;

// перестановка элементов отрезка  1 ..n
  for i :=  1  to (n div  2 ) do
    begin
      t := a[i];
      a[i] := a[(n - i) +  1 ];
      a[(n - i) +  1 ] := t    
    end;
 
// перестановка элементов отрезка n+ 1 ..n+m
  for i :=  1  to (m div  2 ) do
    begin
      t := a[n + i];
      a[n + i] := a[(m + n) +  1  - i];
      a[(m + n) +  1  - i] := t 
    end;



  for i :=  1  to m + n do
      Write(a[i], ' '); 
  Readln;
end.

const
  K =  3 ;
  L =  7 ;

var
  massive: array[ 1 ..K+L] of Integer = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 );
  i: Integer;
  l_a, l_b: Integer;
  b_a, e_b: Integer;
  temp: Integer;

begin
  for i :=  1  to K+L do
    Write(massive[i], ' ');
  Readln;
  
  l_a := K;
  l_b := L;
  b_a :=  1 ;
  e_b := K + L;
  repeat
    i :=  0 ;
    if l_a >= l_b then
      begin
        repeat
          temp := massive[b_a + l_a + i];
          massive[b_a + l_a + i] := massive [b_a + i];
          massive [b_a + i] := temp;
          i := i +  1 
        until (i = l_b);
        l_a := l_a - l_b;
        b_a := b_a + l_b
      end
    else
      begin
        repeat
          temp := massive[e_b - l_a +  1  + i];
          massive[e_b - l_a +  1  + i] := massive[b_a + i];
          massive[b_a + i] := temp;
          i := i +  1 
        until (i = l_a);
        l_b := l_b - l_a;
        e_b := e_b - l_a
      end
  until ((l_a =  0 ) or (l_b =  0 ));

  for i :=  1  to K+L do
    Write(massive[i], ' ');
  Readln;
end.

arr = [ 4 ,  5 ,  6 ,  7 ,  8 ,  9 ,  1 ,  2 ,  3 ]
arr = arr[ 6 :]+arr[: 6 ]

CL-USER> (setf arr (vector  4   5   6   7   8   9   1   2   3 ))
#( 4   5   6   7   8   9   1   2   3 )
CL-USER> (concatenate 'vector (subseq arr  6   9 ) (subseq arr  0   6 ))
#( 1   2   3   4   5   6   7   8   9 )

#include <stdio.h>
int arr[] = { 0 ,  1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 ,  8 ,  9 }, K =  6 , L =  4 ;
int main()
{
  int N=K+L, i, j, Q, tmp; /* initial making sense value, will be changed in loop! */
  for(i= 0 ; i<N; i++) {
    Q =  0 ;
    j=i;
    tmp = arr[j];
    do {
      printf("moving %d to %d\n", j, (j+L)%(K+L));
      tmp ^= (arr[(j+L)%(K+L)] ^= (tmp ^= arr[(j+L)%(K+L)]));
      j = (j+L)%(K+L);
      Q++; 
    } while(j != i);
    N = (K+L)/Q; /* calculate GCD(K, L) :) */
  }
  for(i= 0 ; i<(K+L); i++)
    printf("%d\n", arr[i]);
  return  0 ;
}

tmp ^= (arr[(j+L)%(K+L)] ^= (tmp ^= arr[(j+L)%(K+L)]));