有没有办法在不使用任何循环或条件如“if”的情况下从1到100打印数字？ 我们可以很容易地使用递归但是又有一个if条件。有没有办法不使用“if”？也没有重复的打印语句，或包含1到100之间所有数字的单个打印语句。
Java中的解决方案更可取。
答案 0 :(得分：177)
了解您的图书馆。
public class To100 {
public static void main(String[] args) {
String set = new java.util.BitSet() {{ set(1, 100+1); }}.toString();
System.out.append(set, 1, set.length()-1);
}
}
（您可以使用String.replaceAll更改分隔符。例如，.replaceAll(", ", " ")用于空格分隔。）
说明：
java.util.BitSet是一个方便的小类，代表一组任意大（非稀疏）的正整数。 （它确实有如此糟糕的位：不是最终的，不必要的线程安全，不支持构建良好等）ta。 BitSet只允许我写一次java.util。 JDK7“钻石运算符”应该有助于减少与泛型类型的重复，但对于更常见的情况没有帮助。 :( BitSet.set在集合中设置了一点（两个完全不同的含义“set”在那里 - 我喜欢它）。这是一个半开放的范围 - 最高价值的独家;底部包容。在顶部添加1以包含100. BitSet.toString实际上是由API文档精确定义的。append接口，将PrintStream添加到Appendable。它本质上是一个子串并打印结果。 （一个小秘密：实际上并没有通过规范来保证刷新输出，但实现总是如此。）BitSet的字符串表示中删除大括号。答案 1 :(得分：119)
请勿在任何SANE情况下进行此操作！
public class Fail {
public void thisFails(int x){
System.out.println(x);
Integer[] bigArray = new Integer[9450];
thisFails(x+1);
}
public static void main(String[] args) {
Fail failure = new Fail();
failure.thisFails(1);
}
}
当使用1m的堆空间（java -Xmx1m Fail）运行它时，它将在第100次递归时用完堆。
...
我现在要去洗手了。
答案 2 :(得分：70)
有没有办法在不使用任何循环或条件如“if”的情况下从1到100打印数字？
我无法相信没人建议：
System.out.println("numbers from 1 to 100 without using any loops or conditions like \"if\"?");
答案 3 :(得分：64)
查看C＃主题中的Divide + Conquer答案。这是邪恶的，但很棒：
How to print 1 to 100 without any looping using C#
以下是Java版本：
public class Application {
public static void main(String[] args) {
Print64Numbers();
Print32Numbers();
Print4Numbers();
}
private static int currentNumber = 0;
private static void Print1Number() { System.out.println(++currentNumber); }
private static void Print2Numbers() { Print1Number(); Print1Number(); }
private static void Print4Numbers() { Print2Numbers(); Print2Numbers(); }
private static void Print8Numbers() { Print4Numbers(); Print4Numbers(); }
private static void Print16Numbers() { Print8Numbers(); Print8Numbers(); }
private static void Print32Numbers() { Print16Numbers(); Print16Numbers(); }
private static void Print64Numbers() { Print32Numbers(); Print32Numbers(); }
}
答案 4 :(得分：48)
伪代码。使用一个数组在100个被捕获的元素之后强制执行异常。
function r(array a, int index){
a[index] = a[index-1]+1
print a[index]
r(a, index+1)
}
try{
array a;
a.resize(101)
r(a, 1)
}catch(OutOfBoundsException){
}
修改
Java代码：
public void printTo100(){
int[] array = new int[101];
try{
printToArrayLimit(array, 1);
}catch(ArrayIndexOutOfBoundsException e){
}
}
public void printToArrayLimit(int[] array, int index){
array[index] = array[index-1]+1;
System.out.println(array[index]);
printToArrayLimit(array, index+1);
}
答案 5 :(得分：41)
当然有：
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(10);
System.out.println(11);
System.out.println(12);
System.out.println(13);
System.out.println(14);
System.out.println(15);
System.out.println(16);
System.out.println(17);
System.out.println(18);
System.out.println(19);
System.out.println(20);
System.out.println(21);
System.out.println(22);
System.out.println(23);
System.out.println(24);
System.out.println(25);
System.out.println(26);
System.out.println(27);
System.out.println(28);
System.out.println(29);
System.out.println(30);
System.out.println(31);
System.out.println(32);
System.out.println(33);
System.out.println(34);
System.out.println(35);
System.out.println(36);
System.out.println(37);
System.out.println(38);
System.out.println(39);
System.out.println(40);
System.out.println(41);
System.out.println(42);
System.out.println(43);
System.out.println(44);
System.out.println(45);
System.out.println(46);
System.out.println(47);
System.out.println(48);
System.out.println(49);
System.out.println(50);
System.out.println(51);
System.out.println(52);
System.out.println(53);
System.out.println(54);
System.out.println(55);
System.out.println(56);
System.out.println(57);
System.out.println(58);
System.out.println(59);
System.out.println(60);
System.out.println(61);
System.out.println(62);
System.out.println(63);
System.out.println(64);
System.out.println(65);
System.out.println(66);
System.out.println(67);
System.out.println(68);
System.out.println(69);
System.out.println(70);
System.out.println(71);
System.out.println(72);
System.out.println(73);
System.out.println(74);
System.out.println(75);
System.out.println(76);
System.out.println(77);
System.out.println(78);
System.out.println(79);
System.out.println(80);
System.out.println(81);
System.out.println(82);
System.out.println(83);
System.out.println(84);
System.out.println(85);
System.out.println(86);
System.out.println(87);
System.out.println(88);
System.out.println(89);
System.out.println(90);
System.out.println(91);
System.out.println(92);
System.out.println(93);
System.out.println(94);
System.out.println(95);
System.out.println(96);
System.out.println(97);
System.out.println(98);
System.out.println(99);
System.out.println(100);
答案 6 :(得分：36)
在C ++中：
#include <iostream>
class a {
static unsigned i;
public:
a() {
std::cout << ++i << std::endl;
}
};
unsigned a::i = 0U;
int main() {
a array[100];
}
此解决方案既不使用循环也不使用递归来打印1到100之间的数字。
答案 7 :(得分：22)
从pastebin下载
System.out.println((new URL("http://pastebin.com/pastebin.php?dl=f722c7eb0")).getContent())
答案 8 :(得分：16)
有没有办法在不使用任何循环或条件（如“if”）的情况下从1到100打印数字？
使用优化版this：
System.out.println("1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 , 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , 41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 , 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 , 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 , 97 , 98 , 99 , 100");
下一个问题？
答案 9 :(得分：15)
或者如果您想使用反射： - ）
public class Print100 {
public static void emit0(int index) throws Exception {
System.out.println(index);
String next = new StringBuilder()
.append("emit")
.append(index / 100)
.toString();
Print100.class.getMethod(next, Integer.TYPE)
.invoke(null, index+1);
}
public static void emit1(int index) {
}
public static void main(String[] args) throws Exception {
emit0(1);
}
}
答案 10 :(得分：12)
以Yacoby的答案为基础，但没有抓住。 （赞成回答。）
public class To100 {
public static void main(String[] args) {
final int max = 100;
new java.util.concurrent.Semaphore(max) {
void go() {
acquireUninterruptibly();
System.err.println(max-availablePermits());
go();
}
}.go();
}
}
说明：
Semaphore允许在阻止之前获取指定数量的许可。java.util.concurrent，所以我机会性地延长了Semaphore。acquireUninterruptibly表示我不必声明经过检查的异常。答案 11 :(得分：12)
是的，这是可能的，但它很糟糕。有许多方法可以使用递归或嵌套类型创建，并对流控制进行异常处理。 这没有真实的应用程序IMO，应该不惜一切代价避免在实际代码中使用。
这是一个使用递归类型实例化和异常处理来控制终止的示例。它打印的数字是降序，但是通过从正在打印的值中减去99（或任何常数）来改变升序是微不足道的。
class PrintVal
{
// called with a list containing as many items as you want, less one...
public PrintVal( List<int> items )
{
System.out.println(items.size()+1); // print the size of the list
try {
items.remove( items.size()-1 ); // will throw when items is empty
new PrintVal( items );
}
catch( Exception ) { /* swallow and terminate */ }
}
}
// setup and invocation that performs the output
ArrayList<int> strList = new ArrayList<int>( new int[99] );
PrintVal instance = new PrintVal( strList ); // all output happens here
答案 12 :(得分：10)
让Arrays完成这项工作：
public static void main(String[] args) {
Object[] numbers = new Object[100];
Arrays.fill(numbers, new Object() {
private int count = 0;
@Override
public String toString() {
return Integer.toString(++count);
}
});
System.out.println(Arrays.toString(numbers));
}
答案 13 :(得分：9)
没有条件（没有捷径布尔运算符，没有？ - 运算符，没有异常），没有循环：
import java.util.Vector;
public class PrintOneToHundered {
static int i;
PrintOneToHundered() {}
public String toString() { return ++i+""; }
public static void main(String[] args) {
Vector v1 =new Vector(); v1 .add(new PrintOneToHundered());
Vector v2 =new Vector(); v2 .addAll(v1 ); v2 .addAll(v1 );
Vector v4 =new Vector(); v4 .addAll(v2 ); v4 .addAll(v2 );
Vector v8 =new Vector(); v8 .addAll(v4 ); v8 .addAll(v4 );
Vector v16 =new Vector(); v16 .addAll(v8 ); v16 .addAll(v8 );
Vector v32 =new Vector(); v32 .addAll(v16); v32 .addAll(v16);
Vector v64 =new Vector(); v64 .addAll(v32); v64 .addAll(v32);
Vector v100=new Vector(); v100.addAll(v64); v100.addAll(v32); v100.addAll(v4);
System.out.println(v100);
}
}
说明：
答案 14 :(得分：7)
这是使用线程的一个（我夸大了睡眠时间以考虑系统速度的波动）。我想不出摆脱try / catch的方法：
public class Counter extends Thread{
private int cnt;
public Counter(){
this.cnt = 0;
}
private void increment(){
System.out.println(cnt++);
try{
Thread.sleep(1000);
}catch(Exception e){}
increment();
}
public void run(){
increment();
}
public static void main(String[] args) throws Exception{
Counter cntr = new Counter();
cntr.start();
cntr.join(100000);
cntr.interrupt();
System.exit(0);
}
}
答案 15 :(得分：6)
好的，我迟到了，答案已经被接受，但我想知道为什么没有人使用干净简单的计数器呢？
public class Counter
{
static Counter[] vtab = new Counter[]
{
new Counter(),
new Counter() { public void print( int first, int last ) {} }
};
public void print( int first, int last )
{
vtab[ ( last - first - 1 ) >>> 31 ].print( first, last - 1 );
System.out.println( last );
}
public static void main( String[] args )
{
vtab[ 0 ].print( 1, 100 );
}
}
线程安全，可配置，无异常，不依赖于API副作用，只需简单的OOP和一些简单的数学运算。
对于那些不熟悉二元运算符的人来说，它是如何工作的：
( x >>> n )表达式将整数值x的所有位向右移动n个位置。通过此操作，较低位简单地从右侧掉落，从左侧进入的新位始终为0。
因此，( x >>> 31 )的效果是将x的最高位移至最低位置，并将x的所有其他位设置为0。对于0的所有可能值，结果现在始终为1或x。
由于int的最高位是符号位，正值为0而负值为1，因此表达式( x >>> 31 )的计算结果为对于0的所有负值，x和1的所有正值均为x。
现在，如果first和last都是正数且last大于first，( last - first - 1 )的结果将为{ {1}}如果>= 0为last == first。
如果-1大于( ( last - first - 1 ) >>> 31 )，则0评估为last，如果相等，则first评估为1。
现在，此值0/1用于根据print( int first, int last )和first的比较在last的两个实现之间切换。首先，递归发生而不打印任何东西。 print( 1, 100 )调用print( 1, 99 )等等......直到last等于first才导致切换到print的其他实现，而vtab[ 0 ].print( 1, 100 )则完全不执行任何操作。所以现在堆栈再次展开，值按升序打印，{{1}}的调用正常结束。
答案 16 :(得分：5)
这是一个有用的提示。
assert语句不是禁止的if语句。
答案 17 :(得分：5)
我的解决方案没有冗长。它不使用除功能应用程序之外的任何控制结构。它也不使用库代码来帮助。我的代码很容易扩展，可以打印出范围[a，b]。只需将conts [n / 100]更改为conts [(n - a) / (b - a)]，然后将new Printable (1)更改为new Printable (a)。
<强> To100.java：
class Printable {
private static final Continuation[] conts = {new Next (), new Stop ()};
private final int n;
private final Continuation cont;
Printable (int n) {
this.n = n;
this.cont = conts [n / 100];
}
public void print () {
System.out.println (n);
cont.call (n);
}
}
interface Continuation {
public void call (int n);
}
class Next implements Continuation {
public void call (int n) {
new Printable (n + 1).print ();
}
}
class Stop implements Continuation {
public void call (int n) {
// intentionally empty
}
}
class To100 {
public static void main (String[] args) {
new Printable (1).print ();
}
}
编辑：由于这个问题已经关闭（为什么???）我会在这里发布我的第二个答案。它的灵感来自Tom Hawtin的通知，该程序不必终止。此外，问题不要求只打印数字1-100（甚至按顺序）。
<强> To100Again.java：
class To100Again extends Thread {
private static byte n;
public void run () {
System.out.println (n++);
new To100Again ().start ();
System.gc();
}
public static void main (String[] args) {
new To100Again ().start ();
}
}
答案 18 :(得分：4)
另一种分而治之的：
public class Print100 {
public static void main (String...args) {
Runnable r1 = new Runnable () {
int n;
public void run () {
System.out.println(++n);
}
};
fourTimes(fiveTimes(fiveTimes(r1))).run();
}
public static Runnable twice (Runnable a) {
return add(a,a);
}
public static Runnable fourTimes (Runnable a) {
return twice(twice(a));
}
public static Runnable fiveTimes (Runnable a) {
return add(a,fourTimes(a));
}
public static Runnable add (final Runnable a, final Runnable b) {
return new Runnable () {
@Override
public void run () {
a.run();
b.run();
}
};
}
}
答案 19 :(得分：4)
System.out.println（“数字从1到100”）
答案 20 :(得分：3)
我是.Net开发人员，但我猜想有一个与Java相当的...
static int i = 1;
static System.Timers.Timer timer = new System.Timers.Timer();
static void Main(string[] args)
{
timer.Interval = 10; //milliseconds
timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
timer.Enabled = true;
timer.Start();
//let the timer complete... (3000 to show the output stops)
System.Threading.Thread.CurrentThread.Join(3000);
}
static void timer_Elapsed(object sender, ElapsedEventArgs e)
{
Console.WriteLine(i++);
timer.Enabled = (i < 101);
}
答案 21 :(得分：3)
这里没有看到这个，使用&&运算符的终止顺序。
public class count100 {
public static boolean loop(int i) {
System.out.println(100-i);
return i > 0 && loop(i-1);
}
public static void main(String[] args) {
loop(99);
}
}
答案 22 :(得分：3)
实施递归调用递增并打印数字。配置VM在100次调用后耗尽堆栈。没有条件，没有循环。 咳嗽; - ）
答案 23 :(得分：3)
如果尝试和捕获是合法的，我会认为递归是简单而相当干净的，然后在完成时将其除以零。除此之外，当你为了娱乐和利润而将零除以零时，它总会摇摆不定。
public class Main {
public static void main(String[] args) {
count(100);
}
private static int count(int x) {
try {
int value=1/x;
count(x-1);
System.out.println(x);
}
catch (Exception e){
return 0;
}
return 1;
}
答案 24 :(得分：3)
没有任何循环和条件：
public static void recfunc(int a[], int i)
{
System.out.println(i);
int s = a[i];
recfunc(a, i + 1);
}
public static void main(String[] args)
{
int[] a = new int[100];
try
{
recfunc(a, 1);
}
catch (Exception e)
{
}
}
public static int recfunc(int i)
{
System.out.println(i);
return (i < 100) ? recfunc(i + 1) : 0;
}
public static void main(String[] args)
{
recfunc(1);
}
答案 25 :(得分：3)
滥用例外作为条件。
public class Main {
private static int[] stopper = new int[100];
public static void main(String[] args) {
try {
print(1);
} catch(ArrayIndexOutOfBoundsException e) {
// abuse of try catch
}
}
private static void print(int i) {
System.out.println(i);
stopper[i] = i;
print(i + 1);
}
}
答案 26 :(得分：2)
这让我想起几年前我 TI-55 的编程。它有32个可编程指令步骤，以及一个跳转到指令0的RESET指令，因此可以实现简单的循环。问题是要让它停止，然后将其归结为使其执行导致错误的操作，例如除以零。
因此：
public static void main(String[] args)
{
printN(100);
}
private static void printN(int n)
{
try
{
int t = 1/n; // Exception when n is 0
printN(n-1); // Recurse, down to 0
System.out.println(n);
}
catch (Exception ex)
{
// Stop recursing
}
}
注意：是的，我知道这与@ Yacoby的解决方案类似。
答案 27 :(得分：2)
这个答案很不合理，甚至看起来都不会运行。 ;）
它在输出结尾处获得额外的文本，但它避免了循环，条件，main（）和println（）。 ;）
public class OneHundred {
private static int i = 1;
static {
OneHundred[] hundreds = new OneHundred[100];
Arrays.fill(hundreds, new OneHundred(););
Thread.currentThread().setName(Arrays.toString(hundreds).replaceAll("[\\]\\[, ]+", "\n"));
clear("Exception in thread \""); clear("\" ");
}
private static void clear(String string) {
try {
Field f = String.class.getDeclaredField("count");
f.setAccessible(true);
f.set(string, 0);
} catch (Exception ignored) { }
}
public String toString() { return "" + i++; }
}
答案 28 :(得分：2)
public class PrintUptoHundredWithoutIf {
public static void main(String[] args) {
Thread t = new Thread(task());
t.setDaemon(true);
t.start();
sleep((NUMBERS_TO_PRINT * SLEEP_PERIOD_IN_MILLIS)
+ OS_SLEEP_RESPONSE_IN_MILLIS);
}
private static final int SLEEP_PERIOD_IN_MILLIS = 1000;
private static final int NUMBERS_TO_PRINT = 100;
private static final int OS_SLEEP_RESPONSE_IN_MILLIS = 110;
public void printUptoHundred(byte seq) {
int posVal = Math.abs(~seq);
System.out.println(posVal);
sleep(SLEEP_PERIOD_IN_MILLIS);
printUptoHundred((byte) posVal);
}
private static Runnable task() {
return new Runnable() {
@Override
public void run() {
new PrintUptoHundredWithoutIf().printUptoHundred((byte) 0);
}
};
}
private static void sleep(int millis) {
try {
Thread.sleep(millis);
} catch (Exception e) {
e.printStackTrace();
}
}
}
答案 29 :(得分：1)
public class Main {
// prints 2 numbers starting from i
private static void print2(int i) {
System.out.println(i);
System.out.println(i+1);
}
// prints 10 numbers starting from i
private static void print10(int i) {
print2(i);
print2(i+2);
print2(i+4);
print2(i+6);
print2(i+8);
}
// prints 20 numbers starting from i
private static void print20(int i) {
print10(i);
print10(i+10);
}
// prints 100 numbers starting from i
private static void print100(int i) {
print20(i);
print20(i+20);
print20(i+40);
print20(i+60);
print20(i+80);
}
public static void main(String[] args) {
print100(1);
}
}
或（以及其他许多替代方案）：
public class Main {
private static void print1(int i) {
System.out.println(i);
}
private static void print4(int i) {
print1(i);
print1(i+1);
print1(i+2);
print1(i+3);
}
private static void print16(int i) {
print4(i);
print4(i+4);
print4(i+8);
print4(i+12);
}
private static void print64(int i) {
print16(i);
print16(i+16);
print16(i+32);
print16(i+48);
}
public static void main(String[] args) throws Exception {
print64(1);
print16(1+64);
print16(1+64+16);
print4(1+64+32);
}
}
答案 30 :(得分：1)
它必须是Java吗？如果允许红宝石：
puts [*1..100].join("\n")
我希望在Java中看到这些简洁的内容。
答案 31 :(得分：1)
此示例不使用任何条件，也不例外 （短路中存在一种隐藏状态。） 使用递归可以避免循环。
public class OneToHundered {
public static boolean exit() {
System.exit(0);
return true;
}
public static boolean printToHundered(int i) {
boolean r;
System.out.println(i);
r = (i<100) || exit();
printToHundered(i+1);
return r;
}
public static void main(String[] args) {
printToHundered(1);
}
}
答案 32 :(得分：1)
//降序
class Test {
int count = 101;
public void printNo() {
try {
count = count--;
int nw = count / count; // to prevent printing zero
int[] array = new int[count];
System.out.println(array.length);
printNo();
} catch (Exception e) {
System.out.println("DONE PRINTING");
}
}
public static void main(String[] args) {
Test objTest = new Test();
objTest.printNo();
}
}
答案 33 :(得分：0)
List<Integer> list = new AbstractList<Integer>() {
public int size() { return 100; }
public Integer get(int i) { return i + 1; }
};
System.out.println( list.toString() );
答案 34 :(得分：0)
与迄今为止发布的内容相比，这是一个非常简单的解决方案。它使用短路评估来结束递归：
public class Foo {
static int x = 1;
public static void main(String[] args) {
foo();
}
private static boolean foo() {
System.out.println(x++);
return x > 100 || foo();
}
}
答案 35 :(得分：0)
正如我在那里所说：How to print 1 to 100 without any looping using C#
public static void f(int[] array, int n)
{
System.out.println(array[n] = n);
f(array, n + 1);
}
public static void main(String[] args) {
try { f(new int[101], 1); }
catch (Exception e) { }
}
答案 36 :(得分：0)
然后上帝发明了Perl（拉里墙实际发明了它...... :-)
#!/usr/bin/perl
@range = 1..100;
print @range;
答案 37 :(得分：0)
我认为会有一个类似于以下php
的java$my_numbers = range(0,100);
echo implode($my_numbers, ' ');
这可以避免递归，循环，控制语句等。
答案 38 :(得分：-1)
Clojure是否计数，因为它在JVM上运行？
(range 1 101)
或：
(take 100 (iterate inc 1))
两者都直接在REPL（包括隐含的印刷品）上工作。
答案 39 :(得分：-1)
system("seq 1 100");
将给出所需的结果。找到运行shell命令的等效Java调用。
答案 40 :(得分：-1)
public class Run3
{
public static void number(int i)
{
if(i==100)
{
return;
}
else
{
i++;
System.out.println(i);
number(i);
}
}
public static void main(String[] args)
{
number(0);
}
}
答案 41 :(得分：-1)
public class Test {
static int x = 0;
public static void main(String[] args) {
printTo100();
}
public static void printTo100(){
if(x<=100)
{
System.out.println(x+"");
x++;
printTo100();
}
}
}
答案 42 :(得分：-2)
public class nub
{
static int i=1;
public static void main(String...a)
{
if(i<=1000)//suppose my range is 10000
{
System.out.println(i);
i++;
main();
}
}
}
答案 43 :(得分：-3)
你不需要数组。你可以用递归来做到这一点 试试这个：
public class TestFile {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
TestFile f = new TestFile();
f.print(100);
}
public void print(int x) {
if (x > 0) {
System.out.println(x);
x--;
print(x);
}
}
}
答案 44 :(得分：-6)
尝试：
int i = 1;
System.out.println(i++);
System.out.println(i++);
System.out.println(i++);
....