Ваше завдання: Написати програму, яка, очевидно, повинна припинитися, але вона ніколи (в міру збою комп'ютера) не робить. Зробіть це схожим на те, що воно повинно виконувати просте завдання: додавання чисел, друкування чогось, ... Але воно просто потрапляє у нескінченну петлю.

Постарайтеся зробити свою програму дуже зрозумілою і простою, тоді як вона насправді застрягне в непередбаченому циклі. Виборці: оцініть відповіді про те, наскільки вони "недоторкані"!

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

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

Хоча петлі не мають "робити" перед відкриттям фігурної дужки. Це фактично створює цикл виконання часу всередині циклу (x <10), який закінчується наступним "null заявою" while циклом. Оскільки х збільшується всередині циклу, а потім зменшується в стані циклу "час роботи", внутрішній цикл ніколи не закінчується, і так само, як і зовнішній цикл. Цикл "one-statement" в кінці ніколи не досягається.

Якщо ви все ще плутаєтеся , подивіться тут (зовні розміщено, оскільки 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]}

Замість присвоєння рядку "так" foo [2], це викликає системну команду yes, яка заповнює foo [2] незмінним числом "так \ 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 на непідписаний int . Він також досить добре знав ascii, щоб знати, що вони завжди мають негативне значення. Тому він також змінив char на непідписаний 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");
  }
}

На наступний день він повернувся до хаосу. Лист "a" відсутній, і хоча він мав бути у "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 ().
Але подивіться, що станеться, коли ми використовуємо неподписані знаки. Ми починаємо з char у fgetc (), розширюємо його до int, а потім хочемо мати неподписаний char. Єдина проблема полягає в тому, що ми не можемо зберегти -1 у неподписаних знаках. Програма зберігає його як 255, що вже не дорівнює EOF.

Caveat
Якщо ви подивитесь на розділ 3.1.2.5 Типи в копії документації ANSI C, ви дізнаєтесь, підписаний чи ні знак char залежить тільки від реалізації. Тож хлопця, мабуть, не слід звільняти, оскільки він знайшов дуже хитру помилку, що ховається в коді. Це може вийти при зміні компілятора або переході до іншої архітектури. Цікаво, кого б звільнили, якби помилка вийшла в такому випадку;)

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

Регекс

При відповідному введенні наступний регулярний вираз може призвести до того, що більшість механізмів зворотного відстеження переходять у пекельне відстеження:

^\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.

Хаскелл

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неможливо повернутись, тому програма зайшла в тупик

Для порівняння яблук і апельсинів ... в С

Мені вражено, що тут немає жодного фрагмента коду, використовуючи 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;
}

Дивний стиль коментування - трюк. Підказка: триграфи.

Java

Я особливо люблю цей побічний ефект оптимізації автобоксингу:

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

З - за Autoboxing, Integerоб'єкти поводяться майже як прості intз тут, з одним винятком: i != maxв forпетлях порівнює посилання (ідентичність) з Integerоб'єктів, а не їхня значення (рівність). Для значень до 100 це дивно "працює", проте завдяки оптимізації в JVM: Java попередньо розміщує Integerоб'єкти для "найпоширеніших значень" і повторно використовує їх при автобоксінгу. Отже, для значень до 100 ми маємо тотожність <==> рівність.

Ruby / C

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

Java:

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функцію.

Хаскелл

Деякий код для обчислення часу заданого значення функції Акермана. За дуже низьких значень він зазвичай припиняється. На моїй машині дуже низькі значення означають щось на зразок 3 5 або менших зі складеним кодом та-O . У ghci низькі значення означають щось на зразок 3 3.

'Символ , здається, заплуталися підсвічування синтаксису, не знаю , чому. У деяких місцях вони потрібні, тому не можна їх видалити.

Правка - змінена мова.

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

Це спричиняє живіт. Обчислювальна нитка неодноразово змушує обчислення Ackermann повернутися назад, оскільки вони торкаються тієї ж телевізори.

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

Що я зробив неправильно? Чому моя програма не закінчується? Будь ласка, допоможіть!

Ideone посилання тут .

Це дурний приклад катастрофічного зволікання . Складність становить O (2 ^{п / 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 вище або нижче в стеці, тому я включив перевитрата в обох напрямках.

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 #, цикл, такий як той, у WaitAndGetResultніколи не може закінчитися, якщо ви не вказали змінну як мінливу, оскільки вона модифікована іншим потоком. Докладніше див. У цьому питанні StackOverflow . Помилка залежить від реалізації .NET, тому може вплинути на вас або не вплинути. Але зазвичай запущена версія випуску на процесорі x64, здається, відображає проблему. (Я спробував це з "csc.exe / o + / debug- infinite.cs" .)