Find Beautiful Indices in the Given Array I solution and explanation

arr = [1, 2, 3, 4, 5]
target = 7

for i in range(len(arr) - 1):
    for j in range(i + 1, len(arr)):
        if arr[i] + arr[j] == target:
            print(f"Pair found: ({arr[i]}, {arr[j]})")

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

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] + arr[j] == target) {
                    System.out.println("Pair found: (" + arr[i] + ", " + arr[j] + ")");
                }
            }
        }
    }
}

#include <iostream>
using namespace std;

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

    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i] + arr[j] == target) {
                cout << "Pair found: (" << arr[i] << ", " << arr[j] << ")\n";
            }
        }
    }
    return 0;
}

const arr = [1, 2, 3, 4, 5];
const target = 7;

for (let i = 0; i < arr.length - 1; i++) {
    for (let j = i + 1; j < arr.length; j++) {
        if (arr[i] + arr[j] === target) {
            console.log(`Pair found: (${arr[i]}, ${arr[j]})`);
        }
    }
}

#include <stdio.h>

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

    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i] + arr[j] == target) {
                printf("Pair found: (%d, %d)\n", arr[i], arr[j]);
            }
        }
    }
    return 0;
}

using System;

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

        for (int i = 0; i < arr.Length - 1; i++) {
            for (int j = i + 1; j < arr.Length; j++) {
                if (arr[i] + arr[j] == target) {
                    Console.WriteLine($"Pair found: ({arr[i]}, {arr[j]})");
                }
            }
        }
    }
}

arr = [1, 2, 3, 4, 5]
target = 7
hash_table = {}

for value in arr:
    complement = target - value
    if complement in hash_table:
        print(f"Pair found: ({complement}, {value})")
    hash_table[value] = True

import java.util.HashMap;

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

        HashMap<Integer, Boolean> hashMap = new HashMap<>();

        for (int value : arr) {
            int complement = target - value;
            if (hashMap.containsKey(complement)) {
                System.out.println("Pair found: (" + complement + ", " + value + ")");
            }
            hashMap.put(value, true);
        }
    }
}

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int target = 7;

    unordered_map<int, bool> hashTable;

    for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++) {
        int complement = target - arr[i];
        if (hashTable.find(complement) != hashTable.end()) {
            cout << "Pair found: (" << complement << ", " << arr[i] << ")\n";
        }
        hashTable[arr[i]] = true;
    }

    return 0;
}

const arr = [1, 2, 3, 4, 5];
const target = 7;
const hashTable = {};

for (const value of arr) {
    const complement = target - value;
    if (hashTable[complement]) {
        console.log(`Pair found: (${complement}, ${value})`);
    }
    hashTable[value] = true;
}

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

#define TABLE_SIZE 101

typedef struct HashNode {
    int key;
    int value;
    struct HashNode *next;
} HashNode;

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

void insert(HashNode **table, int value) {
    int index = hash(value);
    HashNode *newNode = (HashNode *)malloc(sizeof(HashNode));
    newNode->key = value;
    newNode->value = value;
    newNode->next = table[index];
    table[index] = newNode;
}

int search(HashNode **table, int value) {
    int index = hash(value);
    HashNode *temp = table[index];
    while (temp != NULL) {
        if (temp->value == value) {
            return 1;
        }
        temp = temp->next;
    }
    return 0;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int target = 7;
    int n = sizeof(arr) / sizeof(arr[0]);
    HashNode *hashTable[TABLE_SIZE] = {0};

    for (int i = 0; i < n; i++) {
        int complement = target - arr[i];
        if (search(hashTable, complement)) {
            printf("Pair found: (%d, %d)\n", complement, arr[i]);
        }
        insert(hashTable, arr[i]);
    }

    return 0;
}

using System;
using System.Collections.Generic;

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

        Dictionary<int, bool> hashTable = new Dictionary<int, bool>();

        foreach (int value in arr) {
            int complement = target - value;
            if (hashTable.ContainsKey(complement)) {
                Console.WriteLine($"Pair found: ({complement}, {value})");
            }
            hashTable[value] = true;
        }
    }
}

func beautifulIndices(s string, a string, b string, k int) []int {

	s_len := len(s)
	a_len := len(a)
	b_len := len(b)

	final := make([]int, 0)
	lps_a := make([]int, a_len)
	lps_b := make([]int, b_len)
	a_index := make([]int, 0)
	b_index := make([]int, 0)

	var pat func(lps []int, s_l int, pattern string)

	pat = func(lps []int, s_l int, pattern string) {

		l := 0
		lps[0] = 0
		i := 1

		for i < s_l {
			if pattern[i] == pattern[l] {
				l++
				lps[i] = l
				i++
			} else {
				if l != 0 {
					l = lps[l-1]
				} else {
					lps[i] = l
					i++
				}
			}
		}
	}

	pat(lps_a, a_len, a)
	pat(lps_b, b_len, b)

	var kmp func(pat string, pat_l int, lps []int, index *[]int)

	kmp = func(pat string, pat_l int, lps []int, index *[]int) {
		i := 0
		j := 0
		for s_len-i >= pat_l-j {
			if s[i] == pat[j] {
				i++
				j++
			}
			if j == pat_l {
				*index = append(*index, i-pat_l)
				j = lps[j-1]
			} else if s[i] != pat[j] {
				if j != 0 {
					j = lps[j-1]
				} else {
					i++
				}
			}
		}
	}

	kmp(a, a_len, lps_a, &a_index)
	kmp(b, b_len, lps_b, &b_index)

	// fmt.Println(a_index, b_index)

	i := 0
	j := 0

	for i < len(a_index) && j < len(b_index) {
		if a_index[i]+k >= b_index[j] && a_index[i]-k <= b_index[j] {
			final = append(final, a_index[i])
			i++
		} else if a_index[i]-k > b_index[j] {
			j++
		} else {
			i++
		}
	}

	return final
}