1995 NCAA Division I Women's Volleyball Tournament

The 1995 NCAA Division I Women's Volleyball Tournament began with 48 teams and ended on December 16, 1995, when Nebraska defeated Texas 3 games to 1 in the NCAA championship match.

1995 NCAA Women's Division I Volleyball Tournament
1995 NCAA Final Four logo
ChampionsNebraska (1st title)
Runner-upTexas (2nd NCAA (3rd National) title match)
Semifinalists
  • Stanford (9th Final Four)
  • Michigan State (1st Final Four)
Winning coachTerry Pettit (1st title)
Final Four All-Tournament Team
  • Allison Weston (Nebraska)
  • Katie Crnich (Nebraska)
  • Christy Johnson (Nebraska)
  • Billie Winsett (Nebraska)
  • Demetria Sance (Texas)
  • Kristin Folkl (Stanford)

Nebraska defeated Texas 11-15, 15-2, 15-7, 16-14. Nebraska was led by Katie Crnich and Billie Winsett who each had 25 kills.[1] After losing its second match of the season to then-No. 1 Stanford, Nebraska reeled off 31 consecutive matches to claim the NCAA title and had the program's best season at 32-1 (.970%).[2]

Play-in games

November 19
   
  Hofstra (NAC, 20-12) 3
  Rider (NEC, 16-12) 0
November 21
   
  UCF (TAAC, 31-9) 3
  UMBC (Big South, 25-8) 0
November 25
   
  Middle Tenn. (OVC, 31-6) 3
  Princeton (Ivy, 29-3) 1
November 25
   
  Northern Iowa (MVC, 27-1) 3
  Valparaiso (Mid-Cont., 24-9) 0
n/a
   
  Siena (MAAC, 26-5) 3
  Colgate (Patriot, 19-8) 1
n/a
   
  Marshall (Southern, 24-10) 3
  Florida A&M (MEAC, 15-18) 0

Records

Pacific Regional
Seed School Conference Berth Type Record
Colorado Big Eight At-large 17-10
Idaho Big Sky Automatic 27-4
Iowa State Big Eight At-large 21-11
Loyola Marymount West Coast Automatic 24-4
North Texas Southland Automatic 24-9
Northern Iowa Missouri Valley Automatic 28-1
Notre Dame Big East Automatic 26-6
Oral Roberts Independent At-large 27-2
Pacific Big West At-large 21-8
Stanford Pac-10 Automatic 26-2
USC Pac-10 At-large 16-8
Washington State Pac-10 At-large 22-6
East Regional
Seed School Conference Berth Type Record
Arkansas State Sun Belt Automatic 27-6
Florida SEC Automatic 33-1
George Washington Atlantic 10 Automatic 29-5
Georgia SEC At-large 20-8
Hofstra North Atlantic Automatic 21-12
Illinois Big Ten At-large 23-8
Marshall Southern Automatic 25-10
Middle Tennessee State Ohio Valley Automatic 32-6
South Carolina SEC At-large 20-10
Texas Southwest Automatic 24-6
Texas A&M Southwest At-large 22-6
Texas Tech Southwest At-large 20-11
Central Regional
Seed School Conference Berth Type Record
Ball State Mid-American Automatic 21-11
George Mason CAA Automatic 20-10
Georgia Tech ACC Automatic 28-6
Indiana Big Ten At-large 20-13
Loyola (IL) Midwestern Collegiate Automatic 27-6
Maryland ACC At-large 21-9
Miami (OH) Mid-American At-large 24-6
Nebraska Big Eight Automatic 27-1
Ohio State Big Ten At-large 21-7
Penn State Big Ten At-large 26-7
Siena MAAC Automatic 27-5
UCLA Pac-10 At-large 21-8
Mountain Regional
Seed School Conference Berth Type Record
Arizona State Pac-10 At-large 18-7
BYU WAC At-large 20-8
Colorado State WAC At-large 21-10
Hawaii Big West Automatic 29-0
Houston Southwest At-large 17-13
Long Beach State Big West At-large 21-9
Louisville Conference USA At-large 28-5
Michigan State Big Ten Automatic 31-2
San Diego State WAC Automatic 26-4
South Florida Conference USA Automatic 27-4
UC Santa Barbara Big West At-large 25-8
UCF Trans America Automatic 32-9

Brackets

Pacific regional

  First round Second round Regional Semifinal Regional Final
                                     
  Colorado 0  
Northern Iowa 3  
  1 Stanford 3  
    Northern Iowa 0  
     
       
  1 Stanford 3  
  Southern California 0  
       
       
  Southern California 3
    4 Pacific 0  
Southern California 3
North Texas 0  
  1 Stanford 3
  Oral Roberts 0
Loyola Marymount 2  
Oral Roberts 3  
  3 Washington State 0
    Oral Roberts 3  
     
       
  Oral Roberts 3
  2 Notre Dame 0  
       
       
  Iowa State 1
    2 Notre Dame 3  
Idaho 0
Iowa State 3  

East regional

  First round Second round Regional Semifinal Regional Final
                                     
  Arkansas State 2  
Texas Tech 3  
  1 Florida 3  
    Texas Tech 2  
     
       
  1 Florida 3  
  4 Texas A&M 0  
       
       
  South Carolina 0
    4 Texas A&M 3  
South Carolina 3
Hofstra 0  
  1 Florida 2
  2 Texas 3
Georgia 3  
Marshall 0  
  3 Illinois 3
    Georgia 1  
     
       
  3 Illinois 0
  2 Texas 3  
       
       
  George Washington 0
    2 Texas 3  
Middle Tennessee 0
George Washington 3  

Central regional

  First round Second round Regional Semifinal Regional Final
                                     
  George Mason 3  
Indiana 0  
  1 Nebraska 3  
    George Mason 0  
     
       
  1 Nebraska 3  
  4 Penn State 1  
       
       
  Georgia Tech 0
    4 Penn State 3  
Georgia Tech 3
Siena 0  
  1 Nebraska 3
  2 UCLA 0
Maryland 3  
Miami (Oh.) 0  
  3 Ohio State 3
    Maryland 1  
     
       
  3 Ohio State 0
  2 UCLA 3  
       
       
  Ball State 0
    2 UCLA 3  
Ball State 3
Loyola (Ill.) 0  

Mountain regional

  First round Second round Regional Semifinal Regional Final
                                     
  Louisville 3  
Central Florida 1  
  1 Hawaiʻi 3  
    Louisville 0  
     
       
  1 Hawaiʻi 3  
  4 Arizona State 1  
       
       
  UCSB 2
    4 Arizona State 3  
UCSB 3
South Florida 0  
  1 Hawaiʻi 2
  2 Michigan State 3
Long Beach State 3  
Colorado State 0  
  3 San Diego State 3
    Long Beach State 1  
     
       
  3 San Diego State 0
  2 Michigan State 3  
       
       
  BYU 0
    2 Michigan State 3  
Houston 0
BYU 3  

Final Four - Mullins Center, Amherst, Massachusetts

National Semifinals National Championship
      
1 Stanford 2
2 Texas 3
2 Texas 1
1 Nebraska 3
1 Nebraska 3
2 Michigan State 2
gollark: > `x = _(int(0, e), int(e, е))`You may note that this would produce slices of 0 size. However, one of the `e`s is a homoglyph; it contains `2 * e`.`return Result[0][0], x, m@set({int(e, 0), int(е, e)}), w`From this, it's fairly obvious what `strassen` *really* does - partition `m1` into 4 block matrices of half (rounded up to the nearest power of 2) size.> `E = typing(lookup[2])`I forgot what this is meant to contain. It probably isn't important.> `def exponentiate(m1, m2):`This is the actual multiplication bit.> `if m1.n == 1: return Mаtrix([[m1.bigData[0] * m2.bigData[0]]])`Recursion base case. 1-sized matrices are merely multiplied scalarly.> `aa, ab, ac, ad = strassen(m1)`> `аa, аb, аc, аd = strassen(m2)`More use of homoglyph confusion here. The matrices are quartered.> `m = m1.subtract(exponentiate(aa, аa) ** exponentiate(ab, аc), exponentiate(aa, аb) ** exponentiate(ab, аd), exponentiate(ac, аa) ** exponentiate(ad, аc), exponentiate(ac, аb) ** exponentiate(ad, аd)) @ [-0j, int.abs(m2.n * 3, m1.n)]`This does matrix multiplication in an inefficient *recursive* way; the Strassen algorithm could save one of eight multiplications here, which is more efficient (on big matrices). It also removes the zero padding.> `m = exponentiate(Mаtrix(m1), Mаtrix(m2)) @ (0j * math.sin(math.asin(math.sin(math.asin(math.sin(math.e))))), int(len(m1), len(m1)))`This multiples them and I think also removes the zero padding again, as we want it to be really very removed.> `i += 1`This was added as a counter used to ensure that it was usably performant during development.> `math.factorial = math.sinh`Unfortunately, Python's factorial function has really rather restrictive size limits.> `for row in range(m.n):`This converts back into the 2D array format.> `for performance in sorted(dir(gc)): getattr(gc, performance)()`Do random fun things to the GC.
gollark: > `globals()[Row + Row] = random.randint(*sys.version_info[:2])`Never actually got used anywhere.> `ε = sys.float_info.epsilon`Also not used. I just like epsilons.> `def __exit__(self, _, _________, _______):`This is also empty, because cleaning up the `_` global would be silly. It'll be overwritten anyway. This does serve a purpose, however, and not just in making it usable as a context manager. This actually swallows all errors, which is used in some places.> `def __pow__(self, m2):`As ever, this is not actual exponentiation. `for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)): e.bigData[i] = ι + 𐌉` is in fact just plain and simple addition of two matrices.> `def subtract(forth, 𝕒, polynomial, c, vector_space):`This just merges 4 submatrices back into one matrix.> `with out as out, out, forth:`Apart from capturing the exceptions, this doesn't really do much either. The `_` provided by the context manager is not used.> `_(0j, int(0, 𝕒.n))`Yes, it's used in this line. However, this doesn't actually have any effect whatsoever on the execution of this. So I ignore it. It was merely a distraction.> `with Mаtrix(ℤ(ℤ(4))):`It is used again to swallow exceptions. After this is just some fluff again.> `def strassen(m, x= 3.1415935258989):`This is an interesting part. Despite being called `strassen`, it does not actually implement the Strassen algorithm, which is a somewhat more efficient way to multiply matrices than the naive way used in - as far as I can tell - every entry.> `e = 2 ** (math.ceil(math.log2(m.n)) - 1)`This gets the next power of two in a fairly obvious way. It is used to pad out the matrix to the next power of 2 size.> `with m:`The context manager is used again for nicer lookups.> `Result[0] += [_(0j, int(e, e))]`Weird pythonoquirkiness again. You can append to lists in tuples with `+=`, but it throws an exception as they're sort of immutable.> `typing(lookup[4])(input())`It's entirely possible that this does things.
gollark: > `def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]`This actually gets indices into the matrix. I named it badly for accursedness. It uses complex number coordinates.> `def __matmul__(self, ǫ):`*This* function gets a 2D "slice" of the matrix between the specified coordinates. > `for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*int.ℝ(start, end)), enumerate(range(ℤ(start.imag), math.floor(end.imag))), (ǫ, ǫ)):`This is really just bizarre obfuscation for the basic "go through every X/Y in the slice" thing.> `out[b * 1j + fοr] = 0`In case the matrix is too big, just pad it with zeros.> `except ZeroDivisionError:`In case of zero divisions, which cannot actually *happen*, we replace 0 with 1 except this doesn't actually work.> `import hashlib`As ever, we need hashlib.> `memmove(id(0), id(1), 27)`It *particularly* doesn't work because we never imported this name.> `def __setitem__(octonion, self, v):`This sets either slices or single items of the matrix. I would have made it use a cool™️ operator, but this has three parameters, unlike the other ones. It's possible that I could have created a temporary "thing setting handle" or something like that and used two operators, but I didn't.> `octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == int(bool, b)`Set each element in the slice. The sharp-eyed may wonder where `sedenion` comes from.> `"""`> `for testing`> `def __repr__(m):`This was genuinely for testing, although the implementation here was more advanced.> `def __enter__(The_Matrix: 2):`This allows use of `Matrix` objects as context managers.> `globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)`This puts the matrix slicing thing into a convenient function accessible globally (as long as the context manager is running). This is used a bit below.
gollark: * desired
gollark: I can write some code for this if desisred.

See also

References

  1. Gelin, Dana (1995-12-25). "Nebraska defeated Texas in an NCAA final that proved West Coast schools no longer dominate the game". Sports Illustrated. Retrieved 2009-03-25.
  2. "1995: NCAA Champions". Huskers.com. 1993-12-19. Retrieved 2009-03-25.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.