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

Постарайтесь сделать вашу программу очень понятной и простой, в то время как она фактически застрянет в непредвиденном цикле. Избиратели: судите ответы, насколько они "закулисны"!

Это конкурс популярности: будь креативным!

Javascript

var x=prompt('Enter a value under 100');
while (x != 100) {
  x=x+1;
}
console.log('End!');

prompt () возвращает строку, и цикл добавляет символ «1», он никогда не будет равен 100.

С

Просто базовый пример программы, которая иллюстрирует три различных типа циклов while в C.

int main() {

    int x = 0;

    // Multi-statement while loops are of the form "while (condition) do { ... }" and
    // are used to execute multiple statements per loop; this is the most common form
    while (x < 10) do {
        x++;
    }

    // x is now 10

    // Null-statement while loops are of the form "while (condition) ;" and are used
    // when the expression's side effect (here, decrementing x) is all that is needed
    while (x-- > 0)
        ; // null statement

    // x is now -1

    // Single-statement while loops are of the form "while (condition) statement;"
    // and are used as a shorthand form when only a single statement is needed
    while (x > -10)
        x--;

    // x is now -10

    return 0;
}

В то время как циклы не имеют «до» до открытия фигурной скобки. Это фактически создает цикл do-while внутри цикла (x <10), который заканчивается следующим «нулевым оператором» цикла while. Поскольку x увеличивается внутри цикла, а затем уменьшается в условии цикла do-while, внутренний цикл никогда не завершается, как и внешний цикл. Цикл «одного оператора» в конце никогда не достигается.

Если вы все еще в замешательстве, посмотрите здесь (внешний хостинг, потому что codegolf.SE не любит блоки кода в спойлерах).

JavaScript

var a = true;
(function() {
  while(!a){}
  alert("infinite");
  var a = true;
})();

Подъем переменной: JavaScript фактически захватит мое второе определение var a = true;, объявит его в верхней части функции как var a;и изменит мое назначение на a = true;значение, aкоторое будет неопределенным во время входа в цикл while.

C #

class Program
{
    // Expected output:
    // 20l
    // 402
    // 804
    // l608
    // 32l6
    // game over man

    static void Main()
    {
        var x = 20l;
        while (x != 6432)
        {
            Console.WriteLine(x);
            x *= 2;
        }
        Console.WriteLine("game over man");
    }
}

Числовой литерал в первой строке функции - это не «201», а «20» с суффиксом «L» ( длинный тип данных) в нижнем регистре . Число будет переполнено довольно быстро, даже не достигнув 6432, но программа продолжит работу, если проверка переполнения не была включена в опциях сборки.
Очевидно, что Visual Studio 2013 (и, возможно, и другие версии) выдает предупреждение для этого кода, рекомендуя использовать «L» вместо «l».

С

Как насчет точности?

int main(void)
{
    double x = 0;
    while(x != 10) x += 0.1;
    return 0;
}

Представьте, что вы должны хранить диапазон целых чисел <0; 3> в памяти компьютера. В этом диапазоне всего 4 целых числа (0,1,2,3). Достаточно использовать 2 бита, чтобы сохранить это в памяти. Теперь представьте, что вам нужно хранить диапазон чисел с плавающей точкой <0; 3>. Проблема в том, что в этом диапазоне бесконечное число чисел с плавающей точкой. Как хранить бесконечное количество номеров? Это невозможно. Мы можем хранить только конечное число чисел. Вот почему некоторые числа, такие как 0,1, на самом деле разные. В случае 0,1 это 0,100000000000000006. Настоятельно рекомендуется не использовать == или! = В условиях, когда вы используете числа с плавающей запятой.

HTML / JavaScript

Представьте, что у вас есть поле ввода на вашей странице:

<input onfocus="if (this.value === '') alert('Input is empty!');">

А теперь вы хотите что-то набрать в нем ... Попробуйте в Chrome: http://jsfiddle.net/jZp4X/ .

Стандартное диалоговое окно браузера, вызываемое с помощью alertфункции, является модальным, поэтому, когда оно отображается, оно убирает фокус из текстового поля, но когда оно закрывается, текстовое поле получает фокус обратно.

C ++

#include <iostream>
#include <cstddef>

int main() {
    size_t sum = 0;
    for (size_t i = 10; i >= 0; --i) {
         sum += i;
    }
    std::cout << sum << std::endl;
    return 0;
}

Условие i >=0всегда верно, потому что size_t без знака.

удар

(Был запрос на отсутствие циклов или рекурсии)

#!/bin/bash

# Demo arrays

foo=("Can I have an array?")

echo $foo

echo ${foo[0]}

foo[2] = `yes`

echo $foo

echo ${foo[2]}

Вместо назначения строки 'yes' для foo [2], это вызывает системную команду yes, которая заполняет foo [2] бесконечной суммой "yes \ n".

С

Буква "х" была потеряна в файле. Программа была написана, чтобы найти это:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  FILE* fp = fopen("desert_file", "r");
  char letter;
  char missing_letter = argv[1][0];

  int found = 0;
  printf("Searching file for missing letter %c...\n", missing_letter);
  while( (letter = fgetc(fp)) != EOF ) {
    if (letter == missing_letter) found = 1;
  }
  printf("Whole file searched.\n");
  fclose(fp);
  if (found) {
    printf("Hurray, letter lost in the file is finally found!\n");
  } else {
    printf("Haven't found missing letter...\n");
  }
}

Он был скомпилирован и запущен, и наконец он кричал:

Hurray, letter lost in the file is finally found!

В течение многих лет письма спасались таким образом, пока не пришел новый парень и не оптимизировал код. Он был знаком с типами данных и знал, что лучше использовать без знака, чем со знаком, для неотрицательных значений, поскольку он имеет более широкий диапазон и обеспечивает некоторую защиту от переполнения. Таким образом, он изменил int на unsigned int . Он также знал ASCII достаточно хорошо, чтобы знать, что они всегда имеют неотрицательную ценность. Таким образом, он также изменил char на unsigned char . Он скомпилировал код и пошел домой, гордясь хорошей работой, которую он сделал. Программа выглядела так:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  FILE* fp = fopen("desert_file", "r");
  unsigned char letter;
  unsigned char missing_letter = argv[1][0];

  unsigned int found = 0;
  printf("Searching file for missing letter %c...\n", missing_letter);
  while( (letter = fgetc(fp)) != EOF ) {
    if (letter == missing_letter) found = 1;
  }
  printf("Whole file searched.\n");
  fclose(fp);
  if (found) {
    printf("Hurray, letter lost in the file is finally found!\n");
  } else {
    printf("Haven't found missing letter...\n");
  }
}

Он вернулся в хаос на следующий день. Буква «а» отсутствовала, и, хотя она должна была находиться в файле «desert_file», содержащем «abc», программа искала его навсегда, распечатывая только:

Searching file for missing letter a...

Они уволили парня и откатились к предыдущей версии, вспомнив, что нельзя оптимизировать типы данных в рабочем коде.

Но какой урок они должны были извлечь здесь?

Прежде всего, если вы посмотрите на таблицу ascii, вы заметите, что EOF отсутствует. Это потому, что EOF - это не символ, а специальное значение, возвращаемое функцией fgetc (), которая может возвращать символ, расширенный до int, или -1, обозначающий конец файла.
Пока мы используем подписанный char, все работает хорошо - char, равный 50, также расширяется с помощью fgetc () до int, равного 50. Затем мы преобразуем его обратно в char и оставляем 50. То же самое происходит для -1 или любого другого вывода, получаемого из fgetc ().
Но посмотрите, что происходит, когда мы используем unsigned char. Мы начинаем с символа в fgetc (), расширяем его до int, а затем хотим иметь неподписанный символ. Единственная проблема в том, что мы не можем сохранить -1 в неподписанном символе. Программа хранит его как 255, который больше не равен EOF.

Предостережение
Если вы взглянете на раздел 3.1.2.5 Типы в копии документации ANSI C, вы обнаружите, что то, является ли char подписанным или нет, зависит исключительно от реализации. Так что парня, вероятно, не стоит увольнять, поскольку он обнаружил в коде очень хитрую ошибку. Это может произойти при смене компилятора или переходе на другую архитектуру. Интересно, кого бы уволили, если бы баг вышел в таком случае;)

PS. Программа была построена вокруг ошибки, упомянутой в языке сборки ПК Полом А. Картером

Regex

При соответствующем вводе следующее регулярное выражение может привести к тому, что большинство движков обратного отслеживания попадут в ад обратного отслеживания:

^\w+(\s*\w+)*$

Простого ввода, такого как "Programming Puzzles and Code Golf Stack Exchange - Mozilla Firefox"или "AVerySimpleInputWhichContainsAnInsignificantSentence."(обе строки приведены для ясности), достаточно для того, чтобы большинство движков обратного отслеживания работало в течение длительного времени.

Так как (\s*\w+)*допускает расширение \w+\w+\w+... \w+, это означает, что механизм регулярных выражений в основном попробует все возможные способы разбить строку символов слова . Это источник отступления ада.
Это может быть легко исправлена путем изменения \s*в \s+, то (\s+\w+)*можно разложить только \s+\w+\s+\w+... \s+\w+.

JavaScript

function thiswillLoop(){
var mynumber = 40;
while(mynumber == 40){
mynumber = 050;
}
return "test";
}
thiswillLoop();

050 - восьмеричная константа в Javascript, и она имеет десятичное значение 40.

Haskell

head $ reverse $ (repeat '!') ++ "olleH"

Ну, подумай об этом! Это было бы так же, как head $ "Hello" ++ (repeat '!'), то есть должно просто вернуться 'H'.

В списках haskell представлены рекурсивные структуры, причем первый элемент является самым верхним. Чтобы добавить в список, вы должны развернуть все эти элементы, поместить свое приложение и вернуть поднятые элементы обратно. Это не сработает в бесконечном списке. Точно так же, обращение бесконечного списка волшебным образом не вернет вам "Hello"спину. Это будет просто висеть вечно.

Java под Windows

public class DoesntStop
{
    public static void main(String[]a) throws InterruptedException, IOException
    {
        ProcessBuilder p = new ProcessBuilder("cmd.exe","/c","dir");
        p.directory(new File("C:\\windows\\winsxs"));
        Process P = p.start();
        P.waitFor();
    }
}

Программа использует застрявший стандартный поток вывода из командной строки, чтобы застрять. В каталоге WinSXS в Windows есть несколько тысяч файлов с длинными именами, поэтому почти гарантировано засорение stdout, а waitForвозврат невозможен, поэтому программа заблокирована

Чтобы сравнить яблоки и апельсины ... в C

Я впечатлен тем, что здесь нет фрагмента кода, использующего goto... (Вы знаете: Goto - это зло! )

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    char *oranges = "2";
    long int apples;

next_harvest:

    apples = random() % 3;

    printf("%ld apples comp. %s oranges ...\n", apples, oranges);

    if( apples != (long int)oranges )
    {
        sleep(1);
        goto next_harvest;
    }

    return 0;
}

Сон только для того, чтобы читать его. Нажмите ^ C, если у вас нет бесконечного количества времени, чтобы ждать чего-то, что никогда не происходит ;-)

C, с некоторыми оптимизирующими компиляторами

Эта программа увеличивает целочисленную переменную до тех пор, пока она не переполнится.

#include <stdio.h>
#include <stdint.h>
int main()
{
    int32_t x = 0;
    while(x + 1 > x)
        x++;
    printf("Got overflow!\n");
    return 0;
}

Целочисленное переполнение со знаком - неопределенное поведение. Обычно на практике это переносится, когда оптимизации отключены. С оптимизацией компиляторы могут и действительно решить, что x + 1 > xэто всегда так.

C ++

int main()
{
  int x = 1;
  //why doesn't this code terminate??/
  x = 0;
  while(x) {} //no-op/
  return 0;
}

Странный стиль комментирования - хитрость. Подсказка: триграфы.

Ява

Мне особенно нравится этот побочный эффект оптимизации автобокса:

class BoxingFun {
  public static void main( String[] args) {
    Integer max;
    Integer i;

    max = 100;
    for( i = 1; i != max; i++ ) {
      System.out.println("Not endless");  
    }
    max = 200;
    for( i = 1; i != max; i++ ) {
      System.out.println("Endless");  
    }
  }
}

Из-за автобокса Integerобъекты ведут себя почти как обычные ints, за одним исключением: циклы i != maxin forсравнивают ссылки (идентичность) Integerобъектов, а не их значение (равенство). Для значений до 100 это удивительно «работает» тем не менее из-за оптимизации в JVM: Java предварительно выделяет Integerобъекты для «наиболее распространенных значений» и повторно использует их при автобоксировании. Таким образом, для значений до 100 мы имеем равенство тождества <==>.

Рубин / С

#include <stdio.h>
#ifdef llama
def int(*args)
end
def main(arg)
  yield
end
void = nil
#endif
#define do {
#define end }
int main(void) {
  int x = 10;
  while(x-=1) do
    printf("%i\n",x);
  end
    return 0;
}

Это работает правильно в C , считая от 9 до 1 в STDOUT. При запуске в Ruby он не завершается, потому что

0 не является ложным значением в Ruby.

JavaScript

// This multiplies the elements in the inner lists and sums the results.
function sum_of_products(var items)
{
        var total = 0;
        for(var i = 0; i < items.length; i++) {
                var subitems = items[i];
                var subtotal = 1;
                for(var i = 0; i < subitems.length; i++) {
                        subtotal *= subitems[i];
                }       
                total += subtotal;
        }
        return total;
}

// Should return 1*2 + 3*4*5 + 6*7*8*9 + 10*11 = 3196
sum_of_products([[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]);

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

С

Это должно напечатать таблицу кодов для всех символов ASCII, от 0 до 255. A charдостаточно велик, чтобы перебирать их.

#include <stdio.h>

int main(){
    char i;
    for(i = 0; i < 256; i++){
        printf("%3d 0x%2x: %c\n", i, i, i);
    }
    return 0;
}

Все символы меньше 256. 255 ++ дает 0 из-за переполнения, поэтому условие i < 256всегда выполняется. Некоторые компиляторы предупреждают об этом, некоторые нет.

питон

a = True
m = 0
while a:
    m = m + 1
    print(m)
    if m == 10:
        exit

так должно быть exit()и нет exit. Насколько я понимаю, exit()это команда выхода из интерпретатора Python. В этом случае вызов к представлению функции, а не к функции, см .: выход-обсуждение . В качестве альтернативы breakбудет лучшим выбором.

C ++

Как насчет классической C ++ - ловушки программиста?

int main()
{
   bool keepGoing = false;

   do {
       std::cout << "Hello, world!\n";
   } while( keepGoing = true );

   return 0;
}

Javascript

var а = 0;
a = 1;
while(а<10){
    a++;
}

Переменные, используемые в 1-й и 3-й строке, отличаются от переменных, используемых во 2-й и 3-й строке.
Один использует в (U + 0061) , в то время как другие используют а (U + 0430)

Ява:

public class LoopBugThing{
   public static void main(String[] args)
   {
      int i = 0;
      while(i < 10)
      {
         //do stuff here
         i = i++;
      }
      System.out.println("Done!");
   }
}

«I = i ++» - довольно распространенная ошибка новичка, и найти ее на удивление сложно

C ++

Немного случайного?

class Randomizer
{
   private:
   int max;

   public:
   Randomizer(int m)
   {
      max = m;
      srand(time(NULL));
   }

   int rand()
   {
      return (rand() % max);
   }
};

int main()
{
  Randomizer r(42);
  for (int i = 0; i < 100; i++)
  {
     i += r.rand();
  }
  return (0);
}

Не вызывает функцию, randа вызывает рекурсивно Randomizer::randфункцию.

Haskell

Некоторый код на время вычисления заданного значения функции Аккермана. Для очень низких значений это обычно заканчивается. На моей машине очень низкие значения означают что-то вроде 3 5 или меньше с скомпилированным кодом и-O . В ghci низкие значения означают что-то вроде 3 3.

'Символ , кажется, запутались подсветка синтаксиса, не знаю , почему. В некоторых местах они необходимы, поэтому не могут удалить их все.

Edit- изменил язык.

{-# LANGUAGE NamedFieldPuns #-}
import Control.Concurrent.STM
import Control.Concurrent
import Data.Time.Clock.POSIX

data D = D { time :: !POSIXTime
           , m :: !Integer
           , n :: !Integer
           , res :: !(Maybe Integer)
           } deriving Show

startvalue = D 0 3 8 Nothing

-- increment time in D. I belive lensen make code like
-- this prettier, but opted out.
inctime t t' (d@D{time}) = d {time = time + t' - t }

-- Counting time
countTime :: TVar D -> POSIXTime -> IO ()
countTime var t = do
    t' <- getPOSIXTime
    atomically $ modifyTVar' var (inctime t t')
    countTime var t'

-- Ackermann function
ack m n
    | m == 0    = n + 1
    | n == 0    = ack (m - 1) 1
    | otherwise = ack (m - 1) (ack m (n - 1))

-- Ackerman function lifted to the D data type and strict
ack' (d@D{m, n}) = let a = ack m n
                   in seq a (d { res = Just a })

-- fork a counting time thread, run the computation
-- and finally print the result.
main = do
    d <- atomically (newTVar startvalue)
    forkIO (getPOSIXTime >>= countTime d)
    atomically $ modifyTVar' d ack'
    (atomically $ readTVar d) >>= print

Это вызывает livelock. Поток подсчета постоянно вызывает откат вычисления Аккермана, поскольку они касаются одного и того же TVar.

Java - нет циклов или рекурсии

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

К сожалению, программа не дает никакого результата. Это держит терминал. Пожалуйста, помогите в поиске проблемы. Я не использовал циклы, рекурсия не задействована. Я полностью сбит с толку.

import java.util.regex.*;

public class LearnRegex {
     public static void main(String[] args) {
         Pattern p = Pattern.compile("(x.|x.y?)+");
         String s = new String(new char[343]).replace("\0", "x");
         if (p.matcher(s).matches())
             System.out.println("Match successful!");
     }
}

Что я сделал не так? Почему моя программа не заканчивается? Пожалуйста помоги!

Идеальная ссылка здесь .

Это глупый пример катастрофического возврата . Сложность O (2 ^{n / 2} ). Хотя программа не может работать бесконечно, она, вероятно, переживет как живые, так и неживые объекты вокруг, а не вокруг .

С

Вам нужен только один из двух циклов, но какой вам нужен, зависит от вашего компилятора.

main()
{
        int i, a[10];

        i = 0;
        while (i <= 10) {
            i++;
            a[i] = 10 - i;
            printf("i = %d\n", i);
        }

        /* Now do it in reverse */

        i = 10;
        while (i >= 0) {
            i--;
            a[i] = 10 - i;
            printf("i = %d\n", i);
        }

}

Простое переполнение границ, которое сбрасывает i до бесконечного значения. Компиляторы могут различаться в зависимости от того, размещают ли они i над или под a в стеке, поэтому я включил переполнения в обоих направлениях.

C / C ++

C ++ просто допускает легкие встроенные объявления переменных, используемые здесь, но так же легко сделать эту ошибку в простом старом C ...

#include <stdio.h>

int main(void)
{
    int numbers[] = {2, 4, 8};

    /* Cube each item in the numbers array */
    for(int i = 0; i < 3; i++) {
      for(int j = 0; j < 3; i++) {
        numbers[j] *= numbers[j];
      }
    }

    /* Print them out */
    for(int i = 0; i < 3; i++) {
      printf("%d\n", numbers[i]);
    }

    return 0;
}

Во внутреннем цикле 'j' сравнивается, но никогда не увеличивается. (На самом деле «i ++» должен быть «j ++»). Это не столько хитрая уловка, сколько реальная ошибка, которую я допустил в прошлом;) На что-то стоит обратить внимание.

C #

Ниже приведен простой класс, выполняющий арифметическую операцию (суммирование) для большого входного массива с использованием фонового потока. Пример программы включен.

Однако, хотя это довольно просто, оно никогда не заканчивается. Обратите внимание, что здесь нет ловкости рук (двойники символов, скрытые / пропущенные точки с запятой, триграфы ;-) и т. Д.)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

class Program
{
    static void Main()
    {
        var summer = new BackgroundSummer(Enumerable.Range(1, 1234567));
        Console.WriteLine(summer.WaitAndGetResult());
    }
}

public class BackgroundSummer
{
    private IEnumerable<int> numbers;
    private long sum;
    private bool finished;

    public BackgroundSummer(IEnumerable<int> numbers)
    {
        this.numbers = numbers;
        new Thread(ComputingThread).Start();
    }

    public long WaitAndGetResult()
    {
        while (!finished) { /* wait until result available */ }
        return sum;
    }

    private void ComputingThread()
    {
        foreach(var num in numbers)
        {
            sum += num;
        }
        finished = true;
    }
}

Это пример реальной неприятной ошибки, которая также может появиться в вашем коде. В соответствии с моделью памяти .NET и спецификацией C # цикл, такой как цикл in, WaitAndGetResultможет никогда не завершиться, если вы не укажете переменную как volatile, потому что она изменена другим потоком. Посмотреть этот вопрос StackOverflow для деталей. Ошибка зависит от реализации .NET, поэтому она может повлиять или не повлиять на вас. Но обычно запуск релизной сборки на процессоре x64, кажется, показывает проблему. (Я попробовал это с «csc.exe / o + / debug- infinite.cs» .)