We Keep Coding

C# getting the biggest area of a matrix which has the same element

In C# I've come to a problem I can't solve myself. I have a 2d matrix which looks like this
1 1 1 0 0 0 0 1 1 1
1 0 1 0 0 0 0 1 1 1
1 0 1 1 1 1 1 0 1 1
1 0 1 1 1 1 1 0 1 1
1 0 1 1 1 1 1 1 1 1
1 1 1 0 0 1 1 1 1 1
1 1 1 0 0 1 1 1 1 1
I want to find out the biggest 4-connected (north, west, south, east) area of 0. For the example above the answer is 8 (the biggest area of all zeroes is on the top of the matrix):
0 0 0 0
0 0 0 0
I have no idea how to cope such a task, so anything could help.
Thanks!
I've tried iterating through the matrix with a for but its not working if the biggest area where 0 are on the same line (or column).

You can scan the map and on each 0 perform a search (in the code below it is Breadth First Search):
Code: (Fiddle)
private static int MaxIsland(int[,] ocean) {
int result = 0;
if (ocean == null)
return result;
var visited = new HashSet<(int y, int x)>();
for (int y = 0; y < ocean.GetLength(0); ++y)
for (int x = 0; x < ocean.GetLength(1); ++x) {
if (ocean[y, x] != 0)
continue;
if (!visited.Add((y, x)))
continue;
int current = 1;
var agenda = new Queue<(int y, int x)>();
agenda.Enqueue((y, x));
while (agenda.Count > 0) {
var (r, c) = agenda.Dequeue();
for (int d = 0; d < 4; ++d) {
int newR = r + (d - 1) % 2;
int newC = c + (d - 2) % 2;
if (newC < 0 || newR < 0 ||
newR >= ocean.GetLength(0) || newC >= ocean.GetLength(1))
continue;
if (ocean[newR, newC] != 0)
continue;
if (visited.Add((newR, newC))) {
agenda.Enqueue((newR, newC));
current += 1;
}
}
}
result = Math.Max(result, current);
}
return result;
}
Time complexity: O(n * m) where n and m are matrix dimensions
Space complexity: O(n * m) in the worst case

Draw diagonal line from top right corner to bottom left using nested for loop in c# console app

I have matrix 5x5 filled with zeroe.
I'm going to draw diagonal line from top right corner to bottom left corner using nested for loop.
expected output :
0 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 1 0 0 0
1 0 0 0 0
my output:
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
my code so far:
using System;
namespace practice_04
{
class Program
{
static void Main(string[] args)
{
int[,] array = new int[5, 5];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
array[i, j] = (i == j) ? 1 : 0;
Console.Write($"{array[i, j]} ");
}
Console.WriteLine(Environment.NewLine);
}
}
}
}
I don't get it how to reverse my output into expected output

Just slight modification will do the trick:
array[i, j] = (i == 4 - j) ? 1 : 0;
For better code quality I'd suggest using array sizes further down the code after initializing it:
for (int i = 0; i < array.GetLength(0); i++)
{
for (int j = 0; j < array.GetLength(1); j++)
and
array[i, j] = (i == array.GetLength(0) - 1 - j) ? 1 : 0;

You print your array like this:
i\j 0 1 2 3 4
0 0 0 0 0 1
1 0 0 0 1 0
2 0 0 1 0 0
3 0 1 0 0 0
4 1 0 0 0 0
Therefore you want i + j == 4 instead of i == j
This is how i+j looks like, if you're not convinced yet:
i\j 0 1 2 3 4
0 0 1 2 3 4
1 1 2 3 4 5
2 2 3 4 5 6
3 3 4 5 6 7
4 4 5 6 7 8

A Little Mistake in the for loop. Attached the correct Line:
for (int j = 4; j >= 0; j--)
{
array[i, j] = (i == j) ? 1 : 0;
Console.Write($"{array[i, j]} ");
}
Then your output will be mirrored:
i\j 4 3 2 1 0
0 0 0 0 0 1
1 0 0 0 1 0
2 0 0 1 0 0
3 0 1 0 0 0
4 1 0 0 0 0

Astar algorithm not working (possibly wrong heuristic value?)

I tried to follow wiki's A* star pseudocode and I had problems creating heuristic value method, so i just used it as Shortest Reach, but the code keeps adding starting node to the closedSet.
public uint TotalNodes = 0;
uint[][] Neighbors = null;
uint[][] Weights = null;
public Graph(uint v)
{
TotalNodes = v + 1;
Neighbors = new uint[TotalNodes][];
Weights = new uint[TotalNodes][];
for (int i = 1; i < TotalNodes; i++)
{
for (int j = 1; j < TotalNodes; j++)
{
Neighbors[i] = new uint[TotalNodes];
Weights[i] = new uint[TotalNodes];
}
}
}
public void AddNeighbor(uint parent, uint neighbor, uint distance)
{
Neighbors[parent][neighbor] = neighbor;
Weights[parent][neighbor] = distance;
}
public void RunAstarAlgorithm(uint start, uint goal)
{
uint[] closedSet = new uint[TotalNodes];
uint[] openSet = new uint[TotalNodes];
uint[] g_score = new uint[TotalNodes];
uint[] f_score = new uint[TotalNodes];
uint openSetNodes = 0, closedSetNodes = 0;
uint currentNode = 0;
uint tentativePathCost = 0;
openSet[0] = start;
for (uint i = 0; i < TotalNodes; i++)
{
if (i == start) f_score[i] = 0;
else f_score[i] = uint.MaxValue;
}
f_score[start] = g_score[start] + (uint)HeuristicCostEstimate(start,goal);
while (openSet.Length != 0)
{
for (uint i = 1; i < TotalNodes; i++)
{
if (f_score[i] == f_score.Min()) currentNode = i;
}
if (currentNode == goal)
{
ReconstructPath(closedSet, currentNode);
return;
}
for (uint i = 0; i < TotalNodes; i++) if (openSet[i] == currentNode) openSet[i] = 0;
closedSet[closedSetNodes] = currentNode;
closedSetNodes++;
foreach (uint neighbor in Neighbors[currentNode])
{
for (uint i = 0; i < TotalNodes; i++)
{
if (closedSet.Contains(neighbor)) continue;
}
tentativePathCost += g_score[currentNode] + Weights[currentNode][neighbor];
if (!openSet.Contains(neighbor) || tentativePathCost < g_score[neighbor])
{
g_score[neighbor] = tentativePathCost;
f_score[neighbor] = g_score[neighbor] + (uint)HeuristicCostEstimate(neighbor,goal);
if (!openSet.Contains(neighbor))
{
openSet[openSetNodes] = neighbor;
openSetNodes++;
}
}
}
}
}
Find heuristic value:
public int HeuristicCostEstimate(uint start, uint goal)
{
Queue<uint> queue = new Queue<uint>();
queue.Enqueue(start);
bool[] visitedNodes = new bool[TotalNodes];
int[] distances = new int[TotalNodes];
for (uint i = 0; i < TotalNodes; i++) distances[i] = -1;
distances[start] = 0;
while(queue.Count > 0)
{
uint node = queue.Dequeue();
if (node == goal) break;
foreach(uint neighbor in Neighbors[node])
{
if (neighbor == 0) continue;
if(distances[neighbor] == -1)
{
distances[neighbor] = distances[node] + 1;
queue.Enqueue(neighbor);
}
}
}
return distances[goal];
}
So i have this graph:
7 node graph
and for ex. i want to go from 1 to 5, so the path should be 1-2-3-6-5 right?
My graph is represented in jagged arrays (ignore the first (0) spot, i start from 1 for printing out purposes)
Neighbors array (first line represents nodes, columns represent their neigbhors:
(0)(1)(2)(3)(4)(5)(6)(7)
(0) 0 0 0 0 0 0 0 0
(1) 0 0 1 0 0 0 0 1
(2) 0 2 0 2 2 0 0 0
(3) 0 0 3 0 3 0 3 0
(4) 0 0 4 4 0 4 0 0
(5) 0 0 0 0 5 0 5 0
(6) 0 0 0 6 0 6 0 6
(7) 0 7 0 0 0 0 7 0
And weight(distance) array (columns represent their neigbhors and what is the distance to them):
(0)(1)(2)(3)(4)(5)(6)(7)
(0) 0 0 0 0 0 0 0 0
(1) 0 0 2 0 0 0 0 5
(2) 0 2 0 3 7 0 0 0
(3) 0 0 3 0 4 0 3 0
(4) 0 0 7 4 0 6 0 0
(5) 0 0 0 0 5 0 1 0
(6) 0 0 0 2 0 1 0 10
(7) 0 5 0 0 0 0 10 0
So how could i achieve shortest path with A* algorithm?

How to get all combinations with a fixed number of flags in array

here I have an array with a specific length and also a specific number of flags which have to be set. The length and number of flags can change from case to case, so they should be generic.
Example:
var array = new bool[] { false, false, false, false, false, false };
var numberOfFlags = 2;
I'd now like to get all permutations / combinations which are possible, when always 2 flags have to be set. Example:
1 1 0 0 0 0
0 1 1 0 0 0
0 0 1 1 0 0
But also for example:
0 1 0 0 0 1
Or:
0 0 0 1 0 1
I simply need a way to get all possible combinations where the predefined number of flags are set. No pattern or anything, just all possible combinations. Preferrably in C#.
I'm really looking forward to an answer and thanks a lot!

I found this on rosettacode.org. (I changed it a little bit). It's non-recursive. It just uses a Stack. It returns the same (modified) array every time, but that can be easily changed if needed.
public static IEnumerable<int[]> Combinations(int n, int k)
{
var result = new int[k];
var stack = new Stack<int>();
stack.Push(0);
while (stack.Count > 0) {
int index = stack.Count - 1;
int value = stack.Pop();
while (value < n) {
result[index++] = value++;
stack.Push(value);
if (index == k) {
yield return result;
break;
}
}
}
}
Combinations(6, 2) will give:
[0,1], [0,2], [0,3], [0,4], [0,5], [1,2], [1,3], [1,4], [1,5], [2,3], [2,4], [2,5], [3,4], [3,5], [4,5]

Just for numberOfFlags = 2 this is a simple sollution:
static void Main(string[] args)
{
var array = new bool[] { false, false, false, false, false, false };
var length = array.Length;
for (int i = 0; i < length; i++)
{
for (int j = i + 1; j < length; j++)
{
var arr = (bool[])array.Clone();
arr[i] = arr[j] = true;
arr.ToList().ForEach(s => Console.Write((s ? 1 : 0) + " "));
Console.WriteLine();
}
}
Console.Read();
}
Output:
1 1 0 0 0 0
1 0 1 0 0 0
1 0 0 1 0 0
1 0 0 0 1 0
1 0 0 0 0 1
0 1 1 0 0 0
0 1 0 1 0 0
0 1 0 0 1 0
0 1 0 0 0 1
0 0 1 1 0 0
0 0 1 0 1 0
0 0 1 0 0 1
0 0 0 1 1 0
0 0 0 1 0 1
0 0 0 0 1 1

The number of combinations can be calculed with:
P=(n!)/(a!·b!)
Where n is the lenght of the array, a is numberOfFlags and b is n - a.
This is a method of achieving what you want:
bool[] array = new bool[] { false, false, false,false};
int numberOfFlags = 1;
int n, a, b,_n,_a,_b;
n = array.Length;
_n = n;
a = numberOfFlags;
_a = a;
b = n - a;
_b = b;
//Calculate n!
for (int i = _n - 1; i >= 1; i--)
n = n * i;
//Calculate a!
for (int i = _a - 1; i >= 1; i--)
a = a * i;
//Calculate a!
for (int i = _b - 1; i >= 1; i--)
b = b * i;
int NumberOfPermutations = n / (a * b);
------EDIT------
This code works only for an array with only 2 possible values. Imagine that we have 3 possible values, then:
n = lenght of the array
a = repetitions of the first value
b = repetitions of the second value
c = n - (a+b) = repetitions of the third value
The number of permutations could be calculed with
P=(n!)/(a!·b!·c! ...)
In the code you should add only some variables, some loops...et voilà

Find string with most frequency of a character in List of strings using LINQ C#

I am dealing with binary vectors so each string in a List<string> looks like
vectors[0] = "1 0 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 1";
vectors[1] = "1 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1";
I want to get the biggest string from the List<string>, with most number of 1's.

I feel like the provided solutions here are way too complicated.
So here is mine:
vectors.OrderByDescending(v => v.Count(c => c == '1')).First();
Note that Count is only evaluated once per "Vector". EnumerableSorter does this for you.
If you want a more performant solution then go with #octavioccls answer

I would do this:
var biggest= vectors.Select(v=> new {Vector = v, Count = v.Count(c => c=='1')})
.Aggregate((seed, current) => seed.Count < current.Count ? current:seed)
.Vector;
You can also use OrderBy extension method but Aggregate is O(n) while OrderBy is O(n* log n).
I first call Select extension to avoid calculate multiple times the amount of 1's of seed:
var biggest= vectors.Aggregate((seed, current)=>seed.Count(c=>c=='1')<current.Count(c=>c=='1')?current:seed);

You can use Count() method:
int index = 0;
int max = vectors[0].Count(x => x == '1');
for (int a = 1; a < vectors.Length; a++)
{
var count = vectors[a].Count(x => x == '$');
if (count > max)
{
max = count;
index = a;
}
}
after loop you will have index of string which has maximum '1'

Using LINQ
var result = vectors.Select(d => new { Item = d,
OneCount = d.Split(' ').Count(y => y == "1")})
.OrderByDescending(t => t.OneCount)
.Select(k=>k.Item).FirstOrDefault();

vectors.OrderByDescending(b => b.Split('1').Length).First()

You can do a loop on the list and for each string calculate the number of occurences of '1' in this way:
int count = myString.Split('1').Length - 1;
Then store a temporary variable with the local maximum and the number of string with that maximum.
Like this:
int max = list[0].Split('1').Length - 1;
int stringMax = 0;
for (int i = 1; i < list.Length; i++)
{
var count = list[i].Split('1').Length - 1;
if (count > max)
{
max = count;
stringMax = i;
}
}
At the end stringMax is the string with max value and max is that value

var vectors = new[] {
"1 0 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 1",
"1 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1",
};
var q = from v in vectors
select new
{
v,
c = v.Split(' ').Count(b => b == "1"),
};
var m = q.First(c => c.c == q.Max(b => b.c)).v;

using System;
using System.Collections.Generic;
public class Program
{
public static void Main()
{
Console.WriteLine("Hello World");
var vectors = new List<string>();
vectors.Add("1 0 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 1");
vectors.Add("1 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1");
foreach(var v in vectors)
{
var result = new List<string>();
int max = 0;
foreach(var c in v)
{
if(string.IsNullOrEmpty(c.ToString().Trim())) continue;
//Console.Write(c);
//Console.Write(max);
if(c != '1')
{
max = 0;
}
else
{
max++;
if(max > result.Count)
{
result.Add(c.ToString());
}
}
}
Console.WriteLine("Final Result: " + string.Join(" ", result));
}
}
}