Sentiment Word Counter

easyFREEText ClassificationNLP 2: Applications

Given a text and two lists of words (positive and negative), count how many positive and negative words appear in the text and determine the overall sentiment.

Function: sentiment_count(pos, neg, text)

pos: list of positive words
neg: list of negative words
text: the text to analyze (words separated by spaces)

Output: Return the string "positive X negative Y LABEL" where X and Y are counts (every occurrence of a word in the text counts), and LABEL is "positive" if X > Y, "negative" if Y > X, or "neutral" if equal.

All matching is case-insensitive.

Example

Input

good,great,happy
bad,sad,terrible
I feel good and great today

Output

positive 2 negative 0 positive

Reasoning

Inputs: pos is the positive vocabulary {good, great, happy}, neg is the negative vocabulary {bad, sad, terrible}, and text is the sentence I feel good and great today.
Case is ignored, so the sentence becomes the six words: i, feel, good, and, great, today. Each word is checked against both vocabularies.
Positive hits: good ✓ and great ✓, so $X = 2$ . The word happy never appears, which simply contributes nothing.
Negative hits: none of bad, sad or terrible occurs, so $Y = 0$ .
Label: since $X > Y$ ( $2 > 0$ ), the sentiment is positive, giving positive 2 negative 0 positive.
Notice that the word "positive" appears twice in the output for different reasons: once as a fixed tag before the count, once as the label. Every occurrence counts, so "Good good BAD" would score $X = 2$ , $Y = 1$ ; and when $X = Y$ (including $0 = 0$ ) the label is neutral.

Constraints

Case-insensitive matching
Words compared after lowercasing
Output format: "positive X negative Y LABEL"

Learn this in

Text ClassificationNLP Study Plan

More from NLP 2: Applications

BIO Entity Span Extractoreasy Simple Entity Taggereasy Keyword Classifiereasy One-Hot Sequence Encodereasy Sequence Paddereasy

Concept primer

Background Knowledge

The "Sentiment Word Counter" problem falls under the category of Text Classification, a fundamental task in Natural Language Processing (NLP). Text classification involves assigning a label or category to a piece of text based on its content. In this case, we're dealing with sentiment analysis, where the goal is to determine the emotional tone or attitude conveyed by the text. Sentiment analysis can be binary (positive vs. negative) or multi-class (positive, negative, neutral). Here, we're focusing on a simple binary classification with an additional neutral category.

The key concept in this problem is tokenization, which is the process of breaking down text into individual words or tokens. We'll also need to consider case insensitivity, as the matching should not be affected by the case of the words. Furthermore, understanding string manipulation techniques will be essential for splitting the input text into words and comparing them with the given lists of positive and negative words.

In the context of NLP, sentiment analysis is a crucial application, enabling computers to understand the sentiment or emotional tone behind human language. This has numerous applications, including customer feedback analysis, opinion mining, and recommender systems. By solving this problem, you'll gain hands-on experience with basic NLP concepts and techniques, laying the groundwork for more advanced topics like machine learning and deep learning in NLP.

Algorithm/Approach

The general approach to solving this problem involves text preprocessing, tokenization, and sentiment scoring. We'll start by preprocessing the input text and the lists of positive and negative words. Then, we'll tokenize the text into individual words and compare each word with the given lists. By counting the occurrences of positive and negative words, we can determine the overall sentiment of the text.

Step-by-Step Strategy

To implement the solution:

Read the input lists of positive and negative words, and store them in separate data structures.
Read the input text and convert it to lowercase to ensure case-insensitive matching.
Split the input text into individual words or tokens.
Iterate through each word in the text and check if it exists in the list of positive or negative words.
Maintain separate counts for positive and negative words.
After iterating through all words, compare the counts to determine the overall sentiment (positive, negative, or neutral).
Print the output in the required format.

Common Pitfalls

When implementing the solution, watch out for:

Forgetting to handle case insensitivity, which can lead to incorrect matching.
Not accounting for punctuation next to words (e.g., "good," or "bad.").
Failing to split the input text into individual words correctly.
Not handling empty input lists or text.

Time & Space Complexity

The expected time complexity for this problem is O(n + m + k), where n is the number of words in the positive list, m is the number of words in the negative list, and k is the number of words in the input text. The space complexity is O(n + m + k) as well, as we need to store the input lists and the words from the text. However, the actual complexity may vary depending on the specific implementation and data structures used.

solution.py

Python 3.13

Test results