Domanda:
Quale gioco professionale ha la sequenza più veloce, a partire dalla prima mossa, fino alle pedine quadruplicate?
Rewan Demontay
2019-04-10 09:01:52 UTC
view on stackexchange narkive permalink

Da quello che ho trovato, su questo sito, la sequenza più breve, partendo da una mossa in una partita di scacchi professionale, alle pedine quadruplicate è di 18 mosse. Il gioco menzionato è questo:

  [Title "Zheliandinov-T. Sereteli, 35th Championship of the USSR, Kharkov, 1967"] [FEN "2r1kbr1 / pp3pqp / 5p2 / 3N1p2 / 5p2 / 6P1 / PPn1BR1P / R2Q2K1 w - - 0 1 "]  

Qui ho tre punti di attenzione.

1) È questo il gioco più breve conosciuto che soddisfa le mie esigenze?

2) Non riesco a trovare il gioco menzionato da nessuna parte. Se riesci a trovarlo, pubblicalo nel replayer insieme al link.

3) C'è comunque che posso trovare facilmente raccolte di giochi di pedoni quadruplicati ovunque online?

Tre risposte:
Ellie
2019-04-11 15:15:04 UTC
view on stackexchange narkive permalink

Riguardo alla tua ultima domanda:

3) Posso comunque trovare facilmente raccolte di giochi di pedoni quadruplicati ovunque online?

Non c'è bisogno di guardare online, puoi farlo da solo.

Ho trovato 3 esempi aggiuntivi dopo aver analizzato circa 300000 giochi di un TWIC DB:

1)

  [fen ""] [Evento "FSIM May"] [Sito "Budapest HUN"] [Data "1996.05.13"] [Round "11"] [White "Lochte, T."] [Black "Gross , S. "] [Risultato" 0-1 "] [WhiteElo" 2220 "] [BlackElo" 2290 "] [PlyCount" 54 "] [EventDate" 1996. ??. ?? "] [SourceDate" 2011.01.01 " ] [StartPly "54"] 1. e4 c5 2. d4 cxd4 3. c3 dxc3 4. Nxc3 d6 5. Bc4 Nc6 6. Nf3 e6 7. OO Bd7 8. Bf4 Qb8 9. Nb5 Ne5 10. Nxe5 dxe5 11. Bg3 Nf6 12. Qe2 a6 13. Nd4 Bd6 14. Rad1 Bc7 15. Nf3 Bc6 16. Bh4 h6 17. Bxf6 gxf6 18. Nh4 h5 19. Qf3 Bd8 20. Qg3 Qc7 21. Qg7 Rf8 22. f4 exf4 23. Rfe1 Qe5 24 . Bd5 Qg5 25. Bxc6 + bxc6 26. Nf5 Bb6 + 27. Kh1 exf5 0-1  

2)

  [fen ""] [Evento "8th World Seniors "] [Sito" Gries kirchen GER "] [Data" 1998.11.09 "] [Round" 2 "] [White" Wegener, H. "] [Black" Knebel, W. "] [Risultato" 0-1 "] [ECO" B95 "] [WhiteElo "2115"] [PlyCount "54"] [EventDate "1998. ??. ??"] [SourceDate "2011.01.01"] [StartPly "48"] 1. e4 c5 2. Nf3 d6 3. d4 cxd4 4. Nxd4 Nf6 5. Nc3 a6 6. Bg5 e6 7. Bd3 Be7 8. OO b5 9. a4 b4 10. Na2 a5 11. e5 dxe5 12. Bxf6 gxf6 13. Qf3 Ra7 14. Bb5 + Kf8 15. Nf5 exf5 16. Qe3 Qd4 17. Qh6 + Kg8 18. c3 Qg4 19. Qe3 Rc7 20. cxb4 axb4 21. Rfc1 Rxc1 + 22. Rxc1 Kg7 23. h3 Qg5 24. f4 exf4 25. Qxe7 Be6 26. h4 Qg3 27. b3 f3 0-1  

3)

  [fen ""] [Evento "Open"] [Sito "Pula CRO"] [Data "2001.05.24"] [Round "7"] [Bianco "Molnar, Be"] [Nero "Polak, T."] [Risultato "1-0"] [ECO "D42"] [WhiteElo "2352"] [BlackElo "2503"] [PlyCount " 80 "] [EventDate" 2001.05.18 "] [SourceDate" 2011.01.01 "] [StartPly" 66 "]
1. e4 c6 2. d4 d5 3. exd5 cxd5 4. c4 Nf6 5. Nc3 e6 6. Nf3 Be7 7. cxd5 Nxd5 8. Bd3 Nc6 9. OO OO 10. Re1 Bf6 11. Be4 Nce7 12. Qd3 h6 13. Ne5 Nxc3 14. Qxc3 Nf5 15. Be3 a5 16. Rad1 a4 17. Ng4 Bg5 18. Bxf5 exf5 19. Bxg5 hxg5 20. Ne5 Qa5 21. Qc4 Be6 22. d5 Rac8 23. b4 axb3 24. Qxb3 Rc5 25. Ng6 Rc3 26. Qxb7 Rc7 27. Qb1 fxg6 28. Rxe6 Kh7 29. d6 Rd7 30. Qb3 Rfd8 31. g4 Qc5 32. Qd5 Qxd5 33. Rxd5 fxg4 34. a4 Ra8 35. Re7 Rdd8 36. a5 Ra6 37. d7 Ra7 38. Kg2 Raa8 39. Rxg5 Ra7 40. Rd5 Raa8 1-0  

In breve, come l'ho fatto in Python e usando python-chess per leggere il DB PGN :

Scorro ogni gioco del DB mappando ogni posizione al suo FEN, quindi espando il FEN sostituendo i numeri con una quantità corrispondente di trattini "-". Nella notazione FEN i numeri tra il rango "/" - le sezioni separate indicano quanti quadrati vuoti ci sono prima che un pezzo raggiunga una data riga) quindi ad esempio, questo FEN

  '3r4 / 3PR1pk / r5p1 / P2R2p1 / 6p1 / 8 / 5P1P / 6K1 ' 

diventa:

 ' --- r ---- / --- PR -pk / r ----- p- / P - R - p - / ------ p - / -------- / ----- PP / ---- --K- ' 

che puoi facilmente fare come segue:

(dopo aver rimosso tutto dopo il primo spazio fen = fen [0: fen. index ('')] )

  def isinteger (s): try: int (s) return True eccetto ValueError: return False per el in fen: if isinteger (el): fen = fen.replace (el, int (el) * '-')  

Quindi sappiamo che vogliamo trovare righe consecutive con pedine (dello stesso colore) sugli stessi file, quindi se dividi la stringa FEN secondo i separatori "/" in una lista ( splitfen = fen.split ('/') ), devi far corrispondere lo schema con la lettera 'p' (che denota pedoni neri in FEN, allo stesso modo, "P" per bianco) si trova in 4 elementi consecutivi della lista e nella stessa posizione delle stringhe di dimensione 8 (per assicurarti che siano sullo stesso file) che puoi fare in molti modi diversi:

  # (la funzione che trova tutti i pattern consecutivamente corrispondenti per t) def checkpattern (sp, t): start = [sp [0]] for i in sp [1:]: if any (all (t == c per c in b) per b in zip (* (start + [i]))): start.append (i) else: if len (start) > 1: yield start start = [i] returnsplitfen = fen. split ('/') forblack = list (checkpattern (splitfen, 'p')) forwhite = list (checkpattern (splitfen, 'P')) total = forblack + forwhite for el in totale: if len (el) == 4 : # (dato che vogliamo pedoni quadruplicati) res = True break  

Tutti questi tipi di query di ricerca sui DB degli scacchi possono essere facilmente eseguiti con un po 'di scripting intorno al FEN per individuare i modelli desiderati (siano essi strutture di pedoni, numero di pezzi, ecc.).

Questo sembra più stabile che cercare di capire quando un giocatore ha quadruplicato le pedine basandosi solo sul punteggio del gioco, che era quello che avrei potuto provare a fare. Potremmo assegnare valori di dizionario black ['a7'] = ... = black ['h7'] = 1 all'inizio di ogni partita, quindi analizzare ogni cattura di o da parte di un pedone. Sarebbe un esercizio interessante, ma il tuo modo rende più sensato.
kentdjb
2019-04-21 12:07:23 UTC
view on stackexchange narkive permalink

Ho pensato che sarebbe stato interessante provare una variazione dell'approccio di @ Phonon e trattare la ricerca essenzialmente come un'attività di pattern-matching utilizzando espressioni regolari. Quindi, dopo aver eseguito la stessa espansione di un FEN e aver isolato i sei ranghi centrali, ho passato la stringa risultante alla funzione search del pacchetto re di Python, cercando le occorrenze di pedone caratteri separati da otto caratteri intermedi (non ho rimosso i separatori di rango dal FEN espanso):

  # Cerca i giochi nel file dato che # hanno 4 pedine adiacenti in una colonna. def process_file (file): file = open (file, encoding = "ISO-8859-1") # Forma le espressioni regolari per entrambi i colori. schema_bianco = "P ........ P ........ P ........ P" schema_nero = "p ........ p ..... ... p ........ p "game = chess.pgn.read_game (file) while game: board = game.board () for move in game.mainline_moves (): board.push (move) fen = board.fen () # Espande le cifre del quadrato vuoto nel FEN ai punti # ed estrae solo la posizione del tabellone. pezzi = "" .join (["." * int (c) if c.isdigit () else c per c in fen]) [: 71] # Elimina il primo e l'ultimo numero perché non possono contenere pedoni. match_area = pieces [9: -9] # Arrenditi se nessuna delle due parti ha pedoni sufficienti. if match_area.count ('P') < 4 e match_area.count ('p') < 4: break if (re.search (white_pattern, match_area)): print (game, "\ n") break if (re. search (black_pattern, match_area)): print (game, "\ n") break game = chess.pgn.read_game (file)  

Ho mantenuto la logica il più semplice possibile per chiarezza ma un ovvio miglioramento sarebbe adattarlo per diversi numeri di pedoni generando le stringhe del modello utilizzando la replica delle stringhe.

In pratica, ho riscontrato che la corrispondenza è relativamente lenta: circa 100 giochi al secondo sulla mia macchina, il che richiederebbe circa 8 ore per cercare un database di 3.000.000 di giochi. Non so se tale velocità sia limitata dalla libreria python-chess o dalla corrispondenza dei modelli.

In alternativa, ho provato il mio programma pgn-extract che può accettare modelli FEN di espressioni regolari da abbinare durante l'analisi dei giochi. Per i pedoni quadruplicati, ci sono solo 24 possibili configurazioni per ogni lato, quindi queste sono relativamente facili da enumerare (a mano o programmaticamente); ad esempio:

  FENPatternI "* / ??????? p / ??????? p / ??????? p / ?????? ? p / * / * / * "FENPatternI" * / * / ??????? p / ??????? p / ??????? p / ??????? p / * / * "FENPatternI" * / * / * / ??????? p / ??????? p / ??????? p / ??????? p / * " 

Utilizzando questo approccio, sono stato in grado di cercare in un database di 3.200.000 giochi in circa 9 minuti, ovvero circa 5.500 partite al secondo. È interessante notare che ho trovato una versione leggermente più breve di qualcosa di simile all'esempio originale dell'OP, con la corrispondenza dopo la 17a mossa del Nero:

  [fen ""] [Evento "CSR-chT 9091 "] [Sito" CSR "] [Data" 1991.01.19 "] [Turno" 5.2 "] [Bianco" Novotny, Jiri "] [Nero" Obsivac, Josef "] [Risultato" 1-0 "]  
  1. e4 c5 2. Nf3 d6 3. d4 cxd4 4. Nxd4 Nf6 5. Nc3 Nc6 6. Bg5 Bd7 7. Be2 Qa5 8. Bxf6 gxf6 9. Nb3 Qg5 10. g3 f5 11. Nd5 Rc8 12. f4 Qg7 13. e5 dxe5 14. Nc5 Nd4 15. Nxd7 Nxc2 + 16. Kf2 exf4 17. N7f6 + exf6 {2r1kb1r / pp3pqp / 5p2 / 3N1p2 / 5p2 / 6P1 / PPn1BK1P / R2Q3R B5 18.8 Kb - 0 18} . Ne7 + 1-0 

Prego. È il mega database di ChessBase di qualche anno fa.
Brandon_J
2019-04-10 19:00:01 UTC
view on stackexchange narkive permalink

Ho trovato il gioco nel database di chess365.com. Ecco il link.

Ecco la ricerca che ho usato per trovarlo.

Ecco il gioco nel replayer.

  [FEN ""] 1. e4 c5 2. Nf3 Nc6 3. d4 cxd4 4. Nxd4 Nf6 5. Nc3 d6 6. Bg5 Bd7 7. Be2 Qa5 8. Bxf6 gxf6 9. Nb3 Qg5 10. Nd5 Rc8 11. OO Rg8 12. g3 f5 13. f4 Qg7 14. e5 dxe5 15. Nc5 Nd4 16. Nxd7 Nxc2 17. Rf2 exf4 18. N7f6 + exf6 19. Bb5 + Kd8 20. Rxc2 fxg3 21. Qd4 1-0  

Ho anche trovato questa raccolta di giochi con pedine triple isolate. Potrebbe essere utile.

Alcune ricerche su Google hanno trovato un famoso gioco di pedoni quadruplicato giocato dal grande Alekhine.

  [fen ""] 1. d4 d5 2. Nf3 e6 3. e3 c6 4. Bd3 f5 5. Ne5 Qf6 6. Nd2 Nd7 7. f4 Nxe5 8. fxe5 Qf7 9. OO Qc7 10. c4 Nh6 11. b3 Bd7 12. a4 Be7 13. cxd5 cxd5 14. Ba3 Bxa3 15. Rxa3 OO 16. Ra2 Rac8 17. Qe2 Qb6 18. Rc2 Rxc2 19. Bxc2 Rc8 20. Bd3 Qb4 21. h3 Nf7 22. Rb1 Rc3 23. Kh2 a6 24. Qf1 Qa3 25. Rd1 Qb2 26. Qe2 Nd8 27. Rb1 Qa3 28. Rf1 Qb4 29. Bb1 b5 30. g4 bxa4 31. gxf5 Bb5 32. Nc4 Rxb3 33. fxe6 dxc4 34. Qf3 Rxb1 35. Rxb1 Qxb1 36. e7 Ne6 37. d5 Qg6 39. Qd5 h6 40. Qc5 c3 41. Qxc3 Qxe7 42. Qc8 + Qe8 43. Qc7 Qxe6 0-1  

Inoltre, controlla la risposta di @Phonon; contiene giochi aggiuntivi.

@RewanDemontay ha anche aggiunto una raccolta di giochi. Penso che questa sarà probabilmente la mia risposta finale.
@Brandon_J fantastico esempio di Alekhine, bel posto! Sembra che Phonon abbia trovato anche altri interessanti esempi.
Ogni singolo esempio è sul lato K. Ci sono esempi con pedoni quadruplicati del lato Q?
Hmmm ... Non conosco @IanBush
Qual è l'ultima mossa (21) in quel gioco? Qd4 non perde solo?
@konsolas sul cellulare rn. Controllerò appena posso.
@RewanDemontay lol - Immagino che "Penso che questa sarà probabilmente la mia risposta finale" ritenuta più vera del previsto. Forse un giorno tornerò su questo ...


Questa domanda e risposta è stata tradotta automaticamente dalla lingua inglese. Il contenuto originale è disponibile su stackexchange, che ringraziamo per la licenza cc by-sa 4.0 con cui è distribuito.
Loading...