[mga010]

Let me advertise my "Bridge Hand Creator and Analyzer", a software which might be useful for you for analysis or teaching. It is a Java program. So you need to install a Java JRE. The source is available. Download of the jar file or the source from SourceForge:

https://sourceforge....ge-hand-replay/

Here is a short description of the features:

Create random hands with optional constraints, such as point counts, placed cards, or suit lengths.

Bid and play the hand. In Windows, the DLL by Bo Haglund for double dummy analysis can be used to analyze the contracts that can be made, to show the correct play, to play against correct defense.

Export to HTML, LIN, PBN is possible. HTML export uses CSS and shows the board and bidding or single hands. Import from LIN and PBN is possible. From IntoBridge, hands can be received via the clipboard, including bid and play.

There is an option to start Monte-Carlo deals with the given constraints, collecting good contracts.

R. Grothmann, Germany.

[mga010]

Probably the wrong forum. No reply and no downloads happening.

[pescetom]

Like most forums, this one is no longer heavily frequented. Also most people who need these capabilities already have some solution. But give it time.

Could you please describe further and clearly the option to start Monte Carlo deals?
This sounds like it might be a unique feature, if people understand what it means and why it is useful.

[mga010]

pescetom, on 2025-August-10, 01:53, said:

Like most forums, this one is no longer heavily frequented. Also most people who need these capabilities already have some solution. But give it time.

Could you please describe further and clearly the option to start Monte Carlo deals?
This sounds like it might be a unique feature, if people understand what it means and why it is useful.

That allows to create multiple boards using the same constraints. E.g., you can fix N/S cards and create random hands for E/W. Then it does a double dummy analysis for each deal, and shows the medians of the number of tricks possible for each contract, and the 2/3 quantile of scores that could be made.

It is currently a rough estimate. Don't actually now if it is helpful. But since there is no feedback, I stopped working on a more detailed analysis.

[mycroft]

Seems interesting, but not helpful for me. Code in spoilers simply for "not a brick wall" response, not because there's anything in there to spoil:

Spoiler

from collections import Counter

from redeal import H, Deal

predeal = {"N": H("AQ8765 K85 - Q863"), "S": H("4 QJT AQT8542 54")}
scores = {"2S": Counter(), "3D": Counter(), "3D+": 0}


def do(deal: Deal) -> None:
    """Analyze the hand in 2S vs 3D."""
    two_s_result = deal.dd_score("2SN")
    three_d_result = deal.dd_score("3DN")
    scores["2S"][two_s_result] += 1
    scores["3D"][three_d_result] += 1
    scores["3D+"] += three_d_result > two_s_result


def final(n_tries: int) -> None:
    """Dump results"""
    print(f"2S scores: {sorted(scores['2S'].items())}")
    print(f"3D scores: {sorted(scores['3D'].items())}")
    print(f"3D scores better on {scores['3D+']} hands of {n_tries}")

While I realize that "10 years of Python programming and 30 years of programming in general", plus "have used this particular package 40 or 50 times" (including to make practise hands for the 6 or 7 SMP modules that are "new" many many times) makes this easier for me than others, this was 15 minutes. Another 15 would probably make the code look good rather than throwaway.

But this question isn't very interesting - I know exactly whether I should have left 2♠ in after:

---

when partner has that hand. And frankly, I'd be surprised if anyone thought otherwise once dummy came down. I'm more interested in:

Spoiler

from collections import Counter

from redeal import H, Deal, SmartStack, Shape, hcp, balanced

predeal = {
    "N": SmartStack(Shape("6xxx"), hcp, range(11, 16)),
    "S": H("4 QJT AQT8542 54"),
}
scores = {"2S": Counter(), "3D": Counter(), "3D+": 0, "total": 0}


def accept(deal: Deal) -> bool:
    """East has a double of forcing NT"""
    if balanced(deal.east) and hcp(deal.east) in range(15, 18):
        return True
    takeout = Shape.from_cond(lambda s, h, d, c: s <= 2 < min(h, d, c))
    if takeout(deal.east) and hcp(deal.east) > 9:
        return True
    return False


def do(deal: Deal) -> None:
    """Analyze the hand in 2S vs 3D."""
    two_s_result = deal.dd_score("2SN")
    three_d_result = deal.dd_score("3DN")
    scores["2S"][two_s_result] += 1
    scores["3D"][three_d_result] += 1
    scores["3D+"] += three_d_result >= two_s_result
    scores["total"] += 1


def final(_: int) -> None:
    """Dump results"""
    print(f"2S scores: {sorted(scores['2S'].items())}")
    print(f"3D scores: {sorted(scores['3D'].items())}")
    print(f"3D scores equal or better on {scores['3D+']} hands of {scores['total']}")

(which it does, about 60% of the time. Just not this time.)

and that took me 5 minutes to tweak from the previous (half of which involved looking up the format for "SmartStack" *again*).

But if you can get close to this in decent time for normal people (not programmers), you will definitely have something. But as I said, not for me. As pescetom says, "most of us already have a tool". Some of them are noted here, if you want to see what functionality is already available.

PS: for those looking at the somewhat odd accept criteria in that second script, guess which type doubler had?