C# 配列とListの使い方の違いを教えてください。

Question

実現したいこと

無限(ある程度大きすぎると困るのでX,Yともに256マスと仮定)にマスがある〇×ゲームの書かれた座標の履歴を
無限の盤面がある3かける3のマルバツゲームを作りたいです。(縦[x]3マス・横[y]3マス・無限にしたい部分[z])

byte型の(Listと配列の違いがわかりません)Listか配列にしてプレイヤーの書いた場所を記録したいです。
byte型の(Listと配列の違いがわかりません)Listか三次元配列にしてプレイヤーの示した場所(1ターンに1度)をプレイヤーがゲームをクリアーできる時まで記録したいです。
”2025/05/29 14:40追記事項”マルバツゲームが終わるまで、盤上の情報を持っておきたいです。その為にZ座標を持たせて三次元で考えております。
1枚目(z=0)何も書かれていない紙を保存して、2枚目(z=1)にどこ(x・y)に何(後でマルバツに対応する数字を入れる)を入れたか記録したいです。

発生している問題・分からないこと

配列は最初から決まっている要素しか持っていませんが、
リストはAdd(T)が使えますが3×3×無限とするため、
配列とリストどちらが今回の内容に沿っていて。どのように設定したらよいのでしょうか。
配列は最初から決まっている要素([3[縦マス],3[横マス],無限にしたい問題の箇所)しか持っていませんが、
リストはAdd(T)が使えますが3×3×無限とするため、
配列とリストどちらが今回の内容に沿っていて。どのようにプログラミングしたらよいのでしょうか。

該当のソースコード

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Hit_And_Blow
{
    public class VariablStorage
    {
~~
    /*
        //解答用を記録する配列
        public byte[,,] answer;
     */

      //解答を記録する配列     
      List<byte> answer = new List<byte> { };
~~


    
        //解答用を記録する配列
        **"public byte[,,] answer;"**

      //解答を記録する配列     
      **"List<byte> answer = new List<byte> { };"**


        /*
         * Array.Resize(ref numbers, numbers.Length + 1);
         * numbers[numbers.Length  - 1] = 7;
         */

         //初期化関数
         public void InitializationMethod()
         {
             ~~answer = new byte[3, 3, 4];~~
             ~~List<byte> numbers = new List<byte> { };~~
             _//ここでListか3次元配列のデータを初期化したい。_
         }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;


namespace Hit_And_Blow
{
    public partial class MainForm : Form
    {
        //変数置き場
        public VariablStorage BoardPlace = new VariablStorage();

        public MainForm()
        {
            InitializeComponent();

            //VariablStorage初期化メソッド
            BoardPlace.InitializationMethod();

        }


        //初期化関数
        public void InitializationMethod()
        {
            BoardPlace.InitializationMethod();
        }
    }
}

試したこと・調べたこと

• teratailやGoogle等で検索した
• ソースコードを自分なりに変更した
• 知人に聞いた
• その他

上記の詳細・結果

https://yossy.penne.jp/wordpress/2024/02/07/c-arrayresizeguid/
ここを見ましたが、一次元配列ならArray.Resize()なのですが、
使いたい配列が三次元配列です。
ここはリストではなく配列が正解なのでしょうか。
よろしくお願いします。

補足

VisualStudio Community 2022
更新プログアムのバージョン17.14.3

デバイス名 user
プロセッサ 12th Gen Intel(R) Core(TM) i7-12700 2.10 GHz
実装 RAM 32.0 GB (31.7 GB 使用可能)
システムの種類 64 ビット オペレーティング システム、x64 ベース プロセッサ
ペンとタッチ 2 タッチ ポイントでのタッチのサポート

Comments

[kikukiku]

無限と言っても実際にはそんなに多くないと思うため
配列でもリストでもどちらでも良いと思います。
自分だったら下記のようにします。
記述が分かりやすくシンプルなものを選びました。

//履歴格納場所を確保
var rireki = new List<Byte[,]>();
//答えがあった
var answer1 = new Byte[2, 2];
answer1[0, 0] = 0;
answer1[0, 1] = 0;
answer1[1, 0] = 0;
answer1[1, 1] = 0;
//履歴に追加
rireki.Add(answer1);
//答えがあった
var answer2 = new Byte[2, 2];
answer2[0, 0] = 1;
answer2[0, 1] = 1;
answer2[1, 0] = 1;
answer2[1, 1] = 1;
//履歴に追加
rireki.Add(answer2);
//履歴から一番古いものを取り出す
var answer3 = rireki[0];
//履歴から一番古いものを削除する
rireki.RemoveAt(0);

[fana]

> 無限(ある程度大きすぎると困るのでX,Yともに256マスと仮定)にマスがある

という話と

> 3×3×無限

なる話の対応関係がわからないのは私だけなんでしょうか．

[fana]

> 使いたい配列が三次元配列です

こういうのは愚直に多次元にするのではなく，例えば「盤面」という型を用意してやればすっきりするような気がします．
「盤面の一次元配列」という話で済みますから，混乱(?)具合も低減できるのではないでしょうか．

> 配列とリストどちら

ご自身にとって実装が楽になる側を選択すれば良いのではないでしょうか．
（とりあえず List<> の方が楽ができそうかな，という気がします）

[turnberry]

kikukiku様
//履歴格納場所を確保
>> var rireki = new List<Byte[,]>();
これを三次元にすれば、盤面(x,y)と何手(z)進んだか分かるのでしょうか。

fana様
3×3のボードが無限個欲しいです。ただ、できる限りいっぱいという訳で厳密には無限ではないですが、何個必要かわからないので無限と書きました。

>「盤面の一次元配列」という話で済みますから，混乱(?)具合も低減できるのではないでしょうか．
盤面は縦横3マスほしいのですが、それを一次元配列にするにはどうすればいいのでしょうか。考えがうまくまとまりませんでした。

[kikukiku]

>//履歴格納場所を確保
>>> var rireki = new List<Byte[,]>();
>これを三次元にすれば、盤面(x,y)と何手(z)進んだか分かるのでしょうか。
２×２から３×３にするためには、上記の定義はそのままでOKです。
下記のように、答えの定義を３×３にすればOKです。
var answer1 = new Byte[3, 3];
answer1[0, 0] = 0;
answer1[0, 1] = 0;
answer1[0, 2] = 0;
answer1[1, 0] = 0;
answer1[1, 1] = 0;
answer1[1, 2] = 0;
answer1[2, 0] = 0;
answer1[2, 1] = 0;
answer1[2, 2] = 0;

[YAmaGNZ]

もしかして
１手目に0,0に〇
2手目に0,1に×
3手目に1,1に〇
と進んで2手目に戻り
2手目に1,0に×
3手目に2,0に〇
というふうにしたときに1回目の3手目[1,1]〇までの盤面と3手目[2,0]〇までの盤面も覚えておいて
やっぱり3手目[1,1]〇の次の手を打ちたいといった感じで自由に行き来できるようにしたいといった感じなんですかね？
そうなるとtree構造のほうがいいような気がします。
[0,0]〇
├[0,1]×
│└[1,1]〇
└[1,0]×
　└[2,0]〇
といった感じでしょうか

[turnberry]

YAmaGNZ様
ご返答頂きありがとうございます。
1手目は白紙にしております。2手目から指定した場所に打つという事がしたいです。
1手目が白紙なのは1手目に戻ると白紙なので初期化しなくていいのかなと思ったからですが、やはり1手目から打った方が良いのでしょうか。
Tree構造は知らないので、いったん調べさせてください。だいぶ時間がかかると思います。なので、アンサーやアンサーを決める時間も多少関わってくると思います。

kikukiku様(2025/05/29 16:07)
var answer1 = new Byte[3, 3];
for(int i=0; i<3; i++){
for(int j=0; j<3; j++){
このfor文で回してもよさそうな感じはありますね。

[kikukiku]

＞var answer1 = new Byte[3, 3];
＞for(int i=0; i<3; i++){
＞for(int j=0; j<3; j++){
＞このfor文で回してもよさそうな感じはありますね。
ご自由にして頂いてOKかと思います。
基本的な考え方だけ、提示しています。

Answer 1

〇×ゲームは三目並べ（Tic tac toe）のことだと思っていますが、合ってますか？
（以下はそうだとします）

また、どのように履歴を保存したいのでしょうか？

リストはAdd(T)が使えますが3×3×無限とするため、

ということですが、私だったら盤面と履歴を独立させて、履歴のほうは

public class HistoryItem
{
    public int x { get; set; } // x座標
    public int y { get; set; } // y座標
    public byte player { get; set; } // ○or×
}

といったようなクラスにします。
そうすれば、

    // 定義
    List<HistoryItem> history = new List<HistoryItem>();

    // 追加時
    history.Add(new HistoryItem() {
        x = 1,
        y = 1,
        player = 0
    });

とすれば、簡単に追加することができ、三次元配列も用意する必要はありません。
また、盤面全体を保持する必要は無いので、メモリの節約にもなります。

---

もし、配置した座標だけでなく、盤面（の配列）も保持したいのであれば、「配列のリスト」や「リストのリスト」も可能なので、それを使うといいでしょう。

    // 定義
    List<byte[,]> history = new List<byte[,]>();
    byte[,] answer = new byte[3, 3]; // 現在の盤面

    // 追加時
    var addHistoryItem = new byte[3, 3];
    Array.Copy(answer, addHistoryItem, answer.Length); // 配列のコピー
    history.Add(addHistoryItem);
    
    // 参照時
    int historyNum = 0; // 参照したい履歴の番号
    for (int y = 0; y < 3; y++)
    {
        for (int x = 0; x < 3; x++)
        {
            System.Console.Write(history[historyNum][x, y]);
            if (x == 2)
            {
                System.Console.Write("\n");
            }
            else
            {
                System.Console.Write(",");
            }
        }
    }

Comments

[fana]

〇×ゲームってパスとかあるんでしたっけ？（無いなら 履歴データにplayerを持たせなくても良いかも）

[fiveHundred]

確かに、通常の○×ゲームにはないはずですので、それでも大丈夫そうですね。
（ただ、盤面がanswerという名前になっているので、通常とは異なるかもしれません）

[turnberry]

チェスの駒が過去や別次元に戻っていくゲームがあり、
それの三目並べもできそうだなと思って、無限の履歴が欲しかったのです。
伝わりましたでしょうか。説明が下手で大変申し訳ございません。

[fiveHundred]

私の回答で「無限の履歴」は（メモリ不足などにならない限り）可能ですが、どこが不足ですか？

[turnberry]

こちらの理解不足から、昨日は分からなかったのですが今日読んでみたらわかりました。
確かにリストでメモリー不足にならない限り無限の履歴が作れると思います。
大変参考になりました。ありがとうございます。
さっそくコードを読み、理解してから、作業を行おうと思っております。
またの発言になりますが、参考になりました。ありがとうございました。

[turnberry]

回答ありがとうございます。
試したところ問題が解決しました！
ベストアンサーに選ばせていただきました。

Answer 2

とりあえず１つの盤面に関する履歴というのを考えると，
3x3の広さなら最大で9手しか打てないのでしょうから
「何手目に，どこの位置に（〇or×が）打たれたか」という話があればよいのかな，と思います．

• 「何手目に」を配列のindexで表すなら，履歴は最大サイズが9な配列とかでよい．
• 「どこの位置に」は，3x3箇所しか候補がないのだから 1～9 の数値とかで表現可能．
• 「〇or×」については，先手がどっちなのかが決まってれば定まるので，いちいち履歴に記録しなくてよい．

というわけで，「どこの位置に」をbyteで表すとしても9byteくらいの情報で済むんじゃないでしょうか．

で，「無限の盤面」（全く同じ場面が多重に存在するのでないならば，有限かもですが）をどうするのか？　については
配列orList というよりも，その「履歴」データの用途に応じてデータ構造を決めるべきではないのかな？　という気がします．
単純に１次元方向に並んでいれば済むのであれば，List で済ませておけば良いのではないでしょうか．

Comments

[turnberry]

回答ありがとうございます。
ベストアンサーは別の方を選ばせていただきましたが、こちらの回答も非常に参考になりました。

Answer 3

解決済みとなっていますが

チェスの駒が過去や別次元に戻っていく

という言葉よりtree構造が実現したいことを表現できるのかなと思いました。

        public class HistoryItem
        {

            // 一手前の履歴
            public HistoryItem parent;

            // この手の次の手のリスト
            public List<HistoryItem> child = new List<HistoryItem>();

            // この手の情報
            public int count { get; set; } // 何手目
            public int x { get; set; } // x座標
            public int y { get; set; } // y座標
            public byte player { get; set; } // ○or×

            // 盤面
            public byte[,] ban;

            public HistoryItem(HistoryItem parent, int x, int y, byte player)
            {
                this.parent = parent;
                this.x = x;
                this.y = y;
                this.player = player;

                // parentがnullの場合は前の手がない＝最初の手ということで盤面を初期化する
                if (parent == null)
                {
                    this.ban = new byte[,] { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } };
                }
                else
                {
                    // 盤面を前の手からコピー
                    this.ban = parent.ban.Clone() as byte[,];
                }

                // 指定された手を反映
                this.ban[x, y] = player;

                // 何手目か計算
                if (parent == null)
                {
                    count = 1;
                }
                else
                {
                    count = parent.count + 1;
                }

                // 一手前の履歴にこの手を次の手として記録
                if (parent != null) this.parent.child.Add(this);

            }

            // このクラスの情報を文字列として返す
            public override string ToString()
            {
                string ret;

                ret = $"{new string(' ', count * 2)}{count}手目 {(player == 1 ? "先手" : "後手")} : ({x},{y})";
                ret += ban2string(ban);

                return ret;
            }

            // 盤面を文字列として表現する
            private string ban2string(byte[,] ban)
            {
                string ret;

                ret = $"\n\t{ban[0, 0]}{ban[1, 0]}{ban[2, 0]}";
                ret += $"\n\t{ban[0, 1]}{ban[1, 1]}{ban[2, 1]}";
                ret += $"\n\t{ban[0, 2]}{ban[1, 2]}{ban[2, 2]}";

                return ret;
            }
        }

といった履歴情報を保持するクラスを作成し

        const int PLAYER1 = 1;
        const int PLAYER2 = 2;

        static void Main(string[] args)
        {

            // 1手目　（１）
            NowHistory = new HistoryItem(null,1,1, PLAYER1);
            starthistory = NowHistory;    

            // 2手目　（２）
            NowHistory = new HistoryItem(NowHistory, 0, 0, PLAYER2);

            // 3手目　（３）
            NowHistory = new HistoryItem(NowHistory, 2, 2, PLAYER1);


            // １手目（１）に戻る
            // NowHistoryが3手目なのでその親(NowHistory.parent)が2手目、2手目の親が1手目となる
            NowHistory = NowHistory.parent.parent;


            // 2手目を新たに指す　（４）
            NowHistory = new HistoryItem(NowHistory, 2, 0, PLAYER2);

            // 3手目　（５）
            NowHistory = new HistoryItem(NowHistory, 0, 1, PLAYER1);

            // 4手目　（６）
            NowHistory = new HistoryItem(NowHistory, 2, 1, PLAYER2);

            // ここから最初の3手目（３）に戻る
            NowHistory = NowHistory.parent.parent.parent.child[0].child[0];

            // 4手目　（７）
            NowHistory = new HistoryItem(NowHistory, 0, 1, PLAYER2);



            Console.WriteLine("履歴を表示");
            PrintHistory(starthistory);

            Console.ReadKey();
        }

        static void PrintHistory(HistoryItem his)
        {
            Console.WriteLine(his.ToString());

            foreach(var item in his.child) {
                PrintHistory(item);
            }
        }

このように手を進めたり戻したりしたいのかなって想像しました。

動作結果としては以下のようになります。

  1手目 先手 : (1,1)
        000
        010
        000
    2手目 後手 : (0,0)
        200
        010
        000
      3手目 先手 : (2,2)
        200
        010
        001
        4手目 後手 : (0,1)
        200
        210
        001
    2手目 後手 : (2,0)
        002
        010
        000
      3手目 先手 : (0,1)
        002
        110
        000
        4手目 後手 : (2,1)
        002
        112
        000

とりあえずの実装なので盤面は3ｘ3固定としていますし、不備や不具合等あるかと思いますが基本的な考え方の参考にはなるのではないでしょうか。

Comments

[turnberry]

YAmaGNZ様
ベストアンサー後にも謎を考えていただきありがとうございます。
またすぐに壁にぶつかるを思いますが、その際はYAmaGNZ様のコメントを見てから考える事にします。
本当にありがとうございます。