Recent

Author Topic: need help with calender  (Read 49591 times)

rvk

  • Hero Member
  • *****
  • Posts: 6056
Re: need help with calender
« Reply #180 on: September 25, 2017, 02:09:05 pm »
instead of while
You mean on line 3 in this post?

How would you make that line then?
Remember what while does and what if does.

Also, please write out in English for us what that line is supposed to do.

molly

  • Hero Member
  • *****
  • Posts: 2330
Re: need help with calender
« Reply #181 on: September 25, 2017, 02:14:35 pm »
instead of while
In addition to rvk's answer, did you had a good look at my animated picture here ?

Do you see the red value (the number 8 is the best example), and then the other values in the array turning green ? that is when the value of the number 8 is checked against the value in that current position in the array. It determines where the number should be inserted into the array, and that is what the while loop does: to determine the correct array index for insertion.

rvk

  • Hero Member
  • *****
  • Posts: 6056
Re: need help with calender
« Reply #182 on: September 25, 2017, 02:29:04 pm »
instead of while
In addition to rvk's answer, did you had a good look at my animated picture here ?
Yeah, that's a nice visualization  8-)

There the search for where to insert the number is done like this:
Code: Text  [Select][+][-]
  1. mark first element as sorted
  2. for each unsorted element X
  3.   'extract' the element X
  4.   for j = lastSortedIndex down to 0
  5.     if current element j > X
  6.       move sorted element to the right by 1
  7.     break loop and insert X here
  8.  
We/I did it previously with a while loop
Code: Text  [Select][+][-]
  1. mark first element as sorted
  2. for each unsorted element X
  3.   'extract' the element X
  4.   j := 1; while current element j < X increase j
  5.   (j marks the spot) move ALL elements from j to spot of X to the right by 1
  6.   insert X on j
In that case there was no break needed.

(Then if you get the question why "while" was needed above "if" on line 4, I'm starting to question my teaching methods  %) )
« Last Edit: September 25, 2017, 02:30:42 pm by rvk »

molly

  • Hero Member
  • *****
  • Posts: 2330
Re: need help with calender
« Reply #183 on: September 25, 2017, 03:31:40 pm »
Yeah, that's a nice visualization  8-)
Thanks.

I was looking for something that was able to show more visually that there actually is something done between getting a value from the array and ending up at the insert location. Your explanantions matched that perfectly (no matter the implementation).

Quote
(Then if you get the question why "while" was needed above "if" on line 4, I'm starting to question my teaching methods  %) )
Please don't doubt yourself. You're doing a splendid job (with the patience of an angel), and there is something to say for being able to match clear explanation with simple implementation. There is usually always room for improvement, taking another approach or using shortcuts.

molly

  • Hero Member
  • *****
  • Posts: 2330
Re: need help with calender
« Reply #184 on: September 25, 2017, 03:50:18 pm »
As promised, and to be able to show TS that his 'sorting code' was a very good first attempt even though by default it will not end up as an insertion sort.

TS started out with the following:
Code: Pascal  [Select][+][-]
  1. program Step0;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. uses
  6.   SysUtils;
  7.  
  8. var
  9.   rank : array[1..10] of integer;
  10.   i : integer;
  11.  
  12. begin
  13.   // randomize;
  14.   for i:=1 to 10 do
  15.   begin
  16.     rank[i]:=random(500);
  17.   end;
  18.  
  19.   for i:= 2-1 downto 1 do
  20.   begin
  21.    if rank[2] < rank[i] then
  22.     rank[i+1]:=rank[i];
  23.    if rank[2]> rank[i] then
  24.     rank[i+1]:=rank[2];
  25.   end;
  26.  
  27.   for i:= 3-1 downto 1 do
  28.   begin
  29.    if rank[3] < rank[i] then
  30.     rank[i+1]:=rank[i];
  31.    if rank[3]> rank[i] then
  32.     rank[i+1]:=rank[3];
  33.   end;
  34.  
  35.   for i:= 4-1 downto 1 do
  36.   begin
  37.    if rank[4] < rank[i] then
  38.     rank[i+1]:=rank[i];
  39.    if rank[4]> rank[i] then
  40.     rank[i+1]:=rank[4];
  41.   end;
  42.  
  43.   for i:= 5-1 downto 1 do
  44.   begin
  45.    if rank[5] < rank[i] then
  46.     rank[i+1]:=rank[i];
  47.    if rank[5]> rank[i] then
  48.     rank[i+1]:=rank[5];
  49.   end;
  50.  
  51.   for i:=1 to 10 do
  52.    begin
  53.     writeln(inttostr(rank[i]));
  54.    end;      
  55. end.
  56.  

Which produced the following output:
Code: [Select]
274  422  422  422  422  428  272  423  211  311


Step 1:
- Introduce Iter variable to get rid of some hard-coded values
- add missing iterations

Code: Pascal  [Select][+][-]
  1. program Step1;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. uses
  6.   SysUtils;
  7.  
  8. var
  9.   rank : array[1..10] of integer;
  10.   i : integer;
  11.   iter: integer;
  12. begin
  13.   // randomize;
  14.   for i:=1 to 10 do
  15.   begin
  16.     rank[i]:=random(500);
  17.   end;
  18.  
  19.   Iter := 2;
  20.   for i:= Iter-1 downto 1 do
  21.   begin
  22.    if rank[Iter] < rank[i] then
  23.     rank[i+1]:=rank[i];
  24.    if rank[Iter]> rank[i] then
  25.     rank[i+1]:=rank[Iter];
  26.   end;
  27.  
  28.   inc(Iter);
  29.   for i:= Iter-1 downto 1 do
  30.   begin
  31.    if rank[Iter] < rank[i] then
  32.     rank[i+1]:=rank[i];
  33.    if rank[Iter]> rank[i] then
  34.     rank[i+1]:=rank[Iter];
  35.   end;
  36.  
  37.   inc(Iter);
  38.   for i:= Iter-1 downto 1 do
  39.   begin
  40.    if rank[Iter] < rank[i] then
  41.     rank[i+1]:=rank[i];
  42.    if rank[Iter]> rank[i] then
  43.     rank[i+1]:=rank[Iter];
  44.   end;
  45.  
  46.   inc(Iter);
  47.   for i:= Iter-1 downto 1 do
  48.   begin
  49.    if rank[Iter] < rank[i] then
  50.     rank[i+1]:=rank[i];
  51.    if rank[Iter]> rank[i] then
  52.     rank[i+1]:=rank[Iter];
  53.   end;
  54.  
  55.   inc(Iter);
  56.   for i:= Iter-1 downto 1 do
  57.   begin
  58.    if rank[Iter] < rank[i] then
  59.     rank[i+1]:=rank[i];
  60.    if rank[Iter]> rank[i] then
  61.     rank[i+1]:=rank[Iter];
  62.   end;
  63.  
  64.   inc(Iter);
  65.   for i:= Iter-1 downto 1 do
  66.   begin
  67.    if rank[Iter] < rank[i] then
  68.     rank[i+1]:=rank[i];
  69.    if rank[Iter]> rank[i] then
  70.     rank[i+1]:=rank[Iter];
  71.   end;
  72.  
  73.   inc(Iter);
  74.   for i:= Iter-1 downto 1 do
  75.   begin
  76.    if rank[Iter] < rank[i] then
  77.     rank[i+1]:=rank[i];
  78.    if rank[Iter]> rank[i] then
  79.     rank[i+1]:=rank[Iter];
  80.   end;
  81.  
  82.   inc(Iter);
  83.   for i:= Iter-1 downto 1 do
  84.   begin
  85.    if rank[Iter] < rank[i] then
  86.     rank[i+1]:=rank[i];
  87.    if rank[Iter]> rank[i] then
  88.     rank[i+1]:=rank[Iter];
  89.   end;
  90.  
  91.   inc(Iter);
  92.   for i:= Iter-1 downto 1 do
  93.   begin
  94.    if rank[Iter] < rank[i] then
  95.     rank[i+1]:=rank[i];
  96.    if rank[Iter]> rank[i] then
  97.     rank[i+1]:=rank[Iter];
  98.   end;
  99.  
  100.  
  101.   for i:=1 to 10 do
  102.    begin
  103.     writeln(inttostr(rank[i]));
  104.    end;      
  105. end.
  106.  

Which outputs:
Code: [Select]
274  428  428  428  428  428  428  428  428  428


Step 2:
- add a sub-routine that displays the values from the rank array and call this routine in our main program when it's useful

Code: Pascal  [Select][+][-]
  1. program Step2;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. procedure DisplayRanks(ranks: array of integer);
  6. const
  7.   iteration : integer = 0;
  8. var
  9.   rankindex : integer;
  10. begin
  11.   Write(iteration, '  :  ');
  12.   for rankindex:=Low(ranks) to High(ranks) do
  13.   begin
  14.     write(ranks[rankindex], '  ');
  15.   end;
  16.   WriteLn;
  17.   inc(Iteration);
  18. end;
  19.  
  20.  
  21. var
  22.   rank : array[1..10] of integer;
  23.   i : integer;
  24.   iter: integer;
  25. begin
  26.   // randomize;
  27.   for i:=1 to 10 do
  28.   begin
  29.     rank[i]:=random(500);
  30.   end;
  31.   DisplayRanks(rank);
  32.  
  33.   Iter := 2;
  34.   for i:= Iter-1 downto 1 do
  35.   begin
  36.    if rank[Iter] < rank[i] then
  37.     rank[i+1]:=rank[i];
  38.    if rank[Iter]> rank[i] then
  39.     rank[i+1]:=rank[Iter];
  40.   end;
  41.   DisplayRanks(rank);
  42.  
  43.   inc(Iter);
  44.   for i:= Iter-1 downto 1 do
  45.   begin
  46.    if rank[Iter] < rank[i] then
  47.     rank[i+1]:=rank[i];
  48.    if rank[Iter]> rank[i] then
  49.     rank[i+1]:=rank[Iter];
  50.   end;
  51.   DisplayRanks(rank);
  52.  
  53.   inc(Iter);
  54.   for i:= Iter-1 downto 1 do
  55.   begin
  56.    if rank[Iter] < rank[i] then
  57.     rank[i+1]:=rank[i];
  58.    if rank[Iter]> rank[i] then
  59.     rank[i+1]:=rank[Iter];
  60.   end;
  61.   DisplayRanks(rank);
  62.  
  63.   inc(Iter);
  64.   for i:= Iter-1 downto 1 do
  65.   begin
  66.    if rank[Iter] < rank[i] then
  67.     rank[i+1]:=rank[i];
  68.    if rank[Iter]> rank[i] then
  69.     rank[i+1]:=rank[Iter];
  70.   end;
  71.   DisplayRanks(rank);
  72.  
  73.   inc(Iter);
  74.   for i:= Iter-1 downto 1 do
  75.   begin
  76.    if rank[Iter] < rank[i] then
  77.     rank[i+1]:=rank[i];
  78.    if rank[Iter]> rank[i] then
  79.     rank[i+1]:=rank[Iter];
  80.   end;
  81.   DisplayRanks(rank);
  82.  
  83.   inc(Iter);
  84.   for i:= Iter-1 downto 1 do
  85.   begin
  86.    if rank[Iter] < rank[i] then
  87.     rank[i+1]:=rank[i];
  88.    if rank[Iter]> rank[i] then
  89.     rank[i+1]:=rank[Iter];
  90.   end;
  91.   DisplayRanks(rank);
  92.  
  93.   inc(Iter);
  94.   for i:= Iter-1 downto 1 do
  95.   begin
  96.    if rank[Iter] < rank[i] then
  97.     rank[i+1]:=rank[i];
  98.    if rank[Iter]> rank[i] then
  99.     rank[i+1]:=rank[Iter];
  100.   end;
  101.   DisplayRanks(rank);
  102.  
  103.   inc(Iter);
  104.   for i:= Iter-1 downto 1 do
  105.   begin
  106.    if rank[Iter] < rank[i] then
  107.     rank[i+1]:=rank[i];
  108.    if rank[Iter]> rank[i] then
  109.     rank[i+1]:=rank[Iter];
  110.   end;
  111.   DisplayRanks(rank);
  112.  
  113.   inc(Iter);
  114.   for i:= Iter-1 downto 1 do
  115.   begin
  116.    if rank[Iter] < rank[i] then
  117.     rank[i+1]:=rank[i];
  118.    if rank[Iter]> rank[i] then
  119.     rank[i+1]:=rank[Iter];
  120.   end;
  121.   DisplayRanks(rank);
  122. end.
  123.  

Which outputs:
Code: [Select]
0  :  274  296  357  422  301  428  272  423  211  311
1  :  274  296  357  422  301  428  272  423  211  311
2  :  274  357  357  422  301  428  272  423  211  311
3  :  274  422  422  422  301  428  272  423  211  311
4  :  274  422  422  422  422  428  272  423  211  311
5  :  274  428  428  428  428  428  272  423  211  311
6  :  274  428  428  428  428  428  428  423  211  311
7  :  274  428  428  428  428  428  428  428  211  311
8  :  274  428  428  428  428  428  428  428  428  311
9  :  274  428  428  428  428  428  428  428  428  428


Step 3:
- add a swaprank sub-routines that swaps two values using the provided indexes in the array (!!).
- Use the new Swaprank routine: That also means we also have to get rid of the unnecessary checks

Code: Pascal  [Select][+][-]
  1. program Step3;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. procedure DisplayRanks(ranks: array of integer);
  6. const
  7.   iteration : integer = 0;
  8. var
  9.   rankindex : integer;
  10. begin
  11.   Write(iteration, '  :  ');
  12.   for rankindex:=Low(ranks) to High(ranks) do
  13.   begin
  14.     write(ranks[rankindex], '  ');
  15.   end;
  16.   WriteLn;
  17.   inc(Iteration);
  18. end;
  19.  
  20.  
  21. procedure SwapRank(var ranks: array of integer; index1, index2: integer);
  22. var
  23.   TempSwapBuffer : integer;
  24. begin
  25.   // note: account for zero indexed array
  26.   TempSwapBuffer      := ranks[Pred(index1)];
  27.   ranks[Pred(index1)] := ranks[Pred(index2)];
  28.   ranks[Pred(index2)] := TempSwapBuffer;
  29.   WriteLn('swap rank[',index1,'] with rank[',index2,']');
  30. end;
  31.  
  32.  
  33. var
  34.   rank : array[1..10] of integer;
  35.   i : integer;
  36.   iter: integer;
  37. begin
  38.   // randomize;
  39.   for i:=1 to 10 do
  40.   begin
  41.     rank[i]:=random(500);
  42.   end;
  43.   DisplayRanks(rank);
  44.  
  45.   Iter := 2;
  46.   for i:= Iter-1 downto 1 do
  47.   begin
  48.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  49.   end;
  50.   DisplayRanks(rank);
  51.  
  52.   inc(Iter);
  53.   for i:= Iter-1 downto 1 do
  54.   begin
  55.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  56.   end;
  57.   DisplayRanks(rank);
  58.  
  59.   inc(Iter);
  60.   for i:= Iter-1 downto 1 do
  61.   begin
  62.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  63.   end;
  64.   DisplayRanks(rank);
  65.  
  66.   inc(Iter);
  67.   for i:= Iter-1 downto 1 do
  68.   begin
  69.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  70.   end;
  71.   DisplayRanks(rank);
  72.  
  73.   inc(Iter);
  74.   for i:= Iter-1 downto 1 do
  75.   begin
  76.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  77.   end;
  78.   DisplayRanks(rank);
  79.  
  80.   inc(Iter);
  81.   for i:= Iter-1 downto 1 do
  82.   begin
  83.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  84.   end;
  85.   DisplayRanks(rank);
  86.  
  87.   inc(Iter);
  88.   for i:= Iter-1 downto 1 do
  89.   begin
  90.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  91.   end;
  92.   DisplayRanks(rank);
  93.  
  94.   inc(Iter);
  95.   for i:= Iter-1 downto 1 do
  96.   begin
  97.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  98.   end;
  99.   DisplayRanks(rank);
  100.  
  101.   inc(Iter);
  102.   for i:= Iter-1 downto 1 do
  103.   begin
  104.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  105.   end;
  106.   DisplayRanks(rank);
  107. end.
  108.  

which outputs:
Code: [Select]
0  :  274  296  357  422  301  428  272  423  211  311
1  :  274  296  357  422  301  428  272  423  211  311
2  :  274  296  357  422  301  428  272  423  211  311
3  :  274  296  357  422  301  428  272  423  211  311
swap rank[5] with rank[4]
4  :  274  296  357  301  422  428  272  423  211  311
5  :  274  296  357  301  422  428  272  423  211  311
swap rank[7] with rank[6]
6  :  274  296  357  301  422  272  428  423  211  311
swap rank[8] with rank[7]
7  :  274  296  357  301  422  272  423  428  211  311
swap rank[9] with rank[8]
8  :  274  296  357  301  422  272  423  211  428  311
swap rank[10] with rank[9]
9  :  274  296  357  301  422  272  423  211  311  428


Step 4:
- Still something wrong with the sorting. We Iterate from narrow to wide while it should be from wide to narrow. We fix that.

Code: Pascal  [Select][+][-]
  1. program Step4;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. procedure DisplayRanks(ranks: array of integer);
  6. const
  7.   iteration : integer = 0;
  8. var
  9.   rankindex : integer;
  10. begin
  11.   Write(iteration, '  :  ');
  12.   for rankindex:=Low(ranks) to High(ranks) do
  13.   begin
  14.     write(ranks[rankindex], '  ');
  15.   end;
  16.   WriteLn;
  17.   inc(Iteration);
  18. end;
  19.  
  20.  
  21. procedure SwapRank(var ranks: array of integer; index1, index2: integer);
  22. var
  23.   TempSwapBuffer : integer;
  24. begin
  25.   // note: account for zero indexed array
  26.   TempSwapBuffer      := ranks[Pred(index1)];
  27.   ranks[Pred(index1)] := ranks[Pred(index2)];
  28.   ranks[Pred(index2)] := TempSwapBuffer;
  29.   WriteLn('swap rank[',index1,'] with rank[',index2,']');
  30. end;
  31.  
  32.  
  33. var
  34.   rank : array[1..10] of integer;
  35.   i : integer;
  36.   iter: integer;
  37. begin
  38.   // randomize;
  39.   for i:=1 to 10 do
  40.   begin
  41.     rank[i]:=random(500);
  42.   end;
  43.   DisplayRanks(rank);
  44.  
  45.   Iter := 10;
  46.   for i:= Iter-1 downto 1 do
  47.   begin
  48.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  49.   end;
  50.   DisplayRanks(rank);
  51.  
  52.   dec(Iter);
  53.   for i:= Iter-1 downto 1 do
  54.   begin
  55.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  56.   end;
  57.   DisplayRanks(rank);
  58.  
  59.   dec(Iter);
  60.   for i:= Iter-1 downto 1 do
  61.   begin
  62.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  63.   end;
  64.   DisplayRanks(rank);
  65.  
  66.   dec(Iter);
  67.   for i:= Iter-1 downto 1 do
  68.   begin
  69.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  70.   end;
  71.   DisplayRanks(rank);
  72.  
  73.   dec(Iter);
  74.   for i:= Iter-1 downto 1 do
  75.   begin
  76.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  77.   end;
  78.   DisplayRanks(rank);
  79.  
  80.   dec(Iter);
  81.   for i:= Iter-1 downto 1 do
  82.   begin
  83.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  84.   end;
  85.   DisplayRanks(rank);
  86.  
  87.   dec(Iter);
  88.   for i:= Iter-1 downto 1 do
  89.   begin
  90.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  91.   end;
  92.   DisplayRanks(rank);
  93.  
  94.   dec(Iter);
  95.   for i:= Iter-1 downto 1 do
  96.   begin
  97.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  98.   end;
  99.   DisplayRanks(rank);
  100.  
  101.   dec(Iter);
  102.   for i:= Iter-1 downto 1 do
  103.   begin
  104.    if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  105.   end;
  106.   DisplayRanks(rank);
  107. end.
  108.  

which outputs:
Code: [Select]
0  :  274  296  357  422  301  428  272  423  211  311
swap rank[10] with rank[8]
swap rank[10] with rank[6]
1  :  274  296  357  422  301  423  272  311  211  428
swap rank[9] with rank[8]
swap rank[9] with rank[6]
2  :  274  296  357  422  301  311  272  211  423  428
swap rank[8] with rank[7]
swap rank[8] with rank[6]
swap rank[8] with rank[4]
3  :  274  296  357  311  301  272  211  422  423  428
swap rank[7] with rank[6]
swap rank[7] with rank[5]
swap rank[7] with rank[4]
swap rank[7] with rank[3]
4  :  274  296  311  301  272  211  357  422  423  428
swap rank[6] with rank[5]
swap rank[6] with rank[4]
swap rank[6] with rank[3]
5  :  274  296  301  272  211  311  357  422  423  428
swap rank[5] with rank[4]
swap rank[5] with rank[3]
6  :  274  296  272  211  301  311  357  422  423  428
swap rank[4] with rank[3]
swap rank[4] with rank[2]
7  :  274  272  211  296  301  311  357  422  423  428
swap rank[3] with rank[2]
swap rank[3] with rank[1]
8  :  272  211  274  296  301  311  357  422  423  428
swap rank[2] with rank[1]
9  :  211  272  274  296  301  311  357  422  423  428
huh ? wait ? what ? a sorted array ?


Step 5:
- re-organize main iterations into a loop.
- get rid of some other hard-coded values


Code: Pascal  [Select][+][-]
  1. program Step5;
  2.  
  3. {$MODE OBJFPC}{$H+}
  4.  
  5. procedure DisplayRanks(ranks: array of integer);
  6. const
  7.   iteration : integer = 0;
  8. var
  9.   rankindex : integer;
  10. begin
  11.   Write(iteration, '  :  ');
  12.   for rankindex:=Low(ranks) to High(ranks) do
  13.   begin
  14.     Write(ranks[rankindex], '  ');
  15.   end;
  16.   WriteLn;
  17.   inc(Iteration);
  18. end;
  19.  
  20.  
  21. procedure SwapRank(var ranks: array of integer; index1, index2: integer);
  22. var
  23.   TempSwapBuffer : integer;
  24. begin
  25.   // note: account for zero indexed array
  26.   TempSwapBuffer      := ranks[Pred(index1)];
  27.   ranks[Pred(index1)] := ranks[Pred(index2)];
  28.   ranks[Pred(index2)] := TempSwapBuffer;
  29.   WriteLn('swap rank[',index1,'] with rank[',index2,']');
  30. end;
  31.  
  32.  
  33. var
  34.   rank : array[1..10] of integer;
  35.   i : integer;
  36.   iter: integer;
  37. begin
  38.   // randomize;
  39.   for i:=Low(Rank) to High(Rank) do
  40.   begin
  41.     rank[i]:=random(500);
  42.   end;
  43.   DisplayRanks(rank);
  44.  
  45.   for Iter:= High(rank) downto Succ(Low(Rank)) do
  46.   begin
  47.     for i:= Pred(Iter) downto Low(rank) do
  48.     begin
  49.       if rank[Iter] < rank[i] then SwapRank(rank, Iter, i);
  50.     end;
  51.     DisplayRanks(rank);
  52.   end;
  53. end.
  54.  

Which (still) outputs:
Code: [Select]
0  :  274  296  357  422  301  428  272  423  211  311
swap rank[10] with rank[8]
swap rank[10] with rank[6]
1  :  274  296  357  422  301  423  272  311  211  428
swap rank[9] with rank[8]
swap rank[9] with rank[6]
2  :  274  296  357  422  301  311  272  211  423  428
swap rank[8] with rank[7]
swap rank[8] with rank[6]
swap rank[8] with rank[4]
3  :  274  296  357  311  301  272  211  422  423  428
swap rank[7] with rank[6]
swap rank[7] with rank[5]
swap rank[7] with rank[4]
swap rank[7] with rank[3]
4  :  274  296  311  301  272  211  357  422  423  428
swap rank[6] with rank[5]
swap rank[6] with rank[4]
swap rank[6] with rank[3]
5  :  274  296  301  272  211  311  357  422  423  428
swap rank[5] with rank[4]
swap rank[5] with rank[3]
6  :  274  296  272  211  301  311  357  422  423  428
swap rank[4] with rank[3]
swap rank[4] with rank[2]
7  :  274  272  211  296  301  311  357  422  423  428
swap rank[3] with rank[2]
swap rank[3] with rank[1]
8  :  272  211  274  296  301  311  357  422  423  428
swap rank[2] with rank[1]
9  :  211  272  274  296  301  311  357  422  423  428

Not very interesting, unless you are TS i guess  :D

 

TinyPortal © 2005-2018