int a[2][2][2] =

{

	{

		{ 0, 0 },

		{ 0, 0 }

	},

	{

		{ 0, 0 },

		{ 0, 0 }

	}

};

あと補足ですが、これでは{}の数が合っていないので、ただの二次元配列"a[8][2]"です

-----------------------------------------------------------------------------

int a[2][2][2] = { 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

{ 0,0 }, 

}; 

-----------------------------------------------------------------------------



要素を全部書く場合は、配列の一番左の値から順に書いていけば大丈夫だと思います。



●a[2][3][2]の場合●



�@：まず、配列全体の{}を書く。

a[2][3][2] = {  };



�A：一番左の数だけカッコを中に書く（この例では2個）

a[2][3][2] = { {   },{   } };



�B：二番目の数だけカッコを更に中に書く（この例では3個）

a[2][3][2] = { {  {},{},{}  },{  {},{},{}  }  };



�C：一番最後の数だけ要素を書く。（この例では2個。要素の間にはコンマを付ける。）

a[2][3][2] = {   { {●,●},{●,●},{●,●} },{ {●,●},{●,●},{●,●},}   };



�D：見やすくする場合は、段落などを付ける。

int a[2][3][2] =

{

	{

		{ ●, ● },

		{ ●, ● },

		{ ●, ● }

	},

	{

		{ ●, ● },

		{ ●, ● },

		{ ●, ● },

	}

};

※a[2][2][2]の場合はGPGAさんのを見て下さい（上記参照）

多重ループのように、どんどん階層が深くなるという感じです。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ついでに、カッコを書かない場合は配列の最初から順に初期化されます。

要素が足りない場合は、残りが全て「0」になります。（多い場合はエラー）



a[2][3][2]={1,2,3,4,5,6,7};



int a[2][3][2] =

{

	{

		{ 1, 2 },

		{ 3, 4 },

		{ 5, 6 }

	},

	{

		{ 7, 0 },

		{ 0, 0 },

		{ 0, 0 },

	}

};



a[0][0][0] = 1

a[0][0][1] = 2

a[0][1][0] = 3

a[0][1][1] = 4

a[0][2][0] = 5

a[0][2][1] = 6

a[1][0][0] = 7

a[1][0][1] = 0

〜以下略〜 



このようになります。

バッファを用意して、

char buf[3];



1バイト変換の時は、

buf[0] = c1;

buf[1] = '\0';



2バイト変換の時は、

buf[0] = c1;

buf[1] = c2;

buf[2] = '\0';



として、後は文字列として処理すれば良いと思います。

一応、Ｃ＋＋で作ってみました。

今回gdgdなのですみません・・・

リサージュ曲線の説明はこちら

http://ja.wikipedia.org/wiki/%E3%83%AA%E3%82%B5%E3%82%B8%E3%83%A5%E3%83%BC%E5%9B%B3%E5%BD%A2



---------- ここから ----------

#include "DxLib.h"

#include <math.h>

const double PI = 3.14159265358979323846;

inline double Get_Angle_To_Radian ( double Temp_Angle ) { return Temp_Angle /180.0 *PI; }

void Draw_Grid ( void );

void Draw_Lissajous ( double Alpha, double Beta, double Delta, double Radius );



int WINAPI WinMain( HINSTANCE hInstance, 

     HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )

{

    ChangeWindowMode ( TRUE ) ;

    if ( DxLib_Init () == -1 ) { return -1; }

    SetDrawScreen ( DX_SCREEN_BACK );

    while ( ProcessMessage () == 0 ) {		// ------------------ ループ開始

	ClearDrawScreen ();



	Draw_Grid ();

	Draw_Lissajous ( 1.0, 2.0, -PI/4.0, 100.0 );



	ScreenFlip ();

	if ( CheckHitKey ( KEY_INPUT_ESCAPE ) == 1 ) { break; }

    }

    DxLib_End();

    return 0;

}

void Draw_Grid ( void )

{

    int Cr = GetColor ( 128, 128, 128 );

    for ( int X = 0; X < 640; X += 16 ) { DrawLine ( X, 0, X, 480, Cr ); }

    for ( int Y = 0; Y < 480; Y += 16 ) { DrawLine ( 0, Y, 640, Y, Cr ); }

    DrawLine ( 320, 0, 320, 480, GetColor ( 0, 0, 255 ) );

    DrawLine ( 0, 240, 640, 240, GetColor ( 0, 0, 255 ) );

    return;

}

void Draw_Lissajous ( double Alpha, double Beta, double Delta, double Radius )

{

    int Cr = GetColor ( 255, 255, 255 );

    for ( int T = 0; T < 360; T += 3 ) {

	DrawCircle ( 320 +cos ( Get_Angle_To_Radian ( Alpha *T ) )*Radius,

		240 -sin ( Get_Angle_To_Radian ( Beta *T ) +Delta )*Radius,

		5, Cr, FALSE );

    }

    return;

}

その通りです。

Hajimeさんのソースが分からないので推測になりますが、関数Draw_Lissajous内を改造してませんか？

この関数の引数を変えるようにして下さい。



// ループの外で変数を定義

double ALPHA = 1.0, BETA = 1.0, DELTA = 4.0, RADIUS = 100.0;

・・・

// ループの中で値を変更して関数を呼び出し

/* Hajimeさんの改造部分で各値を変更 */

Draw_Lissajous ( ALPHA, BETA, -PI /DELTA, RADIUS );

・・・



引数の値を使って計算をしているので、関数の呼び出しの際に引数の値を変えないと同じ結果になってしまいます。



送信した後に気付いたのですが、Radiusは数式内のラージＡとラージＢにあたるので２つ用意した方が、いいかも知れません。（引数を一つ増やす）

X = A *cos ( a *t ), Y = B *sin ( ( b *t ) -δ)

つまり、重複した並びは表示したくないということですね。



それなら今調べている並びが、終わりの並びじゃない時、

次に並んでいる並びと異なっていたら表示したらいいのではないでしょうか。



サンプルを書いておきます。



#include <stdio.h>

#define X 6

#define Y 6

int q[Y][X]={

	{0,0,0,1,1,1},//0

	{0,0,0,1,1,1},//1

	{0,1,0,1,1,1},//2

	{0,0,0,1,1,1},//3

	{0,0,0,0,0,1},//4

	{0,0,0,0,0,1},//5

};

int main(){

	int i,s;

	for(s=0;s<Y;s++){//全部ループ

		if(s<Y-1){//最後じゃない時

			for(i=0;i<X;i++){//1行分ループ

				if(q[s][i]!=q[s+1][i])//1つでも次の要素と違えば

					break;

			}

		}

		else

			i=(!X);//下のif文の条件文を真にする

		if(i!=X){//先ほど1つでも違うものがあれば表示

			printf("%d:",s);

			for(i=0;i<X;i++){

				printf("%d",q[s][i]);

			}

			printf("\n");

		}

	}

	return 0;

}



実行結果



1:000111

2:010111

3:000111

5:000001

＞一回目にbuffer[500]を読みに行くことになるのですが



ならない・・のでは？



pc=(pl+pr)/2;

if(buffer[pc=='(1)'])



pcは最初500だと思いますが、

500=='(1)'

の条件式の評価の結果は0か0以外が返るわけですから、

また、文字コードに500番はありませんから常に儀、つまり0になるでしょうから

buffer[0]が参照されると思います。

ですから、この段階だけなら大丈夫でしょう。



きっと全体の半分、半分、半分と探していけば早いんじゃないかと仰っているのだと思いますが

文字列の終端以降全部\0が入ってるわけじゃないので、それじゃ難しいんじゃないですか？



例えば「hellow」の間にいくつも\0が紛れ込んでいる時、これは文字列としては「he」ですが

 1  2  3  4  5  6  7  8  9 10 11 12

 h  e \0  l \0 \0  l  o \0  w  ! \0 

正しく判定出来るでしょうか？

最初に\0があった場所までなのでやはり最初から探していくしかないのでは。

そのようなアルゴリズムを考えるのが好きでしたら、是非ソートアルゴリズムを考えてみてはどうでしょう。

もう世界中の人間が考えてるのでなかなか新たなソートアルゴリズムの発見は難しいでしょうけど、

結構面白かったりしますよ。

クイックソートやヒープソートとか勉強してもなかなか為になると思います。



後、strlenの実装例です。



#include <stdlib.h>

size_t my_strlen(const char *p){

    size_t n = 0;

    while (*p++)

        n++;

    return (n);

}

unsigned long long mystrlen(char* str)

{

	unsigned long long count = 0;

	for (count = 0; *str != '\0'; ++count, ++str);

	return count;

}

unsigned long long mystrlen(char* str)

{

	unsigned long long count = 0;

	for (; *str != '\0'; ++count, ++str);

	return count;

}

size_t Strlen(const char *pointer)

{

    size_t length = 0;



    while(*pointer++)

        length++;



    return length;

}

int mystrlen(const char *begin){

    const char *incremental = begin;

    while(*incremental){

        ++ incremental;

    }

    return incremental - begin;

}

int mystrlen(const char *begin, const char *end){

    const char *incremental = begin;

    while(*incremental && incremental != end){

        ++ incremental;

    }

    return incremental - begin;

}

class A{

public:

	void fa(){

	}

};

class B{

public:

	void fb(){

		a.fa();

	}

private:

	A a;

};

class A{

public:

	void fa(){

	}

};

class B : public A{

public:

	void fb(){

		fa();

	}

};

        for (i = 0.0; i < 361; i++) {

            s = sin(i);

あぁ、これは確かにわかりにくいかき方ですね。

まず、条件演算子というものはご存知でしょうか。



(1)

int a=0;

int b;

b = a==0 ? 1 : 0;



(2)

int a=0;

int b;

if(a==0)

    b=1;

else

    b=0;



(1)と(2)は同じ意味です。よくわからなければ、「条件演算子」でググってみてください。



また、第一象限〜第四象限についてはご存知でしょうか？

原点を基準にangleの方向が第一象限、第四象限はcosがプラスになり、

第二象限、第三象限はマイナスになりますよね。

それを利用して、現在向いてる方向が第一象限か第四象限ならrを1にし、

違うなら0を代入しています。

なぜそんな事をしたいかというと、向いている向きを交互にさせたいからです。

　→

←

　→

←

　→

と向かせたいのです。

単純にrang(PI/4)の計算結果は-PI/4〜PI/4ですから右側です。

もし現在向いている向きが右側なら左側に向かせ、左側なら右側にむかせたいのです。

ということは、右側なら、計算結果+PIすればよく、左側なら計算結果+0にすればよいです。

ということは



      int r=cos(enemy[i].ang)< 0 ? 0 : 1;

      //「左向き」の条件が正しければrに0をいれ、偽なら1を入れる

      enemy[i].ang=rang(PI/4)+PI*r;

      //左向きなら計算結果+0、右向きなら計算結果+PI



という計算式の意味がわかってきませんか？



      enemy[i].muki=2-2*r;



これは単に敵の向きをセットしているだけですね。

public void SetPixelEx(ref Bitmap bitmap, int x, int y, Color color) 

{ 

	Rectangle angle = new Rectangle(0, 0, bitmap.Width, bitmap.Height); 

	BitmapData data = bitmap.LockBits(angle, ImageLockMode.ReadWrite,　PixelFormat.Format24bppRgb); 

	int stride = data.Stride; 



	unsafe 

	{ 

		byte* p = (byte*)(void*)data.Scan0; 

		int count = 0; 

		int offset = stride - bitmap.Width * 3; 

		count = x * 3 + y * bitmap.Width * 3 + offset * y; 

		p[count] = color.B; 

		p[count + 1] = color.G; 

		p[count + 2] = color.R; 

		bitmap.UnlockBits(data); 

	} 

}