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.
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);
}
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. 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. :( 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.) BitSet
.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.
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\"?");
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(); }
}
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);
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.
télécharger depuis Pastebin
System.out.println((new URL("http://Pastebin.com/Pastebin.php?dl=f722c7eb0")).getContent())
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?
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);
}
}
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.Java.util.concurrent
deux fois. J'ai donc étendu Semaphore
de manière opportuniste.acquireUninterruptibly
signifie que je n'ai pas à déclarer des exceptions embêtantes.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
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));
}
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:
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);
}
}
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.
Voici un conseil utile.
L'instruction assert
n'est pas l'instruction if
interdite.
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 ();
}
}
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();
}
};
}
}
System.out.println ("nombres de 1 à 100")
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);
}
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;
}
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);
}
}
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);
}
}
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);
}
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 ;-)
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();
}
}
}
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++; }
}
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.} _
//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();
}
}
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);
}
}
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);
}
}
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.
Et puis Dieu a inventé Perl (Larry Wall l’a réellement inventé .. :-)
#!/usr/bin/Perl
@range = 1..100;
print @range;
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) { }
}
List<Integer> list = new AbstractList<Integer>() {
public int size() { return 100; }
public Integer get(int i) { return i + 1; }
};
System.out.println( list.toString() );
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.
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();
}
}