A program that analyses text and prints how many of each character there is

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <cctype>
#include <iterator>


template <typename Map_Keys_T, typename Map_Values_T>
void printMap(std::map<Map_Keys_T, Map_Values_T> input_map) { // Iterates through map, printing key and value with a indent between, takes new line for each element
    for (auto &x : input_map) {
        std::cout << x.first << "\t" << x.second << "\n";
    }
}


int countChars(std::string input, char x) { // Counts the amount of times the input character appears in text, and returns that value
    int value = 0;
    for (char letter : input) {
        if (x == letter) {
            value++;
        }
    }
    return value;
}

template <typename Vector_T>
bool isInVector(std::vector<Vector_T> char_vector, Vector_T element_to_search) {
    for (Vector_T element : char_vector) {
        if (element == element_to_search) {
            return true;
        }
    }
}

std::string to_lowercase(std::string text) { // Converts input string to lowercase, and returns the converted text
    std::transform(text.begin(), text.end(), text.begin(),
        [](unsigned char c) { return std::tolower(c); });
    return text;
}

template <typename Key_T, typename Value_T>
std::map<Key_T, Value_T> mapZipper(std::vector<Key_T> keys, std::vector<Value_T> values) { // Zips two vectors together into a map variable and returns the map
    std::map<Key_T, Value_T> final_map;
    for (int i = 0; i < keys.size(); i++) {
        final_map.insert({keys[i], values[i]});
    }
    return final_map;
}

std::map<char, int> sentenceAnalyzer(std::string sentence) { // Analyzes the text, returns a map with the structure: {letter : number_of_times_letter_appears_in_text}
    std::map<char, int> amount_of_letters_map;
    sentence = to_lowercase(sentence);
    std::vector<char> characters;
    std::vector<int> characters_amount;

    for (auto letter : sentence) {
        int number_of_letters_in_text = countChars(sentence, letter);
        if (isInVector(characters, letter) != true) {
            characters.push_back(letter);
            characters_amount.push_back(number_of_letters_in_text);
        }
    }
    amount_of_letters_map = mapZipper<char, int>(characters, characters_amount);
    return amount_of_letters_map;
}


int main() {
    std::string sentence;
    std::map<char, int> results;
    std::map<char, int>::iterator it;
    std::cout << "Enter a sentence: ";
    std::getline(std::cin, sentence);

    results = sentenceAnalyzer(sentence);

    printMap<char, int>(results);
    return 0;
}