Битовые операции / SHIFT0

Const nMax=100;
type indexV=1..nMax;
indexV1=1..nMax+1;
indexV0=0..nMax;
Elem=Char;
vector=array [indexV] of Elem;
{ ’аЁ а §«Ёз­ле аҐиҐ­Ёп § ¤ зЁ ЇҐаҐбв ­®ўЄЁ ᬥ¦­ле ᥣ¬Ґ­в®ў }
{ ¬ ббЁў  (Ё«Ё § ¤ зЁ жЁЄ«ЁзҐбЄ®Ј® б¤ўЁЈ  ᥣ¬Ґ­в  ¬ ббЁў ) }
{ }
{1-© ў аЁ ­в -----------------------------------------------------}
{ ‚бЇ®¬®Ј вҐ«м­ п дг­ЄжЁп: ЌЋ„ ( GCD ) }
function GCD(a, b: Word): Word;
var u,v,Remainder : Word;
begin
u := a; v := b;
{ u>=0 & v>=0 & GCD(u,v)=GCD(a,b) }
while v <> 0 do
begin { u>=0 & v>0 & GCD(u,v)=GCD(a,b) }
Remainder := u mod v;
u := v; v := Remainder;
{ u>0 & v>=0 & GCD(u,v)=GCD(a,b) }
end {while};
{ u>=0 & v=0 & u=GCD(u,0)=GCD(a,b) }
GCD:=u
end{GCD};

procedure Shift1(var a: vector; n, m: indexV);
{ –ЁЄ«ЁзҐбЄЁ© б¤ўЁЈ ᥣ¬Ґ­в  ¬ ббЁў : }
{ n - а §¬Ґа ¬ ббЁў  - a[1..n]; }
{ m - а §¬Ґа б¤ўЁЈ Ґ¬®Ј® ᥣ¬Ґ­в  - a[1..m]; }
{ (n-m) - ўҐ«ЁзЁ­  б¤ўЁЈ  ўЇа ў®; }
{ Ё«Ё (¤агЈ п Ё­вҐаЇаҐв жЁп) ўҐ«ЁзЁ­  б¤ўЁЈ  ў«Ґў® = m }
{ ЏаҐ¤гб«®ўЁҐ: 1<=m<n }
{ Ќ з «м­®Ґ б®бв®п­ЁҐ: }
{ 1 m n }
{ ЙННННННННННННННШННННННННННННННННННННННННННННН» }
{ a: є A[1..m] і A[m+1..n] є }
{ ИННННННННННННННШНННННННННННННННННННННННННННННј }
{ і /А Д Д Д Д Д Д Д Д Д Д Д Д Д Д/ї }
{ / / }
{ і /<ДДДДДДДДДДДДДДДДДДДДДДДДДДД>/ і }
{ / / }
{ А Д Д /Д Д Д Д Д Д Д Д Д Д Д Дї / і }
{ / Џ®бвгб«®ўЁҐ: / }
{ / n-mі / і }
{ ЙННННННННННННННПННННННННННННННШНННННННННННННН» }
{ a: є A[m+1..n] і A[1..m] є }
{ ИННННННННННННННСННННННННННННННШННННННННННННННј }
{ 1 m n-m+1 n }
{--------------------------------------------------------}
var Nc, q, {p, i,} Cur, Next: IndexV;
aTemp: Elem;
begin {Shift1}
if (1<=m) and (m<n) then
begin
{Nc - зЁб«® жЁЄ«®ў (§ ¬Є­гвле ва ҐЄв®аЁ©) ЇҐаҐбв ­®ў®Є}
Nc:=GCD(n,m); {p:=n div Nc;}
for q:=1 to Nc do
begin {®Ўа Ў®вЄ  q-Ј® жЁЄ«  ЇҐаҐбв ­®ў®Є
(q-®© § ¬Є­гв®© ва ҐЄв®аЁЁ) }
aTemp:=a[q];
Cur:=q;
Next:=Cur+m; if Next>n then Next:=Next-n;
{Cur - Єг¤  ЇҐаҐ¬Ґй вм,   Next - ®вЄг¤ }
while Next<>q do {for i:=1 to p-1 do}
begin
a[Cur]:=a[Next];
Cur:=Next;
Next:=Next+m; if Next>n then Next:=Next-n
end{while};
{Next=q}
a[Cur]:=aTemp
end{for q}
end{then} else WriteLn('ЌҐЄ®а४в­л© ўл§®ў Їа®жҐ¤гал Shift1')
{end-if}
end{Shift1};

{2-© ў аЁ ­в ----------------------------------------------------}
{ ђҐиҐ­ЁҐ ­  ®б­®ўҐ ўбЇ®¬®Ј вҐ«м­®© Їа®жҐ¤гал SwapEq ЇҐаҐбв ­®ўЄЁ}
{ ᥣ¬Ґ­в®ў а ў­®© ¤«Ё­л }

procedure SwapEq (var a: Vector; m, k: indexV; s: indexV0);
{ Pred: (Low(a)<=m) & (m+s<=k) & (k+s<=High(a)+1) & }
{ & (a[m..k+s)=A[m..k+s)) }
{ Post: (m+s<=k) & (a[m..m+s)=A[k..k+s)) & }
{ & (a[k..k+s)=A[m..m+s)) & (a[m+s..k)=A[m+s..k)) }
{............................................................}
{€«Ё m m+s k k+s n}
{Pred: ЙННННННННННННННШНННННННОННННННННННННННШНННННН» }
{ a: є A[m..m+s) і є A[k..k+s) і є }
{ ИННННННННННННННШНННННННОННННННННННННННШННННННј }
{ }
{ АДДДДДДВДДДДДДДЩ АДДДДДДДВДДДДДДЩ }
{ s s }
{Post: — бвЁ A[m..m+s) Ё A[k..k+s) ЇҐаҐбв ў«Ґ­л }
{............................................................}
var i: indexV;
j: indexV0;
b: Elem;
begin {SwapEq}
j:=k-1;
for i:=m to m+s-1 do
begin { a[i] <-> a[k+i-m] }
j:=j+1; {j:=k+i-m;}
b:=a[i]; a[i]:=a[j]; a[j]:=b
end
end{SwapEq};

procedure Shift2 (var a: vector; m, n, k: indexV1);
{ }
{ –ЁЄ«ЁзҐбЄЁ© б¤ўЁЈ ᥣ¬Ґ­в  ¬ ббЁў  Ё«Ё }
{ ЇҐаҐбв ­®ўЄ  ᬥ¦­ле ᥣ¬Ґ­в®ў а §­®© ¤«Ё­л: }
{ }
{ ЏаҐ¤гб«®ўЁҐ: m<k<n }
{ Ќ з «м­®Ґ б®бв®п­ЁҐ: }
{ n-k }
{ k-m ЪДДДДДДДДДДДДДДДБДДДДДДДДДДДДДї }
{ ЪДДДДДДДБДДДДДДї }
{ m k n }
{ ЙННННННННННННННШННННННННННННННННННННННННННННН» }
{ a: є A[m..k) і A[k..n) є }
{ ИННННННННННННННШНННННННННННННННННННННННННННННј }
{ і /А Д Д Д Д Д Д Д Д Д Д Д Д Д Д/ї }
{ / / }
{ і /<ДДДДДДДДДДД(n-k)ДДДДДДДДДДД>/ і }
{ / / }
{ А Д Д /Д Д Д Д Д Д Д Д Д Д Д Дї / і }
{ / Џ®бвгб«®ўЁҐ: / }
{ / і / і }
{ ЙННННННННННННННПННННННННННННННШНННННННННННННН» }
{ a: є A[k..n) і A[m..k) є }
{ ИННННННННННННННСННННННННННННННШННННННННННННННј }
{ m k s=m+n-k n }
{........................................................}
var p, q: IndexV;
begin {Shift2}
{Pred: (m<k<n) & (a[m..n)=A[m..n)),
Post: (s=m+n-k) & (a[m..s)=A[k..n)) & (a[s..n)=A[m..k)) }

p:=k-m;
q:=n-k;

{bound: max(p,q)}
{inv: б¬.Є авЁ­Єг}
{ m k-p k k+q n }
{ ЪДДДДДДДДДВДДДДДДДДДДДЕДДДДДДДДДДДДДДДВДДДДДДДДДДДДї }
{ a:і“¦Ґ гбв -іЏҐаҐбв ўЁвмі ЏҐаҐбв ўЁвм і “¦Ґ гбв - і & }
{ і­®ў«Ґ­ іб a[k..k+q)і б a[k-p..k) і ­®ў«Ґ­ і }
{ АДДДДДДДДДБДДДДДДДДДДДЕДДДДДДДДДДДДДДДБДДДДДДДДДДДДЩ }
{ & (0<p<=k-m) & (0<q<=n-k) }

while p<>q do
if p>q then begin SwapEq(a, k-p, k, q);
p:=p-q
end
else {p<q}
begin SwapEq(a, k-p, k+q-p, p);
q:=q-p
end;
{end-while}
SwapEq(a, k-p, k, p)

end {Shift2};

{3-© ў аЁ ­в -----------------------------------------------------}
{ ђҐиҐ­ЁҐ ­  ®б­®ўҐ ўбЇ®¬®Ј вҐ«м­®© Їа®жҐ¤гал Reverse ®Ўа йҐ­Ёп }
{ ᥣ¬Ґ­в  ¬ ббЁў  }

procedure Reverse(var a: Vector; m, n: IndexV1);
{Pred: (Low(a)<=m) & (m<n<=High(a)+1) & a[m..n)= A[m..n) }
{Post: (Low(a)<=m) & (m<n<=High(a)+1) & a[m..n)=Rev(A[m..n))}
{ Ј¤Ґ Rev(A[m..n)) = (A[n-1],A[n-2],A[n-3],...,A[m+1],A[m]) }

var k, i: indexV;
j: IndexV1;
mn1: Integer;
b: Elem;
begin {Reverse}
{P([m..i])==(a[m..i]=Rev(A[j..n)) & (a[j..n)=Rev(A[m..i]) &
& (a(i..j)=A(i..j)) & (m<=i<k) & (i+j=m+n-1) & (k=(m+n) div 2)}

k:=(m+n) div 2; mn1:=m+n-1; j:=n;
for i:=m to k-1 do
begin { a[i] <-> a[mn1-i] }
j:=j-1 {j:=mn1-i};
b:=a[i]; a[i]:=a[j]; a[j]:=b
end {for}
end {Reverse};

procedure Shift3 (var a: vector; m, n, k: indexV1);
{ }
{ –ЁЄ«ЁзҐбЄЁ© б¤ўЁЈ ᥣ¬Ґ­в  ¬ ббЁў  Ё«Ё }
{ ЇҐаҐбв ­®ўЄ  ᬥ¦­ле ᥣ¬Ґ­в®ў а §­®© ¤«Ё­л: }
{ }
{ ЏаҐ¤гб«®ўЁҐ: m<k<n }
{ Ќ з «м­®Ґ б®бв®п­ЁҐ: }
{ n-k }
{ k-m ЪДДДДДДДДДДДДДДДБДДДДДДДДДДДДДї }
{ ЪДДДДДДДБДДДДДДї }
{ m k n }
{ ЙННННННННННННННШННННННННННННННННННННННННННННН» }
{ a: є A[m..k) і A[k..n) є }
{ ИННННННННННННННШНННННННННННННННННННННННННННННј }
{ і /А Д Д Д Д Д Д Д Д Д Д Д Д Д Д/ї }
{ / / }
{ і /<ДДДДДДДДДДД(n-k)ДДДДДДДДДДД>/ і }
{ / / }
{ А Д Д /Д Д Д Д Д Д Д Д Д Д Д Дї / і }
{ / Џ®бвгб«®ўЁҐ: / }
{ / і / і }
{ ЙННННННННННННННПННННННННННННННШНННННННННННННН» }
{ a: є A[k..n) і A[m..k) є }
{ ИННННННННННННННСННННННННННННННШННННННННННННННј }
{ m k s=m+n-k n }
{........................................................}
begin {Shift3}
Reverse( a, m, k);
Reverse( a, k, n);
Reverse( a, m, n)
end {Shift3};

procedure Generation (var a: Vector; n: IndexV);
var b, i: IndexV;
begin
{ЈҐ­Ґа жЁп ¬ ббЁў  бЁ¬ў®«®ў}
i:=Ord('a')-1;
for b:=1 to n do
begin a[b]:=Char(i+b); Write(a[b]) end;
WriteLn;
end{Generation};

procedure OutVec (const a: Vector; n: IndexV);
var b: IndexV;
begin
for b:=1 to n do Write(a[b]);
WriteLn;
{WriteLn('--------------------------------------------');}
end{OutVec};

var a: vector;
n, m:IndexV;


begin {main}
n:=50;
m:=15;

{1-© ¬Ґв®¤:}
WriteLn('-----------------1-© ¬Ґв®¤:-----------------');
Generation(a,n);
Shift1(a, n, m);
OutVec(a,n);

{2-© ¬Ґв®¤:}
WriteLn('-----------------2-© ¬Ґв®¤:-----------------');
Generation(a,n);
Shift2(a, 1, n+1, m+1);
OutVec(a,n);

{3-© ¬Ґв®¤:}
WriteLn('-----------------3-© ¬Ґв®¤:-----------------');
Generation(a,n);
Shift3(a, 1, n+1, m+1);
OutVec(a,n);
WriteLn('-------------Љ®­Ґж-¤Ґ¬®­бва жЁЁ-----------');
end.