周一笔试题

youruiler 2009-06-17 10:01:32
加精
最后两个编程题：题目要求如下：

1、写一个类，实现这样一个方法，此方法给定两个参数N、L（均为整数），N是一个自然数，L表示一个长度。要求此函数输出一个最小长度的连续数的数组，此数组的几个连续数的和要等于给定的N，并且该数组的长度要大于等于给定的L。如没有满足该条件的则返回一个空数组{}。
eg1：（18，3）则应该return {5,6,7}; 分析满足和为18的连续数的数组有两个：{3，4，5，6}、{5，6，7}应题目要求输出最短的数组，所以结果如上。
eg2: (18,4) 则应该返回结果{3,4,5,6};
eg3: (45,10)则返回结果为{0，1，2，3，4，5，6，7，8，9}；


2、写一个，实现这样一个方法，此方法同样两个参数n,k（均为非负整数），要求对给定的数n经过k此位置调换之后输出使得交换结果最大的那个数。若某两个数交换出现最高位是0的情况则返回0.
eg1: (432,1) return 423;即给定一个数432，经过一次调换得到最大数输出，所以只能将3和2交换结果最大。
eg2：（9090，4） return 0；
eg2：（936654，2）return966354 。

如上俩编程题，请教哪位各位高手们给解答下下。
...全文
347 76 打赏 收藏 转发到动态 举报
写回复
用AI写文章
76 条回复
切换为时间正序
请发表友善的回复…
发表回复
bigbug9002 2009-06-25
  • 打赏
  • 举报
 回复
[Quote=引用 53 楼 iloveliming0 的回复:]
引用 4 楼 bigbug9002 的回复:
第一题：

Java codepublicclassMyTest{publicstaticvoidmain(String[] args){int[] a=eg1(45,10);for(inti=0;i <a.length;i++){
System.out.println(a[i]+"");
}
}publicstaticint[] eg1(intn,intl){int[] result=null;intlen=l;while(len <n){if(2*n/len*len==2*n||(2*n/len+1-len)%2==0){break;
}
len++;
}if(len>=n)…
[/Quote]

谢谢提醒!
public class MyTest{

    public static void main(String[] args){

        int[] a=eg1(18,10);

        if(a==null){                                      //找不到返回了null;

        	System.out.println("找不到合适的结果！");

        	System.exit(0);

        }

        for(int i=0;i<a.length;i++){

            System.out.println(a[i]+" ");

        }

    }

    public static int[] eg1(int n,int leng){       //把原来的l改为leng，避免和数字1混淆。

        int[] result=null;

        int len=leng;

        while(len<n){

            if(2*n/len*len==2*n && (2*n/len+1-len)%2==0){  //这里原来是2*n/len*len==2*n || (2*n/len+1-len)%2==0 错了。

                break;

            }

            len++;

        }

        if(len>=n|| 2*n/len-len+1<0) return result;

        

        result=new int[len];

        int start=(2*n/len-len+1)/2;

        int end=start+len-1;

        for(int i=start,j=0;i<=end;i++){

            result[j++]=i;

        }

        return result;

    }

}

//以下是思路：

//假设从自然数x开始有L个连续的自然数之和为N，则由等比数列求和公式得：(x+x+L-1)*L/2=N;由于x,L,N都是整数，所以2*N应该能被L整除。 

//由上式可得：x=((2*N)/L-L+1)/2,由此可见，如果L和N是确定的,x就是确定的。 

//由以上两点，只要2*N能被L整除，同时2*N/L-L+1能被2整除，就有一个长度为L且从x开始的自然数序列之和为N。 

//编程就简单了，让len从L开始递增，看看2*N能不能被len整除，同时，2*N/len-len+1能不能被2整除。如果都能，则用上面的公式求出x(程序中的start） 

//由于求的最小一个序列，所以只要找到一个len就结束了。
lang3879 2009-06-25
  • 打赏
  • 举报
 回复
⊙﹏⊙b汗
插入代码还不会用，菜鸟
[code={0}]
/**
*
*/
package resume.csdn;

/**
* @author lang3879
*
*/
public class ArrayEqualsSum {

public int[] mainGenerateArray(int sum, int length) {
int[] returnMe = this.generateArray(sum, length);
// ↓length的长度不知道如何判断，根据sum好像判断不出
// 比如sum=0，length=3，返回[-1,0,1]
while (length < 20 && returnMe.length == 0) {
length++;
returnMe = this.generateArray(sum, length);
}
return returnMe;
}

/**
* 假设起始为x，长度为3; x+(x+1)+(x+2)=3*x+(0+1+2)=sum 所以x=(sum-(0+1+2+...))/length
*
* @param sum
* 和的值
* @param length
* 数组的长度
* @return
*/
public int[] generateArray(int sum, int length) {
// iSum=(0+1+2+...)
int iSum = 0;
int iStartNumber = 0;
final int startAddEnd = (iStartNumber + (iStartNumber + length - 1));
if (length % 2 == 0) {// 表示偶数，首尾相加并乘以长度的一半
iSum = startAddEnd * (length / 2);
} else {// 表示奇数,首尾相继并乘以长度-1的一半，再加中间的那一个元素
iSum = startAddEnd * ((length - 1) / 2) + startAddEnd / 2;
}
// ↓整除标出x存在
if ((sum - iSum) % length == 0) {
return this.repateNumber((sum - iSum) / length, length);
}
return new int[] {};
}

/**
* 创建startNumber开始长度为length，元素间递增为一的数组
*
* @param startNumber
* @param length
* @return
*/
private int[] repateNumber(int startNumber, int length) {
int[] returnMe = new int[length];
for (int index = 0; index < length; index++) {
returnMe[index] = startNumber;
startNumber++;
}
return returnMe;
}

/**
* int数组转字符串
*
* @param intArray
* @return
*/
private String intArrayToString(int[] intArray) {
StringBuffer sb = new StringBuffer("[");
for (int index = 0; index < intArray.length; index++) {
int i = intArray[index];
sb.append(i).append(",");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
return sb.toString();
}

/**
* 写一个类，实现这样一个方法，此方法给定两个参数N、L（均为整数）， N是一个自然数，L表示一个长度。 要求此函数输出一个最小长度的连续数的数组，
* 此数组的几个连续数的和要等于给定的N， 并且该数组的长度要大于等于给定的L。 如没有满足该条件的则返回一个空数组{}。
* eg1：（18，3）则应该return {5,6,7};
* 分析满足和为18的连续数的数组有两个：{3，4，5，6}、{5，6，7}应题目要求输出最短的数组，所以结果如上。 eg2: (18,4)
* 则应该返回结果{3,4,5,6}; eg3: (45,10)则返回结果为{0，1，2，3，4，5，6，7，8，9}；
*
* @param args
*/
public static void main(String[] args) {
final ArrayEqualsSum arrayEqualsSum = new ArrayEqualsSum();
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(18, 3)));
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(0, 3)));
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(45, 10)));
}

}




[/code]
lang3879 2009-06-25
  • 打赏
  • 举报
 回复 



/**

 * 

 */

package resume.csdn;



/**

 * @author lang3879

 * 

 */

public class ArrayEqualsSum {



	public int[] mainGenerateArray(int sum, int length) {

		int[] returnMe = this.generateArray(sum, length);

		// ↓length的长度不知道如何判断，根据sum好像判断不出

		// 比如sum=0，length=3，返回[-1,0,1]

		while (length < 20 && returnMe.length == 0) {

			length++;

			returnMe = this.generateArray(sum, length);

		}

		return returnMe;

	}



	/**

	 * 假设起始为x，长度为3; x+(x+1)+(x+2)=3*x+(0+1+2)=sum 所以x=(sum-(0+1+2+...))/length

	 * 

	 * @param sum

	 *            和的值

	 * @param length

	 *            数组的长度

	 * @return

	 */

	public int[] generateArray(int sum, int length) {

		// iSum=(0+1+2+...)

		int iSum = 0;

		int iStartNumber = 0;

		final int startAddEnd = (iStartNumber + (iStartNumber + length - 1));

		if (length % 2 == 0) {// 表示偶数，首尾相加并乘以长度的一半

			iSum = startAddEnd * (length / 2);

		} else {// 表示奇数,首尾相继并乘以长度-1的一半，再加中间的那一个元素

			iSum = startAddEnd * ((length - 1) / 2) + startAddEnd / 2;

		}

		// ↓整除标出x存在

		if ((sum - iSum) % length == 0) {

			return this.repateNumber((sum - iSum) / length, length);

		}

		return new int[] {};

	}



	/**

	 * 创建startNumber开始长度为length，元素间递增为一的数组

	 * 

	 * @param startNumber

	 * @param length

	 * @return

	 */

	private int[] repateNumber(int startNumber, int length) {

		int[] returnMe = new int[length];

		for (int index = 0; index < length; index++) {

			returnMe[index] = startNumber;

			startNumber++;

		}

		return returnMe;

	}



	/**

	 * int数组转字符串

	 * 

	 * @param intArray

	 * @return

	 */

	private String intArrayToString(int[] intArray) {

		StringBuffer sb = new StringBuffer("[");

		for (int index = 0; index < intArray.length; index++) {

			int i = intArray[index];

			sb.append(i).append(",");

		}

		sb.deleteCharAt(sb.length() - 1);

		sb.append("]");

		return sb.toString();

	}



	/**

	 * 写一个类，实现这样一个方法，此方法给定两个参数N、L（均为整数）， N是一个自然数，L表示一个长度。 要求此函数输出一个最小长度的连续数的数组，

	 * 此数组的几个连续数的和要等于给定的N， 并且该数组的长度要大于等于给定的L。 如没有满足该条件的则返回一个空数组{}。

	 * eg1：（18，3）则应该return {5,6,7};

	 * 分析满足和为18的连续数的数组有两个：{3，4，5，6}、{5，6，7}应题目要求输出最短的数组，所以结果如上。 eg2: (18,4)

	 * 则应该返回结果{3,4,5,6}; eg3: (45,10)则返回结果为{0，1，2，3，4，5，6，7，8，9}；

	 * 

	 * @param args

	 */

	public static void main(String[] args) {

		final ArrayEqualsSum arrayEqualsSum = new ArrayEqualsSum();

		System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum

				.mainGenerateArray(18, 3)));

		System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum

				.mainGenerateArray(0, 3)));

		System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum

				.mainGenerateArray(45, 10)));

	}



}
lang3879 2009-06-25
  • 打赏
  • 举报
 回复
我也来献丑了。。。
<code>
/**
*
*/
package resume.csdn;

/**
* @author lang3879
*
*/
public class ArrayEqualsSum {

public int[] mainGenerateArray(int sum, int length) {
int[] returnMe = this.generateArray(sum, length);
// ↓length的长度不知道如何判断，根据sum好像判断不出
// 比如sum=0，length=3，返回[-1,0,1]
while (length < 20 && returnMe.length == 0) {
length++;
returnMe = this.generateArray(sum, length);
}
return returnMe;
}

/**
* 假设起始为x，长度为3; x+(x+1)+(x+2)=3*x+(0+1+2)=sum 所以x=(sum-(0+1+2+...))/length
*
* @param sum
* 和的值
* @param length
* 数组的长度
* @return
*/
public int[] generateArray(int sum, int length) {
// iSum=(0+1+2+...)
int iSum = 0;
int iStartNumber = 0;
final int startAddEnd = (iStartNumber + (iStartNumber + length - 1));
if (length % 2 == 0) {// 表示偶数，首尾相加并乘以长度的一半
iSum = startAddEnd * (length / 2);
} else {// 表示奇数,首尾相继并乘以长度-1的一半，再加中间的那一个元素
iSum = startAddEnd * ((length - 1) / 2) + startAddEnd / 2;
}
// ↓整除标出x存在
if ((sum - iSum) % length == 0) {
return this.repateNumber((sum - iSum) / length, length);
}
return new int[] {};
}

/**
* 创建startNumber开始长度为length，元素间递增为一的数组
*
* @param startNumber
* @param length
* @return
*/
private int[] repateNumber(int startNumber, int length) {
int[] returnMe = new int[length];
for (int index = 0; index < length; index++) {
returnMe[index] = startNumber;
startNumber++;
}
return returnMe;
}

/**
* int数组转字符串
*
* @param intArray
* @return
*/
private String intArrayToString(int[] intArray) {
StringBuffer sb = new StringBuffer("[");
for (int index = 0; index < intArray.length; index++) {
int i = intArray[index];
sb.append(i).append(",");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
return sb.toString();
}

/**
* 写一个类，实现这样一个方法，此方法给定两个参数N、L（均为整数）， N是一个自然数，L表示一个长度。 要求此函数输出一个最小长度的连续数的数组，
* 此数组的几个连续数的和要等于给定的N， 并且该数组的长度要大于等于给定的L。 如没有满足该条件的则返回一个空数组{}。
* eg1：（18，3）则应该return {5,6,7};
* 分析满足和为18的连续数的数组有两个：{3，4，5，6}、{5，6，7}应题目要求输出最短的数组，所以结果如上。 eg2: (18,4)
* 则应该返回结果{3,4,5,6}; eg3: (45,10)则返回结果为{0，1，2，3，4，5，6，7，8，9}；
*
* @param args
*/
public static void main(String[] args) {
final ArrayEqualsSum arrayEqualsSum = new ArrayEqualsSum();
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(18, 3)));
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(0, 3)));
System.out.println(arrayEqualsSum.intArrayToString(arrayEqualsSum
.mainGenerateArray(45, 10)));
}

}



</code>
kofhuanghong 2009-06-25
  • 打赏
  • 举报
 回复
蛮难的~
FrankyChan 2009-06-25
  • 打赏
  • 举报
 回复
看都看不懂在問什么. (@_@)!
ryandong 2009-06-25
  • 打赏
  • 举报
 回复
第一个明白了，可第二个就。。。。
seaman_xh 2009-06-25
  • 打赏
  • 举报
 回复
学习
xunhangchengwen 2009-06-25
  • 打赏
  • 举报
 回复
挺复杂的 顶一下
showjim 2009-06-25
  • 打赏
  • 举报
 回复
题1: private static int[] array(int N, int L)
{
int[] value = null;
if (N >= 0)
{
if (L < 1) L = 1;
for (int maxLength = (int)Math.Sqrt(N << 1) + 1; L <= maxLength; L++)
{
if ((N % ((L & 1) == 0 ? (L >> 1) : L)) == 0)
{
int min = ((N << 1) / L) + 1;
if (min >= L && (min & 1) == (L & 1))
{
min = ((min - L) >> 1);
value = new int[L];
for (int i = 0; i < L; i++) value[i] = min++;
break;
}
}
}
}
return value;
}
题2:eg2：（9090，4） return 0；
应该是return 9900;吧
zjfcctv 2009-06-25
  • 打赏
  • 举报
 回复
第一题：
public class HHU {

public static void main(String[] args) {
int[] tc = new int[100];
tc = cal(18, 3);
if (tc == null) {
System.out.println("没有此数列");
System.exit(0);
}
for (int i = 1; i < tc.length; i++) {
if (tc[i] != 0) {
System.out.println(tc[i]);
}
}
}

public static int[] cal(int n, int l) {
int sum = 0;
int jishu = 0;
int j = 0;
int[] tc = new int[100];
for (int i = 0; i < n / 2; i++) {
j = i;
while (sum < n) {
sum = sum + j;
jishu++;
tc[jishu] = j;
j++;
}
if (sum == n && jishu >= l) {
return tc;
}
sum = 0;
jishu = 0;
for (int k = 0; k < tc.length; k++) {
tc[k] = 0;
}
}
return null;

}

}
zl3450341 2009-06-25
  • 打赏
  • 举报
 回复
哎 不太会
hunray 2009-06-25
  • 打赏
  • 举报
 回复
笔试编程题我只会写思路，要我写代码...没有eclipse的智能提示，我就变傻子了。
hunray 2009-06-25
  • 打赏
  • 举报
 回复
第一题是个数学题...
假设结果是x,x+1...,y
那么
y=L-1+x
(x+y)L/2=N

方程1代入方程2
(2x+L-1)L/2=N
如果计算结果x是整数，输入x,x+1...,y，否则无解。
达摩院扫地僧 2009-06-25
  • 打赏
  • 举报
 回复
顶起，再慢慢看，慢慢学习
jtaocs 2009-06-25
  • 打赏
  • 举报
 回复
面试题都这样
主要考你的基础和临场发挥能力
最重要的是思路啊
这才是考官想要的啊
linyubengne 2009-06-25
  • 打赏
  • 举报
 回复
我学了一个学期但好像什么都没学到啊!汗。。。
wenboliang 2009-06-25
  • 打赏
  • 举报
 回复
直接挂掉
yigenyuci 2009-06-24
  • 打赏
  • 举报
 回复
这笔试题也闷麻烦了。
JackRui2008 2009-06-24
  • 打赏
  • 举报
 回复
[Quote=引用 28 楼 JhunHoonXZ 的回复:]
总结一下第二题的意思好了
交换是指相邻的两位交换,即不能个位与百位互换,只能个位十位互换或者十位百位互换

若某两个数交换出现最高位是0的情况则返回0,
应该是指:遵循上面交换原则,但不追求结果最大的话,如果有可能造成最高位是0的情况,返回0

例子:
(9090,4),第一次交换如果不追求结果最大,可能有0990的情况出现,故返回0
如果是(390,2)
第一次交换后是930,第二次交换后是903,返回903
如果是(390,3)
第一…
[/Quote]

感觉你说的还不够全面，第2题就是要求最大的，你还不追求最大？如果说(9090,4),我第一次交换成为9900的话，那么你说第2次应该怎么交换了？？ 所以lz没有规则的话很难说清，也就是说，一样的数字交换算不算一次真正的交换？或者说只要有0出现在最高位的可能，那么结果就是为0，也就是说这样{1230，4}，只要交换数里有0的，而且交换的次数大于等于交换数位数减1的，结果都是0了，前提也是临位置交换。

这些都是规则，不说清楚的话，没法判断，主观判断总有漏洞。所以这题只能根据例子找出一个规则的：
这题的关键就是交换数里带0的判断，没有0的，大家都会了，而楼主的例子里：eg2：（9090，4） return 0；可以看出，如果是（9090，1）的话，那么一定就是9900了，如果是2以上的话，那么（9090，2or3or4等）,就会出现第一次的结果有9900和9009（因为只能临位交换），那么第2次交换的话，一定不能产生2个一样数字交换，也不能产生刚才交换完的2个数再次进行交换，那么我们就要会退到最开始的9090重新交换，于是就产生了0990.于是结果就是例子中的0

所以这题的做法，等同于“八皇后”的写法，写过“八皇后”的人一定能了解吧。
加载更多回复（55）
常见linux笔试题
常见linux笔试题-100道选择题 15． 有一个备份程序mybackup，需要在周一至周五下午1点和晚上8点各运行一次，下面哪条crontab的项可以完成这项工作？ A. 0 13,20 * * 1,5 mybackup B. 0 13,20 * * 1,2,3,4,5 mybackup...
朗讯笔试题，青岛朗讯，笔试
朗讯笔试题在网上搜集了一些往年的青岛朗讯笔试题来应付周一即将参加的笔试 考试地点是在青岛朗讯研发部一楼 不管成功与否 尽力去考不枉这次笔试机会 也希望对以后参加朗讯笔试的同学有帮助
java中级笔试题及答案2015-haskell-pair-programming:haskell对编程
java中级笔试题及答案2015 如何加入？ 加入 。 创建拉取请求。 将您在此文件中的简短联系信息添加到下面的 和 部分。 请注意两个地方的字母顺序。 发送 PR 后，您将获得贡献者权利，使您可以随时更改或删除您的条目...
java8集合源码分析-javaInterview:java面试
很多简单的笔试题, 大概是 手写单例 /冒泡排序, hr简单聊了一下,让我回去了,没有技术面试 0525 牧原数字技术 char数字类型可以存数字么,为什么? java集合 juc包 下常用的类? 线程池下executor 的futre方法? (听不太...
Java后端之美团笔试题
Java后端之美团笔试题
Java SE

62,614

社区成员

307,326

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章