Afficher des nombres de 1 à 100 sans boucles ni conditions

Question

Existe-t-il un moyen d’imprimer des nombres compris entre 1 et 100 sans utiliser de boucles ni de conditions telles que "if"? Nous pouvons facilement utiliser la récursivité, mais cela comporte une condition if. Y a-t-il un moyen de faire sans utiliser "si" aussi? Également, aucun relevé d’impression répétitif, ou un seul relevé d’impression contenant tous les nombres de 1 à 100.

Une solution en Java est préférable.

Answer 1

Pseudo code. Utilise un tableau pour forcer une exception après 100 éléments qui est capturé et ne fait rien.

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){
}

MODIFIER
Code 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);
}

Answer 2

Connaissez vos bibliothèques.

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

(Vous pouvez utiliser String.replaceAll pour modifier le séparateur. Par exemple, .replaceAll(", ", " ") pour la séparation de l'espace.)

Explication:

• Java.util.BitSet est une petite classe pratique qui représente un ensemble arbitrairement grand (non fragmenté) d'entiers positifs. (Il y a tellement de problèmes: non final, inutilement thread-safe, ne supporte pas bien la construction, etc.) ta. 
• Etend BitSet me permet d’écrire Java.util une seule fois. L’opérateur de diamants JDK7 devrait aider à réduire les doubles emplois avec les types génériques, mais aucune aide pour la situation la plus courante. :( 
• Les doubles accolades sont les idiomes Double Brace -, une classe interne anonyme ne contenant qu'un initialiseur d'instance. C'est un hack. Cela augmente la taille de l'exécution, et donc le temps de démarrage. La taille de la distribution est négligeable si vous utilisez pack200.gz. Je pense que le monde moderne est prêt pour cela. Vos collègues peuvent ne pas être. Peut-être commencer par l'utiliser pour le test da
• BitSet.set définit un bit dans l'ensemble (deux significations complètement différentes du mot "set" ici - je l'aime bien). C'est une gamme semi-ouverte - la valeur exclusive exclusive; le bas inclus. Ajoutez 1 en haut pour inclure 100. 
• BitSet.toString est en réalité précisément défini par la documentation de l'API.
• append a été ajouté à PrintStream avec l'introduction de l'interface Appendable dans J2SE 5.0. Il fait essentiellement une sous-chaîne et affiche le résultat. (Un petit secret: les spécifications ne garantissent pas le vidage de la sortie, mais les implémentations le feront toujours.) 
• Commencer l’ajout à 1 et en enlever un de la longueur supprime les accolades de la chaîne représentant BitSet.
• "Connais tes bibliothèques." Tiré de Josh Bloch. Voir Java Puzzlers, puzzle 94. Il est bon de savoir ce qu'il y a dans les bibliothèques. Au moins savoir où regarder. Gagnez du temps, gagnez du temps en maintenance et faites le bon travail du premier coup.

Answer 3

NE FAITES PAS CELA SOUS TOUTES SANE CIRCONSTANCES!

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

Lorsqu'il est exécuté en utilisant 1 m d'espace de segment de mémoire (Java -Xmx1m Fail), il manquera de segment de mémoire à la 100e récursivité.

...

Je vais maintenant aller me laver les mains.

Answer 4

Est-il possible d’imprimer des nombres de 1 à 100 sans utiliser de boucles ou de conditions telles que "if"? 

Je ne peux pas croire que personne ne l'ait suggéré pour le moment:

System.out.println("numbers from 1 to 100 without using any loops or conditions like \"if\"?");

Answer 5

Découvrez la réponse Divide + Conquer à partir du fil C #. C'est diabolique, mais brillant:

Comment imprimer 1 à 100 sans utiliser de boucle en C #

Voici la version 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(); }
}

Answer 6

Bien sûr, il y a:

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);

Answer 7

En C++:

#include <iostream>

class a {
  static unsigned i;

public:
  a() {
    std::cout << ++i << std::endl;
  }
};

unsigned a::i = 0U;

int main() {
  a array[100];
}

Cette solution n’utilise ni boucles ni récursion pour l’impression de nombres de 1 à 100.

Answer 8

télécharger depuis Pastebin

System.out.println((new URL("http://Pastebin.com/Pastebin.php?dl=f722c7eb0")).getContent())

Answer 9

Est-il possible d’imprimer des nombres de 1 à 100 sans utiliser de boucles ou de conditions telles que "if"?

Utiliser une version optimisée de 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"); 

Question suivante?

Answer 10

Ou si vous aimez utiliser la réflexion :-)

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

}

Answer 11

S'appuyant sur la réponse de Yacoby, mais sans le piège. (Upvote cette réponse.)

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();
    }
}

Explication:

• Semaphore permet d'acquérir un nombre spécifié de permis avant le blocage.
• Je ne voulais pas écrire Java.util.concurrent deux fois. J'ai donc étendu Semaphore de manière opportuniste.
• Cela utilise une classe interne anonyme. Anonyme ne signifie pas que ce n'est pas un type. Je peux donc appeler une méthode dessus qui n'est pas déclarée dans une interface de type base/implémentée.
• acquireUninterruptibly signifie que je n'ai pas à déclarer des exceptions embêtantes.
• Personne n'a dit que le programme devait se terminer.

Answer 12

Oui, c'est possible, mais c'est terrible. Il y a plusieurs façons d'utiliser la création de type récursif ou imbriqué, avec la gestion des exceptions pour le contrôle de flux. Cela n’a pas d’application dans le monde réel IMO et devrait être évité à tout prix dans le code réel.

Voici un exemple qui utilise une instanciation de type récursive avec une gestion des exceptions pour contrôler la terminaison. Le nombre affiché est un ordre décroissant, mais il serait facile de passer à un ordre croissant en soustrayant simplement 99 (ou toute autre constante) de la valeur en cours d’impression.

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

Answer 13

laissez les tableaux faire le travail: 

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

Answer 14

Pas de conditions (pas d'opérateurs booléens raccourcis, pas d'opérateurs?, Pas d'exceptions), pas de boucles:

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

Explication:

• définir une classe dont la méthode toString renvoie des entrées consécutives lors d'appels répétés
• créer un vecteur avec 100 éléments, qui sont des instances de la classe
• print le vecteur (la méthode toString d'un vecteur renvoie une chaîne des valeurs toString de tous ses éléments)

Answer 15

En voici une qui utilise un thread (j'ai gonflé le temps de sommeil pour tenir compte des fluctuations de la vitesse du système). Je ne pouvais pas penser à un moyen de se débarrasser de l'essayer/attraper:

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

}

Answer 16

Ok, je suis en retard et une réponse est déjà acceptée, mais je me demande pourquoi personne n’a encore utilisé un compteur propre et simple?

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

Fil de discussion, configurable, pas d'exception, pas de dépendance aux effets secondaires de l'API, mais simplement OOP et quelques calculs triviaux.

---

Pour ceux qui ne connaissent pas les opérateurs binaires, voici comment cela fonctionne:

• L'expression ( x >>> n ) déplace tous les bits de la valeur entière x vers la droite de n places. Les bits inférieurs tombent simplement du côté droit par cette opération et les nouveaux bits qui arrivent du côté gauche sont toujours 0.

• Ainsi, ( x >>> 31 ) a pour effet de déplacer le bit le plus élevé de x à la position la plus basse et de définir tous les autres bits de x sur 0. Le résultat est maintenant toujours soit 0 ou 1 pour toutes les valeurs possibles de x.

• Comme le bit le plus élevé de int est le bit de signe qui est 0 pour les valeurs positives et 1 pour les valeurs négatives, l'expression ( x >>> 31 ) est évaluée à 0 pour toutes les valeurs positives de x et à 1 pour toutes les valeurs négatives de x.

• Maintenant si first et last sont des nombres positifs et si last est supérieur à first, le résultat de ( last - first - 1 ) sera >= 0 et si last == first il sera -1.

• Donc, ( ( last - first - 1 ) >>> 31 ) est évalué à 0 si last est supérieur à first et devient 1 si elles sont égales.

Maintenant, cette valeur 0/1 est utilisée pour basculer entre les 2 implémentations de print( int first, int last ) en fonction de la comparaison de first et last. Au début, la récursivité a lieu sans rien imprimer. print( 1, 100 ) appelle print( 1, 99 ) et ainsi de suite ... jusqu'à ce que last soit égal à first, ce qui provoque le passage à une autre implémentation de print qui, à son tour, ne fait rien du tout. Alors maintenant, la pile se déroule à nouveau et les valeurs sont imprimées en descendant dans l'ordre croissant et l'invocation de vtab[ 0 ].print( 1, 100 ) se termine normalement.

Answer 17

Voici un conseil utile. 

L'instruction assert n'est pas l'instruction if interdite.

Answer 18

Ma solution sans verbosité. Il n'utilise aucune structure de contrôle autre que l'application de fonction. Il n'utilise pas non plus le code de bibliothèque pour aider. Mon code est facilement extensible pour imprimer la plage [a, b]. Il suffit de changer conts [n / 100] en conts [(n - a) / (b - a)] et bien sûr de changer new Printable (1) en 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 ();
  }
}

EDIT: Depuis que cette question a été fermée (pourquoi ???), je posterai ma deuxième réponse ici. Il est inspiré par l'avis de Tom Hawtin selon lequel le programme ne doit pas se terminer. De plus, la question n'exige pas que seuls les chiffres 1 à 100 soient imprimés (ou même dans l'ordre).

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 ();
  }
}

Answer 19

Un autre partage et conquête:

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();
            }
        };
    }
}

Answer 20

System.out.println ("nombres de 1 à 100")

Answer 21

sans boucle ni condition:

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)
    {

    }
}

avec récursion et sans si je pense utiliser "?" pour le conditionnement:

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

Answer 22

Si essayer et attraper sont légaux, je penserais qu’il serait facile et assez propre de récidiver puis de diviser par zéro lorsque vous avez terminé. En plus de tout cela, ça déchire toujours quand on arrive à diviser par zéro, à la fois pour le plaisir et pour le profit.

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;
}

Answer 23

Abuser d'une exception pour servir de condition.

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

Answer 24

Je ne l'ai pas vu ici, en utilisant l'ordre de résiliation de l'opérateur &&.

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

Answer 25

Je suis un développeur .Net mais je suppose qu'il existe un équivalent Java de ceci ...

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

Answer 26

Implémenter un appel récursif en incrémentant et en imprimant le numéro. Configurez votre VM pour qu’elle manque de pile après 100 appels. Pas de conditions, pas de boucles. la toux ;-)

Answer 27

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();
        }
    }
}

Answer 28

Cette réponse est assez perverse pour que cela ne semble même pas fonctionner. ;)

Il y a du texte supplémentaire à la fin de la sortie, mais cela évite les boucles, les conditions, main () et 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++; }
}

Answer 29

Cela me rappelle la programmation de mes TI-55 il y a des années et des années. Il comportait 32 étapes d’instruction programmables et une instruction RESET qui sauterait à l’instruction zéro afin de permettre la mise en boucle simple. Le problème était de l’arrêter, ce qui revenait à lui demander de faire une opération qui provoquait une erreur, par exemple une division par zéro.

Ainsi:

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
    }
}

_ {Remarque: oui, je sais que cela ressemble à la solution de @ Yacoby.} _

Answer 30

//Ordre décroissant

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();
    }
}

Answer 31

Cet exemple n'utilise aucune condition et aucune exception.
(Il y a une sorte de condition cachée dans le court-circuit OU).
Les boucles sont évitées en utilisant la récursivité.

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

Answer 32

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

}

Ou (parmi d'autres nombreuses alternatives): 

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

}

Answer 33

Est-ce que cela doit être Java? Si Ruby est autorisé:

puts [*1..100].join("\n")

J'aimerais voir quelque chose d'aussi concis en Java.

Answer 34

Et puis Dieu a inventé Perl (Larry Wall l’a réellement inventé .. :-) 

#!/usr/bin/Perl
@range = 1..100;
print @range;

Answer 35

Comme je le disais ici: Comment imprimer 1 à 100 sans utiliser de boucle en 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) { }
}

Answer 36

List<Integer> list = new AbstractList<Integer>() {
    public int size() { return 100; }
    public Integer get(int i) { return i + 1; }
};
System.out.println( list.toString() );

Answer 37

je pense qu'il y aurait un équivalent Java à quelque chose comme le php suivant

$my_numbers = range(0,100);
echo implode($my_numbers, ' ');

cela évite les récursions, les boucles, les instructions de contrôle, etc.

Answer 38

Voici une solution qui semble très simple par rapport à ce qui a été posté jusqu'à présent. Il utilise une évaluation de court-circuit pour mettre fin à la récursivité:

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();
  }
}