/// <summary>
/// 分别随机符号位作成左边关系式和右边关系式
/// </summary>
/// <param name="maximumLimit">最大值</param>
/// <param name="signFunc">運算符取得用的表達式</param>
/// <returns>計算式</returns>
private Formula GetFormulaForRandomNumber(int maximumLimit, Func <SignOfOperation> signFunc)
{
// 對四則運算符實例進行cache管理
IArithmetic strategy = CalculateManager(signFunc());
return(strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = maximumLimit,
QuestionType = QuestionType.Default,
MinimumLimit = 0
}));
}
/// <summary>
/// 左側計算式集合作成并返回當前新作成的計算式
/// </summary>
/// <param name="maximumLimit">計算結果最大值</param>
/// <param name="signFunc">運算符取得用的表達式</param>
/// <returns>新作成的計算式</returns>
private Formula MakeLeftFormulas(int maximumLimit, Func <SignOfOperation> signFunc)
{
IArithmetic strategy = CalculateManager(signFunc());
// 計算式作成
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = maximumLimit,
QuestionType = QuestionType.Default,
MinimumLimit = 0
});
return(formula);
}
/// <summary>
/// 算式作成
/// </summary>
/// <param name="p">題型參數</param>
/// <param name="signFunc">運算符取得用的表達式</param>
private void MarkFormulaList(ComputingConnectionParameter p, Func <SignOfOperation> signFunc)
{
// 當前反推判定次數（一次推算內次數累加）
int defeated = 0;
// 按照指定數量作成相應的數學計算式
for (int i = 0; i < p.NumberOfQuestions; i++)
{
Formula previousFormula = null;
IList <Formula> formulas = new List <Formula>();
// 随机获取接龙层数
for (int j = 0; j < p.SectionNumber; j++)
{
// 指定運算符實例作成
IArithmetic strategy = CalculateManager(signFunc());
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = QuestionType.Default,
MinimumLimit = 0
}, previousFormula);
if (CheckIsNeedInverseMethod(p.Formulas, formula, p.MaximumLimit))
{
defeated++;
// 如果大於五次則認為此題無法作成繼續下一題
if (defeated == INVERSE_NUMBER)
{
// 當前反推判定次數復原
defeated = 0;
continue;
}
j--;
continue;
}
previousFormula = formula;
formulas.Add(formula);
}
// 當前反推判定次數復原
defeated = 0;
p.Formulas.Add(new ConnectionFormula()
{
ConfixFormulas = formulas, ConfixNumber = formulas.Count
});
}
}
/// <summary>
/// 算式作成
/// </summary>
/// <param name="p">題型參數</param>
/// <param name="signFunc">運算符取得用的表達式</param>
private void MarkFormulaList(ArithmeticOperationsParameter p, Func <SignOfOperation> signFunc)
{
// 當前反推判定次數（一次推算內次數累加）
int defeated = 0;
// 按照指定數量作成相應的數學計算式
for (var i = 0; i < p.NumberOfQuestions; i++)
{
IArithmetic strategy = CalculateManager(signFunc());
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = p.QuestionType,
MinimumLimit = 0,
LeftScope = p.LeftScope,
RightScope = p.RightScope
});
// 填空項目設定
formula.Gap = CommonUtil.GetRandomNumber(GapFilling.Left, GapFilling.Right);
// 判定是否需要反推并重新作成計算式
if (CheckIsNeedInverseMethod(p, formula))
{
defeated++;
// 如果大於五次則認為此題無法作成繼續下一題
if (defeated == INVERSE_NUMBER)
{
// 當前反推判定次數復原
defeated = 0;
continue;
}
i--;
continue;
}
// 計算式作成
p.Formulas.Add(new ArithmeticOperationsFormula
{
// 四則運算式
Arithmetic = formula,
// 等式值是不是出現在右邊（如果未指定則隨機產生）
AnswerIsRight = p.AnswerIsRight ?? IsRight
});
defeated = 0;
}
}
/// <summary>
/// 算式作成
/// </summary>
/// <param name="p">題型參數</param>
public override void MarkFormulaList(HowMuchMoreParameter p)
{
// 指定單個運算符實例（此題只能用減法運算符）
IArithmetic strategy = CalculateManager(SignOfOperation.Subtraction);
// 按照指定數量作成相應的數學計算式
for (var i = 0; i < p.NumberOfQuestions; i++)
{
// 計算式作成
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
// 10以內計算
MaximumLimit = (p.MaximumLimit > 10) ? 10 : p.MaximumLimit,
QuestionType = QuestionType.Default,
MinimumLimit = 0
});
if (CheckIsNeedInverseMethod(p.Formulas, formula))
{
i--;
continue;
}
// 運算式作成
HowMuchMoreFormula howMuchMoreFormula = new HowMuchMoreFormula()
{
DefaultFormula = formula,
// 選擇左邊作為題目的條件還是右邊（隨機獲取）
DisplayLeft = CommonUtil.GetRandomNumber(LeftOrRight.Left, LeftOrRight.Right) == LeftOrRight.Left,
// 題型選擇：是表示多的題還是少的題（隨機獲取）
ChooseMore = CommonUtil.GetRandomNumber(MoreOrLess.More, MoreOrLess.Less) == MoreOrLess.More
};
// 文字表述部分內容作成
howMuchMoreFormula.MathWordProblem = CreateMathWordProblem(howMuchMoreFormula);
// 答案值（如果顯示的是左邊值，那麼答案就是右邊的值）
howMuchMoreFormula.Answer = ((howMuchMoreFormula.DisplayLeft) ? howMuchMoreFormula.DefaultFormula.RightParameter : howMuchMoreFormula.DefaultFormula.LeftParameter);
// 計算式作成
p.Formulas.Add(howMuchMoreFormula);
}
// 智能提示作成
VirtualHelperBase <HowMuchMoreFormula> helper = new HowMuchMoreDialogue();
p.BrainpowerHint = helper.CreateHelperDialogue(p.Formulas);
}
/// <summary>
/// 算式作成
/// </summary>
/// <param name="p">題型參數</param>
/// <param name="signFunc">運算符取得用的表達式</param>
private void MarkFormulaList(MathUprightParameter p, Func <SignOfOperation> signFunc)
{
// 當前反推判定次數（一次推算內次數累加）
int defeated = 0;
// 按照指定數量作成相應的數學計算式
for (var i = 0; i < p.NumberOfQuestions; i++)
{
IArithmetic strategy = CalculateManager(signFunc());
// 運算式作成
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = p.QuestionType,
MinimumLimit = 1
});
// 判定是否需要反推并重新作成計算式
if (CheckIsNeedInverseMethod(p, formula))
{
defeated++;
// 如果大於八次則認為此題無法作成繼續下一題
if (defeated == INVERSE_NUMBER)
{
// 當前反推判定次數復原
defeated = 0;
continue;
}
i--;
continue;
}
// 計算式作成
p.Formulas.Add(new MathUprightFormula
{
Arithmetic = formula,
// 如果是標準題型則將等式結果項目作為填空項目，以外的情況則隨機產生一個填空項目位置
FillPosition = (p.QuestionType == QuestionType.Standard) ? FillPositions.Last() : CommonUtil.GetRandomNumber(FillPositions),
// 計算式數據鏈作成
FormulaDataLink = CreatFormulaDataLink(formula)
});
defeated = 0;
}
}
/// <summary>
/// 題型構築
/// </summary>
/// <param name="p"></param>
public override void MarkFormulaList(CombinatorialEquationParameter p)
{
for (var i = 0; i < p.NumberOfQuestions; i++)
{
// 對四則運算符實例進行cache管理
IArithmetic strategy = CalculateManager(p.Signs[CommonUtil.GetRandomNumber(0, p.Signs.Count - 1)]);
// 計算式作成
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = QuestionType.Default,
MinimumLimit = 1
});
// 獲得無效參數
int invalidParameter = GetInvalidParameter(formula);
// 判定是否需要反推并重新作成計算式
if (CheckIsNeedInverseMethod(p, formula.LeftParameter, formula.RightParameter, formula.Answer))
{
i--;
continue;
}
p.Formulas.Add(new CombinatorialFormula()
{
ParameterA = formula.LeftParameter,
ParameterB = formula.Answer,
ParameterC = formula.RightParameter,
ParameterD = invalidParameter
});
if (formula.Sign == SignOfOperation.Plus)
{
// 加法算式組合序列
p.Formulas.Last().CombinatorialFormulas = new List <Formula>()
{
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.RightParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Plus
},
new Formula()
{
LeftParameter = formula.RightParameter, RightParameter = formula.LeftParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Plus
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.LeftParameter, Answer = formula.RightParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Subtraction
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.RightParameter, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Subtraction
}
};
}
else if (formula.Sign == SignOfOperation.Subtraction)
{
// 減法算式組合序列
p.Formulas.Last().CombinatorialFormulas = new List <Formula>()
{
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.RightParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Subtraction
},
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.Answer, Answer = formula.RightParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Subtraction
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.RightParameter, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Plus
},
new Formula()
{
LeftParameter = formula.RightParameter, RightParameter = formula.Answer, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Plus
}
};
}
else if (formula.Sign == SignOfOperation.Multiple)
{
// 乘法算式組合序列
p.Formulas.Last().CombinatorialFormulas = new List <Formula>()
{
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.RightParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Multiple
},
new Formula()
{
LeftParameter = formula.RightParameter, RightParameter = formula.LeftParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Multiple
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.LeftParameter, Answer = formula.RightParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Division
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.RightParameter, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Division
}
};
}
else
{
// 除法算式組合序列
p.Formulas.Last().CombinatorialFormulas = new List <Formula>()
{
new Formula()
{
LeftParameter = formula.RightParameter, RightParameter = formula.Answer, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Multiple
},
new Formula()
{
LeftParameter = formula.Answer, RightParameter = formula.RightParameter, Answer = formula.LeftParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Multiple
},
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.RightParameter, Answer = formula.Answer, Gap = GapFilling.Default, Sign = SignOfOperation.Division
},
new Formula()
{
LeftParameter = formula.LeftParameter, RightParameter = formula.Answer, Answer = formula.RightParameter, Gap = GapFilling.Default, Sign = SignOfOperation.Division
}
};
}
// 將參數亂序排列
DisorganizeParameter(p.Formulas.Last());
}
}
/// <summary>
/// 加減算式作成
/// </summary>
/// <param name="p">題型參數</param>
public override void MarkFormulaList(CurrencyOperationParameter p)
{
// 標準題型（指定單個運算符）
if (p.FourOperationsType == FourOperationsType.Standard)
{
// 考虑乘除法接龙答题结果会超出限制,所以只随机加减法策略
if (p.Signs[0] == SignOfOperation.Division || p.Signs[0] == SignOfOperation.Multiple)
{
p.Signs[0] = SignOfOperation.Plus;
}
// 指定單個運算符實例
IArithmetic strategy = CalculateManager(p.Signs[0]);
// 按照指定數量作成相應的數學計算式
for (var i = 0; i < p.NumberOfQuestions; i++)
{
Formula formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = p.QuestionType,
MinimumLimit = 0
});
if (CheckIsNeedInverseMethod(p.Formulas, formula))
{
i--;
continue;
}
// 計算式作成
p.Formulas.Add(new CurrencyOperationFormula
{
// 貨幣運算方程式
CurrencyArithmetic = formula,
// 等式值是不是出現在右邊
AnswerIsRight = IsRight
});
}
}
else
{
// 按照指定數量作成相應的數學計算式
for (var i = 0; i < p.NumberOfQuestions; i++)
{
// 混合題型（加減運算符實例隨機抽取）
SignOfOperation sign = CommonUtil.GetRandomNumber(SignOfOperation.Plus, SignOfOperation.Subtraction);
// 對運算符實例進行cache管理
IArithmetic strategy = CalculateManager(sign);
var formula = strategy.CreateFormula(new ArithmeticParameter()
{
MaximumLimit = p.MaximumLimit,
QuestionType = p.QuestionType,
MinimumLimit = 0
});
if (CheckIsNeedInverseMethod(p.Formulas, formula))
{
i--;
continue;
}
// 計算式作成
p.Formulas.Add(new CurrencyOperationFormula
{
// 貨幣運算方程式
CurrencyArithmetic = formula,
// 等式值是不是出現在右邊
AnswerIsRight = IsRight
});
}
}
}
