Tag: Python

Is Nevada Really The Most Mountainous State?

Which State Has the Most Mountains over 10k Feet?

I was recently asked which state has the most mountains over 10,000 feet. I guessed Colorado, but was surprised to hear that it is allegedly Nevada.

If you Google this, you can find some evidence for it, in particular this Opinion piece from the Great Falls Tribune, which states:

If measured by the state with the number of named mountain ranges, then the distinction goes to Nevada, according to a member of Blurtit.com, an online question and answer community. 

“Nevada has more than 300 named mountain ranges, all running north-south as part of the Great Basin complex. Elevations range from 2,000 to 3,000 feet. The state has the most number of peaks above 10,000 feet. “

Great Falls Tribune edit board

While I don’t doubt that Nevada has a large number of mountain ranges, I found it hard to believe that Nevada had the most peaks above 10,000 feet, particularly because California contains the bulk of the Sierra Nevada range, and Colorado is known for its many 14,000 foot peaks and has significant areas of land above 10,000 feet in elevation.

Curious to find the answer, I looked at topographic data and mountain summit data to dig into it further. From that, here are my findings: Colorado, not Nevada, has the most mountains over 10,000 feet tall.

Running the Numbers

The first source I looked at was summit data from the Environmental Systems Research Institute. It provided data on mountain peaks, including height in meters and the state and county in which each peak is located. Filtering down the dataset to mountains over 3048 meters (10k feet), here’s how many peaks there are in each state:

StateNumber of 10,ooo foot Mountains
Colorado1,593
California506
Wyoming474
Utah265
Montana230
New Mexico169
Idaho119
Nevada117
Alaska108
Hawaii38
Arizona25
Washington13
Oregon5
Source: Environmental Systems Research Institute (Redlands, Calif.)

The number for Nevada from this data closely matches that of this list on Peakbagger.com, which lists 134 peaks above 10,000 feet.

The Colorado number appears harder to verify, but if anything appears vastly undercounted relative to the numbers listed in this article. That link mentions 48 14k footers, 804 13k footers, 1,062 12k footers, 716 11k footers, and 527 10k footers (with at least 300′ clear prominence).

Perhaps the quote above listing Nevada on top is incorporating some sort of prominence metric, but it seems hard to justify putting Nevada on top when there are 7 other states with more 10k footers.

Visualizing

This question gave me a good opportunity to play around with RASTER data, where I used elevation data from the USGS and to map that data alongside state boundary polygons and the summit point data mentioned above. As you can see from the map, Colorado clearly has the most mountains over 10k feet, which are marked in blue.

Below is a map without the mountains.

Seedigami – Women’s March Madness Seed Matchup Analysis

The analysis and charts in this post were inspired by Scorigami, a website which tracks whether a certain final score has occurred in an NFL game. As an example, there has been one game that has ended with a score of 72-41 and no games that have ended with a score of 21-5. This piece is a companion to an analysis of the Men’s Tournament, which you can find here.

In this post, I analyzed all the different matchups between different seeds at the NCAA tournament. All data in the below analyses are sourced from the Kaggle “March Machine Learning Mania 2023” datasets and incorporates results from 1998 to 2022. This doesn’t quite capture every year of the 64-team tournament era, which began in ’94.

Anything under the “N/A” line is an upset. I was surprised to see that there has never been a 3-14 or 2-15 upset in the tournament.

Seedigami – Men’s March Madness Seed Matchup Analysis

The analysis and charts in this post were inspired by Scorigami, a website which tracks whether a certain final score has occurred in an NFL game. As an example, there has been one game that has ended with a score of 72-41 and no games that have ended with a score of 21-5.

In this post, I analyzed all the different matchups between different seeds at the NCAA tournament. All data in the below analyses are sourced from the Kaggle “March Machine Learning Mania 2023” datasets and incorporates results from 1985 to 2022.

Following the completion of the 2023 tournament, the charts will need to be updated, as, among others, this tournament has seen:
– The first 6 seed vs. 15 seed game (Creighton vs. Princeton)
– The first victory of a 6 seed over a 15 seed
– The first victory of a 9 seed over a 3 seed (FAU over Kansas State)

The one fewer 7 – 10 game is due to a forfeit.

Anything under the “N/A” line is an upset.

8 seeds have been particularly successful against lower seeds.

State Adjacency Portmanteaus

A border portmanteau is a region or town near a mutual border that combines the names of two, or occasionally three, adjacent states. The most famous example is probably “Texarkana” which is a combination of Texas, Arkansas and Louisiana. There is a Texarkana, TX and a Texarkana, AR. Having seen “Pen Mar, MD” on the map, I was curious as to which state borders have a border portmanteau.

I generated the border geometries using a slightly modified version of the adjacency code described here. The data came from the “Border portmanteaus” section of the List of geographic portmanteaus Wikipedia article. Some border portmanteaus no longer exist (ex. Nosodak, ND) or have no current population (Oklarado, CO) but are included anyway.

Mapping and Analyzing 16 Years of Data on Top HS Basketball Recruits

For this post, I analyzed ESPN100 men’s HS basketball prospect ratings from 2007 to 2022. For a given year, the dataset looks something like this:

Example of 2022 ESPN100 dataset

For this analysis, I cleaned the dataset and used API Ninja to Geocode hometown information. I ended up analyzing:
– Basic player information like name, height, and weight
– Top high schools for producing ESPN100 players and the colleges players most frequently attend
– Maps of where ESPN100 players come from each year and over time
– Maps of where particular colleges’ ESPN100 players come from
– An analysis of ESPN100 players forgoing college basketball

Notes and some additional information on processing are including at the bottom of the post. In general, I did not edit the dataset and primarily filled in gaps where they existed. The original dataset was accessed manually through the ESPN100 website.

Basic Prospect Data (Names, Height, Weight)

Names

The most common name for ESPN100 recruits from 2007 to 2022 is either Jordan or Jalen, with 21 recruits each having those names. The other names are:
  1. Jordan – 21 recruits
  2. Jalen – 21 recruits
  3. Brandon – 19 recruits
  4. Isaiah – 16 recruits
  5. Josh – 15 recruits
  6. Chris – 15 recruits
  7. Anthony – 14 recruits
  8. Justin – 14 recruits
  9. Tyler – 14 recruits
  10. James – 13 recruits

Height

The tallest player in the dataset is Mamadou Ndiaye, who is listed at 7’5″. Ndiaye was the #74 ranked player in 2013 and went on to play basketball at UC Irvine.

The shortest player in the dataset is Erving Walker, who is listed at 5’6″. Walker was the #75 ranked player in 2008 and went on to play basketball at Florida.

View the full distribution below:

Histogram of player heights from ESPN100 from 2007 to 2022

Weight

The heaviest player in the dataset is Sim Bhullar, who is listed at 7’4″ and 330 lbs. Bhullar was the #82 ranked player in 2011 and went on to play basketball at New Mexico State before becoming the first player of Indian descent to play in the NBA.

There are 8 different players tied for the lightest player in the dataset at 150 pounds.

View the full distribution below:

Histogram of player weights from ESPN100 from 2007 to 2022

Top High Schools and Colleges

The graphic below shows the high schools or prep schools that had the most ESPN100 prospects.

High schools that produced the most ESPN100 prospects

In terms of colleges signing the highest number of ESPN100 recruits, Kentucky and Duke are a clear tier above the rest.

Colleges that recruited the most ESPN100 prospects

Recruits by Hometown Every Year and in Total

The two graphics depict where ESPN100 recruits came from in a given year. Some possible trends include a lot fewer players from the Bay Area over time and more players from the Twin Cities and Seattle.

Mapping where top basketball players came from on ESPN100 in total across 2007 to 2022

Where Colleges Get Their Recruits

The following section shows maps for the 76 schools that signed more than 5 ESPN100 recruits from 2007 to 2022. The slideshow is loaded in descending order, with schools with more numbers of recruits at the beginning. For each school, the map plots the hometown of every recruit they signed, with a catchall “Overseas” category.

In many cases, one could come pretty close to guessing the school just by the location of its top recruits.

Players Forgoing College Basketball

During this time period, players were not allowed to enter the NBA directly out of high school. Nonetheless, 26 players on the list did not end up signing with a college to play basketball. The number of such players peaked at 8 in 2020, which coincided with the inaugural season of the NBA G League Ignite.

Graphic depicting ESPN100 prospects

Notable prospects to forgo college basketball (2007 – 2002):
  • Jaden Hardy: #2 in ’21
  • Jalen Green: #1 in ’20
  • Jonathan Kuminga: #4 in ’20
  • LaMelo Ball: #21 in ’19
  • Anfernee Simons: #9 in ’18
  • Mitchell Robinson: #11 in ’17
  • Emmanuel Mudiay: #5 in ’14
  • Brandon Jennings: #1 in ’08
  • Terrelle Pryor: #39 in ’08
Note: Terrelle Pryor appears to be the only player from 07-22 to forgo basketball entirely. He went on to play football at Ohio State

Data Processing and Cleaning

For each class year, the ESPN100 data provides the following fields
– Rank
– Player Name
– Position
– Hometown (including High School name and City / State)2
– Height
– Weight
– Stars
– Grade (0 to 100 recruit grade determined by ESPN)
– College (School where they signed or committed)

A few notes about the dataset:
– For the “Hometown” field, the City / State information is not always the City / State of the High School, and appears to be the actual City / State where the player is from. At least for this analysis, I am more interested in a player’s hometown and not the location of the school where they played their basketball season. See (appendix) for more details.
– The dataset includes international recruits.
– In the original ESPN100 dataset, not every player has complete “College” data. In most cases the name of the college where they signed a letter of intent is listed, but in some cases, the field just lists where a player committed to play or simply provides a list of school
– In certain cases, a single college or destination is not provided, in those instances I looked into the player’s career and generally marked where they played next played basketball.

Notes

1 For whatever reason, ESPN100 does not always list exactly 100 recruits, and in some years, fewer recruits are listed.

2 Many elite HS basketball recruits attend high schools or prep schools to play basketball. In general, it seems like the ESPN100 list provides the name of the high school or prep school but the city and state of the player’s hometown, and not the location of the school. For example, Brandon Jennings is listed as “Los Angeles, CA Oak Hill Academy” in the dataset, even though Oak Hill Academy is in Mouth of Wilson, VA. I deferred to ESPN and did not significantly edit these values.

Four Maps to Better Understand the Last 6 Presidential Elections (2000 – 2020)

The 5 maps above show data relating to how the counties of the lower 48 states (and DC) have voted across the last six presidential elections. I decided not to include Alaska and Hawaii data, primarily because Alaska has had a number of county boundary changes since 2000. If I had wanted to include Alaska and Hawaii, I could have followed the instructions in this post.

The bulk of the election data comes from MEDSL, with additional 2020 data from VEST used to fill in some of the gaps in MEDSL’s file. For each county, I retrieved vote totals for the following six Presidential elections:
– 2000: Bush vs. Gore
– 2004: Bush vs. Kerry
– 2008: McCain vs. Obama
– 2012: Romney vs. Obama
– 2016: Trump vs. Clinton
– 2020: Trump vs. Biden

The first four maps group counties into categories I found interesting:
– Counties that supported for a candidate of the same party in every election
– Counties that began the 2000s voting Democratic and have voted Republican since (only flipping once)
– Counties that began the 2000s voting Republican and have voted Democratic since (only flipping once)
– Counties that supported Republicans in every election, except for Obama at least once

The above four categories do not encompass every county (3,108) in the contiguous United States + DC, but only 2,954. Information on the counties not included is shown below.

The number of counties with a specific Presidential voting pattern not included in those 4 maps is included below. Counties included above contain a strikethrough. Broomfield, CO is excluded from the data as it did not exist in 2000. For simplicity, I did not try to modify the 2000 election results for the counties that previously contained the area of Broomfield.

'Republican': 2064,
 'Democratic': 343,
 "Rep. except Obama '08": 120,
 'Democratic until 2016': 90,
 'Democratic until 2004': 88,
 'Republican until 2004': 68,
 'Rep. except Obama twice': 49,
 'Democratic until 2008': 39,
 'Republican until 2020': 31,
 'Rep: Bush (second), Romney, 2 x Trump': 26,
 'Republican except for Kerry, 2 x Obama ': 23,
 'Republican until 2016': 22,
 'Rep: Bush (second), 2 x Trump': 20,
 'Democratic until 2012': 19,
 'Republican except for Obama (first), Biden': 13,
 'Democratic except Trump first term': 12,
 'Republican except for Obama (first), Clinton, Biden': 10,
 'Democratic except Bush second term': 10,
 'Democratic until 2020': 10,
 'Republican except for 2 x Obama, Biden': 9,
 'Republican until 2012': 6,
 'Rep: Bush (second), McCain, 2 x Trump': 6,
 'Republican except Kerry, Obama (first)': 5,
 "Rep. except Obama '12": 5,
 'Republican except for Kerry, 2 x Obama, Biden': 4,
 'Republican except for 2 x Obama, Clinton': 3,
 'Rep Bush (second), Trump (second)': 3,
 'Republican except for Obama (second), Biden': 3,
 'Republican except for Kerry': 3,
 'County Boundaries Changed': 1,
 'Democratic except Romney first term': 1,
 'Rep Bush (second), Trump (first)': 1,
 'Rep: McCain, 2 x Trump': 1

The fifth map looks at how many times each county had majority support for the winning Presidential candidate in these 6 elections. Interestingly, no county voted for the losing candidate in every Presidential election from 2000-2020 and 9 counties have supported the winning candidate in every one. Broomfield County is not included here, so there are only 3,107 counties.

0 winners: 0 counties
1 winner: 40 counties
2 winners: 121 counties
3 winners: 2543 counties
4 winners: 256 counties
5 winners: 138 counties
6 winners: 9 counties

Note: This post contains an updates to the maps I had previously shared in these two posts (2000 – 2016 and 2000 – 2020).

Zip Codes, ZCTAs and ZCTAs that Cross State Boundaries

Zip codes are used by the United States Postal Service (USPS) to deliver mail and are not always polygon areas. The Census Bureau releases Zip Code Tabulation Areas which approximate the boundaries of zip codes. Zip Code Tabulation Areas do not cover the entire country, as represented by the grey areas in the maps below.

One problem that comes up when working with Zip Codes is the fact that some Zip Codes contain areas in multiple states. While this does not use official USPS zip code data, the lower map shows Zip Code Tabulation areas that cross state lines, of which there are 137.

The below table lists out the ZCTAs highlighted in red above.

ZCTA5 States Number of States
86514 {UT, NM, AZ} 3
82082 {WY, NE, CO} 3
57717 {MT, SD, WY} 3
71749 {AR, LA} 2
69168 {NE, CO} 2
69201 {SD, NE} 2
69212 {SD, NE} 2
69216 {SD, NE} 2
69337 {SD, NE} 2
71953 {OK, AR} 2
71937 {OK, AR} 2
72338 {TN, AR} 2
72644 {MO, AR} 2
73949 {OK, TX} 2
75556 {AR, TX} 2
79835 {NM, TX} 2
69026 {KS, NE} 2
02861 {MA, RI} 2
79922 {NM, TX} 2
66541 {KS, NE} 2
59275 {ND, MT} 2
59847 {ID, MT} 2
63673 {MO, IL} 2
65729 {MO, AR} 2
65733 {MO, AR} 2
65761 {MO, AR} 2
66955 {KS, NE} 2
68978 {KS, NE} 2
68325 {KS, NE} 2
68327 {KS, NE} 2
68420 {KS, NE} 2
68719 {SD, NE} 2
68755 {SD, NE} 2
68943 {KS, NE} 2
79837 {NM, TX} 2
81120 {NM, CO} 2
80737 {NE, CO} 2
86515 {NM, AZ} 2
99128 {ID, WA} 2
99033 {ID, WA} 2
97913 {ID, OR} 2
97910 {ID, OR} 2
97635 {CA, OR} 2
89832 {ID, NV} 2
89439 {CA, NV} 2
89421 {OR, NV} 2
89061 {CA, NV} 2
89060 {CA, NV} 2
89019 {CA, NV} 2
89010 {CA, NV} 2
88430 {NM, TX} 2
87328 {NM, AZ} 2
86504 {NM, AZ} 2
59221 {ND, MT} 2
86044 {UT, AZ} 2
84536 {UT, AZ} 2
84531 {UT, AZ} 2
84034 {UT, NV} 2
83856 {ID, WA} 2
83342 {UT, ID} 2
83127 {ID, WY} 2
83120 {ID, WY} 2
82930 {UT, WY} 2
82801 {MT, WY} 2
82701 {SD, WY} 2
82063 {WY, CO} 2
81324 {UT, CO} 2
81137 {NM, CO} 2
59270 {ND, MT} 2
58653 {ND, SD} 2
03579 {NH, ME} 2
38549 {TN, KY} 2
54540 {MI, WI} 2
52626 {MO, IA} 2
52573 {MO, IA} 2
52542 {MO, IA} 2
51640 {MO, IA} 2
51557 {IA, NE} 2
51360 {MN, IA} 2
51023 {SD, IA} 2
51001 {SD, IA} 2
42602 {TN, KY} 2
42223 {TN, KY} 2
40965 {TN, KY} 2
38852 {AL, MS} 2
38769 {AR, MS} 2
38326 {TN, MS} 2
56136 {MN, SD} 2
38079 {TN, KY} 2
37752 {VA, TN} 2
37642 {VA, TN} 2
36855 {AL, GA} 2
30741 {TN, GA} 2
30165 {AL, GA} 2
28675 {NC, VA} 2
27048 {NC, VA} 2
24622 {VA, WV} 2
24604 {VA, WV} 2
21912 {DE, MD} 2
21874 {DE, MD} 2
20135 {VA, WV} 2
19973 {DE, MD} 2
56027 {MN, IA} 2
56144 {MN, SD} 2
58649 {ND, SD} 2
57660 {ND, SD} 2
58639 {ND, SD} 2
58623 {ND, SD} 2
58621 {ND, MT} 2
58568 {ND, SD} 2
58439 {ND, SD} 2
58436 {ND, SD} 2
58413 {ND, SD} 2
58225 {ND, MN} 2
58053 {ND, SD} 2
58043 {ND, SD} 2
58041 {ND, SD} 2
58030 {ND, MN} 2
57735 {SD, NE} 2
57724 {MT, SD} 2
57648 {ND, SD} 2
56164 {MN, SD} 2
57645 {ND, SD} 2
57642 {ND, SD} 2
57641 {ND, SD} 2
57638 {ND, SD} 2
57430 {ND, SD} 2
57255 {ND, SD} 2
57068 {MN, SD} 2
57034 {SD, IA} 2
57030 {MN, SD} 2
57026 {MN, SD} 2
56744 {ND, MN} 2
56257 {MN, SD} 2
56220 {MN, SD} 2
56219 {MN, SD} 2
99362 {WA, OR} 2

Moving Alaska and Hawaii for Mapping in National Maps

Problems Mapping Alaska and Hawaii

As anyone who has tried to make a map of the United States would tell you, the true locations of Alaska and Hawaii make creating good national maps difficult. Including these two states in their true locations leaves a lot of blank space on the map. As such, maps will oftentimes either cut out Alaska and Hawaii and only show the continental United States or resize and move them so as they appear close to the other states. The latter option is definitely preferable if you want to include Alaska and Hawaii in your map.

Scaling and Translating Alaska and Hawaii

Scaling changes the size of a geometry and translating it moves left, right, up or down. Given Alaska’s size, particularly in coordinate reference systems like 3857, Alaska and Hawaii need to be scaled and translated to fit in nicely with the lower 48 states. One quirk with scaling geographic data is that if you are attempting to plot sub-state geographies of Alaska and Hawaii, the scaling step may pull these geographies apart, as in the example below:

In the above map, the counties in Alaska and Hawaii being plotted are not scaled around a fixed point, but instead to the center of their own respective geometries. This is mostly fine for Hawaii as its counties largely consist of islands, but destroys the county adjacency relationship in Alaska. If you scale the county geometries around a fixed point however, the adjacency relationships are maintained and Alaska looks just like you’d expect it to, as in the map below:

Code to Scale and Translate Alaska and Hawaii

I’ve had to perform this operation many times and have found myself digging back into old code to find the exact numbers used in the scaling and translation. The code below includes the necessary scaling and translation to move data for Alaska and Hawaii in a Python GeoDataFrame to these locations.

The fourth parameter used when performing the scale operation is the fixed point. Please note that the code currently modifies the GeoDataFrame to be in crs 3857. For other coordinate reference systems, different scaling and translating values may be required.

The code takes in a GeoDataFrame containing data for Alaska and Hawaii, a string to refer to the column name where Alaska and Hawaii can be filtered and then inputs for the values for Alaska and Hawaii in that column.

def move_alaska_hawaii(gdf, filter_col, ak_id, hi_id):
    
    gdf = gdf.to_crs(3857)
        
    alaska = gdf[gdf[filter_col] == ak_id]
    hawaii = gdf[gdf[filter_col] == hi_id]
    
    remaining = gdf[~gdf[filter_col].isin([ak_id, hi_id])]
    
    alaska = alaska.set_geometry(alaska.scale(.2,.2,.2,(-13452629.057,3227683.786)).translate(.215e7, -1.36e6))
    hawaii = hawaii.set_geometry(hawaii.scale(1.5,1.5,1.5,(-14384434.819, 2342560.248)).translate(.57e7, 1e6))
    
    gdf = gp.GeoDataFrame(pd.concat([alaska, hawaii, remaining]), crs = 3857)
        
    return gdf

Python GeoDataFrame Dissolve on Adjacencies

Python code to dissolve geopandas GeoDataFrames on adjacent geometries, with parameters to include or exclude point adjacencies.

Find the most up-to-date version of the code here.

import geopandas as gp
from itertools import combinations, starmap

def adjacency_dissolve(gdf, include_point_adjacency = True):
    '''
    Code that takes in a geodataframe and returns the geodataframe with adjacencies dissolved
    Includes a "include_point_adjacency" parameter, with a default value set to "True"
    Currently the code is not fine-tuned to handle non-geometric data during the dissolve 
    '''
    # Make sure that the index column is unique
    if "index" in gdf.columns:
        raise ValueError("Column already named 'index'")
        
    gdf.reset_index(inplace = True, drop = False)
    
    if not gdf.index.is_unique:
        raise ValueError ("Non-unique index column")
    
    adj_groups = calculate_adjacency(gdf, include_point_adjacency)
    
    if "Dissolve_Assignment" in gdf.columns:
        raise ValueError("Existing 'Dissolve_Assignment' column")
    
    gdf["Dissolve_Assignment"] = ""
    for i in range(0,len(adj_groups)):
        if type(adj_groups[i])==gdf.dtypes["index"]:
            gdf.loc[gdf["index"]== adj_groups[i],"Dissolve_Assignment"] = i
        elif type(adj_groups[i])==set:
            gdf.loc[gdf["index"].isin(adj_groups[i]) ,"Dissolve_Assignment"] = i
    
    dissolved = gdf.dissolve("Dissolve_Assignment")
    dissolved.reset_index(drop = False, inplace = True)
    dissolved.drop(["index","Dissolve_Assignment"], axis = 1, inplace = True)
    
    return dissolved


def calculate_adjacency(gdf, include_point_adjacency = True):
    '''
    Code that takes a geodataframe and returns a dictionary of adjacencies
    '''    
    # Intersected the GeoDataFrame with the buffer with the original GeoDataFrame
    test_intersection = gp.overlay(gdf, gdf, how = "intersection", keep_geom_type = False)
    
    # If the include_point_adjacency is False
    if (include_point_adjacency == False):
        # Filter out the intersections that are just points
        test_intersection = test_intersection[test_intersection.geom_type != "Point"]
    
    # Get value counts after the intersections
    ser = test_intersection["index_1"].value_counts()
    
    # Filter out self-intersections
    test_intersection = test_intersection[test_intersection["index_1"]!=test_intersection["index_2"]]
    
    # Define a tuple of zips of the unique_col pairs present in the intersection
    test_intersection_tuples = list(list(zip(test_intersection["index_1"], test_intersection["index_2"])))
    
    return subadjacencies_faster_3([set(i) for i in test_intersection_tuples]) + list(ser[ser==1].index)

def subadjacencies_faster_3(dup_list):
    all_intersections = starmap(set.intersection, combinations(dup_list, 2))
    finished = True
    for val in all_intersections:
        if val != set():
            finished = False
    if finished:
        return [sorted(list(i)) for i in dup_list]
    else:
        final_holder = []
        for val in dup_list:
            added = False
            added_indices = []
            for idx, x in enumerate(final_holder):
                if len(x.intersection(val)) > 0:
                    final_holder[idx] = x.union(val)
                    added_indices.append(idx)
                    added = True
            if len(added_indices) > 1:
                for i in range(1, len(added_indices)):
                    final_holder[added_indices[0]] = final_holder[added_indices[0]].union(final_holder[added_indices[i]])
                for i in range(len(added_indices)-1,0,-1):
                    final_holder.pop(added_indices[i])
            if not added:
                final_holder.append(val)
        return final_holder