Il tuo compito: scrivere un programma che dovrebbe ovviamente terminare, ma non lo fa mai (nella misura di un crash del computer). Fai sembrare che dovrebbe svolgere un semplice compito: aggiungere numeri, stampare qualcosa, ... Ma viene catturato in un ciclo infinito.

Cerca di rendere il tuo programma molto chiaro e semplice, mentre in realtà rimarrà bloccato in un ciclo imprevisto. Elettori: giudica le risposte su quanto siano "subdoli"!

Questo è un concorso di popolarità: sii creativo!

Javascript

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

prompt () restituisce una stringa e il ciclo aggiunge il carattere '1', non sarà mai uguale a 100.

C

Solo un programma di esempio di base che illustra i tre diversi tipi di while-loop in 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;
}

Mentre i loop non hanno un "do" prima dell'apertura parentesi graffa. Questo in realtà crea un ciclo do-while all'interno del ciclo (x <10) che termina con la seguente "istruzione null" mentre il ciclo. Poiché x viene incrementato all'interno del loop e quindi decrementato nelle condizioni del loop do-while, il loop interno non termina mai, e quindi nemmeno il loop esterno. Il ciclo "single-statement" alla fine non viene mai raggiunto.

Se sei ancora confuso, guarda qui (ospitato esternamente perché a codegolf.SE non piacciono i blocchi di codice negli spoiler).

JavaScript

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

Sollevamento di variabili: JavaScript prenderà effettivamente la mia seconda definizione di var a = true;, la dichiarerà nella parte superiore della funzione come var a;e modificherà il mio assegnamento al a = true;significato anon sarà definito nel momento in cui entra nel ciclo 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");
    }
}

Il numero letterale nella prima riga della funzione non è un '201', ma un '20' con un suffisso 'L' minuscolo ( tipo di dati lungo ). Il numero traboccerà abbastanza rapidamente senza mai toccare 6432, ma il programma continuerà a meno che nelle opzioni di generazione non sia stato attivato il controllo di trabocco.
Sensibilmente, Visual Studio 2013 (e probabilmente anche altre versioni) ti dà un avvertimento per questo codice, raccomandando di usare 'L' invece di 'l'.

C

Che ne dici di precisione?

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

Immagina di dover memorizzare un intervallo di numeri interi <0; 3> nella memoria del computer. Ci sono solo 4 numeri interi in questo intervallo (0,1,2,3). Basta usare 2 bit per archiviarlo in memoria. Ora immagina di dover memorizzare un intervallo di numeri in virgola mobile <0; 3>. Il problema è che esiste un numero infinito di numeri in virgola mobile in questo intervallo. Come memorizzare un numero infinito di numeri? È impossibile. Possiamo solo memorizzare un numero finito di numeri. Questo è il motivo per cui alcuni numeri come 0.1 sono in realtà diversi. In caso di 0,1 è 0,100000000000000006. Si consiglia vivamente di non utilizzare == o! = In condizioni purché si utilizzino numeri in virgola mobile.

HTML / JavaScript

Immagina di avere una casella di input nella tua pagina:

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

E ora vuoi digitare qualcosa al suo interno ... Prova in Chrome: http://jsfiddle.net/jZp4X/ .

La finestra di dialogo del browser standard chiamata con alertfunzione è modale, quindi quando viene visualizzata toglie lo stato attivo dalla casella di testo, ma quando viene ignorata la casella di testo riceve nuovamente lo stato attivo.

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

La condizione i >=0è sempre vera perché size_t è senza segno.

bash

(C'è stata una richiesta per nessun loop o ricorsione)

#!/bin/bash

# Demo arrays

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

echo $foo

echo ${foo[0]}

foo[2] = `yes`

echo $foo

echo ${foo[2]}

Invece di assegnare la stringa 'yes' a foo [2], questo chiama il comando di sistema yes, che riempie foo [2] con una quantità infinita di "yes \ n".

C

La lettera "x" è stata persa in un file. È stato scritto un programma per trovarlo:

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

È stato compilato e funzionante e finalmente ha gridato:

Hurray, letter lost in the file is finally found!

Per molti anni le lettere sono state salvate in questo modo fino a quando il nuovo ragazzo è arrivato e ha ottimizzato il codice. Conosceva i tipi di dati e sapeva che è meglio usare valori non firmati che firmati per valori non negativi poiché ha un intervallo più ampio e offre una certa protezione contro gli overflow. Quindi ha cambiato int in unsigned int . Conosceva anche ascii abbastanza bene da sapere che hanno sempre un valore non negativo. Quindi ha anche cambiato carattere in carattere non firmato . Compilò il codice e tornò a casa orgoglioso del buon lavoro che aveva fatto. Il programma sembrava così:

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

È tornato in rovina il giorno successivo. Mancava la lettera "a" e anche se doveva essere nel "file_sviluppo" contenente "abc", il programma lo cercava per sempre stampando solo:

Searching file for missing letter a...

Hanno licenziato il ragazzo e sono tornati alla versione precedente ricordando che non si dovrebbero mai ottimizzare i tipi di dati nel codice di lavoro.

Ma qual è la lezione che avrebbero dovuto imparare qui?

Prima di tutto, se dai un'occhiata alla tabella ASCII noterai che non esiste EOF. Questo perché EOF non è un carattere ma un valore speciale restituito da fgetc (), che può restituire il carattere esteso a int o -1 che indica la fine del file.
Finché stiamo usando il carattere con segno tutto funziona bene - il carattere uguale a 50 viene esteso da fgetc () in int uguale a 50. Quindi lo trasformiamo nuovamente in char e ne abbiamo ancora 50. Lo stesso accade per -1 o qualsiasi altro output proveniente da fgetc ().
Ma guarda cosa succede quando usiamo caratteri non firmati. Iniziamo con un carattere in fgetc () estenderlo a int e quindi vogliamo avere un carattere senza segno. L'unico problema è che non possiamo conservare -1 nel carattere senza segno. Il programma lo sta memorizzando come 255 che non è più uguale a EOF.

Avvertimento
Se dai un'occhiata alla sezione 3.1.2.5 Tipi in copia della documentazione ANSI C scoprirai che se il carattere è firmato o meno dipende esclusivamente dall'implementazione. Quindi probabilmente il ragazzo non dovrebbe essere licenziato poiché ha trovato un bug molto complicato in agguato nel codice. Potrebbe venire fuori quando si cambia il compilatore o si passa a un'architettura diversa. Mi chiedo chi verrebbe licenziato se il bug emergesse in tal caso;)

PS. Il programma è stato costruito attorno al bug menzionato in PC Assembly Language da Paul A. Carter

regex

Con l'input appropriato, il seguente regex può causare la maggior parte del motore regex di backtracking nell'inferno di backtracking:

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

Un input semplice come "Programming Puzzles and Code Golf Stack Exchange - Mozilla Firefox"o "AVerySimpleInputWhichContainsAnInsignificantSentence."(entrambe le stringhe citate per chiarezza) è sufficiente per mantenere la maggior parte dei motori regex di backtrack in funzione per molto tempo.

Dato che (\s*\w+)*consente l'espansione \w+\w+\w+... \w+, il che significa che il motore regex proverà sostanzialmente tutti i modi possibili per dividere una stringa di caratteri di parole . Questa è la fonte dell'inferno di backtracking.
Può essere facilmente risolto modificando \s*a \s+, allora (\s+\w+)*può essere esteso solo \s+\w+\s+\w+... \s+\w+.

JavaScript

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

050 è una costante ottale in Javascript e sembra avere il valore decimale di 40.

Haskell

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

Beh, pensaci! Sarebbe lo stesso head $ "Hello" ++ (repeat '!'), cioè dovrebbe solo tornare 'H'.

Nelle liste di haskell sono strutture ricorsive, con il primo elemento in cima. Per aggiungere un elenco, è necessario srotolare tutti quegli elementi, posizionare l'appendice e rimettere gli elementi sollevati. Non funzionerebbe su un elenco infinito. Allo stesso modo, invertire una lista infinita non ti darà magicamente le "Hello"spalle. Rimarrà appeso per sempre.

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

Il programma fa affidamento su un flusso di output standard inceppato dalla riga di comando per rimanere bloccato. La directory di WinSXS in Windows ha più di migliaia di file con nomi lunghi, quindi è quasi sicuro di intasare stdout e waitFornon può tornare, quindi il programma è bloccato

Per confrontare mele e arance ... in C

Sono impressionato dal fatto che qui non esiste un codice usando un goto... (Sai: Goto è malvagio! )

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

Il sonno è solo per poterlo leggere. Premi ^ C se non hai un tempo infinito per aspettare qualcosa che non accade mai ;-)

C, con alcuni compilatori ottimizzanti

Questo programma incrementa una variabile intera finché non trabocca.

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

L'overflow di numeri interi con segno è un comportamento indefinito. Di solito in pratica si avvolge quando le ottimizzazioni sono disattivate. Con le ottimizzazioni attivate, i compilatori possono e decidere che x + 1 > xè sempre vero.

C ++

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

Lo strano stile di commento è il trucco. Suggerimento: trigrafi.

Giava

In particolare, adoro questo effetto collaterale dell'ottimizzazione dell'autoboxing:

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

A causa del box automatico, gli Integeroggetti si comportano quasi come semplici ints qui, con un'eccezione: Il i != maxnei forcicli confronta i riferimenti (identità) degli Integeroggetti, non il loro valore (uguaglianza). Per valori fino a 100, ciò "sorprende" in modo sorprendente, tuttavia, a causa di un'ottimizzazione nella JVM: Java prealloca gli Integeroggetti per i "valori più comuni" e li riutilizza durante il box automatico. Quindi per valori fino a 100 abbiamo identità <==> uguaglianza.

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

Ciò funziona correttamente in C , conto alla rovescia da 9 a 1 in STDOUT. Quando eseguito in Ruby, non termina, perché

0 non è un valore falso in 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]]);

Entrambi i loop usano la stessa variabile loop, quindi a seconda dell'ingresso, il loop interno può impedire che il loop esterno finisca mai.

C

Questo dovrebbe stampare una tabella di codici per tutti i caratteri ASCII, da 0 a 255. A charè abbastanza grande da scorrere su di essi.

#include <stdio.h>

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

Tutti i caratteri sono inferiori a 256. 255 ++ dà 0 a causa dell'overflow, quindi la condizione è i < 256sempre valida. Alcuni compilatori lo avvertono, altri no.

Pitone

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

dovrebbe essere exit()e non exit. A quanto ho capito, exit()è il comando per uscire dall'interprete Python. In questo caso la chiamata è alla rappresentazione della funzione e non alla funzione vedi: exit-discussione . In alternativa breaksarebbe una scelta migliore.

C ++

Che ne dici del classico C ++ - trappola del programmatore?

int main()
{
   bool keepGoing = false;

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

   return 0;
}

Javascript

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

Le variabili utilizzate in 1a e 3a riga sono diverse da quelle usate in 2a e 3a riga.
Uno usa un (U + 0061) mentre l'altro usa un (U + 0430)

Giava:

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 ++" è un errore per principianti abbastanza comune e può essere sorprendentemente difficile da trovare

C ++

Un po 'casuale?

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

Non chiama la funzione randma chiama ricorsivamente la Randomizer::randfunzione.

Haskell

Alcuni codici per calcolare il tempo di un dato valore della funzione Ackermann. Per valori molto bassi di solito termina. Sulla mia macchina valori molto bassi significano qualcosa come 3 5 o più piccolo con codice compilato e-O . In ghci valori bassi significano qualcosa come 3 3.

Il 'simbolo sembra incasinare l'evidenziazione della sintassi, non so perché. In alcuni punti sono necessari, quindi non è possibile rimuoverli tutti.

Modifica- lingua cambiata.

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

Questo provoca un livelock. Il thread di conteggio provoca ripetutamente il rollback del calcolo di Ackermann poiché toccano la stessa TVar.

Java: nessun loop o ricorsione

Ho appena iniziato a studiare espressioni regolari e ho scritto il mio primo programma per verificare se la mia stringa corrisponde a un'espressione regolare.

Sfortunatamente, il programma non produce alcun risultato. Tiene il terminale. Aiuta a trovare il problema. Non ho fatto uso di loop, non vi è alcuna ricorsione. Sono completamente sconcertato.

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

Cosa ho fatto di sbagliato? Perché il mio programma non finisce? Per favore aiuto!

Link Ideone qui .

Questo è uno stupido esempio di catastrofico backtracking . La complessità è O (2 ^{n / 2} ). Mentre il programma potrebbe non funzionare a tempo indeterminato, che sarebbe probabilmente sopravvivono sia vivente e non vivente oggetti in giro e non-così-around .

C

Dovresti avere bisogno solo di uno dei due loop, ma quale ti serve dipende dal tuo compilatore.

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

}

Un semplice superamento dei limiti che reimposta i su un valore non terminante. I compilatori possono differire dal fatto che essi allocare i sopra o sotto un sullo stack, quindi ho incluso sforamenti in entrambe le direzioni.

C / C ++

C ++ consente solo le facili dichiarazioni di variabili in linea utilizzate qui, ma è altrettanto facile fare questo errore nella vecchia 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;
}

Nel ciclo interno, 'j' viene confrontato ma mai incrementato. ("I ++" dovrebbe in realtà essere "j ++"). Questo non è tanto un trucco subdolo, ma più di un vero errore che ho commesso in passato;) Qualcosa a cui fare attenzione.

C #

Di seguito è una semplice classe che esegue un'operazione aritmetica (somma) su un array di input di grandi dimensioni utilizzando un thread in background. È incluso un programma di esempio.

Tuttavia, anche se è abbastanza semplice, non termina mai. Nota che non c'è gioco di prestigio (personaggi simili, punti e virgola nascosti / mancanti, trigrafi ;-), ecc.)

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

Questo è un esempio di un brutto bug del mondo reale che potrebbe apparire anche nel tuo codice. Secondo il modello di memoria .NET e le specifiche C #, un ciclo come quello in WaitAndGetResultpotrebbe non terminare mai a meno che non si specifichi la variabile come volatile, poiché viene modificata da un altro thread. Vedi questa domanda StackOverflow per i dettagli. Il bug dipende dall'implementazione di .NET, quindi potrebbe o meno influire su di te. Ma di solito, l'esecuzione di una build di rilascio su un processore x64 sembra mostrare il problema. (L'ho provato con “csc.exe / o + / debug- infinite.cs” .)