Battleships in a Board solution and explanation

def brute_force_solution(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(i + 1, n):
            # Check your condition here and process the pair (arr[i], arr[j])
            pass

arr = [1, 2, 3, 4, 5]
brute_force_solution(arr)

public class BruteForceSolution {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        bruteForceSolution(arr);
    }

    public static void bruteForceSolution(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                // Check your condition here and process the pair (arr[i], arr[j])
            }
        }
    }
}

#include <iostream>
#include <vector>

void bruteForceSolution(std::vector<int> &arr) {
    for(size_t i = 0; i < arr.size() - 1; i++) {
        for(size_t j = i + 1; j < arr.size(); j++) {
            // Check your condition here and process the pair (arr[i], arr[j])
        }
    }
}

int main() {
    std::vector<int> arr = {1, 2, 3, 4, 5};
    bruteForceSolution(arr);
    return 0;
}

function bruteForceSolution(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            // Check your condition here and process the pair (arr[i], arr[j])
        }
    }
}

const arr = [1, 2, 3, 4, 5];
bruteForceSolution(arr);

#include <stdio.h>

void bruteForceSolution(int arr[], int n) {
    for(int i = 0; i < n - 1; i++) {
        for(int j = i + 1; j < n; j++) {
            // Check your condition here and process the pair (arr[i], arr[j])
        }
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    bruteForceSolution(arr, n);
    return 0;
}

using System;

class Program
{
    static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        BruteForceSolution(arr);
    }

    static void BruteForceSolution(int[] arr)
    {
        int n = arr.Length;
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                // Check your condition here and process the pair (arr[i], arr[j])
            }
        }
    }
}

def optimized_solution(arr):
    hash_table = {}
    for num in arr:
        # Use hash_table to implement the condition (like finding pairs)
        hash_table[num] = True
        # Your logic here

arr = [1, 2, 3, 4, 5]
optimized_solution(arr)

import java.util.HashMap;

public class OptimizedSolution {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        optimizedSolution(arr);
    }

    public static void optimizedSolution(int[] arr) {
        HashMap<Integer, Boolean> hashMap = new HashMap<>();
        for (int num : arr) {
            // Use hashMap to implement the condition (like finding pairs)
            hashMap.put(num, true);
            // Your logic here
        }
    }
}

#include <iostream>
#include <unordered_map>
#include <vector>

void optimizedSolution(std::vector<int> &arr) {
    std::unordered_map<int, bool> hashTable;
    for(int num : arr) {
        // Use hashTable to implement the condition (like finding pairs)
        hashTable[num] = true;
        // Your logic here
    }
}

int main() {
    std::vector<int> arr = {1, 2, 3, 4, 5};
    optimizedSolution(arr);
    return 0;
}

function optimizedSolution(arr) {
    const hashTable = {};
    for (const num of arr) {
        // Use hashTable to implement the condition (like finding pairs)
        hashTable[num] = true;
        // Your logic here
    }
}

const arr = [1, 2, 3, 4, 5];
optimizedSolution(arr);

#include <stdio.h>
#include <stdlib.h>

#define TABLE_SIZE 1000

int hashFunction(int key) {
    return abs(key) % TABLE_SIZE;
}

void optimizedSolution(int arr[], int n) {
    int hashTable[TABLE_SIZE] = {0};
    for (int i = 0; i < n; i++) {
        // Use hashTable to implement the condition (like finding pairs)
        int key = hashFunction(arr[i]);
        // Your logic here
        hashTable[key] = 1;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    optimizedSolution(arr, n);
    return 0;
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        OptimizedSolution(arr);
    }

    static void OptimizedSolution(int[] arr)
    {
        Dictionary<int, bool> hashTable = new Dictionary<int, bool>();
        foreach (int num in arr)
        {
            // Use hashTable to implement the condition (like finding pairs)
            hashTable[num] = true;
            // Your logic here
        }
    }
}

function countBattleships(board: string[][]): number {
    const m = board.length;
    const n = board[0].length;
    let ans = 0;
    for (let i = 0; i < m; ++i) {
        for (let j = 0; j < n; ++j) {
            if (board[i][j] === '.') {
                continue;
            }
            if (i && board[i - 1][j] === 'X') {
                continue;
            }
            if (j && board[i][j - 1] === 'X') {
                continue;
            }
            ++ans;
        }
    }
    return ans;
}

func countBattleships(board [][]byte) (ans int) {
	for i, row := range board {
		for j, c := range row {
			if c == '.' {
				continue
			}
			if i > 0 && board[i-1][j] == 'X' {
				continue
			}
			if j > 0 && board[i][j-1] == 'X' {
				continue
			}
			ans++
		}
	}
	return
}