1991 Ben Hogan Tour graduates
This is a list of players who graduated from the Ben Hogan Tour in 1991. The top five players on the Ben Hogan Tour's money list in 1991 earned their PGA Tour card for 1992.
| 1991 Hogan Tour | 1992 PGA Tour | |||||||
|---|---|---|---|---|---|---|---|---|
| Player | Money list rank | Earnings ($) | Starts | Cuts made | Best finish | Money list rank | Earnings ($) | |
 | 1 | 141,934 | 29 | 25 | T2 | 24 | 579,093 | |
| 2 | 106,406 | 30 | 14 | T4 | 147 | 84,152 | |
| 3 | 84,432 | 29 | 11 | T6 | 116 | 123,684 | |
.svg.png){kind=small} | 4 | 77,919 | 33 | 8 | T39 | 212 | 19,312 | |
| 5 | 77,450 | 32 | 13 | T6 | 152 | 74,785 | |
*PGA Tour rookie for 1992.
T = Tied
Green background indicates the player retained his PGA Tour card for 1993 (finished inside the top 125).
Yellow background indicates player did not retain his PGA Tour card for 1993, but retained conditional status (finished between 126–150).
Red background indicates the player did not retain his PGA Tour card for 1993 (finished outside the top 150).
Runners-up on the PGA Tour in 1992
| No. | Date | Player | Tournament | Winner | Winning score | Runner-up score |
|---|---|---|---|---|---|---|
| 1 | Sep 20 | |
Hardee's Golf Classic | .svg.png){kind=small} |
−14 (62-68-64-72=266) | −11 (64-69-66-70=269) |
gollark: ```python# parsita-based pseudocode syntax parserfrom stmt import *from parsita import *from parsita.util import constantdef compose(f, g): return lambda x: f(g(x))def map_expr(x): start, end = x if end == "": return start return Op([start, end[1]], end[0])def map_unop_expr(x): return Op(x[1], x[0])def aliases(name, aliases): p = lit(name) for alias in aliases: p |= (lit(alias) > (lambda _: name)) return pclass ExprParser(TextParsers): ε = lit("") IntLit = reg("\-?[0-9]+") > compose(IntLit, int) StrLit = "'" >> reg("[^']*") << "'" > StrLit # TODO escapes (not in "spec" but could be needed) FloatLit = reg("\-?[0-9]+\.[0-9]+") > compose(FloatLit, float) Identifier = reg("[a-zA-Z_]+[a-zA-Z_0-9]*") > Var BracketedExpr = "(" >> Expr << ")" UnaryOperator = lit("NOT") Start = FloatLit | StrLit | IntLit | BracketedExpr | (UnaryOperator & Expr > map_unop_expr) | Identifier # avoid left recursion problems by not doing left recursion # AQA pseudocode does not appear to have a notion of "operator precedence", simplifying parsing logic nicely BinaryOperator = aliases("≤", ["<="]) | aliases("≠", ["!="]) | aliases("≥", [">="]) | lit("DIV") | lit("MOD") | lit("AND") | lit("OR") | reg("[+/*\-=<>]") End = (BinaryOperator & Expr) | ε Expr = (Start & End) > map_exprparse = ExprParser.Expr.parsex = parse("1+2+3 != 6 AND NOT 4 AND x + y")if isinstance(x, Failure): print(x.message)else: print(x.value)```
gollark: <@332271551481118732> Expression parsing is done, I think.
gollark: I wonder if AQA pseudocode *does* have operator precedence. We may need to harvest exam papers.
gollark: This will allow 3% more efficient harnessing of character set anomalies.
gollark: The parser supports anomalous unicode, muahaha.
References
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.