<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by VAIBHAVI G on Medium]]></title>
        <description><![CDATA[Stories by VAIBHAVI G on Medium]]></description>
        <link>https://medium.com/@g.vaibhavi410?source=rss-0be2f6358c20------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*w_KIFmiFNQBphY-z</url>
            <title>Stories by VAIBHAVI G on Medium</title>
            <link>https://medium.com/@g.vaibhavi410?source=rss-0be2f6358c20------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 13:59:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@g.vaibhavi410/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Understanding EDA]]></title>
            <link>https://medium.com/@g.vaibhavi410/understanding-eda-910ccad1bef0?source=rss-0be2f6358c20------2</link>
            <guid isPermaLink="false">https://medium.com/p/910ccad1bef0</guid>
            <dc:creator><![CDATA[VAIBHAVI G]]></dc:creator>
            <pubDate>Thu, 06 Aug 2026 15:40:40 GMT</pubDate>
            <atom:updated>2026-08-06T15:46:29.906Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>What is EDA and why does it even matter?</em></strong></p><p>Before building any predictive model,there’s a step known as “Exploratory Data Analysis” or “EDA”. This process involves looking at your data before doing anything else with it in simple terms it means understanding what each column means, spotting missing values or inconsistencies, finding outliers and finding patterns that aren’t obvious just from looking at raw numbers in a spreadsheet.</p><p>EDA is done in stages- starting with univariate analysis i.e looking at a one column at a time or looking at one variable at a time for eg.:(the distribution of runs scored on a single ball), second one is Bivariate analysis as the name suggest “Bi”-means two so here we look at two variables or two columns and find relation between them for eg.: (runs scored across different overs) and the next one is Multivariate analysis means bringing three or more variables together or finding relation between multiple columns for eg.: (how scoring patterns differ by team and by over simultaneously)</p><p>In this article, we are going to take a look at all this stages and understand them.I’m going to use the IPL cricket dataset from Kaggle (deliveries.csv) in which we will understand how scoring evolves through an innings, which teams and players stand out and whether the pressure of chasing a target actually changes how batters play.</p><p>The dataset- deliveries.csv contains ~193,068 rows, where each row represents a single ball bowled in an IPL match. Columns include which teams were playing, who was batting and bowling, how many runs were scored, and whether a wicket fell.</p><p>So before diving into analysis, we did some basic checks like- .shape, .head(), .info(),.isnull().sum() which helps us to understand few basic things how the data looks .shape tells you the size of the dataset(rows and columns), .head() gives a quick preview of the first few rows, .info() shows column data types and non-null values count and .isnull().sum() flags how many missing values each column has.</p><p><strong>Cleaning the data:</strong></p><p>After doing some basic checks it’s worth checking inconsistencies. We started by checking .unique() on the batting_team and bowling_team columns to find out the unique teams and found a issue that “Rising Pune Supergant” and “Rising Pune Supergants”were being treated as two different teams, purely because of a missing “s”. If left unfixed, this would split the team’s stats across two labels -undercounting their actual runs, wickets, and appearances. We merged them using .replace( ), which brought the unique team count down by one.</p><p>We also checked for missing values using .isnull().sum(). Columns like fielder,dismissal_kind, and player_dismissed had a large number of NaNs .These columns are only populated when a wicket actually falls, so most balls in the dataset naturally leave them empty. At last we checked .duplicated().sum(), which gives zero as result as there are no duplicate rows. Looking at extras_type, wides turned out to be the most common type of extra, followed by leg byes, no-balls, and byes.</p><p><strong>Univariate Analysis:</strong></p><p>The first stage of any EDA is univariate analysis- looking at a single column and understand its distribution before comparing it. Starting with batsman_runs (runs scored on a single ball), the most common value by far is 0 which makes sense as in T20 format most balls are defended or blocked not hit for runs.Next looking at wickets by over using is_wicket, grouped by the over column. Wickets aren’t spread evenly across the innings they are increased around the 19th over.Batters usually take far more risk in second-to-last over, which makes high possiblity of maximazing the boundaries which naturally increases the chance of getting out.Finally, we checked dismissal_kind to see how batters most commonly get out. “Caught” was by far the most frequent dismmisal type.</p><p><strong>Bivariate Analysis:</strong></p><p>The next step is checking how two variables/columbs relate which is bivariate analysis.Plotting average runs per over reveals how that in the powerplay the runs increases and as the powerplay gets over there’s a sharp-dip and this “middle overs” phase stays relatively flat through roughly over 14. From there the runs increases steadily again into the death overs(15–19). Looking as team-wise totals, Chennai Super Kings lead in total runs scored across the dataset. On bowling side Mumbai Indians took the most wickets.</p><p><strong>Multivariate Analysis:</strong></p><p>Looking at three variables or more than that here we build heatmap of average runs per over which results in this: in the death overs, most runs are scored by all teams, not just one or two (shown in dark red). Middle overs (6–14) are consistently the palest zone for nearly every team too. A couple of outliers stood out. Kochi Tuskers Kerala showed a surprising spike around overs 3-4 -but this is worth reading with caution, since they only played a single IPL season, meaning their numbers are based on far fewer matches than teams like Mumbai Indians or Chennai Super Kings. A heatmap makes it easy to spot patterns like this, but it’s just as important to notice when a “pattern” is really just a small sample of data creating a misleading spike.</p><p><em>Player level analysis:</em></p><blockquote><em>Team and phase-level patterns tell part of the story, but individual players are where cricket really comes alive. So we zoomed in to see who stands out across the whole dataset. Looking at total runs scored, Raina made the most runs, but Sehwag has a higher strike rate -a nice contrast between two different paths to being a standout batter, one built on consistency and longevity, the other on fast, explosive scoring whenever he’s at the crease. For bowling, Malinga takes the top spot in both wickets taken and economy rate, a rare combination since attacking bowlers usually concede more runs while chasing wickets.</em></blockquote><p><em>Does batting really change when you’re chasing?</em></p><p>One question which needs to be answered : does the pressure of chasing a target actually change how batters approach scoring, compared to batting first and setting one? To answer this we compared the distribution of run values between the 1st and 2nd innings using a KDE plot-and the two distributions overlap almost perfectly. We also compared the over-by-over scoring trend between innings using a line plot, and again, the two lines track each other closely throughout the innings, including through the powerplay-dip-death-overs pattern seen earlier.</p><blockquote><strong><em>Key insights</em></strong></blockquote><blockquote>1. Dot balls (0 runs) are the single most common outcome of any delivery</blockquote><blockquote>2.Scoring follows a clear three-phase pattern -powerplay rise, middle-overs dip, death-overs surge -and this holds across nearly every team, not just on average.</blockquote><blockquote>3.Wickets spike in the 19th over, as batters take on more risk late in the innings</blockquote><blockquote>4.1st and 2nd innings show nearly identical run distributions and over-by-over scoring trends-chasing pressure doesn’t visibly change ball-by-ball behavior</blockquote><blockquote>5.Raina leads in total runs (consistency), while Sehwag leads in strike rate (explosiveness).</blockquote><blockquote>6.Malinga leads in both wickets taken and economy rate -a rare combination that points to genuinely efficient bowling</blockquote><blockquote><strong><em>Conclusion</em></strong></blockquote><blockquote><em>This blog covered univariate, bivariate, and multivariate analysis using ball-by-ball IPL data alone. If you’d like to see the full code and plots behind this analysis, the notebook is available on my GitHub [</em><a href="https://github.com/Vaibhavi410/ipl-ball-by-ball-eda"><em>https://github.com/Vaibhavi410/ipl-ball-by-ball-eda</em></a><em>].</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=910ccad1bef0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Bit to ‘Built-in’: A Deep Dive into Datatypes in C]]></title>
            <link>https://medium.com/@g.vaibhavi410/from-bit-to-built-in-a-deep-dive-into-datatypes-in-c-6d4f164f8128?source=rss-0be2f6358c20------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d4f164f8128</guid>
            <category><![CDATA[datatypes-in-c]]></category>
            <dc:creator><![CDATA[VAIBHAVI G]]></dc:creator>
            <pubDate>Sat, 08 Nov 2025 15:36:22 GMT</pubDate>
            <atom:updated>2025-11-08T15:36:22.632Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*ySG-92MFzXmU5VlxJLS6VA.png" /></figure><p>As far as we all know there are some datatypes in any programming language because that’s what we have been taught at start of any programming language.. So now let’s deep dive into that, think of our human body what’s the fundamental unit of that ?? Obviously it has to be Cell. And collection of cells is known as tissues.</p><p>Similarly Bit is the basic storage unit which computer understands it can store only two values either “0” or “1”. Take the examples of switches consider switch is a bit so for “1” we can mean it’s “ON” and for “0” we can it’s “OFF”..</p><p>But don’t you think that single bit is too small to use that’s why we or rather Computer uses collection of bits for all operations. Do you know collection of bits which is also called as bytes is also known as “OCTET”. There’s a reason why it’s called octet we know 1 byte consists of 8 bits and what 8 is called ??? OCTET !!</p><p>Let’s now look at some datatypes we have 3 categories in that</p><ul><li><em>Primary Datatypes</em></li><li><em>User defined datatypes</em></li><li><em>Derived Datatypes</em></li></ul><h3>Primary Datatypes</h3><p>So first one Primary Datatypes or we can call them as Built-in Datatypes. C’s built-in integer datatypes do not assume all possible integral values, but values between maximum and minimum bound. The reason for these bounds is that C uses fixed amount of memory for individual integer. If that size is 32 bits, then only 2³² integers can be represented, since bit has only 2 states.</p><p>Let’s see this through a diagram:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/0*DyY6Na_fGAxxfsPR" /></figure><p>Primary Data types</p><ul><li>Integer Datatype ( int, short int, long int, unsigned int, unsigned short int, unsigned long int)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/0*tzSyVDwmeqXeOXoi" /></figure><p>Integer data type</p><ul><li>Character( signed char, unsigned char)</li></ul><p>Do you know character is also integer datatype you might be wondering that why so? let’s get into this we know every char has it’s ASCII value so we can treat them as character too or as integer also by printing their ASCII value..</p><p>Following are the ASCII value:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/937/0*lwQnexKnledetDyk" /></figure><p>ASCII Values</p><ul><li>Floating Point type( Float, double, long double)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/258/0*MQLXHDx48UuQ0r0s" /></figure><p>Float Datatype</p><p>Extra Knowledge💡<em>:ANSI C The first official standardized version of C programming language.(American National Standards Institute)</em></p><h3>Derived Datatypes</h3><p>We know primitive or basic datatypes are used to store single values but what if we want to store multiple values of same datatype in one variable rather than creating multiple variable separately. So here we have Derived Datatypes which allows to combine the basic data types and store multiple values in a single variable..</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/185/0*F-7y8f0YqVBekzhr" /></figure><ul><li>Array: An array is a collection of similar data-type elements stored in a contiguous memory location. The default value of an integer array will be zero.</li><li>Pointer: Pointer is a variable used to store the address of another variable. To store the address of a variable, the pointer variable should be of the same data type. Pointer enables a user to perform dynamic memory allocation in C language and also pass variables by reference, which means that the user can pass the pointer having the address of the variable. A pointer with no address is known as the null pointer, while a pointer with no data type is called a void or general-purpose pointer. To access the value stored in the address that the pointer is referring to, you should use the ‘*’ operator.</li><li>Union: Union is also a collection of elements with similar or different data types, but the memory location is the same for all the elements. It is a special kind of data type in C language, where you can declare many variables, but only one variable can store the value at a given time. Union is defined by the ‘union’ keyword, where each object will represent a single record. The size of a union will be equal to the memory needed for the largest variable inside it</li></ul><h3>User Defined Datatypes/Enumeration Datatype</h3><p>These are the datatypes which are created by programmers there structure is made by programmers. Enumeration is a user-defined data type used to assign names to the integral constants and enhance the readability of your program.</p><ul><li>Enum constants get default values by the compiler</li><li>They can be declared in the local scope</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/407/0*klDDh13Xv2FMW2sL" /></figure><p>Now let’s see one by one</p><ol><li>Structure (struct) →Group different data types together.</li><li>Union (union) →Store different data types in same memory location (saves memory)Store either int or float or char at one time.</li><li>Enumeration (enum) Create names for integer values.</li><li>Typedef (typedef) Create a short name for a datatype.</li></ol><p>That’s it !! Thank you..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d4f164f8128" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>