扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
下载作业帮安装包
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
一道数学题求解&
荪惬觅竧蒍柫濓
扫二维码下载作业帮
拍照搜题，秒出答案，一键查看所有搜题记录
1、获利百分率=(计算期末最后收入金额-计算期初投入金额)*100%/(计算期初投入金额25%=(10-x)x100%÷xx=8即每个成本2、y=-10x+300个(-10x+300)x(x-8)=1200x^2-30x+360=0x=20或x=18即单价18或20
为您推荐：
扫描下载二维码一道数学题求解？？？【高考吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
一道数学题求解？？？收藏
x∈[0,1]log4^（2-X）&1/4
(即log以4为底的（2-X）的对数大于1/4)两个联立方程求交集？？？跪求答案及过程
拜托别沉了
求以4为底的Z的对数=1/4,因为log4x是单增函数,所以只要2-x大于z 就ok我数学也不好- -#不过应该是这样做的吧
xEUR[0,2-根2)
划同底，取交集…
真数大于0 和前两个求交集 那个对数的1/4可写成以四为底根二的对数 底数4大于一 增 后面的自己做吧
复合函数单调性 2-x 是减函数，log是增函数，增减得减，也就是整体为减函数，那么不是2-x大于0小于根号2吗？我解得
（2-根2,1】
但答案应该是和4楼一样，求解释
函数f（x）是定义域为R的偶函数，且对任意的x∈R。均有f（x+2）=f（x）成立。当x∈[0,1]时，当f（x）=log以a为底的（2-x）（a＞1）。若f（x）的最大值为1/2，解关于x的不等式f（x）&#.原题是这道题
解释在七楼
不是复合函数吗？复合函数单调性增减得减吗？
（2-X）为减函数啊
登录百度帐号推荐应用利用编程解决一道数学题_C#应用_动态网站制作指南
利用编程解决一道数学题
来源：人气：435
在朋友空间看到一道题，如下：
当时顺手画了条数轴，在数轴上标出了各个算式的解的特点：和为7的算式的解关于4对称,和为9的解关于5对称等等。草草算了下，发现很难同时满足5个条件。而细算又太麻烦，算了，反正是程序员，写程序求解吧。
利用笛卡尔积求解
因为是4个算式，很自然的就想到穷举法。将每个算式可能的结果放在一起算笛卡尔积，如果有解的话，则必然存在一个笛卡尔积里面存在1到8这8个不同的元素。
计算笛卡尔积的代码如下：
/// &summary&
/// 计算元素集列表的笛卡尔积
/// &/summary&
/// &typeparam name="T"&元素具体类型&/typeparam&
/// &param name="sets"&元素集列表&/param&
/// &returns&笛卡尔积列表&/returns&
public static T[][] CalculateCartesianoduct&T&(this IList&IList&T&& sets)
// 笛卡尔积总数
int total = 1;
// 元素集个数
int setCount = 0;
foreach (var set in sets)
total *= set.C
setCount++;
// 笛卡尔积列表
var products = new T[total][];
// 除数列表，用于计算每个笛卡尔积的情况
var dividers = new int[setCount];
int divider = 1;
// 倒序循环，因为后面的多种情况对应前面的一种情况
for (int counter = setCount - 1; counter &= 0; counter--)
dividers[counter] =
divider *= sets[counter].C
// 计算笛卡尔积,共有permutationNumber个笛卡尔积,
// 从0到permutationNumber中,每个数字对应一种笛卡尔积情况
for (int counter = 0; counter & counter++)
// 一个笛卡尔积的情况
var permutation = new T[setCount];
int index = 0;
foreach (var set in sets)
// 将数字映射到元素集中的位置
var pos = (counter / dividers[index]) % set.C
permutation[index] = set[pos];
products[counter] =
原理是将笛卡尔积解的总个数里的每个数字映射到一个解。
比如前面几个笛卡尔积如下：
[2, 1] [3, 1] [1, 6] [1, 8] [2, 1] [3, 1] [1, 6] [2, 7]
[2, 1] [3, 1] [1, 6] [3, 6]
[2, 1] [3, 1] [1, 6] [4, 5]
[2, 1] [3, 1] [2, 5] [1, 8]
[2, 1] [3, 1] [2, 5] [2, 7]
[2, 1] [3, 1] [2, 5] [3, 6]
[2, 1] [3, 1] [2, 5] [4, 5]
后面我又想到，实际上计算全排列也可以解决此题。将1到8取全排列，如果此题有解的话，则必然存在一个全排列，使得每两个元素为一对，依次满足4个算式。
简单粗暴的解法
代码如下：
/// &summary&
/// 计算指定元素集的全排列
/// &/summary&
/// &typeparam name="T"&元素的具体类型&/typeparam&
/// &param name="collection"&元素集&/param&
/// &returns&全排列&/returns&
public static IEnumerable&T[]& CalculatePermutationCrude&T&(ICollection&T& collection)
// 元素个数
int elementCount = collection.Count();
// 全排列列表
var permutations = new List&T[]&();
// 一个全排列
var permutation = new List&T&();
CalculatePermutationCrude(permutations, permutation, collection, elementCount);
/// &summary&
/// 计算指定元素集的全排列
/// &/summary&
/// &typeparam name="T"&元素的具体类型&/typeparam&
/// &param name="permutations"&全排列列表&/param&
/// &param name="permutation"&一个全排列&/param&
/// &param name="collection"&元素集&/param&
/// &param name="setLength"&集合长度&/param&
private static void CalculatePermutationCrude&T&(
List&T[]& permutations,
List&T& permutation,
ICollection&T& collection,
int setLength)
if (permutation.Count & setLength)
foreach (var item in collection)
// 不是可重排列,不能包含
if (!permutation.Contains(item))
var temp = permutation.ToList();
temp.Add(item);
if (temp.Count == setLength)
// 达到最大计算深度,表示完成一个全排列,添加
permutations.Add(temp.ToArray());
CalculatePermutationCrude(permutations, temp, collection, setLength);
原理是有多少个元素，就循环多少次，将包含重复元素的排列剔除掉，自然就是集合的全排列了。
深度优先遍历解法
代码如下：
/// &summary&
/// 计算指定元素集的全排列
/// &/summary&
/// &typeparam name="T"&元素的具体类型&/typeparam&
/// &param name="set"&元素集&/param&
/// &returns&全排列&/returns&
public static IEnumerable&T[]& CalculatePermutationDFS&T&(IEnumerable&T& set)
var permutations = new List&T[]&();
var path = new List&T&();
bool[] visited = new bool[set.Count()];
CalculatePermutationDFS(set, permutations, path, visited);
/// &summary&
/// 计算指定元素集的全排列
/// &/summary&
/// &typeparam name="T"&元素的具体类型&/typeparam&
/// &param name="set"&元素集&/param&
/// &param name="permutations"&全排列&/param&
/// &param name="path"&排列的元素列表&/param&
/// &param name="visited"&元素访问与否的数组&/param&
private static void CalculatePermutationDFS&T&(
IEnumerable&T& set,
List&T[]& permutations,
List&T& path,
bool[] visited)
if (path.Count == set.Count())
permutations.Add(path.ToArray());
for (int i = 0; i & set.Count(); i++)
if (!visited[i])
path.Add(set.ElementAt(i));
visited[i] = true;
CalculatePermutationDFS(set, permutations, path, visited);
path.RemoveAt(path.Count - 1);
visited[i] = false;
在代码中使用了一个辅助列表保存遍历过的元素，一个辅助数组保存元素的访问情况，在深度遍历前设置相关信息，遍历完成后重置相关信息。
非递归解法
上面的两种解法使用了递归，众所周知，全排列的个数为待排列个数的阶乘。而在数据量较大时，阶乘比指数爆炸更可怕。如果不使用自建堆栈，将递归化为迭代，有没有其他办法计算全排列，就像前面计算笛卡尔积一样，将每个数字映射到一个解。经过多次试错，总算被我想到了一个办法。
将每一个全排列对应一个数，以1234为例，如下图：
将每个序号（从0开始）对应到一个数。对应数的有如下规律：
位数总是比全排列的元素个数少1。
设从右到左，每个数位对应的权值依次递增，最右边个数权植为1。则对应数的每位上的数值为序号除以位数权值的阶乘然后对其位数的权值加1取余（真是太绕了）。注：在程序运算中转型会直接向下取整。以23为例：第1位(23/1！)%2=23%2=1；第2位（23/2！）%3=11%3=2，第3位(23/3!)%4=3再以13为例，第1位（13/1!)%(2）=13%1=1；第2位(13/2!)%3=6%3=0，第三位（13/3!)%4=2。
从对应数到全排列，只需要从左到右，依次在元素集中取出剩余数中从小到大的第对应数数位位上的数（从0开始计数，同样还是很绕），最后还将剩下的数取出即可。示例如下：
终于可以上代码了：
/// &summary&
/// 计算指定元素集的全排列
/// &/summary&
/// &typeparam name="T"&元素的具体类型&/typeparam&
/// &param name="collection"&元素集&/param&
/// &returns&全排列&/returns&
public static IEnumerable&T[]& CalculatePermutation&T&(IList&T& collection)
// 全排列总数
int total = 1;
// 元素个数
int elementCount = collection.C
// 除数列表，用于计算每个全排列的情况
var dividers = new int[elementCount - 1];
for (int i = 2; i &= elementC i++)
dividers[i - 2] =
// 全排列列表
var permutations = new T[total][];
// 计算全排列,共有permutationNumber个全排列,
// 从0到permutationNumber中,每个数字对应一种全排列情况
for (int counter = 0; counter & counter++)
// 一个全排列的情况
var permutation = new T[elementCount];
// 指示数组，指示全排列对应元素集中的位置
var indicates = new int[elementCount - 1];
// 使用数组，指示元素集中对应的元素是否已使用
var usedFlags = new bool[elementCount];
for (int j = 0; j & elementCount - 1; j++)
// 从右向左计算
indicates[elementCount - 2 - j] = (counter / dividers[j]) % (j + 2);
// 全排列的索引
int index = 0;
foreach (var indicate in indicates)
int pos = 0;
// 统计未使用的元素
int unusedCount = -1;
for (; pos & elementC pos++)
if (!usedFlags[pos])
unusedCount++;
// 找到了要放入的元素位置
if (unusedCount &= indicate)
permutation[index] = collection[pos];
usedFlags[pos] = true;
// 将最后剩余的元素放入全排列
for (int j = 0; j & elementC j++)
if (!usedFlags[j])
permutation[elementCount - 1] = collection[j];
permutations[counter] =
经过一番劳累，结局是悲伤的，答案就是没有答案。可能有的朋友会说特殊运算，由于题目的限制，幂跟对数是不可能了，唯一能够使用的特殊运算就只有平方，在这种情况下，依然没有答案。当然，如果你硬要说立方也是特殊运算，那么还是有解的。
此刻我的内心是崩溃的
优质网站模板求解一道难的数学题
本回答由提问者推荐《暗杀教室》中期末考试最后一道数学压轴题具体是怎么解的？ - 知乎4被浏览2477分享邀请回答21 条评论分享收藏感谢收起2添加评论分享收藏感谢收起