Wahrscheinlichkeit für das Bestehen einer Talentprobe/Programme

==Maple 10 von Vincent==
pEP := proc (e1, e2, e3, TaW)
 local success, s, restTaP;
 if TaW < 0 then return pEP(e1+TaW, e2+TaW, e3+TaW, 0) end if;
 success := 0;
 for w1 to 20 do
 for w2 to 20 do
 for w3 to 20 do
 if nops([(ListTools[SearchAll])(1, [w1, w2, w3])]) >= 2 then
 # meisterhaft gelungen (zwei oder mehr "1"er)
 s := 1
 elif nops([(ListTools[SearchAll])(20, [w1, w2, w3])]) >= 2 then
 # Patzer (zwei oder mehr "20"er)
 s := 0
 else
 # schauen, ob die Rest-TaP nicht unter 0 fallen
 restTaP := TaW-max(0, w1-e1)-max(0, w2-e2)-max(0, w3-e3);
 if restTaP >= 0 then
 # hat gereicht
 s := 1
 else
 s := 0
 end if
 end if;
 success := success+s
 end do
 end do
 end do;
 evalf(1/8000*success)
end proc;
Für erleichterte oder erschwerte Talentproben ist der Parameter TaW vor dem Aufruf anzupassen; es stehen um den Wert verändert entsprechend mehr oder weniger Talentpunkte zur Verfügung, um "schlechte" Würfe zu kompensieren.
==Mathematica von Gial==
pEP[e1_, e2_, e3_, taw_] := 
 Module[{a, b, c, t, result, success, restTaW}, a = e1;
 b = e2;
 c = e3;
 t = taw;
 result = 0;
 If[t < 0, result = pEP[a + t, b + t, c + t, 0];,
 For[i = 1, i <= 20,
 For[j = 1, j <= 20, success = 0;
 restTaW = t - Max[i - a, 0] - Max[j - b, 0];
 If[i == 20 && j == 20, ,
 If[restTaW >= 0, success = Min[20, c + restTaW]];
 If[(i == 1 || j == 1) && success == 0, success = 1;];
 If[(i == 20 || j == 20) && success == 20, success = 19;];
 result = result + success;];
 j++];
 i++];
 result = result/8000;];
 result]
copy and paste -> notebook
\!\(pEP[e1_, e2_, e3_, taw_] := Module[{a, b, 
 c, t, result, success, restTaW}, \[IndentingNewLine]\ta = 
 e1; \[IndentingNewLine]\tb = e2; \[IndentingNewLine]\tc = e3; \
\[IndentingNewLine]\tt = taw; \[IndentingNewLine]\[IndentingNewLine]result = \
0; \[IndentingNewLine]If[t < 0, \(result = pEP[a + t, b + t, c + t, 0];\), \
\[IndentingNewLine]\tFor[i = 1, i ≤ \ 20, \[IndentingNewLine]\tFor[j = 1, j ≤ \
\ 20, \[IndentingNewLine]\tsuccess = 0; \[IndentingNewLine]\trestTaW = 
 t - Max[i - a, 0] - Max[j - b, 0]; \[IndentingNewLine]\tIf[i ==
 20 && j == 20, , \[IndentingNewLine]\t\(If[i == 
 1 && j == 1, \(result = result + 
 20;\), \[IndentingNewLine]\tIf[restTaW ≥ \ 0, success = \
Min[20, c + restTaW]]; \[IndentingNewLine]\t
 If[\((i == 1 || j == 1)\) && success == 0, \(success = 1;\)]; \
\[IndentingNewLine]\t
 If[\((i == 20 || j == 20)\) && success == 20, \(success = \
19;\)]; \[IndentingNewLine]\tresult = result + success;\[IndentingNewLine]\t\
];\)\[IndentingNewLine]\t]; \[IndentingNewLine]\(j++\)]; \
\[IndentingNewLine]\(i++\)]; \[IndentingNewLine]result =
 result\/8000;\[IndentingNewLine]]; \[IndentingNewLine]\
\[IndentingNewLine]result\[IndentingNewLine]]\)
==Java von Geran==
public class Probe {
	
	
	public static void main(String[] args) {
		System.out.println(test(14,14,14,5));
		
	}
	public static double test(int e1, int e2, int e3, int taw) {
		
		 int success, restTaP;
		 if (taw < 0) return test(e1+taw, e2+taw, e3+taw, 0) ;
		 
		 success = 0;
		 for (int w1=1;w1<= 20;w1++) {
			 for (int w2=1;w2<= 20;w2++){
				 for (int w3=1;w3<= 20;w3++){
					 if (meisterhaft(w1,w2,w3)){
						 success++; 
						 continue;
					 }
					 else if (patzer(w1,w2,w3)){
						 continue;
					 }
 					 else { // schauen, ob die Rest-TaP nicht unter 0 fallen
					 restTaP = taw-Math.max(0, w1-e1)-Math.max(0, w2-e2)-Math.max(0, w3-e3);
					 if (restTaP >= 0) {	// hat gereicht
							 success++;
				 	 }
					 }
				 }
			 }
		 }
		 return (100d/8000d*(success));			
	}
	private static boolean meisterhaft(int w1, int w2, int w3) {
		return (w1==1)&&(w2==1)||
			 (w2==1)&&(w3==1)||
			 (w1==1)&&(w3==1);
	}
	private static boolean patzer(int w1, int w2, int w3) {
		return (w1==20)&&(w2==20)||
		 (w2==20)&&(w3==20)||
		 (w1==20)&&(w3==20);
	}
}
==Python (ab 2.6) von 84.133.213.24==
from itertools import product, starmap, izip, imap
from functools import partial
from operator import sub, add
def _analyse(probe, taw=0):
 """
 Berechnet die Erfolgswahrscheinlichkeit einer Talentprobe.
 Wird durch die Funktion analyse() gekapselt, da diese auch
 einen Restwert berücksichtigt, auch TaW* genannt.
 
 :param probe: Eigenschaftswerte auf die geprüft werden soll
 :param taw: der Talentwert kumuliert mit Abzügen oder Aufschlägen
 
 :type probe: iterable of ints
 :type taw: int
 
 :returns: Die Anzahl an Erfolgen und die berechnete Wahrscheinlichkeit
 """
 if taw < 0:
 return _analyse(probe=list(imap(partial(add, taw), probe)))
 wuerfe = product(xrange(1, 21), repeat=3)
 erfolg = 0
 test_meisterhaft = lambda wurf: wurf.count(1) > 1
 test_patzer = lambda wurf: wurf.count(20) > 1
 for wurf in wuerfe:
 if test_patzer(wurf):
 continue
 elif test_meisterhaft(wurf):
 erfolg += 1
 continue
 else:
 if taw - sum(imap(partial(max, 0), (starmap(sub, \
 (izip(wurf, probe)))))) >= 0:
 erfolg += 1
 return taw, erfolg, erfolg/8000.0
def analyse(probe, taw=0, rest=0):
 """
 Wrapper Funktion für _analyse(). Hier wird noch die Möglichkeit geboten,
 einen Restwert bei einer Probe zu fordern.
 :param rest: Der Restwert, der bei einer Probe übrig bleiben soll
 """
 if rest > taw and rest > 0:
 raise Exception(u"Unmögliche Forderung: TaW* > TaW!")
 return _analyse(probe, taw-rest)
==C von 130.183.86.13==
#define EIMPOSSIBLE 1
#define MIN(a, b) ((a>b)?(b):(a))
#define MAX(a, b) ((a 20)
		eig1 = 20;
	if (eig2 > 20)
		eig2 = 20;
	if (eig3 > 20)
		eig3 = 20;
	/* Möglichkeiten, bei denen nicht ausgeglichen werden muss */
	retval = eig1 * eig2 * eig3;
	/* Fälle wo eig1 auf alle Fälle ausgeglichen werden muss */
	i1 = 1;
	while (i1 <= taw && eig1 + i1 <= 20) {
		int rest1 = taw - i1;
		/* nur eig2 gleicht nicht aus */
		if (eig3 + rest1 >= 20)
			retval += eig2 * 20;
		else
			retval += eig2 * (eig3 + rest1);
		i2 = 1;
		/* eig1 und eig2 müssen ausgeglichen werden */
		while (i2 <= rest1 && eig2 + i2 <= 20) {
			int rest2 = rest1 - i2;
			if (eig3 + rest2 >= 20)
				retval += 20;
			else
				retval += eig3 + rest2;
			i2++;
		}
		i1++;
	}
	/* Fälle wo eig1 NICHT ausgeglichen werden muss */
	i2 = 1;
	while (i2 <= taw && eig2 + i2 <= 20) {
		int rest2 = taw - i2;
		int _eig3;
		if (eig3 + rest2 > 20)
			_eig3 = 20;
		else
			_eig3 = eig3 + rest2;
		retval += eig1 * _eig3;
		i2++;
	}
	/* Fälle wo weder eig1 NOCH eig2 ausgeglichen werden muss */
	retval += eig1 * eig2 * ((eig3 + taw > 20)?(20 - eig3):(taw));
	/* Doppel-1 dazuzählen */
	retval += MAX(20 - (eig1 + taw), 0) +
		 MAX(20 - (eig2 + taw), 0) +
		 MAX(20 - (eig3 + taw), 0);
remove_2x20:
	/* Doppel-20 abziehen */
	if (eig1 + taw >= 20) {
		int rest1 = taw - 20 + eig1;
		if (eig2 + rest1 >= 20) {
			int rest2 = rest1 - 20 + eig2;
			retval -= MIN(eig3 + rest2, 19);
		}
		if (eig3 + rest1 >= 20) {
			int rest3 = rest1 - 20 + eig3;
			retval -= MIN(eig2 + rest3, 19);
		}
	}
	if (eig2 + eig3 + taw >= 40) {
		int rest1 = taw - 40 + eig2 + eig3;
		retval -= MIN(eig1 + rest1, 19);
	}
	if (eig1 + eig2 + eig3 + taw >= 60) {
		retval--;
	}
	return retval;
}
==C++ von Borbaradwurm==
#include <algorithm>
double test (int e1, int e2, int e3, int taw)
{
	int success = 0, restTaP = 0;
	if (taw < 0)
	{
		return test (e1 + taw, e2 + taw, e3 + taw, 0);
	}
	for (int w1 = 1; w1 <= 20; w1++)
	{
		for (int w2 = 1; w2 <= 20; w2++)
		{
			for (int w3 = 1; w3 <= 20; w3++)
			{
				if ((w1 == 1) && (w2 == 1) || (w2 == 1) && (w3 == 1) || (w1 == 1) && (w3 == 1))
				{
					success++;
				}
				else
				{ 
					if (!((w1 == 20) && (w2 == 20) || (w2 == 20) && (w3 == 20) || (w1 == 20) && (w3 == 20)))
					{
						restTaP = taw - std::max(0, w1 - e1) - std::max(0, w2 - e2) - std::max(0, w3 - e3);
						if (restTaP >= 0)
						{
							success++;
						}
					}
				}
			}
		}
	}
	return 1.0f / 8000.0f * success;
}
==C# von 77.10.70.247 und Rondrian==
/// <summary>
/// Dient zur Berechnung von Erfolgschancen bei Talent-Proben.
/// </summary>
public class TalentProbenErgebnis
{
 /// <summary>
 /// Berechnet die Erfolgswahrscheinlichkeit einer Talent-Probe und gibt die Chance in Prozent zurück.
 /// </summary>
 /// <param name="e1">Wert der ersten Eigenschaft.</param>
 /// <param name="e2">Wert der zweiten Eigenschaft.</param>
 /// <param name="e3">Wert der ditten Eigenschaft.</param>
 /// <param name="taw">Talentwert (Erschwernisse auf die Probe abziehen und Erleichterungen hinzurechnen).</param>
 /// <returns>Chance in Prozent.</returns>
 public static string ErfolgsChance(int e1, int e2, int e3, int taw)
 {
 return String.Format("{0:P} Chance", ErfolgsChanceBerechnen(e2, e2, e3, taw));
 }
 /// <summary>
 /// Berechnet die Erfolgswahrscheinlichkeit einer Talent-Probe.
 /// </summary>
 /// <param name="e1">Wert der ersten Eigenschaft.</param>
 /// <param name="e2">Wert der zweiten Eigenschaft.</param>
 /// <param name="e3">Wert der dritten Eigenschaft.</param>
 /// <param name="taw">Talentwert (Erschwernisse auf die Probe abziehen und Erleichterungen hinzurechnen).</param>
 /// <returns>Chance als Kommazahl.</returns>
 public static double ErfolgsChanceBerechnen(int e1, int e2, int e3, int taw)
 {
 int success, restTaP;
 if (taw < 0) return ErfolgsChanceBerechnen(e1 + taw, e2 + taw, e3 + taw, 0);
 success = 0;
 for (int w1 = 1; w1 <= 20; w1++)
 {
 for (int w2 = 1; w2 <= 20; w2++)
 {
 for (int w3 = 1; w3 <= 20; w3++)
 {
 if (CheckMeisterhaft(w1, w2, w3))
 {
 success++;
 }
 else
 {
 if (!CheckPatzer(w1, w2, w3))
 {
 // schauen, ob die Rest-TaP nicht unter 0 fallen
 restTaP = taw - Math.Max(0, w1 - e1) - Math.Max(0, w2 - e2) - Math.Max(0, w3 - e3);
 if (restTaP >= 0)
 {
 // hat gereicht
 success++;
 }
 }
 }
 }
 }
 }
 return (1d / 8000d * (success));
 }
 private static bool CheckMeisterhaft(int w1, int w2, int w3)
 {
 return (w1 == 1) && (w2 == 1) ||
 (w2 == 1) && (w3 == 1) ||
 (w1 == 1) && (w3 == 1);
 }
 private static bool CheckPatzer(int w1, int w2, int w3)
 {
 return (w1 == 20) && (w2 == 20) ||
 (w2 == 20) && (w3 == 20) ||
 (w1 == 20) && (w3 == 20);
 }
}
==JavaScript von Little.yoda==
function ErfolgsChanceBerechnen(e1,e2, e3, taw)
{
	var success;
	var restTaP;
	if (taw < 0) {
		return ErfolgsChanceBerechnen(e1 + taw, e2 + taw, e3 + taw, 0);
	}
	success = 0;
	for (var w1 = 1; w1 <= 20; w1++)
	{
		for (var w2 = 1; w2 <= 20; w2++)
		{
			for (var w3 = 1; w3 <= 20; w3++)
			{
				if (CheckMeisterhaft(w1, w2, w3))
				{
					success++;
				}
				else
				{
					if (!CheckPatzer(w1, w2, w3))
					{
						// schauen, ob die Rest-TaP nicht unter 0 fallen
						restTaP = taw - Math.max(0, w1 - e1) - Math.max(0, w2 - e2) - Math.max(0, w3 - e3);
						if (restTaP >= 0)
						{
							// hat gereicht
							success++;
						}
					}
				}
			}
		}
	}
	return (1.0 / 8000.0 * (success));
}
function CheckMeisterhaft( w1, w2, w3)
{
	return (w1 == 1) && (w2 == 1) ||
	(w2 == 1) && (w3 == 1) ||
	(w1 == 1) && (w3 == 1);
}
function CheckPatzer(w1, w2, w3)
{
	return (w1 == 20) && (w2 == 20) ||
	(w2 == 20) && (w3 == 20) ||
	(w1 == 20) && (w3 == 20);
}
Kategorie:DSA aus mathematischer Sicht