Wrestling at the 1980 Summer Olympics – Men's Greco-Roman 52 kg
The Men's Greco-Roman 52 kg at the 1980 Summer Olympics as part of the wrestling program were held at the Athletics Fieldhouse, Central Sports Club of the Army.[1]
| Men's Greco-Roman 52 kg at the Games of the XXII Olympiad | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Venue | Central Sports Club of the Army | ||||||||||||
| Dates | 21–23 July | ||||||||||||
| Competitors | 10 from 10 nations | ||||||||||||
| Medalists | |||||||||||||
| |||||||||||||
| Wrestling at the 1980 Summer Olympics | ||
|---|---|---|
 | ||
| Freestyle | Greco-Roman | |
| 48 kg | 48 kg | |
| 52 kg | 52 kg | |
| 57 kg | 57 kg | |
| 62 kg | 62 kg | |
| 68 kg | 68 kg | |
| 74 kg | 74 kg | |
| 82 kg | 82 kg | |
| 90 kg | 90 kg | |
| 100 kg | 100 kg | |
| +100 kg | +100 kg | |
Medalists
| Gold | Vakhtang Blagidze |
| Silver | Lajos Rácz |
| Bronze | Mladen Mladenov.svg.png){kind=small} |
Tournament results
The competition used a form of negative points tournament, with negative points given for any result short of a fall. Accumulation of 6 negative points eliminated the loser wrestler. When only three wrestlers remain, a special final round is used to determine the order of the medals.
- Legend
- TF — Won by Fall
- IN — Won by Opponent Injury
- DQ — Won by Passivity
- D1 — Won by Passivity, the winner is passive too
- D2 — Both wrestlers lost by Passivity
- FF — Won by Forfeit
- DNA — Did not appear
- TPP — Total penalty points
- MPP — Match penalty points
- Penalties
- 0 — Won by Fall, Technical Superiority, Passivity, Injury and Forfeit
- 0.5 — Won by Points, 8-11 points difference
- 1 — Won by Points, 1-7 points difference
- 2 — Won by Passivity, the winner is passive too
- 3 — Lost by Points, 1-7 points difference
- 3.5 — Lost by Points, 8-11 points difference
- 4 — Lost by Fall, Technical Superiority, Passivity, Injury and Forfeit
Round 1
| TPP | MPP | Score | MPP | TPP | ||
|---|---|---|---|---|---|---|
| 4 | 4 |  | TF / 5:21 | | 0 | 0 |
| 0 | 0 | | TF / 8:28 |  | 4 | 4 |
| 4 | 4 | .svg.png){kind=small} | DQ / 6:49 |  | 0 | 0 |
| 3 | 3 |  | 6 - 7 | .svg.png){kind=small} | 1 | 1 |
| 4 | 4 | %3B_Flag_of_Syria_(1963%E2%80%931972).svg.png){kind=small} | DQ / 5:29 | | 0 | 0 |
Round 2
| TPP | MPP | Score | MPP | TPP | ||
|---|---|---|---|---|---|---|
| 7 | 3 | | 3 - 4 | | 1 | 1 |
| 0 | 0 | | TF / 2:43 | | 4 | 8 |
| 8 | 4 | | 6 - 19 | | 0 | 3 |
| 0 | 0 | | DQ / 7:30 | | 4 | 8 |
| 5 | 4 | | D2 / 7:44 | | 4 | 4 |
Round 3
| TPP | MPP | Score | MPP | TPP | ||
|---|---|---|---|---|---|---|
| 1 | 1 | | 7 - 2 | | 3 | 4 |
| 4 | 4 | | DQ / 7:57 | | 0 | 5 |
| 7 | 4 | | DQ / 7:30 | | 0 | 4 |
Round 4
| TPP | MPP | Score | MPP | TPP | ||
|---|---|---|---|---|---|---|
| 1 | 0 | | TF / 3:57 | | 4 | 8 |
| 5 | 1 | | 5 - 2 | | 3 | 8 |
| 4 | | Bye |
Final
Results from the preliminary round are carried forward into the final (shown in yellow).
| TPP | MPP | Score | MPP | TPP | ||
|---|---|---|---|---|---|---|
| 1 | | 7 - 2 | | 3 | ||
| 4 | | 1 - 19 | | 0 | 1 | |
| 6 | 3 | | 0 - 5 | | 1 | 5 |
Final standings
gollark: I didn't do any horrible homoglyph hacks with THAT.
gollark: It uses the function, yes.
gollark: So, I finished that to highly dubious demand. I'd like to know how #11 and such work.
gollark: > `x = _(iｎt(0, e), iｎt(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({iｎt(e, 0), iｎt(е, 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, iｎt.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))))), iｎt(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, iｎt(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, iｎt(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.
References
- "Wrestling at the 1980 Moscow Summer Games: Men's Flyweight, Greco-Roman". Sports Reference. Archived from the original on 18 April 2020. Retrieved 12 April 2019.
External links
| |
|
.svg.png){kind=small}
.svg.png){kind=small}
.svg.png){kind=small}
.svg.png){kind=small}
.svg.png){kind=small}
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.