我想知道所有一位数字可以分割的最小数字是什么,而不是查找它我创建了这个.
public static void main(String[] args) {
for (int i = 100; i < 10000; i++) {
if (i % 2 ==0) {
if (i % 3 ==0) {
if (i % 4 ==0) {
if (i % 5 ==0) {
if (i % 6 ==0) {
if (i % 7 ==0) {
if (i % 8 ==0) {
if (i % 9 ==0) {
System.out.println(i);
break;
}
}
}
}
}
}
}
}
}
}
如您所见,我在if语句x9中有一个if语句.代码工作但我想使用数组压缩我的if语句来使我的if语句像这样,但它不起作用.
if (i % x[1, 2, 3, 4, 5, 6, 7, 8]) {
System.out.println(i);
break;
}
有什么建议？
rge*_*man 152
首先,您会认为您可以通过在%操作员右侧放置2到9的产品来一次测试所有这些产品.
if (i % (2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) == 0)
但由于某些数字包括其分解中的先前数字,因此您应使用较低的数字,特别是最小公倍数.8是2和4的倍数,9是3的倍数,如果产品中有8和9,则也覆盖6(2*3).
if (i % (5 * 7 * 8 * 9) == 0)
结果是2520,这是最不常见的倍数.使用它会更具可读性,2520并在评论中解释为什么使用这个数字.
/**
* The goal is to test if the number is a multiple of all integers
* from 2 through 9. Mathematically, the least common multiple to is a
* multiple of all its input numbers. Here, the LCM of 2, 3, ..., 9 is 2520.
*/
public static final int LCM_2_THRU_9 = 2520;
我宣布了一个常量,我会在这里使用它:
if (i % LCM_2_THRU_9 == 0)
sak*_*029 84
试试这个.
for (int i = 100; i < 10000; ++i) {
int x = i;
if (IntStream.of(2, 3, 4, 5, 6, 7, 8, 9).allMatch(k -> x % k == 0)) {
System.out.println(i);
break;
}
}
-> 2520
或者你可以把它写成一个声明.
int result = IntStream
.range(100, 10000)
.filter(i -> IntStream.of(2, 3, 4, 5, 6, 7, 8, 9).allMatch(k -> i % k == 0))
.findFirst()
.getAsInt();
System.out.println(result);
-> 2520
小智 46
如前所述,编写您要做的事情的最佳方法可能是检查2到9的乘积.
但是,回答你关于如何压缩if语句的问题; 嵌套if语句等效于逻辑运算符AND,因此您也可以按以下方式编写if语句:
if (i % 2 == 0 && i % 3 == 0 && i % 4 == 0 && i % 5 == 0 && i % 6 == 0 && i % 7 == 0 && i % 8 == 0 && i % 9 == 0) {
System.out.println(i);
}
dis*_*ame 42
你为什么不..
反转IF？
public static void main(String[] args) {
for (int i = 100; i < 10000; i++) {
//If value is not valid, continue to next value
if (i % 2 != 0) continue;
if (i % 3 != 0) continue;
if (i % 4 != 0) continue;
if (i % 5 != 0) continue;
if (i % 6 != 0) continue;
if (i % 7 != 0) continue;
if (i % 8 != 0) continue;
if (i % 9 != 0) continue;
//Valid value found. Print and break out of the loop.
System.out.println(i);
break;
}
}
或者,上述代码可以进一步重构为:
public static void main(String[] args) {
for (int i = 100; i < 10000; i++) {
if (isPrintable(i)) {
System.out.println(i);
break;
}
}
}
private static boolean isPrintable(int value) {
return value % 2 == 0
&& value % 3 == 0
&& value % 4 == 0
&& value % 5 == 0
&& value % 6 == 0
&& value % 7 == 0
&& value % 8 == 0
&& value % 9 == 0;
}
此外,根据@ TeePeemm的建议,isPrintable()可以简化为:
private static boolean isPrintable(int value) {
for (int divisor = 2; divisor < 10; divisor++) {
if (value % divisor != 0) return false;
}
return true;
}
1.正如其他答案所建议的那样,也有基于语言的快捷方式.我同意他们.
2.许多答案使用数字的LCM来使代码简洁,但这是一个等待咬人的休眠错误.循环执行完全改变,可以通过注释掉看到break;.看似简单的解决方案引入了一个微妙的潜在错误.
pkp*_*pnd 20
在Java 8以后,您可以使用Stream方法(特别是使用IntStream).
首先,我们使用IntStream.rangeClosed(2, 9)(或等效地IntStream.range(2, 10))获得以(包括)Integer开头2和结尾的连续s 流9.我们可以boolean通过使用将此流转换为a .allMatch(...),true当且仅当每个流元素都符合某些条件时才会返回.期望标准以的形式提供lambda表达式,n -> i % n == 0.这可以用verbosely编写(Integer n) -> (i % n == 0),因此lambda表达式Integer从被调用的流中获取输入a n,并返回i(循环计数器)是否可被整除n.因此,.allMatch(n -> i % n == 0)返回trueif i可以被Integer流中的每个整除.
我们需要再做一次修改:lambda表达式中使用的变量(例如i)必须是有效的最终变量:
在初始化之后其值永远不会改变的变量或参数实际上是最终的.(Oracle文档)
然而,循环计数器i是不是有效的决赛中,因为它被递增(从而重新分配)每次迭代.解决方案是int x = i;在循环内声明一个新变量,这样x只在其范围内分配一次(即循环的一次迭代).因此,x实际上是最终的并且可以在lambda表达式中使用.
这是最终的解决方案:
import java.util.stream.IntStream;
public static void main(String[] args) {
for (int i = 100; i < 10000; i++) {
int x = i; // x is effectively final
if (IntStream.rangeClosed(2, 9).allMatch(n -> x % n == 0)) {
System.out.println(i);
break;
}
}
}
mac*_*e21 18
更简单的方法:
public static boolean isDivisible(int number) {
for (int i = 2; i <= 9; i++) {
if (num % i != 0) {
return false;
}
}
return true;
}
使用相同类型的结构,主要方法变为:
public static void main(String[] args) {
for (int i = 100; i <= 100000; i++) {
if (isDivisible(i)) {
System.out.println("Divisible by numbers 2...9: " + i);
break;
}
}
}
Md *_*lam 16
什么你基本上做的是试图找到数i这是LCM的2 * 3 * 4 * 5 * 6 * 7 * 8 * 9.最初,您可能只是想写
if (i % (2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) == 0) {
System.out.println(i);
break;
}
如果所有数字都是互质的,那将是真的.这意味着他们没有任何共同因素.但在这种情况下,这些数字不是互质的,而且有共同的因素.像8 = 2*2*2, 4 = 2*2, 6 = 2*3所有人都有2. 3 = 1 * 3 , 6 = 2*3, 9 = 3*9所有人都有3.所以基本上我们必须采用LCM数字2,3,4,5,6,7,8,9.请参阅以下编辑以更正上述公式.
LCM(最小公倍数)的数字2,3,4,5,6,7,8,9是= 2520.因此,通过所有测试用例的正确公式如下
if ( i % 2520 == 0) {
System.out.println(i);
break;
}
使用的另一个解决方案是简单地检查以下所有条件:
if(i % 9 == 0 && i % 8 ==0 && i % 7 == 0 && i % 5 == 0) {
System.out.println(i);
break;
}
Fra*_*rax 12
这个问题实际上是双重的:第一部分是,如何将具有相似条件的9 if语句压缩为一些更易读的形式.另一个也许是无意识的问题是,如何将"单位数字的LCM"这样的东西添加到代码中.让我们从后者开始,然后转到下面的前者.
如果您需要这种数量在你的程序(而不是程序是指计算它的唯一目的),你应该只用最简单的获得它的必要手段(在这种情况下,谷歌搜索的"最小数量由所有一个位数整除"),并在你的程序中包含一个常量,或许可以对数字来自何处进行一些评论.
如果您不能找到它,请尝试自己计算(如rgettman所做),并再次将其包含为常量.如果失败或花费太多时间,请编写一次性程序来计算数字,但不要使用常量使其成为更大程序的一部分.不过,将一次性代码存储在某处是个好主意.评论可能是正确的地方.
现在这是关于压缩if语句.
有使用流的解决方案,但在您的情况下,简单的数组可能会更好.这段代码也更通用,您可以轻松地将它移植到几乎任何语言,并且它不以数字方式绑定(您可以使用任何数组).奖励点 - 任何人都应该理解它.
static boolean divisibleByAll(int n, int[] divisors) {
for (int d : divisors) {
if (n % d != 0) {
return false;
}
}
return true;
}
static int lcmOfSingleDigits() {
int[] divisors = {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 100; i < 10000; i++) {
if (divisibleByAll(i, divisors)) {
return i;
}
}
return -1; // Perhaps better to throw an exception
}
public static void main(String args[]) {
System.out.println("Smallest number divisible by all one digit numbers: " +
lcmOfSingleDigits());
}
大多数Java-ish解决方案,这是您应该在实践中使用的 - 除非您需要非Java程序员来阅读您的代码.以saka1029和pkpnd的答案为主题,所以我不再重复了.
我认为你可以使用(1,2,3,4,5,6,7,8,9)= 2520的LCM(最小公倍数),如下所示:
if (i % 2520 == 0) {
System.out.println(i);
break;
}
| 归档时间： |
|
| 查看次数： |
12829 次 |
| 最近记录： |