Tugas Anda: Untuk menulis sebuah program yang jelas-jelas harus berakhir, tetapi tidak pernah (sejauh crash komputer) tidak. Buat itu terlihat seperti itu harus melakukan tugas sederhana: menambahkan angka, mencetak sesuatu, ... Tapi itu hanya terjebak dalam loop yang tak terbatas.

Cobalah untuk membuat program Anda sangat jelas dan sederhana, sementara itu sebenarnya akan terjebak dalam lingkaran yang tidak terduga. Pemilih: nilai jawaban tentang seberapa "curang" mereka!

Ini adalah kontes popularitas: Jadilah kreatif!

Javascript

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

prompt () mengembalikan sebuah string dan loop menambahkan karakter '1', itu tidak akan pernah sama dengan 100.

C

Hanya contoh program dasar yang menggambarkan tiga jenis while-loop di 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;
}

Sementara loop tidak memiliki "lakukan" sebelum kurung kurawal pembukaan. Ini sebenarnya membuat loop do-while di dalam loop (x <10) yang diakhiri oleh "pernyataan nol" while. Karena x bertambah di dalam loop dan kemudian dikurangi dalam kondisi loop do-while, loop dalam tidak pernah berakhir, dan demikian juga loop luar. Loop "pernyataan tunggal" pada akhirnya tidak pernah tercapai.

Jika Anda masih bingung, lihat di sini (di-host secara eksternal karena codegolf.SE tidak suka blok kode di spoiler).

JavaScript

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

Pengangkat variabel: JavaScript akan benar-benar mengambil definisi kedua saya var a = true;, menyatakannya di bagian atas fungsi sebagai var a;, dan memodifikasi tugas saya ke a = true;makna aakan ditentukan pada saat memasuki loop sementara.

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

Angka literal pada baris pertama fungsi bukan '201', tetapi '20' dengan akhiran 'L' ( datatype panjang ) akhiran. Jumlahnya akan meluap dengan cepat tanpa mencapai 6432, tetapi program akan terus berjalan kecuali pemeriksaan melimpah dihidupkan dalam opsi build.
Secara masuk akal, Visual Studio 2013 (dan mungkin versi lain juga) memberi Anda peringatan untuk kode ini, merekomendasikan agar Anda menggunakan 'L' bukannya 'l'.

C

Bagaimana dengan presisi?

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

Bayangkan Anda harus menyimpan sejumlah angka integer <0; 3> dalam memori komputer. Hanya ada 4 bilangan bulat dalam kisaran ini (0,1,2,3). Cukup menggunakan 2 bit untuk menyimpannya dalam memori. Sekarang bayangkan Anda harus menyimpan sejumlah angka floating point <0; 3>. Masalahnya adalah ada jumlah angka floating point yang tak terbatas dalam kisaran ini. Bagaimana cara menyimpan jumlah angka yang tidak terbatas? Itu tidak mungkin. Kami hanya dapat menyimpan jumlah angka yang terbatas. Inilah mengapa beberapa angka seperti 0,1 sebenarnya berbeda. Dalam hal 0,1 itu adalah 0,100000000000000006. Sangat disarankan untuk tidak menggunakan == atau! = Dalam kondisi sejauh Anda menggunakan angka floating point.

HTML / JavaScript

Bayangkan Anda memiliki kotak input di halaman Anda:

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

Dan sekarang Anda ingin mengetikkan sesuatu di dalamnya ... Coba di Chrome: http://jsfiddle.net/jZp4X/ .

Kotak dialog browser standar yang disebut dengan alertfungsi adalah modal, jadi ketika itu ditampilkan ia mengeluarkan fokus keluar dari kotak teks, tetapi ketika itu ditolak kotak teks menerima kembali fokus.

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

Kondisi i >=0ini selalu benar karena size_t tidak ditandatangani.

pesta

(Ada permintaan untuk tidak ada loop atau rekursi)

#!/bin/bash

# Demo arrays

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

echo $foo

echo ${foo[0]}

foo[2] = `yes`

echo $foo

echo ${foo[2]}

Alih-alih menetapkan string 'ya' untuk foo [2], ini memanggil perintah sistem yes, yang mengisi foo [2] dengan jumlah "ya \ n" yang tidak pernah berakhir.

C

Huruf "x" hilang dalam file. Sebuah program ditulis untuk menemukannya:

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

Itu dikompilasi dan dijalankan dan akhirnya berteriak:

Hurray, letter lost in the file is finally found!

Selama bertahun-tahun surat telah diselamatkan dengan cara ini sampai orang baru datang dan mengoptimalkan kode. Dia akrab dengan tipe data dan tahu bahwa lebih baik menggunakan unsigned daripada menandatangani untuk nilai-nilai non-negatif karena memiliki rentang yang lebih luas dan memberikan perlindungan terhadap luapan. Jadi dia mengubah int menjadi unsigned int . Dia juga tahu ascii cukup baik untuk mengetahui bahwa mereka selalu memiliki nilai non-negatif. Jadi dia juga mengubah char menjadi char yang tidak ditandatangani . Dia menyusun kode dan pulang dengan bangga atas pekerjaan bagus yang dia lakukan. Programnya terlihat seperti ini:

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

Dia kembali ke malapetaka pada hari berikutnya. Huruf "a" hilang dan meskipun seharusnya berada di "desert_file" yang berisi "abc", program tersebut mencarinya selamanya hanya untuk mencetak:

Searching file for missing letter a...

Mereka memecat orang itu dan kembali ke versi sebelumnya mengingat bahwa orang tidak boleh mengoptimalkan tipe data dalam kode kerja.

Tapi pelajaran apa yang seharusnya mereka pelajari di sini?

Pertama-tama, jika Anda melihat tabel ascii Anda akan melihat bahwa tidak ada EOF. Itu karena EOF bukan karakter tetapi nilai khusus yang dikembalikan dari fgetc (), yang dapat mengembalikan karakter diperluas ke int atau -1 yang menunjukkan akhir file.
Selama kita menggunakan char yang ditandatangani semuanya berfungsi dengan baik - char yang sama dengan 50 diperpanjang oleh fgetc () menjadi int sama dengan 50 juga. Kemudian kita mengubahnya kembali menjadi char dan masih memiliki 50. Hal yang sama terjadi untuk -1 atau output lain yang berasal dari fgetc ().
Tapi lihat apa yang terjadi ketika kita menggunakan char yang tidak ditandatangani. Kami mulai dengan char di fgetc () memperluasnya ke int dan kemudian ingin memiliki char yang tidak ditandatangani. Satu-satunya masalah adalah bahwa kita tidak dapat menyimpan -1 di char yang tidak ditandatangani. Program menyimpannya sebagai 255 yang tidak lagi sama dengan EOF. Jika Anda melihat bagian 3.1.2.

Peringatan
salinan dokumentasi ANSI C Anda akan mengetahui bahwa apakah char ditandatangani atau tidak, semata-mata tergantung pada implementasi. Jadi orang itu mungkin tidak boleh dipecat karena dia menemukan bug yang sangat rumit bersembunyi di kode. Itu bisa keluar ketika mengubah kompiler atau pindah ke arsitektur yang berbeda. Saya ingin tahu siapa yang akan dipecat jika bug keluar dalam kasus seperti itu;)

PS. Program dibangun di sekitar bug yang disebutkan dalam Bahasa Majelis PC oleh Paul A. Carter

Regex

Dengan input yang tepat, regex berikut ini dapat menyebabkan mesin regex backtracking masuk ke neraka backtracking:

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

Input sederhana seperti "Programming Puzzles and Code Golf Stack Exchange - Mozilla Firefox"atau "AVerySimpleInputWhichContainsAnInsignificantSentence."(kedua string dikutip untuk kejelasan) sudah cukup untuk membuat mesin regex yang paling mundur berjalan untuk waktu yang lama.

Karena (\s*\w+)*memungkinkan untuk ekspansi \w+\w+\w+... \w+, yang berarti mesin regex pada dasarnya akan mencoba semua cara yang mungkin untuk memisahkan serangkaian karakter kata . Ini adalah sumber dari neraka yang mundur.
Hal ini dapat dengan mudah diperbaiki dengan mengubah \s*ke \s+, maka (\s+\w+)*hanya dapat diperluas untuk \s+\w+\s+\w+... \s+\w+.

JavaScript

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

050 adalah konstanta oktal dalam Javascript, dan kebetulan memiliki nilai desimal 40.

Haskell

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

Nah, pikirkan itu! Itu akan sama dengan head $ "Hello" ++ (repeat '!'), yaitu hanya harus kembali 'H'.

Dalam daftar haskell adalah struktur rekursif, dengan elemen pertama yang paling atas. Untuk menambahkan ke daftar, Anda harus membuka gulungan semua elemen itu, letakkan lampiran Anda, dan kembalikan elemen yang terangkat. Itu tidak akan bekerja pada daftar yang tak terbatas. Demikian pula, membalik daftar yang tak terbatas tidak akan secara ajaib memberi Anda "Hello"dukungan. Itu hanya akan menggantung selamanya.

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

Program mengandalkan aliran output standar macet dari commandline untuk macet. Direktori WinSXS di bawah windows memiliki ribuan file dengan nama panjang sehingga hampir dijamin untuk menyumbat stdout, dan waitFortidak dapat kembali sehingga program menemui jalan buntu

Untuk membandingkan apel dan jeruk ... di C

Saya terkesan bahwa tidak ada kode di sini menggunakan goto... (Anda tahu: Goto itu jahat! )

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

Tidur hanya untuk bisa membacanya. Tekan ^ C jika Anda tidak memiliki banyak waktu untuk menunggu sesuatu yang tidak pernah terjadi ;-)

C, dengan kompiler pengoptimal tertentu

Program ini menambah variabel integer hingga melimpah.

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

Overflow integer yang ditandatangani adalah perilaku yang tidak terdefinisi. Biasanya dalam praktiknya membungkus, ketika optimasi dimatikan. Dengan optimisasi aktif, kompiler dapat dan memang memutuskan itu x + 1 > xselalu benar.

C ++

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

Gaya berkomentar yang aneh adalah triknya. Petunjuk: trigraph.

Jawa

Saya khususnya menyukai efek samping optimasi autoboxing ini:

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

Karena autoboxing, Integerobjek berperilaku hampir seperti biasa intdi sini, dengan satu pengecualian: The i != maxin the forloop membandingkan referensi (identitas) dari Integerobjek, bukan nilai mereka (kesetaraan). Untuk nilai hingga 100, ini secara mengejutkan "berfungsi" karena optimasi di JVM: Java mengalokasikan ulang Integerobjek untuk "nilai paling umum" dan menggunakannya kembali saat melakukan autoboxing. Jadi untuk nilai hingga 100, kami memiliki identitas <==> kesetaraan.

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

Ini bekerja dengan benar dalam C , menghitung mundur dari 9 ke 1 dalam STDOUT. Ketika dijalankan di Ruby, itu tidak berakhir, karena

0 bukan nilai yang salah di 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]]);

Kedua loop menggunakan variabel loop yang sama, jadi tergantung pada input, loop dalam dapat menjaga loop luar dari penyelesaian.

C

Ini harus mencetak tabel kode untuk semua karakter ASCII, dari 0 hingga 255. A charcukup besar untuk diulanginya.

#include <stdio.h>

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

Semua karakter kurang dari 256. 255 ++ memberi 0 karena melimpah, sehingga kondisinya i < 256selalu bertahan. Beberapa kompiler memperingatkan tentang hal itu, beberapa tidak.

Python

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

seharusnya exit()dan tidak exit. Seperti yang saya pahami, exit()adalah perintah untuk keluar dari juru bahasa python. Dalam hal ini panggilan adalah untuk representasi fungsi dan bukan ke fungsi, lihat: keluar-diskusi . Atau breakakan menjadi pilihan yang lebih baik.

C ++

Bagaimana dengan C ++ klasik - jebakan programmer?

int main()
{
   bool keepGoing = false;

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

   return 0;
}

Javascript

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

Variabel yang digunakan dalam baris 1 dan 3 berbeda dari yang digunakan pada baris 2 dan 3.
Satu menggunakan a (U + 0061) sedangkan yang lain menggunakan a (U + 0430)

Jawa:

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 ++" adalah kesalahan pemula yang sangat umum dan bisa sangat sulit ditemukan

C ++

Sedikit acak?

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

Tidak memanggil fungsi randmelainkan memanggil Randomizer::randfungsi secara rekursif .

Haskell

Beberapa kode waktu menghitung nilai yang diberikan dari fungsi Ackermann. Untuk nilai yang sangat rendah biasanya berakhir. Pada komputer saya nilai yang sangat rendah berarti sekitar 3 5 atau lebih kecil dengan kode yang dikompilasi dan -O. Dalam ghci nilai rendah berarti sekitar 3 3.

The 'simbol tampaknya mengacaukan sintaks, tidak yakin mengapa. Di beberapa tempat mereka dibutuhkan sehingga tidak dapat menghapus semuanya.

Edit- bahasa yang diubah.

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

Ini menyebabkan livelock. Thread penghitungan berulang kali menyebabkan komputasi Ackermann untuk mundur karena mereka menyentuh TVar yang sama.

Java - Tidak ada loop atau rekursi

Saya baru mulai belajar ekspresi reguler dan menulis program pertama saya untuk menguji apakah string saya cocok dengan ekspresi reguler.

Sayangnya, program ini tidak membuahkan hasil. Itu memegang terminal. Tolong bantu dalam menemukan masalah. Saya belum menggunakan loop, tidak ada rekursi yang terlibat. Saya benar-benar bingung.

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

Apa yang telah saya lakukan salah? Mengapa program saya tidak berakhir? Tolong bantu!

Tautan ideone di sini .

Ini adalah contoh bodoh dari kemunduran bencana . Kompleksitasnya adalah O (2 ^{n / 2} ). Meskipun program ini mungkin tidak berjalan tanpa batas waktu, program itu mungkin hidup lebih lama dari benda hidup dan tidak hidup di sekitar dan tidak begitu di sekitar .

C

Anda seharusnya hanya membutuhkan satu dari dua loop, tetapi yang mana yang Anda butuhkan tergantung pada kompiler Anda.

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

}

Batas sederhana dikalahkan yang mengatur ulang i ke nilai yang tidak berakhir. Compiler dapat berbeda pada apakah mereka mengalokasikan i di atas atau di bawah a di stack, jadi saya sudah memasukkan overruns di kedua arah.

C / C ++

C ++ hanya memungkinkan deklarasi variabel inline mudah yang digunakan di sini, tetapi sama mudahnya untuk membuat kesalahan ini di 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;
}

Di loop dalam, 'j' dibandingkan tetapi tidak pernah bertambah. ('I ++' sebenarnya harus 'j ++'). Ini bukan trik licik tetapi lebih dari kesalahan aktual yang saya buat di masa lalu;) Sesuatu yang harus diperhatikan.

C #

Berikut ini adalah kelas sederhana yang melakukan operasi aritmatika (penjumlahan) pada array input besar menggunakan utas latar belakang. Program sampel disertakan.

Namun, meskipun cukup mudah, itu tidak pernah berakhir. Perhatikan bahwa tidak ada sulap (karakter lookalikes, tersembunyi / hilang titik koma, trigraph ;-), dll.)

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

Ini adalah contoh dari bug jahat dunia nyata yang mungkin muncul dalam kode Anda juga. Sesuai model .NET memory dan spesifikasi C #, loop seperti yang ada di WaitAndGetResultmungkin tidak akan pernah berhenti kecuali Anda menetapkan variabel sebagai volatile, karena itu dimodifikasi oleh utas lainnya. Lihat pertanyaan StackOverflow ini untuk detailnya. Bug tergantung pada implementasi .NET, sehingga mungkin atau mungkin tidak mempengaruhi Anda. Tetapi biasanya, menjalankan rilis yang dibangun pada prosesor x64 tampaknya menampilkan masalah. (Saya mencobanya dengan "csc.exe / o + / debug- infinite.cs" .)