What professional game has the quickest sequence, starting from move one, to quadrupled pawns? In the blog &quot;AJEDREZ, SIN DUDA&quot;, I came across a page that gives a game featuring quadrupled pawns.
[Title &quot;Zheliandinov-T. Sereteli, 35th Championship of the USSR, Kharkov, 1967&quot;]
[FEN &quot;2r1kbr1/pp3pqp/5p2/3N1p2/5p2/6P1/PPn1BR1P/R2Q2K1 w - - 0 1&quot;]

It occurred to me that this game might have the shortest sequence, starting from move one in a professional chess game, to quadrupled pawns. It happens here in just 18 moves.
I have three points of focus.


Is this the shortest such game that satisfies my requirements?
I cannot find the score for the mentioned game. If you can find it, please link it and put it into the replayer.
Is there a way to easily find collections of quadrupled pawn games online?
Regarding your last question:


Is there a way to easily find collections of quadrupled pawn games online?


No need to look online, you can do this on your own.
I've found 3 additional examples after parsing through roughly 300000 games of a TWIC DB:
1)
 [fen &quot;&quot;]
 [Event &quot;FSIM May&quot;]
 [Site &quot;Budapest HUN&quot;]
 [Date &quot;1996.05.13&quot;]
 [Round &quot;11&quot;]
 [White &quot;Lochte, T.&quot;]
 [Black &quot;Gross, S.&quot;]
 [Result &quot;0-1&quot;]
 [WhiteElo &quot;2220&quot;]
 [BlackElo &quot;2290&quot;]
 [PlyCount &quot;54&quot;]
 [EventDate &quot;1996.??.??&quot;]
 [SourceDate &quot;2011.01.01&quot;]
 [StartPly &quot;54&quot;]

 1. e4 c5 2. d4 cxd4 3. c3 dxc3 4. Nxc3 d6 5. Bc4 Nc6 6. Nf3 e6 7. O-O 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




 [fen &quot;&quot;]
 [Event &quot;8th World Seniors&quot;]
 [Site &quot;Grieskirchen GER&quot;]
 [Date &quot;1998.11.09&quot;]
 [Round &quot;2&quot;]
 [White &quot;Wegener, H.&quot;]
 [Black &quot;Knebel, W.&quot;]
 [Result &quot;0-1&quot;]
 [ECO &quot;B95&quot;]
 [WhiteElo &quot;2115&quot;]
 [PlyCount &quot;54&quot;]
 [EventDate &quot;1998.??.??&quot;]
 [SourceDate &quot;2011.01.01&quot;]
 [StartPly &quot;48&quot;]

 1. e4 c5 2. Nf3 d6 3. d4 cxd4 4. Nxd4 Nf6 5. Nc3 a6 6. Bg5 e6 7. Bd3 Be7 8. O-O 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




 [fen &quot;&quot;]
 [Event &quot;Open&quot;]
 [Site &quot;Pula CRO&quot;]
 [Date &quot;2001.05.24&quot;]
 [Round &quot;7&quot;]
 [White &quot;Molnar, Be&quot;]
 [Black &quot;Polak, T.&quot;]
 [Result &quot;1-0&quot;]
 [ECO &quot;D42&quot;]
 [WhiteElo &quot;2352&quot;]
 [BlackElo &quot;2503&quot;]
 [PlyCount &quot;80&quot;]
 [EventDate &quot;2001.05.18&quot;]
 [SourceDate &quot;2011.01.01&quot;]
 [StartPly &quot;66&quot;]

 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. O-O O-O 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


Briefly, how I've done it in Python and using python-chess to read the PGN DB:
I scan through each game of the DB mapping each position to its FEN, then I expand the FEN by replacing numbers with a corresponding amount of dashes '-'. In the FEN notation numbers in between the rank '/'-separated sections denote how many empty squares there are before a piece reached on a given row) so e.g., this FEN
'3r4/3PR1pk/r5p1/P2R2p1/6p1/8/5P1P/6K1'

becomes:
'---r----/---PR-pk/r-----p-/P--R--p-/------p-/--------/-----P-P/------K-'

which you can easily do as follows:
(after removing everything after the first space fen=fen[0:fen.index(' ')])
def isinteger(s):
    try:
        int(s)
        return True
    except ValueError:
        return False

for el in fen:
        if isinteger(el):
            fen = fen.replace(el,int(el)*'-')

Then we know we want to find consecutive rows having pawns (of same color) on the same files, so if you split the FEN string
according to the '/' separators into a list (splitfen = fen.split('/')), you have to match the pattern that letter 'p' (denoting black pawns in FEN, similarly, 'P' for white) occurs in 4 consecutive elements of the list and at the same position of the strings of size 8 (to ensure they're on same file) which you can go about in many different way:
#(the function that finds all consecutively matching patterns for t)
def checkpattern(sp,t):
    start = [sp[0]]
    for i in sp[1:]:
        if any(all(t == c for c in b) for b in zip(*(start+[i]))):
            start.append(i)
        else:
            if len(start) &gt; 1:
                yield start
            start = [i]
    return

splitfen = fen.split('/')

forblack = list(checkpattern(splitfen,'p'))
forwhite = list(checkpattern(splitfen,'P'))
total = forblack+forwhite
  for el in total:
    if len(el)==4: #(since we want quadrupled pawns)
      res = True
      break

All such kinds of search queries across chess DB's can be easily performed with a bit of scripting around the FEN to spot the wanted patterns (be they pawn structures, number of pieces etc).