显示从1到100的数字，没有循环或条件

时间：2010-01-11 18:42:01

标签： java loops

有没有办法在不使用任何循环或条件如“if”的情况下从1到100打印数字？ 我们可以很容易地使用递归但是又有一个if条件。有没有办法不使用“if”？也没有重复的打印语句，或包含1到100之间所有数字的单个打印语句。

Java中的解决方案更可取。

45 个答案:

答案 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“钻石运算符”应该有助于减少与泛型类型的重复，但对于更常见的情况没有帮助。 :(
  • 双括号是Double Brace idiom - 一个只包含实例初始化程序的匿名内部类。这是一个黑客。它增加了运行时间大小，从而增加了启动时间。如果使用pack200.gz，分发大小可以忽略不计。我认为现代世界已经做好了准备。你的同事可能不是。也许首先将它用于测试da
  • BitSet.set在集合中设置了一点（两个完全不同的含义“set”在那里 - 我喜欢它）。这是一个半开放的范围 - 最高价值的独家;底部包容。在顶部添加1以包含100.
  • BitSet.toString实际上是由API文档精确定义的。
    • 通过在J2SE 5.0中引入append接口，将
  • PrintStream添加到Appendable。它本质上是一个子串并打印结果。 （一个小秘密：实际上并没有通过规范来保证刷新输出，但实现总是如此。）
  • 在1处开始追加，并从长度中取出一个从BitSet的字符串表示中删除大括号。
  • “了解你的图书馆。”取自Josh Bloch。请参阅Java Puzzlers，谜题94.了解库中的内容真的很好。至少知道在哪里看。节省您的时间，节省维护时间，并在第一时间正确使用。

答案 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);
  }
}

说明：

  • 定义一个类，其toString方法在重复调用时返回连续的int。
  • 创建一个包含100个元素的向量，它是类
    • 的实例
  • 打印向量（Vector的toString-method返回其所有元素的toString值的字符串）

答案 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。

    < / LI>

现在，此值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");
C中的

将给出所需的结果。找到运行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++);
....
相关问题
最新问题