COUNTING ONES IN

A WINDOW
Name: Dhruv Singhal
Roll Number: 2K20/PE/25
Definition of Counting Ones
■ Counting Ones refers to the process of counting the number of digits in a binary representation
of a number that are equal to 1. In other words, it is the count of how many times the bit 1
appears in a binary number. This technique is commonly used in computer science and digital
electronics for various applications, such as analyzing data, optimizing algorithms, and designing
circuits.
■ Sliding Window Technique
– The sliding window technique involves dividing a continuous data stream into fixed-sized
windows and processing the data within each window. As new data arrives, the window
slides over the stream, and calculations are made on the elements within the window. This
technique is commonly used in various data analysis applications, such as signal processing
and time series analysis, to detect patterns or anomalies in real-time. The size of the
window is an important parameter that affects the analysis results.
Algorithm for Counting Ones In A
Window
1. Initialize two pointers: start and end, both pointing to the first digit of the window.
2. Set a variable 'count' to 0, which will hold the number of ones found in the window.
3. While the end pointer is within the bounds of the array/string:
1. Check if the value at the end pointer is 1.
2. If yes, increment the count variable by 1.
3. Increment the end pointer by 1.
4. Check if the window size is greater than the desired size:
1. If yes, check if the value at the start pointer is 1.
2. If yes, decrement the count variable by 1.
3. Increment the start pointer by 1.
4. Return the count variable as the result.

This algorithm maintains a sliding window of a fixed size and moves it over the array/string one element at a time.
At each step, it checks if the value at the end pointer is 1 and updates the count variable accordingly. It then
checks if the window size is greater than the desired size and adjusts the count variable by decrementing it if the
value at the start pointer is 1. Finally, it returns the count variable as the result of counting ones in the window.
DGIM Algorithm
■ The DGIM (Datar-Gionis-Indyk-Motwani) algorithm is a method for counting the number of ones in a sliding
window of a binary array. The algorithm uses a binary tree data structure to efficiently store information
about the ones in the array.
■ The binary tree has log n levels, where n is the size of the array, and each level represents a different time
interval. At each level, the ones in the corresponding time interval are grouped into buckets, with each bucket
containing twice as many ones as the previous bucket. The algorithm works by periodically merging adjacent
buckets to reduce the number of levels in the tree and maintain a logarithmic time complexity.
■ To count the number of ones in a sliding window, the algorithm first determines the levels that intersect with
the window and sums the ones in the corresponding buckets. It then uses the merged buckets to estimate
the number of ones in the remaining levels and adds the estimated count to the sum. The final count is
obtained by subtracting the overestimated ones from the last merged bucket.
■ Overall, the DGIM algorithm is a powerful and efficient method for counting ones in a window, with a time
complexity of O(log n) and a space complexity of O(log n). It has many real-world applications, including
network traffic monitoring, database management, and social media analytics.
Here's an example of a binary array and window size:
■ Binary Array: 1101101000111010
■ Window Size: 5
■ In this example, the binary array has 16 elements and contains a mix of ones and zeros. The window size is
set to 5, which means that we need to count the number of ones in every window of 5 elements that slides
over the array.
■ We can apply the sliding window technique to count the number of ones in each window as follows:
– Window 1: 11011 -> count = 4
– Window 2: 10110 -> count = 3
– Window 3: 01101 -> count = 2
– Window 4: 11010 -> count = 3
– Window 5: 10100 -> count = 2
– Window 6: 01000 -> count = 1
– Window 7: 10001 -> count = 2
– Window 8: 00011 -> count = 1
– Window 9: 00111 -> count = 2
– Window 10: 11101 -> count = 3
– Window 11: 11010 -> count = 3

■ In this example, we have counted the number of ones in each window of size 5 and recorded the counts in
the order in which the windows appear in the array. The counts vary from window to window depending on
the number of ones in each window.
Complexities

■ Time Complexity
– The time complexity of the DGIM algorithm is O(log n), where n is the size of the sliding window. This is
because the algorithm maintains a bucket array with a maximum of O(log n) buckets, and each update
operation on the array takes O(log n) time. The total number of ones in the sliding window can be
calculated in O(log n) time by adding up the counts from the buckets in the array. Therefore, the DGIM
algorithm is efficient for counting ones in a sliding window of a binary array.
■ Space Complexity
– The space complexity of the DGIM algorithm is O(log n), where n is the size of the sliding window. This
is because the algorithm maintains a bucket array with a maximum of O(log n) buckets, and each
bucket stores information about the count of ones in a certain time range. Since the number of buckets
in the array is at most O(log n), the space complexity of the algorithm is also O(log n). Therefore, the
DGIM algorithm requires a relatively small amount of space to perform efficient counting of ones in a
sliding window of a binary array.
Comparison of the algorithm with other
approaches

■ The DGIM algorithm is a space-efficient algorithm for counting ones in a sliding window of a binary array.
Compared to other traditional approaches like the naive approach of iterating over the window and counting
the ones or maintaining a sliding window with a bit array, the DGIM algorithm offers better time and space
complexity. It can count ones in O(log n) time and with O(log n) space, where n is the size of the sliding
window.
■ Other approaches, like the Bloom filter, can also count ones in a binary array, but they are more suited for
cases where the number of ones is much smaller than the size of the array. In contrast, the DGIM algorithm is
designed to handle scenarios where the number of ones can be relatively large and can fit in a sliding
window.
■ Overall, the DGIM algorithm is a useful and efficient approach for counting ones in a sliding window of a
binary array and can be used in various applications such as network traffic monitoring, social media
analytics, and database management.
Examples of how the algorithm can be
used in various fields
■ The DGIM algorithm can be used in various fields to efficiently count ones in a sliding window of a binary
array. Here are some examples:
1. Internet of Things (IoT): In IoT applications, devices generate large volumes of data that need to be
processed in real-time. The DGIM algorithm can be used to efficiently count the number of events or
messages generated by IoT devices within a sliding time window. This information can help to monitor device
activity, detect anomalies, and trigger alerts when necessary.
2. Financial data analysis: In financial data analysis, the DGIM algorithm can be used to count the number of
trades or transactions within a sliding time window. This information can help to monitor market activity,
detect unusual trading patterns, and prevent fraud.
3. Social media advertising: In social media advertising, the DGIM algorithm can be used to count the number
of clicks or impressions generated by ads within a sliding time window. This information can help advertisers
to measure the effectiveness of their campaigns, optimize their targeting, and adjust their budget
accordingly.
4. Healthcare monitoring: In healthcare monitoring, the DGIM algorithm can be used to count the number of
events or alarms generated by medical devices within a sliding time window. This information can help to
monitor patient health, detect anomalies, and trigger alerts when necessary.
■ Overall, the DGIM algorithm is a powerful tool for counting ones in a sliding window of a binary array, and its
applications are diverse and span across many fields, including IoT, finance, social media, and healthcare.
Real-world applications
■ Counting ones in a window has many real-world applications, particularly in the field of data processing and
analysis. Some examples include:
1. Network traffic monitoring: In network monitoring, counting ones in a sliding window is used to keep track
of the number of incoming and outgoing packets. This information can help network administrators to
identify potential network issues, such as packet loss, congestion, or security breaches.
2. Social media analytics: In social media analytics, counting ones in a sliding window can be used to monitor
the number of likes, shares, and comments on social media posts. This information can help businesses and
marketers to understand the popularity and reach of their content and adjust their social media strategy
accordingly.
3. Database management: In database management, counting ones in a sliding window can be used to monitor
the number of active sessions, queries, and transactions. This information can help database administrators
to optimize the database performance and prevent system overload.
4. Video streaming: In video streaming, counting ones in a sliding window can be used to monitor the number
of viewers and their viewing behavior. This information can help content providers to optimize the streaming
quality and prevent buffering and other issues.
■ Overall, counting ones in a sliding window is a powerful tool for data processing and analysis, and its
applications are diverse and far-reaching.
Importance of counting ones in a
window
■ Counting ones in a window is an important technique in data science and machine learning for various
reasons, including:
1. Data preprocessing: In data preprocessing, counting ones in a sliding window of a binary array can be used to
create new features from raw data. For example, in natural language processing, counting the occurrence of
specific words in a sliding window can help to identify the topic or sentiment of a text.
2. Anomaly detection: In machine learning, counting ones in a sliding window can be used to detect anomalies
or outliers in time-series data. For example, if the number of ones in a sliding window suddenly increases or
decreases significantly, it can indicate an unusual event or behavior that needs further investigation.
3. Time-series analysis: In time-series analysis, counting ones in a sliding window can be used to calculate
various statistics, such as the mean, standard deviation, or trend of the data within the window. This
information can help to identify patterns or trends in the data, and to make predictions about future values.
4. Model evaluation: In machine learning, counting ones in a sliding window can be used to evaluate the
performance of a model. For example, if the model predicts the number of ones in a sliding window, the
difference between the actual and predicted values can be used as a performance metric.
■ Overall, counting ones in a window is a versatile technique that can be used in various data science and
machine learning tasks, including data preprocessing, anomaly detection, time-series analysis, and model
evaluation.
Summary
■ In this discussion, we covered the following key points related to counting ones in a window and the DGIM
algorithm:
• Counting ones in a window is a technique for counting the number of ones in a sliding window of a binary
array.
• The sliding window technique involves moving a fixed-sized window across the array and counting the
number of ones within the window.
• The DGIM algorithm is a more efficient approach for counting ones in a window that uses a binary tree data
structure to store information about the ones in the array.
• The time complexity of the DGIM algorithm is O(log n), which is much faster than the naive approach of
scanning the entire window, which has a time complexity of O(w).
• The space complexity of the DGIM algorithm is O(log n), which is relatively small compared to the size of the
input array.
• Counting ones in a window has many real-world applications, including network traffic monitoring, social
media analytics, database management, and video streaming.
• Counting ones in a window is an important technique in data science and machine learning for tasks such as
data preprocessing, anomaly detection, time-series analysis, and model evaluation.