Simulating 10,000 6-player games. Each player start with 5 coins.

No couples: 112 minutes
One couple: 101 minutes
Two couples: 84 minutes
Three couples: 68 minutes

Disallow joint victories:
One couple: 114 minutes
Two couples: 121 minutes
Three couples: 127 minutes

#!/usr/bin/python

# How long does a game of dreidel take?
# How does that change when couples form "alliances" and help each other out?

import random
from numpy import average, round
from scipy.stats import stderr

def pay(i, coins, couples):
	"""Pay what is owed, or have your partner pay, or lose the game."""
	if coins[i] > 0:
		# Player can pay.
		coins[i] -= 1
		paid = True
	elif couples[i]:
		# Player has a partner.
		if coins[couples[i]] > 0:
			# That partner can afford a loan.
			coins[couples[i]] -= 1
			paid = True
		else:
			coins[i] = None # Player is out of the game.
			paid = False
	else:
		coins[i] = None # Player is out of the game.
		paid = False
	return coins, paid

def play_round(coins, couples, turn_counter, next_player):
	"""Simulate one round of the game, and count turns."""
	# Ante up.
	pot = 0
	for i in range(len(coins)):
		if coins[i] is not None:
			coins, paid = pay(i, coins, couples)
			if (paid): pot += 1

	# Take turns.
	while pot > 0:
		# List players in order, starting with whoever's turn it is.
		for i in map(lambda x: x % len(coins), range(next_player, next_player+len(coins))):
			if coins[i] is None:
				continue # Player is already out of the game.
			roll = random.choice(['nun', 'gimmel', 'hey', 'shin'])
			if roll is 'gimmel':
				coins[i] += pot
				pot = 0
			elif roll is 'hey':
				coins[i] += pot/2
				pot = pot - pot/2
			elif roll is 'shin':
				coins, paid = pay(i, coins, couples)
				if paid:
					pot += 1
			turn_counter += 1
			if pot is 0:
				next_player = i+1
				break

	return coins, turn_counter, next_player

def game(number_of_players, starting_money, couples, allow_joint_victory=True):
	"""Simulate a game, and count turns."""
	coins = number_of_players*[starting_money]
	turn_counter = 0
	next_player = 0

	# In the function call, couples may be specified as an explicit list with a seating arrangement.
	# Alternatively, the call may simply give the NUBMER of couples. They will be seated beside each other.
	if type(couples) is not list:
		number_of_couples = couples
		couples = number_of_players*[None]
		for i in range(number_of_couples):
			couples[2*i]=2*i+1
			couples[2*i+1]=2*i

	while True:
		# Check whether game has ended.
		winners = [i for i, c in enumerate(coins) if c is not None]
		if (len(winners) is 1): break # One winner.
		if (len(winners) is 2 and
			winners[0] == couples[winners[1]]):
				if (allow_joint_victory is True):
					break # Joint win.
				else:
					# End the alliance and play it out.
					couples = number_of_players*[None]

		coins, turn_counter, next_player = play_round(coins, couples, turn_counter, next_player)
	return turn_counter

def simulate_games(N, number_of_players, starting_money, number_of_couples, allow_joint_victory=True):
	"""Return average game duration of N simulated games."""
	TURNS_PER_MIN = 5 # estimated turns per minute, to interpret result
	outcomes = [game(number_of_players, starting_money, number_of_couples, allow_joint_victory) for x in range(N)]
	value = int(round(average(outcomes)/TURNS_PER_MIN))
	error = int(round(stderr(outcomes)/TURNS_PER_MIN))
	return str(value) + ' +/- ' + str(error) + ' minutes'

TRIALS = 10000
N_PLAYERS = 6
MONEY = 5

print 'Simulating 10,000 6-player games. Each player starts with 5 coins.'
print 'No couples:', simulate_games(TRIALS, N_PLAYERS, MONEY, 0)
print 'One couple:', simulate_games(TRIALS, N_PLAYERS, MONEY, 1)
print 'Two couples:', simulate_games(TRIALS, N_PLAYERS, MONEY, 2)
print 'Three couples:', simulate_games(TRIALS, N_PLAYERS, MONEY, 3)

print 'Disallow joint victories:'
print 'One couple:', simulate_games(TRIALS, N_PLAYERS, MONEY, 1, False)
print 'Two couples:', simulate_games(TRIALS, N_PLAYERS, MONEY, 2, False)
print 'Three couples:', simulate_games(TRIALS, N_PLAYERS, MONEY, 3, False)

Hide the code.