LINQで2次元配列で最後に見つかった条件に合う要素のインデックスの取得。

Question

前提・実現したいこと

下記のような2次元配列があったとして、

        var cells = new int[,]
        {
           { 0, 0, 0}, 
           { 0, 0, 0},
           { 1, 1, 0},
           { 0, 0, 0}, 
           { 1, 1  1},
        };

この要素の配列の中で、最後に見つかった全て0の要素で埋まっている配列の1次元目のインデックスを
LINQで取得する方法のご教示をお願い致します。

        var cells = new int[,]
        {
           { 0, 0, 0},  //0で埋まっているけど最後に見つかっていない。
           { 0, 0, 0},  //0で埋まっているけど最後に見つかっていない。
           { 1, 1, 0},
           { 0, 0, 0},  //最後に見つかった0で埋まっている配列要素。この1次元目のインデックス：3
           { 1, 1  1}
        };

今回の例ですと、インデックス3を取得したいです。

ただし、下記のように条件に合う配列要素がなかった場合は、-1を取得するようにしたいです。

        var cells = new int[,]
        {
           { 1, 0, 0},  //0で埋まっていない。
           { 0, 1, 0},  //0で埋まっていない。
           { 1, 1, 0},  //0で埋まっていない。
           { 0, 0, 1},  //0で埋まっていない。
           { 1, 1  1}   //0で埋まっていない。
        };

試したこと

    int[,] cells = new int[,]
    {
       { 0, 0, 0}, 
       { 0, 0, 0},
       { 1, 1, 0},
       { 0, 0, 0}, 
       { 1, 1, 1}
    };

    var comparison = new int[] { 0, 0, 0 };

    int lastIndex = Enumerable
    .Range(0, cells.GetLength(0))
    .Select(a => Enumerable
        .Range(0, cells.GetLength(1))
        .Select(b => cells[a, b]))
    .Select((a, i) => a.SequenceEqual(comparison) ? i : -1)
    .Last(a => a != -1);

    Debug.Log(lastIndex);  //3

この場合はインデックス3がとれますが、
条件に合わない場合(2次元配列cellsの要素に0で埋まっている配列がない場合)、
-1を返すようにする方法がわかりません。

調べたのですが、
DefaultIfEmptyというものがあるらしいですが、これは配列やリストで返すみたいなので、
できなさそうだと思いました。
また、LastOrDefaultだと既定値の0が返ってきてしまうので、これもできないと思いました。

あと、最後から2行目、

.Select((a, i) => a.SequenceEqual(comparison) ? i : -1)

の記述ですが、もしかしたら、ここはSelectじゃなく、Lastとか使って、
もっとLINQを短くすることができるかもしれないと思い、考えたのですが、わかりませんでした。
このSelectの箇所をLastとか使って短くすることは可能ですか？

Answer 1

後ろから見ていって最初に見つかったものを返してください。
データをインデックスに変換しているので Select でなければいけませんが、見つからなかった場合に null を返すようにすれば DefaultIfEmpty が null を返すので -1 に変換すればいいでしょう。

前の質問から結局何がしたいのかわかりませんが、手に余るなら LINQ はあきらめて素直に for を使うのがいいと思います。応用が利かないということは保守できないということです。

追記

LINQ を使うなら相性が悪いとわかっている二次元配列をわざわざ使わなくても別のものに変換すれば簡単になります。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
	public static class Program
	{
		public static void Main(string[] args)
		{
			var cells = new int[,]
			{
				{ 0, 0, 0 },
				{ 0, 0, 0 },
				{ 1, 1, 0 },
				{ 0, 0, 0 },
				{ 1, 1, 1 },
			};
			int index = cells
				.Cast<int>()
				.ToMap(new Xy(cells.GetLength(1), cells.GetLength(0)))
				.GetRows()
				.Select((a, i) => a.All(b => b == 0) ? new int?(i) : null)
				.LastOrDefault(a => a != null)
				?? -1;
			Console.WriteLine(index);
			Console.ReadKey();
		}
	}

	#region Xy
	public static class XyExtension
	{
		public static Xy ToXy(this IEnumerable<int> source)
		{
			var list = source as IReadOnlyList<int> ?? source.ToList();
			if (list.Count != 2) throw new ArgumentException();
			return new Xy(list[0], list[1]);
		}
	}

	public struct Xy : IReadOnlyList<int>
	{
		public Xy(int x, int y)
		{
			X = x;
			Y = y;
			hashCode = null;
			area = null;
			directions = null;
			distance = null;
		}

		public int X { get; private set; }
		public int Y { get; private set; }

		public int Count { get { return 2; } }

		public int this[int index]
		{
			get
			{
				switch (index)
				{
					case 0:
						return X;
					case 1:
						return Y;
					default:
						throw new IndexOutOfRangeException();
				}
			}
		}

		public override bool Equals(object obj)
		{
			return base.Equals(obj);
		}

		private int? hashCode;
		public override int GetHashCode()
		{
			if (hashCode == null)
			{
				hashCode = this.Aggregate(1861411795, (a, b) => a * -1521134295 + b);
			}
			return hashCode.Value;
		}

		public IEnumerator<int> GetEnumerator()
		{
			yield return X;
			yield return Y;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public Xy Square()
		{
			return this * this;
		}

		public double Distance(Xy xy)
		{
			return (this - xy).Distance();
		}

		private double? distance;
		public double Distance()
		{
			if (distance == null)
			{
				distance = Math.Sqrt(Square().Sum());
			}
			return distance.Value;
		}

		private int? area;
		public int Area
		{
			get
			{
				if (area == null) area = X * Y;
				return area.Value;
			}
		}

		public override string ToString()
		{
			return string.Format("({0},{1})", X, Y);
		}

		private static List<Xy> directions;
		private static IEnumerable<Xy> Spin(Xy source)
		{
			var item = source;
			for (int i = 0; i < 4; i++)
			{
				yield return item;
				item = new Xy(-item.Y, item.X);
			}
		}
		public static IEnumerable<Xy> Directions
		{
			get
			{
				if (directions == null)
				{
					directions = Spin(new Xy(1, 0))
						.Concat(Spin(new Xy(1, 1)))
						.ToList();
				}
				return directions;
			}
		}

		public static implicit operator Xy(int i)
		{
			return new Xy(i, i);
		}

		public static bool operator ==(Xy xy1, Xy xy2)
		{
			return EqualityComparer<Xy>.Default.Equals(xy1, xy2);
		}

		public static bool operator !=(Xy xy1, Xy xy2)
		{
			return !(xy1 == xy2);
		}

		public static Xy operator +(Xy xy1, Xy xy2)
		{
			return new Xy(xy1.X + xy2.X, xy1.Y + xy2.Y);
		}

		public static Xy operator -(Xy xy1, Xy xy2)
		{
			return new Xy(xy1.X - xy2.X, xy1.Y - xy2.Y);
		}

		public static Xy operator *(Xy xy1, Xy xy2)
		{
			return new Xy(xy1.X * xy2.X, xy1.Y * xy2.Y);
		}

		public static Xy operator /(Xy xy1, Xy xy2)
		{
			return new Xy(xy1.X / xy2.X, xy1.Y / xy2.Y);
		}

		public static Xy operator %(Xy xy1, Xy xy2)
		{
			return new Xy(xy1.X % xy2.X, xy1.Y % xy2.Y);
		}
	}
	#endregion

	#region Map
	public static class MapExtension
	{
		public static Map<T> ToMap<T>(this IEnumerable<T> source, Xy size)
		{
			return new Map<T>(source, size);
		}
	}
	public class Map<T> : IReadOnlyList<T>
	{
		public Map(T[] source, Xy size)
		{
			if (source.Length != size.Area) throw new ArgumentException();
			Source = new T[source.Length];
			source.CopyTo(Source, 0);
			Size = size;
		}
		public Map(IReadOnlyList<T> source, Xy size)
			: this(source as T[] ?? (source == null ? new T[0] : source.ToArray()), size) { }
		public Map(IEnumerable<T> source, Xy size)
			: this(source as IReadOnlyList<T> ?? (source == null ? new T[0] : source.ToArray()), size) { }

		protected T[] Source { get; private set; }
		public Xy Size { get; private set; }

		public int Count { get { return Source.Length; } }

		public Xy GetIndices(int index)
		{
			if (!Includes(index)) throw new ArgumentOutOfRangeException();
			return new Xy(index % Size.X, index / Size.X);
		}
		public int GetIndex(Xy indices)
		{
			if (!Includes(indices)) throw new ArgumentOutOfRangeException();
			return indices.Y * Size.X + indices.X;
		}

		public bool Includes(Xy indices)
		{
			return indices.X >= 0
				&& indices.Y >= 0
				&& indices.X < Size.X
				&& indices.Y < Size.Y;
		}
		public bool Includes(int index)
		{
			return index >= 0 && index < Count;
		}

		public T this[int index]
		{
			get { return Source[index]; }
			set
			{
				Source[index] = value;
				hashCode = null;
			}
		}
		public T this[Xy indices]
		{
			get { return this[GetIndex(indices)]; }
			set { this[GetIndex(indices)] = value; }
		}

		public IEnumerable<IReadOnlyList<T>> GetRows()
		{
			for (int y = 0; y < Size.Y; y++)
			{
				var result = new T[Size.X];
				Array.Copy(Source, Size.X * y, result, 0, Size.X);
				yield return result;
			}
		}

		public IEnumerable<IReadOnlyList<T>> GetColumns()
		{
			for (int x = 0; x < Size.X; x++)
			{
				var result = new T[Size.Y];
				int index = x;
				for (int y = 0; y < Size.Y; y++)
				{
					result[y] = Source[index];
					index += Size.X;
				}
				yield return result;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			foreach (var item in Source) yield return item;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public override string ToString()
		{
			return string.Join("\n", GetRows().Select(a => string.Join(" ", a)));
		}

		public override bool Equals(object obj)
		{
			var d = obj as Map<T>;
			return d != null && Source.SequenceEqual(d.Source) && Size == d.Size;
		}

		int? hashCode;
		public override int GetHashCode()
		{
			if (hashCode == null)
			{
				hashCode = Source.Aggregate(262889186, (a, b) => a * -1521134295 + b.GetHashCode());
				hashCode = hashCode * -1521134295 + Size.GetHashCode();
			}
			return hashCode.Value;
		}

		public static bool operator ==(Map<T> d1, Map<T> d2)
		{
			return EqualityComparer<Map<T>>.Default.Equals(d1, d2);
		}

		public static bool operator !=(Map<T> d1, Map<T> d2)
		{
			return !(d1 == d2);
		}
	}
	#endregion
}

追記

質問とは直接関係ありませんが、null を代入できる構造体の例。

using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
	class Program
	{
		static void Main(string[] args)
		{
			MyNullable<int> a = null;
			Console.WriteLine(a == null);
			MyNullable<int> b = 1;
			Console.WriteLine(b == null);
			Console.WriteLine(b == 1);
			Console.ReadKey();
			// 結果は True, False, True になる。
		}
	}

	struct MyNullable<T>
	{
		public MyNullable(T value)
		{
			HasValue = true;
			Value = value;
		}

		public T Value { get; private set; }

		public bool HasValue { get; private set; }

		public override bool Equals(object obj)
		{
			switch (obj)
			{
				case null:
					return !HasValue;
				case T comparison:
					return EqualityComparer<T>.Default.Equals(comparison, Value);
				case MyNullable<T> comparison:
					if (!comparison.HasValue && !HasValue) return true;
					if (!comparison.HasValue || !HasValue) return false;
					return EqualityComparer<T>.Default.Equals(comparison.Value, Value);
				default:
					return false;
			}
		}

		public override int GetHashCode()
		{
			var hashCode = 1816676634;
			hashCode = hashCode * -1521134295 + EqualityComparer<T>.Default.GetHashCode(Value);
			hashCode = hashCode * -1521134295 + HasValue.GetHashCode();
			return hashCode;
		}

		public static bool operator ==(MyNullable<T> nullable1, MyNullable<T> nullable2)
		{
			return Equals(nullable1, nullable2);
		}

		public static bool operator !=(MyNullable<T> nullable1, MyNullable<T> nullable2)
		{
			return !(nullable1 == nullable2);
		}

		public static implicit operator MyNullable<T>(Dummy dummy)
		{
			if (dummy != null) throw new InvalidCastException();
			return default(MyNullable<T>);
		}

		public static implicit operator MyNullable<T>(T value)
		{
			return new MyNullable<T>(value);
		}

		public static explicit operator T(MyNullable<T> nullable)
		{
			return nullable.Value;
		}
	}

	public class Dummy { }
}

Comments

[wwbQzhMkhhgEmhU]

手に余るとか言い方はどうかと思いますが、多次元配列にするならLINQにしない方が速そうだし、メリットがないように思います。
それでも保守性ガン無視で突き進むなら、最後を
.Select((a, i) => a.SequenceEqual(comparison) ? i +1: 0)
.(a => a != 0)
.LastOrDefault() - 1;
にすると更に汚くできます。

[Zuishin]

null と LastOrDefault を使うイメージを追記しました。二次元配列から別のものに変換しているので要件には合いませんが、二次元配列に対応させるのも難しくないはずです。
+1 -1 するより null を使う方が好みです。
LastOrDefault を使う場合、無関係の行まで Select で変換してしまうので、後ろから見ていって最初に null でない行を見つける方が良さそうに思います。

[wwbQzhMkhhgEmhU]

あわわ、回答者さんに言ったのではなくて、質問者さんに言ったつもりでした。
ここに書いてしまうとそう捉えてしまいますよね。至らずすみませんでした。
コードはなかなか方向性の違う試みにさらに一歩進ませてしまったようで、すみません。
二次元なので、X,Y座標から値をマップして走査する形なんですね。しかも専用のマップ。
元のコードのロジックの傾向を引き継ぐLINQ化。。。斬新です。
まあ、回答者さんのお気持ちはよく分かりました。

というわけで質問者さんは好きなように取り組んでください。
オススメは後方からのforによる走査、ということでした。

[退会済みユーザー]

ご回答ありがとうございます。
他の方々もおっしゃっているように多次元配列にLINQを使うべきでないことがわかりました。
今回は2次元配列を使うことは前提として、LINQについて勉強したかった為、保守性無視で質問致しました。forの走査が賢明と心得ました。

a.All(b => b == 0) ? new int?(i) : null
のコードについて質問させていただきたいのですが、
a.All(b => b == 0)がtrueのときに、new int?(i)が通り、falseのときにnullが通ると認識しているのですが、このnew int?(i)がどういったコードかわかりませんでした。
このintの後の?は何かの処理になりますか？

Mapクラス等のご教示ありがとうございます。
こちらは時間をかけて勉強していこうと思います。

[Zuishin]

https://docs.microsoft.com/ja-jp/dotnet/csharp/programming-guide/nullable-types/
ここを参照してください。

[退会済みユーザー]

ご回答ありがとうございます。
ご提示のURLで?がNULL許容型とわかりました、ありがとうございます。
new int?(i)
これのnewの意味がわからなく、下記URLでnew演算子であることはわかったのですが、
https://docs.microsoft.com/ja-jp/dotnet/csharp/language-reference/keywords/new-operator
int i = new int();
だとコードは通るのですが、
int i = new int(1);
や
int i=0;
int j = new int(i);
だとコードが通らず、
int i=2;
int? k = new int?(i);
でコードが通りました。
これより、「new int?(i)」は、「NULL許容型のint値」と解釈しようとしたのですが、
int? k = new int?(null);
や
int? i = null;
int? k = new int?(i);
を書くとエラーになってしまい、わかりませんでした。
「new int?(i)」は、「NULL許容型のint値」ですか？
どういったものかご教示いただけませんか？

[Zuishin]

リンク先に書いてあるように、int? は Nullable<int> と同じものです。
なので new int?(i) は new Nullable<int>(i) と同じです。
型にはそれぞれコンストラクタがあります。
int 型と Nullable<int> 型は別の型なのでコンストラクタもメソッドもプロパティも全部違います。
その型にどのようなメンバーがあるかは次を参照し、検索窓に型名を入れてください。
https://docs.microsoft.com/ja-jp/dotnet/api/

[Zuishin]

Nullable<T> のコンストラクタ
https://docs.microsoft.com/ja-jp/dotnet/api/system.nullable-1.-ctor

int 型にはコンストラクタが無い
https://docs.microsoft.com/ja-jp/dotnet/api/system.int32

[退会済みユーザー]

ご回答ありがとうございます。
理解力がなくて申し訳ないです。
まず、ご教示いただいて Nullable<int>は、int型ではないと理解したつもりですが、
疑問点が湧いてしまいました。

Nullable<T>(T) Constructorは、
public Nullable (T value);
で、valueのTは値型と書かれてたので、nullは値型でないので(nullは値型ではないですか?)、
これのコンストラクタにnullは入れられないということですか？
そうすると、new Nullable<int>(i)のiには、nullは入れらず、普通のintしか入れられないということですか？
そうすると、new Nullable<int>(i)の値と普通のintのiの違いは何なのかわからなくなってしまいました。

int? k = new int?(2);
とは書けるものの、
int? k = new int?(null);
とは書けないので、
結局kには普通のint値しか入らないのではないか？という疑問です。

[Zuishin]

int? k は Nullable<int> k と同じものです。
リンク先に書いてありますが、Nullable<T> は値型なので null にはなりません。また同じく T も値型なので null にはなりません。ただし、k == null のように、Nullable<T> と null を比較することはできます。
なぜ k が null になり得ないのに k == null が true になることがあるのかは次を参照してください。
https://qiita.com/Zuishin/items/62c5b726bfa589b3fb9b

また int? k = null のように Nullable<T> 型の変数に null を代入することができます。この時に k は null にはなりません。Nullable<T> は値型なので null にはならないからです。しかし k == null は true になります。この時、`k.` と打って Ctrl+Space を押してみてください。null ならメンバーは無いので `null.` と打っても補完されませんが、`k.` の場合は補完されます。k は null ではなく、null と値が等しい別の物というにすぎません。具体的に言うと HasValue が false の時、Nullable<T> は Equals メソッドおよび == のオーバーロードによって自らの値が null に等しいと言っているだけにすぎません。

[Zuishin]

ここからわかるように、k には普通の int 値も入りませんし、null も入りません。
入るのは Nullable<int> だけです。
Nullable<int> 型の変数に int 値や null を代入する時、それは Nullable<int> にキャストされます。そしてキャスト演算のオーバーロードにより、(Nullable<int>)1 は new Nullable<int>(1) と同じものであり、(Nullable<int>)null は new Nullable() と同じものになります。

[Zuishin]

https://referencesource.microsoft.com/#mscorlib/system/nullable.cs,ffebe438fd9cbf0e
Nullable<T> のソース

[tamoto]

nullableはC#の「構文上」めちゃくちゃ特別扱い(structなのにnullを代入するような式が「特別に」書ける)なので、一般的な値型とは扱いが異なるものと覚えてしまうのがよいです(内部的にはただの値型なのです)
というかこれ別の質問に起こしたほうが良かったのでは……

[Zuishin]

構文上特別なのは T? になるからで、null を代入できる struct は書けますよ。
追記します。

[tamoto]

なるほど。implicit conversionなら確かに同じ見た目を実現できますね。発想が強い……
しかし、やはり実際のNullable<T>にはそのようなHackは使われていない(はず)ので、コンパイラによる特別対応でnull代入を実現しているということには違いはないと思ってます。nullを代入するとdefaultを代入した扱いでコンパイルされるだけなんですけどね。

[Zuishin]

ソースをよく見ると確かにこのままでは null を代入できませんね。四則演算もオーバーロードされてないので言語レベルで特別扱いされているようです。勘違いしていました。

[退会済みユーザー]

ご回答ありがとうございます。
おそらく、理解できたと思いますが、もしまたわからないことがあれば、ご指摘の通り、
別の質問に起こさせていただきたいと思います。
Zuishin様、ご教示ありがとうございました。
wwbQzhMkhhgEmhU様もtamoto様もありがとうございました。

Answer 2

(これは回答ではないです。)

前の質問にも目を通してきましたが、Linqと多次元配列は「相性が悪い」なんてものではなく、Linqは「多次元配列は一切サポートしていない」と言い切ってしまって良いくらい、多次元配列のことは考慮していないです。
無理やりにLinqを使うことは、「無理やりに再帰を使って書かれたロジック」並にどうしようもないコードになります。
直列的な元データからジャグ配列の形を経て「最終的に多次元配列にまとめる」という話なら採用の余地はありますが、元々の多次元配列に対してLinqで処理を行おうというのは一切避けるべき手法です。もしコードレビューの文化があるなら100%リジェクトされるでしょうね。

多次元配列に、Linqを使うのを、諦めてください。

Comments

[退会済みユーザー]

ご助言ありがとうございます。
多次元配列にLINQを使うべきでないということがわかりました。