第２９講　細胞構成法による魔方陣の作成の普遍化△

第５話　素数次でない奇数次魔方陣のコード解説
コード再掲
#include<stdlib.h>
#include<math.h>　//平方根を求める計算のために必要
　　　　　　　・
　　　　　　　・
　　　　　　　・
#pragma endregion
　　 private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {
　　　　　　　　　　　label2->Text=L"";
　　　　　　　　　　　DateTime^ hj=DateTime::Now;
　　　　　　　　　　　n=int::Parse(textBox1->Text);
　　　　　　　　　　　char h=1;
　　　　　　　　　　　if(n<3 || n>14 || n%2==0){　//とりあえず９で動作確認
　　　　　　　　　　　　　label2->Text=L"TextBoxには３以上１１以下の奇数\r\nを入力し再度実行ボタンを\r\n押して下さい。";
　　　　　　　　　　　　　h=0;
　　　　　　　　　　　}
　　　　　　　　　　　s=0;
　　　　　　　　　　　if(n%2==1){
　　　　　　　　　　　　　cn=0;
　　　　　　　　　　　　　h=sh();　　//素数判定　素数なら１が返ってくる
　　　　　　　　　　　}
　　　　　　　　　　　else{
　　　　　　　　　　　　　h=1;　//後に偶数の場合でも使えるように入れてある
　　　　　　　　　　　}
　　　　　　　　　　　if(h==0 && n%2==1){
　　　　　　　　　　　　　kf1(0);
　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(31);
　　　　　　　　　　　　　int i;
　　　　　　　　　　　　　w[25]=n.ToString();w[26]=L"次";w[27]=L"魔";w[28]=L"方";w[29]=L"陣";w[30]=s.ToString();
　　　　　　　　　　　　　for(i=0;i<25;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　DateTime^ ow=DateTime::Now;
　　　　　　　　　　　　　TimeSpan sa=ow->Subtract(*hj);
　　　　　　　　　　　　　w[25]=L"時";w[26]=L"間";w[27]=L"計";w[28]=L"則";w[29]=L"：";w[30]=(sa.TotalSeconds).ToString();
　　　　　　　　　　　　　for(i=0;i<25;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　}
　　　　　　　　　　　/*
　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　s=0;
　　　　　　　　　　　　　if(n%2==1)g1(n);
　　　　　　　　　　　　　if(n%2==0)g2(n);
　　　　　　　　　　　　　syokika();
　　　　　　　　　　　　　cn=0;
　　　　　　　　　　　　　zhy();
　　　　　　　　　　　　　sbs(0);
　　　　　　　　　　　　　sbg(0);
　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(15);
　　　　　　　　　　　　　int i;
　　　　　　　　　　　　　w[9]=(2*n).ToString();w[10]=L"次";w[11]=L"魔";w[12]=L"方";w[13]=L"陣";w[14]=s.ToString();
　　　　　　　　　　　　　for(i=0;i<8;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　DateTime^ ow=DateTime::Now;
　　　　　　　　　　　　　TimeSpan sa=ow->Subtract(*hj);
　　　　　　　　　　　　　w[9]=L"時";w[10]=L"間";w[11]=L"計";w[12]=L"則";w[13]=L"：";w[14]=(sa.TotalSeconds).ToString();
　　　　　　　　　　　　　for(i=0;i<9;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　}
　　　　　　　　　　　*/
　　　　　　　　　}
　　　　　　　　　char sh(){　//素数判定
　　　　　　　　　　　double k;
　　　　　　　　　　　k=sqrt((double)n);
　　　　　　　　　　　char i;
　　　　　　　　　　　for(i=3;i<=k;i+=2){
　　　　　　　　　　　　　if(n%i==0)return(0);
　　　　　　　　　　　}
　　　　　　　　　　　return(1);
　　　　　　　　　}
　　　　　　　　　void kf1(int g){　//素数でない奇数の種1作り
　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　if(g==0){
　　　　　　　　　　　　　a1[0][0]=n/2+1;
　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　}
　　　　　　　　　　　char i,j,h,k,kk,kkk,l;
　　　　　　　　　　　if(g>0){
　　　　　　　　　　　　　kk=rand()%n;
　　　　　　　　　　　　　for(i=1;i<n+1;i++){
　　　　　　　　　　　　　　　kkk=((kk+i-1)%n)+1;
　　　　　　　　　　　　　　　a1[0][g]=kkk;
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　if(a1[0][g]==a1[0][j]){
　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　kf2(0);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　}
　　　　　　　　　　　}
　　　　　　　　　}
　　　　　　　　　void kf2(int g){　//素数でない奇数の種2作り
　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　if(g==0){
　　　　　　　　　　　　　a2[0][n-1]=n/2+1;
　　　　　　　　　　　　　kf2(g+1);
　　　　　　　　　　　}
　　　　　　　　　　　char i,j,h,k,kk,kkk,l;
　　　　　　　　　　　if(g>0){
　　　　　　　　　　　　　kk=rand()%n;
　　　　　　　　　　　　　for(i=1;i<n+1;i++){
　　　　　　　　　　　　　　　kkk=((kk+i-1)%n)+1;
　　　　　　　　　　　　　　　a2[0][n-1-g]=kkk;
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　if(a2[0][n-1-g]==a2[0][n-1-j]){
　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　kf2(g+1);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　l=((n-1)*j+k)%n;
　　　　　　　　　　　　　　　　　　　　　a2[j][l]=a2[0][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　mah[j][k]=n*(a1[j][k]-1)+a2[j][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(30);
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　w[k]=(mah[j][k]).ToString();
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　for(j=0;j<30;j++)w[j]=L"";
　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　s++;
　　　　　　　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　}
　　　　　　　　　　　}
　　　　　　　　　}
　　　　　　　}
　　　　　　　　　　　　　　　・
　　　　　　　　　　　　　　　・
　　　　　　　　　　　　　　　・
解説
#include<math.h>　//平方根を求める計算のために必要
は、素数判定関数sh()において、sqrt()を使うために入れてあります。
素数判定関数sh()の()内が空欄になっているのは、nはグローバル変数になっていて渡す必要がないからです。
もし、nがローカル変数の場合は値をsh(n)として引き渡す必要があります。
もちろんその場合は、char sh(int n)としなければなりません。
nが素数であるかどうかは、nの平方根以下の奇数で割っていけば判定できます。
if(h==0 && n%2==1)によって偶数の場合は除かれているからです。
偶数の可能性がある場合には、２で割って余りが出ることを確認しなければなりませんが。
例えば、２５なら５以下の奇数３，５で割り切れないことを確認すればよいのです。
５の２乗は２５ですから、それより大きい数では割りきれません。

　　　　　　　　　　　if(h==0 && n%2==1){
　　　　　　　　　　　　　kf1(0);
　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(31);
　　　　　　　　　　　　　int i;
　　　　　　　　　　　　　w[25]=n.ToString();w[26]=L"次";w[27]=L"魔";w[28]=L"方";w[29]=L"陣";w[30]=s.ToString();
　　　　　　　　　　　　　for(i=0;i<25;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　DateTime^ ow=DateTime::Now;
　　　　　　　　　　　　　TimeSpan sa=ow->Subtract(*hj);
　　　　　　　　　　　　　w[25]=L"時";w[26]=L"間";w[27]=L"計";w[28]=L"則";w[29]=L"：";w[30]=(sa.TotalSeconds).ToString();
　　　　　　　　　　　　　for(i=0;i<25;i++)w[i]=L"";
　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　}
は列数が増えたための変更です。

　　　　　　　　　char sh(){　//素数判定
　　　　　　　　　　　double k;
　　　　　　　　　　　k=sqrt((double)n);
　　　　　　　　　　　char i;
　　　　　　　　　　　for(i=3;i<=k;i+=2){
　　　　　　　　　　　　　if(n%i==0)return(0);
　　　　　　　　　　　}
　　　　　　　　　　　return(1);
　　　　　　　　　}
についてはすでに説明してあります。
nの平方根以下で割って、割り切れると素数でなく、すべて余りが出る場合は素数です。
割り切れてしまった場合は、もうそれ以上ループ処理をする必要がないのでreturn(0);としています。
これもループを強制的にやめる方法のひとつです。
(double)nはsqrt()に入れることが出来る数は、double型に決まっているからです。
int型を強制的にdouble型に変更しています。

　　　　　　　　　void kf1(int g){　//素数でない奇数の種1作り
　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　if(g==0){
　　　　　　　　　　　　　a1[0][0]=n/2+1;
　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　}
　　　　　　　　　　　char i,j,h,k,kk,kkk,l;
　　　　　　　　　　　if(g>0){
　　　　　　　　　　　　　kk=rand()%n;
　　　　　　　　　　　　　for(i=1;i<n+1;i++){
　　　　　　　　　　　　　　　kkk=((kk+i-1)%n)+1;
　　　　　　　　　　　　　　　a1[0][g]=kkk;
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　if(a1[0][g]==a1[0][j]){
　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　kf2(0);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　}
　　　　　　　　　　　}
　　　　　　　　　}
のおいては、種の１番目の作成を行っています。
奇数次魔方陣種の制約によって、順列の最初は真ん中の数字と決まっていますので、
　　　　　　　　　　　if(g==0){
　　　　　　　　　　　　　a1[0][0]=n/2+1;
　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　}
となっています。kf1(g+1);を忘れると、セル番号０のみを埋めて関数は終わってしまいます。
kf1(g+1);によって、次の入れ子式人形の世界＝セル番号１の世界に進みます。
セル番号１以降は、
　　　　　　　　　　　if(g>0){
　　　　　　　　　　　　　kk=rand()%n;
　　　　　　　　　　　　　for(i=1;i<n+1;i++){
　　　　　　　　　　　　　　　kkk=((kk+i-1)%n)+1;
　　　　　　　　　　　　　　　a1[0][g]=kkk;
１からnまでの数字をランダムに入れていきます。
kkk=((kk+i-1)%n)+1;はkkが何であっても、１からnの場合をすべて網羅します。
真ん中の数字は、セル番号１以降は入れられませんが、その可能性は後のｉｆ文で排除しています。
例えば、n=9でkk=5（kkはランダム発生した整数を９で割った余りなので９未満の整数です)の場合でトレースすると
ｉ＝１のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋１－１）％９）＋１＝（５％９）＋１＝５＋１＝６
ｉ＝２のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋２－１）％９）＋１＝（６％９）＋１＝６＋１＝７
ｉ＝３のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋３－１）％９）＋１＝（７％９）＋１＝７＋１＝８
ｉ＝４のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋４－１）％９）＋１＝（８％９）＋１＝８＋１＝９
ｉ＝５のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋５－１）％９）＋１＝（９％９）＋１＝０＋１＝１
ｉ＝６のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋６－１）％９）＋１＝（１０％９）＋１＝１＋１＝２
ｉ＝７のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋７－１）％９）＋１＝（１１％９）＋１＝２＋１＝３
ｉ＝８のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋８－１）％９）＋１＝（１２％９）＋１＝３＋１＝４
ｉ＝９のとき、
ｋｋｋ＝（（ｋｋ＋ｉ－１）％ｎ）＋１＝（（５＋９－１）％９）＋１＝（１３％９）＋１＝４＋１＝５
どうです。見事に６，７，８，９，１，２，３，４，５すべてが網羅されていますね。
その他いかなる場合でトレースしても必ず漏れなくすべての整数が現れることを確認して下さい。
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　if(a1[0][g]==a1[0][j]){
　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
は、前のセルと同じ数字が入っていないかチェックしています。
同じ数字が発見されるとｈは０となり
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　kf2(0);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
は実行されず、ｉは次へとループされます。
このｉｆ文において真ん中の数字も排除されていることがわかります。
なぜなら、

となった時点でチェックされｉはインクリメントされ

となるからです。
一番最初にセル番号０に５が入れられているので、
前のセルとの重複チェックにおいて自動的に真ん中の数字の可能性が排除されるのです。
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　　　kf1(g+1);
　　　　　　　　　　　　　　　　　}
は、セル番号の最後に来るまで実行されます。
つまり、入れ子式の人形の一番内側の人形に達するまで跳躍が続けられます。

最後のセルに達すると、もっとも奥にある本当の自分の姿を見いだし、自分探しの旅は終わりを告げ、
　　　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　kf2(0);
　　　　　　　　　　　　　　　　　}
の命令が遂行されます。
さて、
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
では何をしているのでしょうか。

実は、1行目の順列を１ずらして1個目の種を完成させています。
トレースをして確認してみましょう。
　　　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　　　l=(j+k)%n;
　　　　　　　　　　　　　　　　　　　　　　　a1[j][l]=a1[0][k];
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　}
Ⅰ　ｊ＝１の場合
　ⅰ　ｋ＝０のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋０）％９＝１％９＝１より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［１］＝ａ１［０］［０］となり、
　　　　ａ１［１］［１］には５がはいります。
　ⅱ　ｋ＝１のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋１）％９＝１％９＝２より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［２］＝ａ１［０］［１］となり、
　　　　ａ１［１］［２］には３がはいります。
　ⅲ　ｋ＝２のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋２）％９＝３％９＝３より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［３］＝ａ１［０］［２］となり、
　　　　ａ１［１］［３］には６がはいります。
　ⅳ　ｋ＝３のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋３）％９＝４％９＝４より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［４］＝ａ１［０］［３］となり、
　　　　ａ１［１］［４］には１がはいります。
　ⅴ　ｋ＝４のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋４）％９＝５％９＝５より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［５］＝ａ１［０］［４］となり、
　　　　ａ１［１］［５］には４がはいります。
　ⅵ　ｋ＝５のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋５）％９＝６％９＝６より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［６］＝ａ１［０］［５］となり、
　　　　ａ１［１］［６］には９がはいります。
　ⅶ　ｋ＝６のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋６）％９＝７％９＝７より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［７］＝ａ１［０］［６］となり、
　　　　ａ１［１］［７］には２がはいります。
　ⅷ　ｋ＝７のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋７）％９＝８％９＝８より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［８］＝ａ１［０］［７］となり、
　　　　ａ１［１］［８］には７がはいります。
　ⅸ　ｋ＝８のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（１＋８）％９＝９％９＝０より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［１］［０］＝ａ１［０］［８］となり、
　　　　ａ１［１］［０］には８がはいります。

Ⅱ　ｊ＝２の場合
　ⅰ　ｋ＝０のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋０）％９＝２％９＝２より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［２］＝ａ１［０］［０］となり、
　　　　ａ１［２］［２］には５がはいります。
　ⅱ　ｋ＝１のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋１）％９＝３％９＝３より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［３］＝ａ１［０］［１］となり、
　　　　ａ１［２］［３］には３がはいります。
　ⅲ　ｋ＝２のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋２）％９＝４％９＝４より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［４］＝ａ１［０］［２］となり、
　　　　ａ１［２］［４］には６がはいります。
　ⅳ　ｋ＝３のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋３）％９＝５％９＝５より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［５］＝ａ１［０］［３］となり、
　　　　ａ１［２］［５］には１がはいります。
　ⅴ　ｋ＝４のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋４）％９＝６％９＝６より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［６］＝ａ１［０］［４］となり、
　　　　ａ１［２］［６］には４がはいります。
　ⅵ　ｋ＝５のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋５）％９＝７％９＝７より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［７］＝ａ１［０］［５］となり、
　　　　ａ１［２］［７］には９がはいります。
　ⅶ　ｋ＝６のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋６）％９＝８％９＝８より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［８］＝ａ１［０］［６］となり、
　　　　ａ１［２］［８］には２がはいります。
　ⅷ　ｋ＝７のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋７）％９＝９％９＝０より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［０］＝ａ１［０］［７］となり、
　　　　ａ１［２］［０］には７がはいります。
　ⅸ　ｋ＝８のとき、
　　　　ｌ＝（ｊ＋ｋ）％ｎ＝（２＋８）％９＝１０％９＝１より
　　　　ａ１［ｊ］［ｌ］＝ａ１［０］［ｋ］は、ａ１［２］［１］＝ａ１［０］［８］となり、
　　　　ａ１［２］［１］には８がはいります。
以下トレースはご自分で確認して下さい。

最後の
　　　　　　　　　void kf2(int g){　//素数でない奇数の種2作り
　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　if(g==0){
　　　　　　　　　　　　　a2[0][n-1]=n/2+1;
　　　　　　　　　　　　　kf2(g+1);
　　　　　　　　　　　}
　　　　　　　　　　　char i,j,h,k,kk,kkk,l;
　　　　　　　　　　　if(g>0){
　　　　　　　　　　　　　kk=rand()%n;
　　　　　　　　　　　　　for(i=1;i<n+1;i++){
　　　　　　　　　　　　　　　kkk=((kk+i-1)%n)+1;
　　　　　　　　　　　　　　　a2[0][n-1-g]=kkk;
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　if(a2[0][n-1-g]==a2[0][n-1-j]){
　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　if(g+1<n){
　　　　　　　　　　　　　　　　　kf2(g+1);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　else{
　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　l=((n-1)*j+k)%n;
　　　　　　　　　　　　　　　　　　　　　a2[j][l]=a2[0][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　mah[j][k]=n*(a1[j][k]-1)+a2[j][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(30);
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　w[k]=(mah[j][k]).ToString();
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　for(j=0;j<30;j++)w[j]=L"";
　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　s++;
　　　　　　　　　　　　　　　　　if(s==10)return;
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　}
　　　　　　　　　　　}
　　　　　　　　　}
　　　　　　　}
については、種１作りとほとんど同じです。違う点は３点あります。
まず、１点目は、a2[0][n-1-g]=kkk;をごらんになればお分かりのようにセルを逆順で埋めていることです。
つまり最初にセル番号ｎ－１番目に数字を入れ、次にｎ－２番目という風に入れています。
これは、最後のセルが真ん中の数字に決まっているので、そこと重複しないようにするためです。
もし、正順で入れていくとなるといちいち最後のセルとの重複チェックをしなければなりません。
つまり、
　　　　　　　　　　　　　　　h=1;
　　　　　　　　　　　　　　　if(a2[0][g]==a2[0][n-1])h=0;
　　　　　　　　　　　　　　　if(h==1){
　　　　　　　　　　　　　　　　　for(j=0;j<g;j++){
　　　　　　　　　　　　　　　　　　　if(a2[0][g]==a2[0][j]){
　　　　　　　　　　　　　　　　　　　　　h=0;
　　　　　　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
としなければならないことになって余計な手間がかかります。
２点目は、
　　　　　　　　　　　　　　　　　for(j=1;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　l=((n-1)*j+k)%n;
　　　　　　　　　　　　　　　　　　　　　a2[j][l]=a2[0][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
におけるずらし方の違いです。ｎ－１ずらし（ｎ＝９なら８ずらし）は逆１ずらしに相当することを下表からご確認ください。

トレースは種１の場合を参考にご自分でなさってください。
３点目は、
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　mah[j][k]=n*(a1[j][k]-1)+a2[j][k];
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　array<String^>^ w=gcnew array<String^>(30);
　　　　　　　　　　　　　　　　　for(j=0;j<n;j++){
　　　　　　　　　　　　　　　　　　　for(k=0;k<n;k++){
　　　　　　　　　　　　　　　　　　　　　w[k]=(mah[j][k]).ToString();
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　for(j=0;j<30;j++)w[j]=L"";
　　　　　　　　　　　　　　　　　dataGridView1->Rows->Add(w);
　　　　　　　　　　　　　　　　　s++;
　　　　　　　　　　　　　　　　　if(s==10)return;
です。これは種の合体による魔方陣の作成と表示を行っています。



第４話へ 第６話へ

VC++講義第１部へ
vb講義へ
ＶＢ講義基礎へ
初心者のための世界で一番わかりやすいVisual C++入門基礎講座
初心者のための世界で一番わかりやすいVisual Basic入門基礎講座
初心者のための世界で一番わかりやすいVBA入門講義（基礎から応用まで）