Числа дисплея от 1 до 100 без циклов или [закрытых] условий

Ознакомьтесь с ответом Divide + Conquer из потока 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(); }
}

Есть ли способ печатать числа от 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"); 

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

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

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

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

Пояснение:

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

Еще один разделить и побеждают:

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

злоупотребление исключением, чтобы служить состоянием.

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

В C ++:

#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.

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

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

}

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

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

}

Это должно быть Java? Если Ruby допустил:

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

Я хотел бы видеть все, что эта краткая в Java.

Не делайте этого при любых зданых обстоятельствах!

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), он будет констать от кучи при 100-й рекурсии.

...

Теперь я пойду руками.

Это напоминает мне о программировании My Ti-55 лет назад. Он имел 32 программируемых шагов инструкций, а сброс инструкция . Проблема получила его, чтобы остановиться, что варено, чтобы получить его выполнять операцию, вызванную ошибку, например, разделить на ноль.

Таким образом:

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.

Скачать из pastebin

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

Пусть массивы делают работу:

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

Могу поспорить, вы также можете создать свой собственный файл .dmg с файловой системой размера ... Скажи 2МБ и напишите ему. Если это работает, то он очень легко для тестирования - вы просто устанавливаете его и переключаете путь для тестирования. Если DMG достаточно маленький, вы, вероятно, даже загрузите его к контролю источника.

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

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

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

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-метод возвращает последовательный INT на повторных вызовах
• Вектор с 100 элементами, то есть экземпляры класса
• Распечатать вектор (ToString-метод вектора возвращает строку ToString-значения всех его элементов)

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

Заявление ASSERT не запрещено , если утверждение.

Мое решение без глаголов. В нем не используется никакая структура управления, кроме применения функций. Также не использует библиотечный код для помощи. Мой код легко расширяется, чтобы распечатать диапазон [a, b]. Просто поменяйте conts [n / 100] на conts [(n - a) / (b - a)] и, конечно же, поменяйте новый Printable (1) на новый 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 ();
  }
}

Ответ на мой собственный вопрос.

Windows имеет функцию WSADuplicateSocket, которая может использоваться для дублирования собственного сокета. Базовый сокет останется открытым до тех пор, пока не будут освобождены все дескрипторы для этого сокета.

http://msdn.microsoft.com/en-us/library/ms741565 (VS.85) .aspx

Спорим, вы также можете создать свой собственный файл .dmg с файловой системой размера... скажи 2Mb и напиши. Если это работает, то это супер-легко для тестирования - вы просто монтируете его и переключаете путь для тестирования. Если dmg достаточно мал, его можно даже загрузить в систему управления версиями.

Да, это возможно, но это ужасно. Существует любое количество способов, которые будут использовать рекурсию или создание вложенного типа, за исключением обработки для управления потоком. Это не имеет реального применения 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

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

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

Существует много эквивалентов LINQ для Java, см. здесь для сравнения.

Для текстовой структуры стиля Quaere/LINQ рекомендуется использовать Querydsl . Querydsl поддерживает коллекции JPA/Hibernate, JDO, SQL и Java.

Я сопровождаю Querydsl, поэтому этот ответ является предвзятым.

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

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.reoteAll . Например, .reureAll («», «») для разделения пространства.)

Объяснение:

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

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

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

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

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

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

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

• Теперь, если первый и последний являются положительными числами и если последний больше, чем первый , результат (последний - первый - 1) будет > = 0 , а если последний == первый , он будет -1 .

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

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

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

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

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

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

Попробуйте:

int i = 1;
System.out.println(i++);
System.out.println(i++);
System.out.println(i++);
....