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

Есть ли способ печати чисел от 1 до 100 без использования каких-либо циклов или условий, подобных «if»? Мы можем легко использовать рекурсию, но это снова имеет условие if. Есть ли способ обойтись без использования «if»? Также нет повторяющихся операторов печати или одного оператора печати, содержащего все числа от 1 до 100.

Решение на Java предпочтительнее.

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

  • Проверка входного сигнала сканера во время цикла
  • Почему объекты R не печатаются в функции или в цикле «для»?
  • Зацикливание через t.tests для подмножеств фрейма данных в r
  • Эмуляция цикла do-while в Bash
  • Как выйти из цикла в Perl?
  • Однострочный цикл с обязательной парой фигурных скобок в Java
  • Создание треугольника с петлями
  • Эффект точки с запятой после цикла «for»
  • Каков наилучший способ перебора словаря?
  • Как я могу перебирать все подпункты UIView, а также их подзоны и их подпрограммы
  • Цикл через массив имен переменных в Less
  • Давайте будем гением компьютера.