猴子算法
A. 猴子排序法的实际意义是什么
这个算法突破了排序算法最优时间复杂度只能是O(NlogN)的限制，但是实际应用不现实。
这种排序被称为最原始和最低效率的排序算法，因为它可能让你永远无法得到结果。因此在实际中不被使用，只供大家娱乐！
原理：现有一组未排序数据和相同数量的方格，然后依次随机地取出数据随机地放入方格中，直到把方格放满即止。
之所以又被称为猴子排序，我的猜测是因为。将这种随机的特性利用猴子来形容，毕竟猴子并不懂数的大小，让猴子选择和放置数据肯定就是随机的了！
这也是排序？不过再看其实它还是能达到我们想要的排序效果的，虽然概率很小（数据比较多的时候）。既然能解决问题，被称为方法也是无可厚非。
排序算法的含义：
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。
排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
B. java经典算法题——猴子吃桃
public class Monkey
{
public static void main(String[] args)
{
int sum=0,remain=1;
//每天吃剩的桃子加一个正好是前一天桃子的一半，每天桃子的总数就是前一天剩下桃子的数量
for(int day=9;day>=1;day--)
{
sum=(remain+1)*2;
remain=sum;
System.out.println("第"+day+"天还剩"+remain+"个桃子");
}
System.out.println(sum);
}
}
C. 猴子分桃算法
晕死，问题都不发，咋个回答？
是不是这个问题：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只 猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，三、第四、第五只猴子都是这样做的， 问海滩上原来最少有多少个桃子？
#include "stdio.h"
void main()
{
int i,s,n;//定义s为最初桃子的数量；n为最初桃子数减去1
for(n=5;n<=10000;n+=5)//因为可以被分成5份，n一定是5的倍数。
{
s=n+1;
for(i=1;i<=5;i++)//i用来控制5次循环，即分5次
if(s%5==1)//判断桃子能否被分5份并余下一个,成立就开始往下分，
s=(s-1)*4/5;
else
break;//不成立就直接跳出，不用执行后面的循环,即分不下去了
if(i==6)//注意：5次循环之后，i值为6。既然已经分了5次，那么n就找到了。
{
s=n+1;
printf("海滩上原来最少有%d个桃子\n",s);
break;
}
}
}
D. 猴子过河 java算法
importjava.util.Arrays;
importjava.util.List;
importjava.util.Stack;
publicclassMonkey{
publicString[]monkeys={"a","b","c","A","B","C"};
Rulerule1=newRule1();
Rulerule2=newRule2();
publicintcount=0;
publicStringBuffersuccess=newStringBuffer(2000);
publicvoidboat(){
Stack<String>left=newStack<String>();
Stack<String>right=newStack<String>();
for(inti=0;i<monkeys.length;i++){
left.add(monkeys[i]);
}
go(left,right,"");
System.out.println("***********************共"+count+"种成功方案***********************");
System.out.println(success.toString());
System.out.println("***********************共"+count+"种成功方案***********************");
}
privatevoidgo(Stack<String>left,Stack<String>right,Strings){
for(inti=0;i<left.size();i++){
Stringmonkey1=left.get(i);
for(intj=i+1;j<left.size();j++){
StringBuffersb=newStringBuffer();
Stringmonkey2=left.get(j);
sb.append(s);
sb.append(monkey1);
sb.append(monkey2);
sb.append("->");
sb.append("");
if((rule1.isCanBoat(monkey1,monkey2,sb))&&(rule2.isCanBoat(monkey1,monkey2,sb))){
Stack<String>nextLeft=newStack<String>();
Stack<String>nextRight=newStack<String>();
nextLeft.addAll(left);
nextRight.addAll(right);
nextLeft.remove(monkey1);
nextLeft.remove(monkey2);
nextRight.push(monkey1);
nextRight.push(monkey2);
if(nextLeft.size()==0){
success.append(sb.toString()+nextLeft.toString()+nextRight.toString());
success.append(" ");
count++;
continue;
}
back(nextLeft,nextRight,sb.toString());
}
}
}
}
privatevoidback(Stack<String>left,Stack<String>right,Strings){
for(inti=0;i<right.size();i++){
Stringmonkey1=right.get(i);
StringBuffersb=newStringBuffer();
sb.append(s);
sb.append(monkey1);
sb.append("<-");
sb.append("");
if(rule2.isCanBoat(monkey1,monkey1,sb)){
Stack<String>nextLeft=newStack<String>();
Stack<String>nextRight=newStack<String>();
nextLeft.addAll(left);
nextRight.addAll(right);
nextLeft.push(monkey1);
nextRight.remove(monkey1);
go(nextLeft,nextRight,sb.toString());
}
}
}
publicstaticvoidmain(String[]args){
Monkeymonkey=newMonkey();
monkey.boat();
}
}
interfaceRule{
booleanisCanBoat(Stringm1,Stringm2,StringBuffersb);
}
classRule1implementsRule{
String[]childMonkeys={"a","b","c"};
String[]monkeys={"A","B","C"};
publicbooleanisCanBoat(Stringm1,Stringm2,StringBuffersb){
if(m1.toLowerCase().equals(m2.toLowerCase())){
returntrue;
}
List<String>childMonkeysList=Arrays.asList(childMonkeys);
List<String>monkeysList=Arrays.asList(monkeys);
if((monkeysList.contains(m1)&&monkeysList.contains(m2))
||(childMonkeysList.contains(m1)&&childMonkeysList.contains(m2))){
returntrue;
}
sb.append("大猴欺负小猴！");
System.out.println(sb.toString());
returnfalse;
}
}
classRule2implementsRule{
String[]smartMonkeys={"A","B","C","a"};
publicbooleanisCanBoat(Stringm1,Stringm2,StringBuffersb){
List<String>smartMonkeysList=Arrays.asList(smartMonkeys);
if(smartMonkeysList.contains(m1)||smartMonkeysList.contains(m2)){
returntrue;
}
sb.append("没有会划船的猴子！");
System.out.println(sb.toString());
returnfalse;
}
}
E. 猴子选大王算法（快 得急）
我用java写了一个，也是给人帮忙啦，可以给兄台参考参考，有空的话，给你改个指针版出来
MonkeyNumber.java源程序如下：
package test;
import java.util.Scanner;
/**
* @author Administrator
*
* 有M只猴子围成一圈，每只各一个从1到M中的编号，
* 打算从中选出一个大王；经过协商，决定出选大王的规则：从第一个开始循环报数，
* 数到N的猴子出圈，最后剩下来的就是大王。
* 要求：从键盘输入M、N，编程输出猴子出列的次序并计算哪一个编号的猴子成为大王（用数组实现）。
* 要求程序完整，并且验证过，
*
*/
public class MonkeyNumber {
/**
* 出圈
* <b>方法描述</b>：第outNo号出圈 <p>
* <b>方法流程</b>：
* <p>
* @param monkey
* @param n
* @return outNo 出圈的索引号
*/
private static int getOut(int[] monkey,int n){
int outNo = -1;
int intValidVoters = getVotersNumber(monkey);
for(int i=0; i<monkey.length; i++){
if(intValidVoters > n){
if(monkey[i]==n%intValidVoters){
outNo = i+1;
monkey[i]=-1;// 去除该位置的值
System.out.print("--编号为["+outNo+"]的猴子出圈！--");
return outNo;
}
}
else if(intValidVoters < n){
if(monkey[i]==(n%intValidVoters==0?intValidVoters:n%intValidVoters)){
outNo = i+1;
monkey[i]=-1;// 去除该位置的值
System.out.print("--编号为["+outNo+"]的猴子出圈！--");
return outNo;
}
}
else if(intValidVoters==n){
if(monkey[i]==n){
outNo = i+1;
monkey[i]=-1;// 去除该位置的值
System.out.print("--编号为["+outNo+"]的猴子出圈！--");
return outNo;
}
}
}
return outNo;
}
/**
* 重新初始化数组
* <b>方法描述</b>：对输入的数组重新进行赋初值 <p>
* <b>方法流程</b>：
* <p>
* @param monkey
* @param startPos 从startPos位置开始赋初值，startPos索引的数组，其值置为1
*/
private static void reAssign(int[] monkey, int startPos){
int count = 0;
//数组中大于等于位置startPos的有效值的个数
int behindCount = getVotersNumber(monkey, startPos);
//对号码重新初始化
for(int i=0;i<monkey.length; i++){
int differenceValue = i-startPos+1;
if(monkey[i] != -1){
if(differenceValue < 0){
monkey[i]= ++behindCount;
}
else if(differenceValue >= 0){
monkey[i]= ++count;
}
}
}
}
/**
* <b>方法描述</b>：取得当前有效选民数 <p>
* <b>方法流程</b>：
* <p>
* @param monkey
* @return
*/
private static int getVotersNumber(int[] monkey){
int count = 0;
//计算目前多少个号码有效
for(int i=0;i<monkey.length; i++){
if(monkey[i] != -1){
count++;
}
}
System.out.print("当前有["+count+"]只猴子参加选举！");
return count;
}
/**
* <b>方法描述</b>：取得大于等于位置startPos的有效选民数 <p>
* <b>方法流程</b>：
* <p>
* @param monkey
* @return
*/
private static int getVotersNumber(int[] monkey,int startPos){
int count = 0;
//计算目前多少个号码有效
for(int i=startPos;i<monkey.length; i++){
if(monkey[i] != -1){
count++;
}
}
return count;
}
/**
* <b>方法描述</b>：主程序 <p>
* <b>方法流程</b>：测试
* <p>
* @param args
*/
public static void main(String[] args){
System.out.println("Input:M N ");
Scanner scanner = new Scanner(System.in);
String strM = scanner.next();
String strN = scanner.next();
while (strM == null || !strM.matches("[0-9]+")){
System.out.println("输入错误，您输入的第一个参数不是数字，请再次输入:");
scanner = new Scanner(System.in);
strM = scanner.next();
}
while (strN == null || !strN.matches("[0-9]+")){
System.out.println("输入错误，您输入的第二个参数不是数字，请再次输入:");
scanner = new Scanner(System.in);
strN = scanner.next();
}
int m = Integer.parseInt(strM);
int n = Integer.parseInt(strN);
System.out.println("当前有::["+m+"]只猴子"+",即将报的数是::["+n+"]");
int monkey[] = new int[m];
//赋初值
for(int i=0; i<m; i++){
monkey[i]=i+1;
}
for(int i=0; i<m-1; i++){
//出圈
int outNum = getOut(monkey,n);
int startPos = -1;
if(outNum==m){
startPos = 0;
}
else{
startPos = outNum;
}
//再次循环赋初值
reAssign(monkey,startPos);
System.out.println();
}
for(int i=0; i<m; i++){
if(monkey[i]!=-1){
System.out.println("Voting Success!!!编号为["+(i+1)+"]的猴子成为大王！");
}
}
}
}
F. 小猴子算术（作文 ）
小猴算算术作文
今年小猴拜师学艺，学会了一些数学乘法知识。他想：“这一下朱毛‘打’不过我了吧！我一定要报仇雪恨。”于是他向学校走去……终于朱毛出来了。只见小猴双手叉着腰，气势汹汹地说：“朱毛，快点和我比一比。”朱毛说：“比什么啊？”小猴说：“呵呵，你还真健忘，半年前，我和你比赛算算术我连连败下阵来，我现在再次向你挑战。你敢吗？”朱毛说：“都什么时候啦！还说比赛，好好，比就比！我们还是去找老黄牛当裁判吧！”他们找到老黄牛，他正在耕地呢！朱毛说：“老黄牛，你给我们当裁判好吗？”老黄牛说：“好啊，比什么呀？你们先帮我解决一道难题，再比好吗？”“好呀！”朱毛说。老黄牛说：“我有一块地，长40米，宽20米，问我沿着边缘耕地一圈，一共要走多少米？”小猴忙说：“这好办，我跑一圈不就知道了吗？”然后转身就跑。 不一会小猴就跑回来了，他气喘吁吁地说：“我知道了，知道了，是120米，对吗？”老黄牛笑着说：“小猴啊，小猴，人家朱毛早就算出来啦！你是怎么算的？”小猴说：“我是跑了20米再跑了40米又跑了20米和40米它们加起来不就是120米吗。”老黄牛说：“朱毛比你算法好，听朱毛给你解释吧！”朱毛说：“先把20米乘2等于40米，然后，把40米乘2等于80米，再把40和80加起来，就等于120米。”小猴这才知道这就是一场比赛。老黄牛说：“还比吗？”小猴惭愧的说：“这次算我输了，不比了，可是我下次一定会赢的！”朱毛说：“小猴咱们一起回家吧！”小猴说：“好！”就这样朱毛和小猴一起回家了！
G. 转贴：猴子搬香蕉算法，答案是多少
一只小猴摘了300个香蕉，需要搬回家，每次最多搬100个。小猴离家100米，它每走1米，都需要吃掉1个香蕉来补充能量，请问它最多能够搬回家多少个？
先搬100根香蕉到67.5米处放下，吃掉67根，还剩下33根；
把留下的200分别搬到67.5米，总剩下99根；
把这99根香蕉搬回家要吃掉33根，还剩下66根
所以小猴子最多能够搬回家66个。
找不到最好的答案，还是我的答案正确。
H. 猴子偷桃的问题 算法
5个猴子摘了一堆桃,第一个猴平均分5份,余出一个,拿走其中一份和多出的一个,第二个猴将剩下的4份平均分成5份,又余出一个.....第5个后又将剩下的4分平均分成5份,多出一个,求最开始至少有多少个桃?(用递归算法)
# include <iostream.h>
int i;
int fentao(int k)
{
if(i==4) return k;
else if(k%5!=1||k%4!=0)
return 0;
else
{
k=k/4*5;
i++;
return fentao(k);
}
}
void main()
{
for(int j=0;j<100000;j++)
{
i=0;
if(fentao(j)!=0)
{
cout<<fentao(j);
break;
}
}
}
看程序应该能明白的吧
实在不好讲
I. 一头大象重5408千克,是猴子208倍,猴子重多少千克,两种算法
（1）算术法：
猴子重量=大象重量÷倍数=5408÷208=26千克；
（2）方程法：
设猴子重量为x千克,则有;
208x=5408；
x=5408÷208;
x=26;
所以猴子重26千克
J. 猴子吃桃问题.设计算法解决
第9天:(1+1)*2=4
第8天:(4+1)*2=10
第7天:(10+1)*2=22
第6天:(22+1)*2=46
第5天:(46+1)*2=94
第4天:(94+1)*2=190
第3天:(190+1)*2=382
第2天:(382+1)*2=766
第1天:(766+1)*2=1534 1534\2+1=768
所以第一天共摘768个桃子。