Отображать номера от 1 до 100 без петель или условий

Псевдокод. Использует массив для принудительного исключения после 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); } 

Знайте свои библиотеки.

 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 – удобный небольшой class, представляющий произвольно большой (не разреженный) набор положительных целых чисел. (У этого есть так плохие бит: не окончательный, излишне streamобезопасный, не поддерживает хорошо здание и т. Д.) Ta.
• Расширение BitSet позволяет мне писать java.util только один раз. «Алмазный оператор JDK7» должен помочь уменьшить дублирование с помощью типовых типов, но не поможет более общей ситуации. 🙁
• Двойными скобками являются идиома Double Brace – анонимный внутренний class, содержащий только инициализатор экземпляра. Это взломать. Это увеличивает время выполнения и, следовательно, время запуска. Размер дистрибутива пренебрежимо мал, если вы используете pack200.gz. Я думаю, что современный мир готов к этому. Ваши коллеги могут не быть. Возможно, начните с использования его для теста da
• BitSet.set устанавливает бит в наборе (два совершенно разных значения слова «set» там – мне это нравится). Это полуоткрытый диапазон – исключительное значение высшего качества; внизу включительно. Добавьте 1 к вершине, чтобы включить 100.
• BitSet.toString фактически точно определяется документами API.
• append был добавлен в PrintStream с введением интерфейса Appendable в J2SE 5.0. Он по существу выполняет подстроку и печатает результат. (Немного секрет: на самом деле это не гарантируется спецификацией, чтобы очистить вывод, но реализации всегда будут.)
• Запуск append в 1 и снятие одной из длинной полосы BitSet к BitSet из строкового представления BitSet .
• «Знай свои библиотеки». Взято от Джоша Блоха. См. Java Puzzlers, головоломка 94. Очень хорошо знать, что находится в библиотеках. По крайней мере, знать, где искать. Сохраните ваше время, сэкономьте время обслуживания и получите его в первый раз.

НЕ ДЕЛАЙТЕ ЭТО ПОД КАКИЕ-ЛИБО ОБСТОЯТЕЛЬСТВА 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); } } 

Когда это выполняется с использованием 1 м кучного пространства (java -Xmx1m Fail), он закончится с кучи на 100-й рекурсии.

…

Теперь я пойду вымыть руки.

Есть ли способ печати чисел от 1 до 100 без использования каких-либо циклов или условий, подобных «if»?

Не могу поверить, что никто этого не предложил:

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

Проверьте ответ Divide + Conquer из streamа C #. Это зло, но блестяще:

Как печатать от 1 до 100 без каких-либо циклов с использованием 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(); } } 

Конечно, есть:

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

В C ++:

 #include  class a { static unsigned i; public: a() { std::cout << ++i << std::endl; } }; unsigned a::i = 0U; int main() { a array[100]; } 

Это решение не использует циклы и рекурсии для печати чисел от 1 до 100.

скачать из пастабин

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

Есть ли способ печати чисел от 1 до 100 без использования каких-либо циклов или условий, подобных «if»?

Используя оптимизированную версию этого :

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

Следующий вопрос?

Или если вы хотите использовать reflection 🙂

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

Да, это возможно, но это ужасно. Существует несколько способов использования рекурсии или вложенного типа с обработкой исключений для управления streamом. Это не имеет реального применения IMO, и его следует избегать в реальном коде любой ценой.

Вот пример, который использует рекурсивный тип экземпляра с обработкой исключений для управления завершением. Он печатает число в порядке убывания, но это было бы тривиально изменить на восходящий, просто вычитая 99 (или любую другую) из печатаемого значения.

 class PrintVal { // called with a list containing as many items as you want, less one... public PrintVal( List 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 strList = new ArrayList( new int[99] ); PrintVal instance = new PrintVal( strList ); // all output happens here 

Основываясь на ответе Якоби, но без улова. (Возьмите этот ответ.)

 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 .
• Это использует анонимный внутренний class. Аноним не означает, что это не тип. Поэтому я могу вызвать метод, который не объявлен в базовом типе / реализованном интерфейсе.
• acquireUninterruptibly означает, что мне не нужно объявлять отвратительные проверенные исключения.
• Никто не сказал, что программа должна завершиться.

пусть Массивы выполняют свою работу:

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

Нет условий (без коротких логических операторов, нет? -Оператора, без исключений), нет циклов:

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

Объяснение:

• определить class, метод toString которого возвращает последовательные ints при повторных вызовах
• создать вектор со 100 элементами, которые являются экземплярами classа
• print the vector (toString-метод вектора возвращает строку значений toString всех ее элементов)

Вот один, использующий stream (я раздул время сна, чтобы учитывать колебания скорости системы). Я не мог придумать, как избавиться от 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); } } 

Хорошо, я опоздал на это, и ответ уже принят, но я удивляюсь, почему никто не использовал чистый и простой счетчик?

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

Thread safe, настраиваемый, без исключений, не зависит от побочных эффектов 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 ) будет >= 0 а если last == first будет -1 .

• Итак, ( ( last - first - 1 ) >>> 31 ) оценивается до 0 если last больше first и становится равным 1 если они равны.

Теперь это значение 0/1 используется для переключения между двумя реализациями print( int first, int last ) на основе сравнения first и last . Сначала recursion происходит без печати. print( 1, 100 ) вызывает print( 1, 99 ) и т. д. … до тех пор, пока last станет first что приведет к переключению на другую реализацию print которая, в свою очередь, ничего не делает. Итак, теперь стек снова разматывается, и значения печатаются по пути вниз в порядке возрастания, и вызов vtab[ 0 ].print( 1, 100 ) заканчивается нормально.

Вот подсказка, которая будет полезна.

Утверждение assert не является запрещенным if выражением.

Мое решение без подробностей. Он не использует какую-либо структуру управления, отличную от приложения-приложения. Он также не использует библиотечный код, чтобы помочь. Мой код легко расширяется, чтобы распечатать диапазон [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 (); } } 

EDIT: Поскольку этот вопрос был закрыт (почему ???), я отправлю свой второй ответ здесь. Это вдохновляет Тома Хотина на то, что программа не должна заканчиваться. Также вопрос не требует, чтобы печатались (или даже в порядке) только цифры 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 (); } } 

Еще один разрыв и победа:

 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 («числа от 1 до 100»)

Внедрите рекурсивный вызов, увеличивая и печатая номер. Настройте свою виртуальную машину для завершения работы после 100 вызовов. Нет условий, нет петель. кашель 😉

Злоупотреблять исключением служит условие.

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

без какой-либо петли и условия:

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

Если попытка и улов законны, я думаю, что было бы легко и довольно чисто, чтобы рекурсировать, а затем просто делить на ноль, когда вы закончите. Помимо всего этого, он всегда качается, когда вы начинаете делиться на ноль и для удовольствия, и для прибыли.

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

Я разработчик .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); } 

Не видел этого здесь, используя порядок завершения оператора && .

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

Это напоминает мне программирование моего TI-55 лет и лет назад. Он имел 32 программируемых шага команды и инструкцию 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.

Этот ответ достаточно извращен, что он даже не выглядит так, как он будет работать. 😉

Он получает дополнительный текст в конце вывода, но избегает циклов, условий, 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++; } } 

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

Должна ли она быть Java? Если ruby разрешен:

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

Я бы хотел увидеть что-то подобное на Java.