Number of Ways to Select Buildings solution and explanation

def two_pointer(arr):
    left, right = 0, len(arr) - 1
    while left < right:
        # Condition and logic to be implemented
    # Return or modify based on the problem needs

public class TwoPointer {
    public void twoPointerMethod(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            // Condition and logic to be implemented
        }
    }
}

#include <iostream>
#include <vector>

void twoPointer(const std::vector<int> &arr) {
    int left = 0, right = arr.size() - 1;
    while (left < right) {
        // Condition and logic to be implemented
    }
}

function twoPointer(arr) {
    let left = 0, right = arr.length - 1;
    while (left < right) {
        // Condition and logic to be implemented
    }
    // Return or manipulate array as needed
}

#include <stdio.h>

void twoPointer(int arr[], int n) {
    int left = 0, right = n - 1;
    while (left < right) {
        // Condition and logic to be implemented
    }
    // Output result or modify based on application
}

using System;

public class TwoPointer {
    public void TwoPointerMethod(int[] arr) {
        int left = 0, right = arr.Length - 1;
        while (left < right) {
            // Condition and logic to be implemented
        }
    }
}

def hash_map_approach(arr):
    hash_map = {}
    for num in arr:
        # Logic utilizing the hash map
    # Output or further manipulation based on specific logic

import java.util.HashMap;

public class HashMapTechnique {
    public void hashMapMethod(int[] arr) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int num : arr) {
            // Logic utilizing the hash map
        }
    }
}

#include <iostream>
#include <unordered_map>

void hashMapApproach(const std::vector<int> &arr) {
    std::unordered_map<int, int> map;
    for (int num : arr) {
        // Logic utilizing the hash map
    }
}

function hashMapApproach(arr) {
    const map = new Map();
    for (const num of arr) {
        // Logic utilizing the hash map
    }
    // Return or further processing based on constraints
}

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

// Hashmap implementation
typedef struct {
    int key;
    int value;
} HashMapItem;

int hashFunction(int key) {
    return key % 1000; // Example hash function
}

void hashMapApproach(int arr[], int n) {
    // Hash Map logic to be implemented
}

using System;
using System.Collections.Generic;

public class HashMapTechnique {
    public void HashMapMethod(int[] arr) {
        Dictionary<int, int> map = new Dictionary<int, int>();
        foreach (int num in arr) {
            // Logic utilizing the hash map
        }
    }
}

function numberOfWays(s: string): number {
    const n = s.length;
    const l: number[] = [0, 0];
    const r: number[] = [s.split('').filter(c => c === '0').length, 0];
    r[1] = n - r[0];
    let ans: number = 0;
    for (const c of s) {
        const x = c === '0' ? 0 : 1;
        r[x]--;
        ans += l[x ^ 1] * r[x ^ 1];
        l[x]++;
    }
    return ans;
}

func numberOfWays(s string) (ans int64) {
	n := len(s)
	l := [2]int{}
	r := [2]int{}
	r[0] = strings.Count(s, "0")
	r[1] = n - r[0]
	for _, c := range s {
		x := int(c - '0')
		r[x]--
		ans += int64(l[x^1] * r[x^1])
		l[x]++
	}
	return
}