常連

注目の的

社会貢献

拍手喝采

自己紹介

こんにちは。

C++11で対応された範囲ベースfor、すっごく便利なのでよく使っているのですが、たまにインデックス番号も欲しい時があります。
そんな時は、`for (size_t i=0; 云々`で回してます。ドン臭いし、既に範囲ベースforで書いているコードを書き換えるのも面倒です。

begin(), end()で回せばdistance()が使えることは分かっているのですが、`for (size_t i=0; 云々`と同様書き換えが面倒なのです。更にバグでイテレータがend()を越えるとちょっと怖いです。

頭で`size_t index=0;`してループの最後で`++index;`もありですが、`continue`使うとはまりそうです。

範囲ベースforで回している時にインデックス番号をスマートに計算する方法ってないでしょうか？
ありそうな気もするのですが、グーグル先生教えてくれないのです。orz

---
【閑話休題】
なぜに範囲ベースforはiteratorを返さないのでしょう？
[for-range-declaration = *__begin;](http://cpplover.blogspot.jp/2009/08/n2930-range-based-for-loop.html)じゃなくて、`for-range-declaration = __begin;`なら良かったのに。

---
【その後】
その後、調べていて、ランダム・アクセス・イレテータでないコンテナの場合、std:distance()はリストを追跡するらしいことが分かりました。ということは同様にoperator[]も追跡する筈ですね。（何を今更なのですが。）
今はvectorで範囲ベースforを使ってますが一部はforward_listへ変更します。これを見越すと、インデックスを使うためにはイテレータ型のfor文へ変更しインデックスも追加する必要があります。for文がごちゃごちゃになり、範囲ベースforとの落差に悶え死にそうでした。しかも、autoの型が変わってしまうし．．．

個人的にこれらが許せないので、yumetodoさんのリンク先の記事からヒントを得て、ツールを作りました。
考え方は、自作の隠しイテレータをコンパイラへ返して、それがインクリメントされた時にインデックスも一緒にインクリメントするイメージです。
ですので、listでも使えますし、listのイテレータをdistanceした時のような追跡処理も発生しません。そして、autoで推論される型は同じコンテナの要素のままですので、範囲ベースforブロック内の変更も不要です。

```C++
#include <iterator>

// ***************************************************************************
//      範囲ベースforにインデックス機能を追加する
// ***************************************************************************

namespace staff_only
{

//----------------------------------------------------------------------------
//      隠しイテレータ・クラス
//----------------------------------------------------------------------------

template<typename tValueType, typename tParentIterator>
class Iterator
{
    tParentIterator mParentIterator;
    std::size_t&    mIndexReference;
public:
    explicit Iterator(tParentIterator iIterator, std::size_t& iIndexReference) :
        mParentIterator(iIterator),
        mIndexReference(iIndexReference)
    { }

    tValueType& operator*() {return *mParentIterator;}
    tParentIterator& operator++()
    {
        ++mParentIterator;
        ++mIndexReference;
        return mParentIterator;
    }
    bool operator==(Iterator const& rhs) {return mParentIterator==rhs.mParentIterator;}
    bool operator!=(Iterator const& rhs) {return mParentIterator!=rhs.mParentIterator;}
};

//----------------------------------------------------------------------------
//      コンテナ
//----------------------------------------------------------------------------

template<class tContainer>
class Indexer
{
    typedef typename tContainer::value_type ValueType;
    typedef typename tContainer::iterator ParentIterator;
    typedef Iterator<ValueType, ParentIterator> InnerIterator;

    // Indexer実体
    tContainer&     mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(tContainer& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(mContainer.begin(), mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(mContainer.end(), mIndexReference);
    }
};

//----------------------------------------------------------------------------
//      生配列
//----------------------------------------------------------------------------

template<class tValueType, size_t tDim>
class Indexer<tValueType[tDim]>
{
    typedef tValueType* ParentIterator;
    typedef Iterator<tValueType, ParentIterator> InnerIterator;

    // Indexer実体
    typedef tValueType Container[tDim];
    Container&      mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(Container& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(&mContainer[0], mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(&mContainer[tDim], mIndexReference);
    }
};
}   // namespace staff_only

//----------------------------------------------------------------------------
//      API
//----------------------------------------------------------------------------

template<class tContainer>
staff_only::Indexer<tContainer> getIndexer(tContainer& iContainer, std::size_t& iIndexReference)
{
    return staff_only::Indexer<tContainer>(iContainer, iIndexReference);
}

// ***************************************************************************
//      使い方
// ***************************************************************************

#include <array>
#include <vector>
#include <forward_list>
#include <list>

#include <iostream>

int main()
{
    struct TestClass
    {
        int x, y;
    };
    TestClass                       wRawArray[] = {{5,1}, {4,2}, {3,3}, {2,4}, {1,5}, {0,6}};
    std::array<TestClass, 5>        wArray      ={{{4,2}, {3,3}, {2,4}, {1,5}, {0,6}}};
    std::vector<TestClass>          wVector     = {{3,3}, {2,4}, {1,5}, {0,6}};
    std::forward_list<TestClass>    wForwardList= {{2,4}, {1,5}, {0,6}};
    std::list<TestClass>            wList       = {{1,5}, {0,6}};

    std::size_t wIndex;

    std::cout << "raw-array\n";
    for (auto& wData : getIndexer(wRawArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::array\n";
    for (auto& wData : getIndexer(wArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::vector\n";
    for (auto& wData : getIndexer(wVector, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::forward_list\n";
    for (auto& wData : getIndexer(wForwardList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::list\n";
    for (auto& wData : getIndexer(wList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    return 0;
}


```

msvc2015とMinGW 5.2.0で動作確認してます。

２点不満が残りました。orz
イテレータはこっそりインクリメントされているので、インデックスもこっそりインクリメントされます。範囲ベースforの仕様とも言えるのでこの点は許容することにしました。
インデックスのスコープがforの外側になってしまいます。内側にしたいのですが、範囲ベースforの構文に割り込めず諦め。

C++ 範囲ベースforの中でインデックス番号を取り出す方法

unityで地形自動生成をしようとしてます。
しかし、地形がどうしても有機的になってしまい、なかなかマイクラみたいにリアルに出来ません。
もっとこう・・
滑らかにしたいです。
スクリプトに問題点があると思いますが、ぜひ修正して頂きたいと思っております。

![](1524bddff6b8f9912eb72e8305acc9a7.png)
![](0f0620bd9422507145145ccb82028665.png)

![バイオーム](14e415d24169c50691556861c87b80bc.png)

中点変位法を採用しております。
超大まかな手順
・高さを求める
↓
・低い所は海、中位は平地、高い所は山って風に置く

すくりぷと
```Unity-C#
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;

public class MapMaker : MonoBehaviour {

	int mapSize=1024;
	//高度マップ
	int[,] hightMap = new int[1025, 1025];
	//バイオーム生成用
	//湿度マップ
	int[,] waterMap = new int[1025, 1025];
	//温度マップ
	int[,] tempMap  = new int[1025, 1025];
	//バイオームマップ
	byte[,] bomMap   = new byte[1025, 1025];
	//空き地マップ
	public static int[,] monoMap  = new int[1025, 1025];
	//構造物入れ
	List<GameObject> monos=new List<GameObject>();

	//地面プレハブ
	public GameObject[] zimens;
	//城とか木とか山とかプレハブ
	public GameObject[] objects;

	//ロードディングバー。気にしないで下さい。
	public GameObject Fill;
	public GameObject Back;
	public GameObject slider;
	public Slider bar;

	void Start(){
		//カクカクなのでフレーム固定とガベコレ。気にしないで下さい。
		Application.targetFrameRate = 60;
		System.GC.Collect ();
		//生成
		StartCoroutine (CoStart ());	
	}
	// Use this for initialization
	IEnumerator CoStart () {

		//高度マップ生成。第一問題点。
		Make (0,0,mapSize,Random.Range(0,100),Random.Range(0,100),Random.Range(0,100),Random.Range(0,100));
		bar.value = 0.05f;
		//ローディングバーのための画面更新。
		yield return null;
		//湿度マップ生成。第一問題点。
		MakeWater (0,0,mapSize,Random.Range(0,100),Random.Range(0,100),Random.Range(0,100),Random.Range(0,100));
		bar.value = 0.1f;
		yield return null;
		//温度マップ生成。第一問題点。
		MakeTemp (0,0,mapSize,Random.Range(0,100),Random.Range(0,100),Random.Range(0,100),Random.Range(0,100));
		bar.value = 0.15f;
		yield return null;

		//オブジェクト生成。ここからは問題ないと思われる。
		for (int x = 0; x < mapSize; x++) {
			for (int y = 0; y < mapSize; y++) {
				if (x == 250 && y == 250) {
					bar.value = 0.3f;
					yield return null;
				}
				if (x == 500 && y == 500) {
					bar.value = 0.45f;
					yield return null;
				}
				if (x == 750 && y == 750) {
					bar.value = 0.6f;
					yield return null;
				}
				Instantiate (Myground (hightMap [x, y], waterMap [x, y], tempMap [x, y],x,y), new Vector3 (x * 0.5f, y * 0.5f, 0), new Quaternion (0, 0, 0, 0));
			}
		}
		bar.value = 0.7f;
		yield return null;

		//構造物生成
		Setobj (objects [0], mapSize / 2-1, mapSize / 2-1);
		for (int x = 0; x < mapSize; x++) {
			for (int y = 0; y < mapSize; y++) {
				if (x == 500 && y == 500) {
					bar.value = 0.8f;
					yield return null;
				}
				//山

				if (forlot(x,y,1,1)) {
					if (hightMap [x, y] > 75) {
						Setobj (objects [1], x, y);
						continue;
					}
				}
				//木
				switch (bomMap[x,y]) {
				//ジャングル
				case 1:
					if (forlot (x, y, 2, 2) && Random.Range (0, 4) > 2) {
						Setobj (objects [2], x, y);
					}
					break;
					//森
				case 2:
					if (forlot (x, y, 1, 1) && Random.Range (0, 5) > 1) {
						Setobj (objects [3], x, y);
					}
					break;
					//雪
				case 3:
					if (forlot (x, y, 1, 1) && Random.Range (0, 6) > 4) {
						Setobj (objects [4], x, y);
					}
					break;
					//サバンナ
				case 4:
					if (forlot (x, y, 1, 1) && Random.Range (0, 5) > 2) {
						Setobj (objects [5], x, y);
					}
					break;
					//平原
				case 5:
					if (forlot (x, y, 1, 1) && Random.Range (0, 4) > 2) {
						Setobj (objects [6], x, y);
					}
					break;
					//沼	
				case 6:
					if (forlot (x, y, 1, 1) && Random.Range (0, 5) > 1) {
						Setobj (objects [7], x, y);
					}
					break;
					//砂漠
				case 7:
					if (forlot (x, y, 1, 1) && Random.Range (0, 6) > 4) {
						Setobj (objects [8], x, y);
					}
					break;
					//荒地
				case 8:
					if (forlot (x, y, 1, 1) && Random.Range (0, 5) > 2) {
						Setobj (objects [9], x, y);
					}
					break;
				default:
					break;
				}
			}

		}
		bar.value = 1;
		//バーの消去アニメーション。木にするな！
		Image fill = Fill.GetComponent<Image> ();
		Image back = Back.GetComponent<Image> ();
		for (float a = 1; a != 0; a -= 0.01f) {
			fill.color = new Color (1, 1, 1, a);
			back.color = new Color (0, 0, 0, a);
			yield return new WaitForSeconds(0.005f);
		}
		Destroy (slider);
	}
	//温度
	void MakeTemp(int x,int y,int size,int tl,int tr,int bl,int br){
		if (size < 1) {
			tempMap [x, y] = (tl + tr + bl + br) / 4+Random.Range(-1,2);
		} else {
			int t = (tl + tr) / 2;
			int b = (bl + br) / 2;
			int l = (tl + tr) / 2;
			int r = (tr + br) / 2;
			int mid = (t + b + l + r) / 4+Random.Range(-4,5);


			if (size == 1024)
				mid = 50;

			size /= 2;
			MakeTemp (x, y, size,tl, t, l, mid);
			MakeTemp (x + size, y, size, t, tr, mid, r);
			MakeTemp (x, y + size, size, l, mid, bl, b);
			MakeTemp (x + size, y + size, size, mid, r, b, br);
		}
	}
	//湿度
	void MakeWater(int x,int y,int size,int tl,int tr,int bl,int br){
		if (size < 1) {
			waterMap [x, y] = (tl + tr + bl + br) / 4+Random.Range(-1,2);
		} else {
			int t = (tl + tr) / 2+Random.Range(-4,5);
			int b = (bl + br) / 2+Random.Range(-4,5);
			int l = (tl + tr) / 2+Random.Range(-4,5);
			int r = (tr + br) / 2+Random.Range(-4,5);
			int mid = (t + b + l + r) / 4+Random.Range(-4,5);

			if (size == 1024)
				mid = 50;

			size /= 2;
			MakeWater (x, y, size,tl, t, l, mid);
			MakeWater (x + size, y, size, t, tr, mid, r);
			MakeWater (x, y + size, size, l, mid, bl, b);
			MakeWater (x + size, y + size, size, mid, r, b, br);
		}
	}
	//高度
	void Make(int x,int y,int size,int tl,int tr,int bl,int br){
		if (size < 1) {
			hightMap [x, y] = (tl + tr + bl + br) / 4+Random.Range(-4,5);
		} else {
			int t = (tl + tr) / 2;
			int b = (bl + br) / 2;
			int l = (tl + tr) / 2;
			int r = (tr + br) / 2;
			int mid = (t + b + l + r) / 4+Random.Range(-4,5);

			if (size == 1024) {
				mid = 70;
			}

			size /= 2;
			Make (x, y, size,tl, t, l, mid);
			Make (x + size, y, size, t, tr, mid, r);
			Make (x, y + size, size, l, mid, bl, b);
			Make (x + size, y + size, size, mid, r, b, br);
		}
	}

	GameObject Myground(int hight,int water,int temp,int x,int y){
		//「ジ」「森」「雪」
		//「サ」「平」「沼」
		//「砂」「荒」「岩」

		if (water > 66) {  //水分：大
			if (temp > 66) {
				bomMap [x, y] = 1;
				if (hight > 60) {
					return zimens [0];
				} else if (60 >= hight && hight > 55) {
					return zimens [9];
				} else if (55 >= hight) {
					return zimens [10];
				}
			} else if (temp > 33) {
				bomMap [x, y] = 2;
				if (hight > 60) {
					return zimens [1];
				} else if (60 >= hight && hight > 55) {
					return zimens [9];
				} else if (55 >= hight) {
          *
          *
          *
     割愛
	}

	bool forlot(int bx,int by,int x,int y){
		int a = 0;
		for(int u=bx;u<=bx+x;u++){
			for (int v=by; v <= by+y; v++) {
				if (u <= mapSize+1 && v <= mapSize+1 && u >= 0 && v >= 0) {
					a += monoMap [u, v];
					if (hightMap [u, v] < 61) {
						return false;
					}
				} else {
					return false;
				}
			}
		}
		if ((float)a / (x * y) == 0) {
			return true;
		}
		return false;
	}
	void Setobj(GameObject o,int x,int y){
		GameObject mono = Instantiate (o, new Vector3 (x * 0.5f, y * 0.5f, 0), new Quaternion (0, 0, 0, 0))as GameObject;
		objBase Base = mono.GetComponent <objBase> ();
		Base.point.X = x;
		Base.point.Y = y;
		monos.Add (mono);
		Base.id = monos.Count;
		for(int u=0;u<Base.sizeX;u++){
			for (int v=0; v < Base.sizeY; v++) {
				monoMap [Base.point.X+u, Base.point.Y+v] = Base.id;
			}
		}

	}

}
```
参考
http://loumo.jp/wp/archive/20130526220501/

unityでマイクラみたいな感じで地形自動生成したい。地形を滑らかにしたい。。

＊たくさんの方よりご指摘をいただけてとてもありたいです。
 引き続き、よろしくお願い致します。

C言語を勉強している初心者のものです。

今課題をいただき、その作成をしております。
先日提出(全18問）したのですが、大部分が間違っているので、
再度問題を見なおした上で提出してくれと言われてしまいました。

今回は課題なので、間違っている点を教えていただけませんでした。
個人的には、どの辺りが間違っているのかわからないため、
客観的な視点が欲しく、今回ご相談させていただきました。

回答の例を提示されているのですが、
nが大きくなるとで画面の見栄えが悪くなると思い、
同じような表示にはしませんでした。
また懸念点として、nが大きくなるにつれて
intでは処理しきれなくなってしまうのでと思ったのですが、
この場合、いかがでしょうか。

回答が趣旨と外れているように感じましたら
ご指摘いただけますと幸いです。

【問題】
正の整数nを入力し、1+2+3+....nの結果を表示するプログラムを作成せよ。

例）「4」を入力した際には1+2+3+4の結果、「10」となる。

【回答】
```
#include <stdio.h>

int main(void)
{
	int score;
	printf("整数を入力してください。");
	scanf("%d",&score);
		
	if (score >= 0)
	{ 
		printf("入力した整数までの合計は%dとなります。\n",(1 + score) * score / 2);
	}
	else
	{		
		printf("再度整数を入力してください");
	}
	return 0;
}

```

【C言語の質問です】整数nまでの合計を表示するプログラムを作成するには・・

###前提・実現したいこと
キャラクターが動く迷路ゲームのようなものを作成しています。
また、現在AIにも興味があるので最終的には自動で動くものを作成したいと考えています。
###発生している問題・エラーメッセージ
360度どの方向にも動ける仕様で作成したいと思っています。
フィールドはこのような感じで、左下から出発し設定したゴールへ向かわせます。
![イメージ説明](f1206d5fb29dfd81f6b1f68ce0546409.png)

上にも書いたのですが、自分でキャラクターを動かすのではなく、AIにキャラクターを動かしてもらうことが目的です。
そのためには、自分が今いる現在地などを整数で表す必要があると本で読みました。
今360度どこにもいけるプログラムを書きたいので下の図のよう360度を45度ずつ分けてエリアを分割したいと思っています。
![イメージ説明](f238f5b1058b4324f06d44bd1fff33c2.png)


----------------------------------------追加-------------------------------------------

このエリアの分割でキャラクターの状態を表現しようと思うと、(30.5,40.5)の時と(5.5,10.5)の時の区別がつけられないのではないかと考えました。
![イメージ説明](dc7d6ceb990921e2caa54eea0f972866.png)

そのため、キャラクターの(x,y)座標とエリアの中心からの角度でキャラクターの状態付けをできないかどうかというのが悩みです。

衝突判定や空間分割などのサイトやと本で調べた結果、"四分木空間分割"が近いかと思ったのですが、私の作成したい度数で分けることには流用できないような気がしています。
わかりづらい質問で申し訳ありませんが、もし、このように度数でエリアを分割する方法をご存知の方がいらっしゃいましたら教えてくださるとうれしいです!

よろしくお願いします。

###補足情報(言語/FW/ツール等のバージョンなど)
C言語で作成中です。

空間分割の方法

###前提・実現したいこと
強化学習(Q学習)でスタート地点からゴール地点までの最適な道のりを求めようとしています。
###発生している問題・エラーメッセージ
今、プログラムを50回回しても答えが出なかったら次の試行に行くようにしているのですが、次の試行に移った時にxy座標が更新されません。
また、ネットなどで調べてみると、最終的にQ学習は答えが収束すると書いてあったのですが、プログラムの試行回数を増やしても答えが収束しません。
この2つに悩んでいます。

お力を貸していただけると嬉しいです。
よろしくお願いします。

###ソースコード
```C
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define _USE_MATH_DEFINES
#include <math.h>

typedef struct car {
	double x;	//現在位置x
	double y;	//現在位置y
	double dx;	//次の位置x
	double dy;	//次の位置y
	double max_x;	//xの最大値
	double max_y;	//yの最大値
	int s;
	int sd;
	int L = 50;
}agent;

int move(car *agent, int a, int sd);
int select_action(car *agent, int num_a, double** Qtable);
double max_Qval(car *agent, int num_a, double** Qtable);
int epsilon_greedy(car *agent, int epsilon, int num_a, double** Qtable);
int xy2s(car *agent, int a);

int main() {
	FILE *file;
	file = fopen("car.csv", "w");
	car agent;

	int num_step;	//ステップ数
	int num_trial; //試行回数
	int i, j;
	int a;
	double alpha, gamma;

	int reward; //報酬

	int num_a;	//行動
	int num_s;	//状態
	double **Qtable;
	double Qmax;
	int epsilon;

	//パラメータの設定
	alpha = 0.5;
	gamma = 0.9;
	epsilon = 10;

	num_step = 50;
	num_trial =500;

	num_a = 4;

	//エリアの数
	num_s = 25;
	int sepa = 5;

	//乱数の初期化
	srand((unsigned)time(NULL));

	//Q-table
	Qtable = new double*[num_s];
	for (i = 0; i < num_s; i++) {
		Qtable[i] = new double[num_a];
	}

	//Q-tableの初期化
	for (i = 0; i < num_s; i++) {
		for (j = 0; j < num_a; j++) {
			Qtable[i][j] = 0;
		}
	}

	//agentの初期設定
	agent.x = 25.0;
	agent.y = 25.0;
	agent.max_x = 250.0;
	agent.max_y = 250.0;

	agent.s = (int)agent.x / agent.L + (int)agent.y / agent.L * sepa;

	//学習開始
	for (i = 0; i < num_trial; i++) {
		fprintf(file, "i=%d\n", i);
		for (j = 0; j < num_step; j++) {
			//fprintf(file, "j=%d\n", j);
			flag:
			a = epsilon_greedy(&agent, epsilon, num_a, Qtable);//どの方向に動くか決める
			agent.s = (int)agent.x / agent.L + (int)agent.y / agent.L * sepa;//現在のarea
			
			agent.sd = move(&agent, a, agent.s);
			printf("%f,%f\n", agent.x, agent.y);

			//ここで障害物の設定
			//障害物があるagent.sに入るとrewardに-10が入り試行を終了する
			//Goalに入るとrewardに+10が入り試行を終了
			//その他はreward=0なのでそのまま続行

			if (agent.s == 20) {
				reward = 1000;
			}
			else if(agent.s == 15) {
				reward = -10;
			}
			else {
				reward = 0;
			}
			if (agent.dx < 0 || agent.dx > agent.max_x || agent.dy < 0 || agent.dy > agent.max_y) {
				goto flag;
			}

			Qmax = max_Qval(&agent, num_a, Qtable);
			Qtable[agent.s][a] = (1 - alpha)*Qtable[agent.s][a] + alpha * ((double)reward + gamma*Qmax);//??

			fprintf(file, "%f,%f,a=%d,s=%d,sd=%d,%d\n", agent.x, agent.y, a, agent.s, agent.sd,reward);
			
			if (reward < 0) {
				//失敗
				agent.x = 25.0;
				agent.y = 25.0;
				agent.s = (int)agent.x / agent.L + (int)agent.y / agent.L * sepa;
				break;
			}
			else if (reward > 0) {
				//成功
				agent.x = 25.0;
				agent.y = 25.0;
				agent.s = (int)agent.x / agent.L + (int)agent.y / agent.L * sepa;
				break;
			}
			else {
				//続行
				agent.x = agent.dx;
				agent.y = agent.dy;
				agent.s = agent.sd;
			}
		}
	}

	fclose(file);
	return 0;
}

int move(car *agent, int a, int sd) {

	switch (a) {
	case 0://↑
		agent->dy = agent->y + 50.0;
		agent->dx = agent->x;
		break;
	case 1://→
		agent->dx = agent->x + 50.0;
		agent->dy = agent->y;
		break;
	case 2://↓
		agent->dy = agent->y - 50.0;
		agent->dx = agent->x;
		break;
		case 3://←
		agent->dx = agent->x - 50.0;
		agent->dy = agent->y;
		break;
	}
	//sdはアクションが起こった後のagent.sを表す
	agent->sd = (int)agent->dx / agent->L + (int)agent->dy / agent->L * 5;
	return agent->sd;
}


int select_action(car *agent, int num_a, double**Qtable) {
	double max;
	int i = 0;
	int* i_max = new int[num_a];
	int num_i_max = 1;
	int a;
	i_max[0] = 0;
	max = Qtable[agent->s][0];

	for (i = 0; i < num_a; i++) {
		if (Qtable[agent->s][i] > max) {
			num_i_max = 1;
			i_max[0] = i;
		}
		else if (Qtable[agent->s][i] == max) {
			num_i_max++;
			i_max[num_i_max - 1] = i;
		}
	}

	a = i_max[rand() % num_i_max];
	return a;
}

double max_Qval(car *agent, int num_a, double** Qtable) {
	double max;
	int i = 0;

	max = Qtable[agent->s][0];//?
	for (i = 0; i < num_a; i++) {//1?
		if (Qtable[agent->s][i] > max) {
			max = Qtable[agent->s][i];
		}
	}
	return max;
}

int epsilon_greedy(car *agent, int epsilon, int num_a, double** Qtable) {
	int a;
	if (epsilon > rand() % 100) {
		a = rand() % num_a;
	}
	else {
		a = select_action(agent, num_a, Qtable);
	}
	return a;
}
```

###補足情報(言語/FW/ツール等のバージョンなど)