1class Solution {
2    /**
3     * Generates a tag from the given caption in hashtag style.
4     * The first word is in lowercase, subsequent words are capitalized.
5     * The result is prefixed with '#', and output is limited to 100 characters.
6     *
7     * @param caption the input string to generate the tag from
8     * @return the formatted tag string
9     */
10    public String generateTag(String caption) {
11        // Trim the caption and split it into words using whitespace as delimiter
12        String[] words = caption.trim().split("\\s+");
13        // Initialize a StringBuilder with the hashtag prefix
14        StringBuilder tagBuilder = new StringBuilder("#");
15
16        // Iterate through the split words
17        for (int i = 0; i < words.length; i++) {
18            String word = words[i];
19            // Skip empty words (caused by consecutive spaces)
20            if (word.isEmpty()) {
21                continue;
22            }
23
24            // Convert word to lowercase
25            word = word.toLowerCase();
26            if (i == 0) {
27                // First word remains fully in lowercase
28                tagBuilder.append(word);
29            } else {
30                // Capitalize the first letter, leave the rest in lowercase
31                tagBuilder.append(Character.toUpperCase(word.charAt(0)));
32                if (word.length() > 1) {
33                    tagBuilder.append(word.substring(1));
34                }
35            }
36
37            // If we've reached or exceeded the length cap, stop processing further words
38            if (tagBuilder.length() >= 100) {
39                break;
40            }
41        }
42
43        // Ensure the final tag does not exceed 100 characters
44        return tagBuilder.length() > 100 ? tagBuilder.substring(0, 100) : tagBuilder.toString();
45    }
46}
47

1class Solution {
2public:
3    // Generates a tag from the input caption.
4    string generateTag(string caption) {
5        istringstream input_stream(caption);   // To split words by spaces
6        string word;
7        ostringstream tag;                     // To build the result hashtag
8        tag << "#";
9
10        bool isFirstWord = true;               // To track the first word for lowercase
11        while (input_stream >> word) {
12            // Convert word to lowercase
13            transform(word.begin(), word.end(), word.begin(), ::tolower);
14
15            if (isFirstWord) {
16                tag << word;
17                isFirstWord = false;
18            } else {
19                // Capitalize first letter for subsequent words (CamelCase)
20                word[0] = toupper(word[0]);
21                tag << word;
22            }
23
24            // If the tag length has reached or exceeded 100, exit loop
25            if (tag.str().length() >= 100) {
26                break;
27            }
28        }
29
30        string result = tag.str();
31        // Ensure the tag does not exceed 100 characters in length
32        if (result.length() > 100) {
33            result = result.substr(0, 100);
34        }
35        return result;
36    }
37};
38

1/**
2 * Converts a caption into a single camel-cased hashtag string.
3 * Words are concatenated together with the first word in lowercase,
4 * subsequent words capitalized, and prefixed with '#'.
5 * Maximum length of result is 100 characters (including the '#').
6 *
7 * @param caption - The input string to be converted.
8 * @returns The generated hashtag string.
9 */
10function generateTag(caption: string): string {
11    // Split caption into an array of non-empty words
12    const words: string[] = caption.trim().split(/\s+/);
13
14    // Initialize the result with '#'
15    let result: string = '#';
16
17    for (let i = 0; i < words.length; i++) {
18        // Convert current word to lowercase
19        const word: string = words[i].toLowerCase();
20
21        // Add the word to result, capitalizing first letter if not the first word
22        if (i === 0) {
23            result += word;
24        } else {
25            result += word.charAt(0).toUpperCase() + word.slice(1);
26        }
27
28        // Truncate the result to 100 characters if necessary
29        if (result.length >= 100) {
30            result = result.slice(0, 100);
31            break;
32        }
33    }
34
35    return result;
36}
37