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

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

Предпочтительным является решение в Java.

ОТВЕТЫ

Ответ 1

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

Ответ 2

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

public class To100 {
    public static void main(String[] args) {
        String set = new java.util.BitSet() {{ set(1, 100+1); }}.toString();
        System.out.append(set, 1, set.length()-1);
    }
}

(Вы можете использовать String.replaceAll для изменения разделителя. Например, .replaceAll(", ", " ") для разделения пространства.)

Пояснение:

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

Ответ 3

НЕ ДЕЛАЙТЕ ЭТО ПОД КАКИЕ-ЛИБО СООБЩЕНИЯ ОБ АНКЕТЕ!

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-й рекурсии.

...

Теперь я буду молить руки.

Ответ 4

Есть ли способ распечатать числа от 1 до 100 без использования каких-либо циклов или условий типа "если"?

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

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

Ответ 5

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

Как печатать от 1 до 100 без цикла с использованием С#

Вот версия 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(); }
}

Ответ 6

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

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

Ответ 7

В С++:

#include <iostream>

class a {
  static unsigned i;

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

unsigned a::i = 0U;

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

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

Ответ 8

скачать с pastebin

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

Ответ 9

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

Используя оптимизированную версию 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");

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

Ответ 10

Или если вы хотите использовать отражение: -)

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

}

Ответ 11

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

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

class PrintVal
{
  // called with a list containing as many items as you want, less one...
  public PrintVal( List<int> items )
  {
      System.out.println(items.size()+1);  // print the size of the list
      try { 
        items.remove( items.size()-1 );  // will throw when items is empty
        new PrintVal( items );
      }
      catch( Exception ) { /* swallow and terminate */ }
  }
}

// setup and invocation that performs the output
ArrayList<int> strList = new ArrayList<int>( new int[99] );
PrintVal instance = new PrintVal( strList );  // all output happens here

Ответ 12

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

public class To100 {
    public static void main(String[] args) {
        final int max = 100;
        new java.util.concurrent.Semaphore(max) {
            void go() {
                acquireUninterruptibly();
                System.err.println(max-availablePermits());
                go();
            }
        }.go();
    }
}

Пояснение:

  • Semaphore позволяет получить определенное количество разрешений до блокировки.
  • Я не хотел писать java.util.concurrent дважды, поэтому я оппортунистически расширил Semaphore.
  • Это использует анонимный внутренний класс. Аноним не означает, что это не тип. Поэтому я могу вызвать метод, который не объявлен в базовом типе/реализованном интерфейсе.
  • acquireUninterruptibly означает, что мне не нужно объявлять отвратительные проверенные исключения.
  • Никто не сказал, что программа должна завершиться.

Ответ 13

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

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

Ответ 14

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

import java.util.Vector;

public class PrintOneToHundered {
  static int i;
  PrintOneToHundered() {}
  public String toString() { return ++i+""; }
  public static void main(String[] args) {
    Vector v1  =new Vector(); v1  .add(new PrintOneToHundered());
    Vector v2  =new Vector(); v2  .addAll(v1 ); v2  .addAll(v1 );
    Vector v4  =new Vector(); v4  .addAll(v2 ); v4  .addAll(v2 );
    Vector v8  =new Vector(); v8  .addAll(v4 ); v8  .addAll(v4 );
    Vector v16 =new Vector(); v16 .addAll(v8 ); v16 .addAll(v8 );
    Vector v32 =new Vector(); v32 .addAll(v16); v32 .addAll(v16);
    Vector v64 =new Vector(); v64 .addAll(v32); v64 .addAll(v32);
    Vector v100=new Vector(); v100.addAll(v64); v100.addAll(v32); v100.addAll(v4);
    System.out.println(v100);
  }
}

Пояснение:

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

Ответ 15

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

}

Ответ 16

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

public class Counter
{
    static Counter[] vtab = new Counter[]
    {
        new Counter(),
        new Counter() { public void print( int first, int last ) {} }
    };

    public void print( int first, int last )
    {
        vtab[ ( last - first - 1 ) >>> 31 ].print( first, last - 1 );
        System.out.println( last );
    }

    public static void main( String[] args )
    {
        vtab[ 0 ].print( 1, 100 );
    }
}

Безопасный поток, настраиваемый, без исключений, без зависимости от побочных эффектов API, просто ООП и некоторые тривиальные математические данные.

Для тех, кто не знаком с бинарными операторами, вот как это работает:

  • Выражение ( 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 используется для переключения между 2 реализациями print( int first, int last ) на основе сравнения first и last. Сначала рекурсия происходит без печати. print( 1, 100 ) вызывает print( 1, 99 ) и т.д.... до last равно first, что приводит к переключению на другую реализацию print, которая в свою очередь ничего не делает. Итак, теперь стек снова разматывается, и значения печатаются по пути вниз в порядке возрастания, а вызов vtab[ 0 ].print( 1, 100 ) завершается нормально.

Ответ 17

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

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

Ответ 18

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

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

Ответ 19

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

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

Ответ 20

System.out.println( "числа от 1 до 100" )

Ответ 21

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

Ответ 22

без какого-либо цикла и условия:

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

Ответ 23

Нарушение исключения служит условием.

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

Ответ 24

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

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

Ответ 25

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

Ответ 26

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

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

Ответ 27

Это напоминает мне программирование моего 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.

Ответ 28

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

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

Ответ 29

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

Ответ 30

//По убыванию

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