당신의 작업 : 분명히 종료해야하지만 결코 (컴퓨터 충돌의 한도) 결코 끝나지 않는 프로그램을 작성하는 것. 숫자를 추가하고, 무언가를 인쇄하는 등 간단한 작업을 수행해야하는 것처럼 보이게하십시오. 그러나 그것은 무한 루프에 빠지게됩니다.

실제로 예상치 못한 루프에 빠지는 동안 프로그램을 매우 명확하고 간단하게 만드십시오. 유권자 : 그들이 어떻게 "손이 닿았는지"에 대한 답을 판단하십시오!

이것은 인기 콘테스트입니다 : 창의력을 발휘하십시오!

자바 스크립트

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

prompt ()는 문자열을 반환하고 루프는 문자 '1'을 추가하며 100과 같지 않습니다.

씨

C의 세 가지 종류의 while 루프를 보여주는 기본 예제 프로그램입니다.

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

while 루프는 여는 중괄호 앞에 "do"가 없습니다. 이것은 실제로 "x <10) 루프 안에 do-while 루프를 생성하고 다음"null 문 "while 루프로 종료됩니다. 루프 내부에서 x가 증가한 다음 do-while 루프 상태에서 감소하기 때문에 내부 루프는 종료되지 않으므로 외부 루프도 종료되지 않습니다. 끝에있는 "단일 문"루프에는 도달하지 않습니다.

여전히 혼란 스럽다면 여기를보십시오 (codegolf.SE는 스포일러의 코드 블록을 좋아하지 않기 때문에 외부에서 호스팅됩니다).

자바 스크립트

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

변수 게양 : JavaScript는 실제로의 두 번째 정의를 가져 와서 var a = true;함수 맨 위에로 선언 하고 while 루프에 들어갈 때 정의되지 않은 의미로 var a;내 할당을 수정 합니다.a = true;a

씨#

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'이 아니라 소문자 'L'( 긴 데이터 유형) 접미 부가 있는 '20'입니다 . 이 숫자는 6432를 누르지 않고 빠르게 오버플로되지만 빌드 옵션에서 오버플로 검사가 켜지지 않으면 프로그램은 계속 진행됩니다.
현명하게도 Visual Studio 2013 (및 아마도 다른 버전도)은이 코드에 대해 'l'대신 'L'을 사용하도록 권장합니다.

씨

정밀도는 어떻습니까?

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

컴퓨터 메모리에 정수 범위 <0; 3>을 저장해야한다고 상상해보십시오. 이 범위 (0,1,2,3)에는 4 개의 정수만 있습니다. 메모리에 2 비트를 저장하면 충분합니다. 이제 다양한 부동 소수점 숫자 <0; 3>을 저장해야한다고 상상해보십시오. 문제는이 범위에 무한한 부동 소수점 숫자가 있다는 것입니다. 무한대의 숫자를 저장하는 방법? 불가능하다. 한정된 수의 숫자 만 저장할 수 있습니다. 이것이 0.1과 같은 일부 숫자가 실제로 다른 이유입니다. 0.1의 경우 0.100000000000000006입니다. 부동 소수점 숫자를 사용하는 조건에서는 == 또는! =를 사용하지 않는 것이 좋습니다.

HTML / 자바 스크립트

페이지에 입력 상자가 있다고 상상해보십시오.

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

그리고 지금 당신은 그것에 무언가를 입력하고 싶습니다 ... Chrome에서 시도하십시오 : http://jsfiddle.net/jZp4X/ .

alertfunction으로 호출 된 표준 브라우저 대화 상자 는 모달이므로 표시되면 텍스트 상자에서 포커스를 가져 오지만 닫으면 텍스트 상자가 포커스를 다시받습니다.

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 >=0size_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]에 할당하는 대신 시스템 명령을 호출하여 yesfoo [2]를 끝없는 "yes \ n"으로 채 웁니다.

씨

파일에서 문자 "x"가 유실되었습니다. 그것을 찾기 위해 프로그램이 작성되었습니다.

#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로 변경했습니다 . 그는 또한 그들이 음이 아닌 가치를 가지고 있음을 알기에 충분히 아스키를 알고있었습니다. 그래서 그는 또한 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");
  }
}

그는 다음날 혼란에 돌아 왔습니다. 문자 "a"가 누락되었고 "abc"를 포함하는 "desert_file"에 있어야했지만 프로그램이 영원히 인쇄 만 검색했습니다.

Searching file for missing letter a...

그들은 직원을 해고하고 이전 버전으로 롤백하여 작업 코드에서 데이터 유형을 최적화해서는 안된다는 것을 기억했습니다.

그러나 그들이 여기서 배워야 할 교훈은 무엇입니까?

우선, ascii 테이블을 보면 EOF가 없다는 것을 알 수 있습니다. EOF는 문자가 아니라 fgetc ()에서 반환 된 특수 값이기 때문에 int로 확장 된 문자를 반환하거나 파일의 끝을 나타내는 -1을 반환 할 수 있기 때문입니다.
우리가 signed char을 사용하는 한 모든 것이 잘 작동합니다-50과 같은 char은 fgetc ()에 의해 int와 50으로 확장됩니다. 그런 다음 다시 char로 변환하고 여전히 50을 갖습니다. -1 또는 fgetc ()에서 나오는 다른 출력에서도 마찬가지입니다.
그러나 서명되지 않은 문자를 사용하면 어떻게되는지보십시오. fgetc ()에서 char로 시작하여 int로 확장 한 다음 서명되지 않은 char을 원합니다. 유일한 문제는 부호없는 char에서 -1을 유지할 수 없다는 것입니다. 프로그램이 더 이상 EOF와 같지 않은 255로 저장합니다.

경고
ANSI C 문서의 사본 에서 3.1.2.5 유형을 살펴보면 char이 서명되었는지 여부는 전적으로 구현에 달려 있다는 것을 알 수 있습니다. 따라서 코드에 숨어있는 매우 까다로운 버그를 발견했을 때 아마도 그 사람은 약탈해서는 안됩니다. 컴파일러를 변경하거나 다른 아키텍처로 이동할 때 나올 수 있습니다. 그런 경우에 버그가 나면 누가 해고 될지 궁금합니다.)

추신. 프로그램은 Paul A. Carter가 PC Assembly Language에서 언급 한 버그를 중심으로 구축되었습니다.

정규식

적절한 입력으로 다음 정규식을 사용하면 대부분의 역 추적 정규식 엔진이 역 추적 지옥에 빠질 수 있습니다.

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

"Programming Puzzles and Code Golf Stack Exchange - Mozilla Firefox"or 와 같은 간단한 입력 "AVerySimpleInputWhichContainsAnInsignificantSentence."(명확성을 위해 인용 된 문자열)은 대부분의 역 추적 정규식 엔진을 오랫동안 계속 실행하기에 충분합니다.

(\s*\w+)*확장을 허용하기 때문에 \w+\w+\w+... \w+, 정규 표현식 엔진은 기본적으로 단어 문자열을 분할하는 가능한 모든 방법을 시도 합니다 . 이것이 역 추적 지옥의 근원입니다.
쉽게 변경하여 고정 할 수 \s*에 \s+이어서, (\s+\w+)*만 확장 될 수있다 \s+\w+\s+\w+... \s+\w+.

자바 스크립트

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

050은 Javascript에서 8 진 상수이며 10 진수 값은 40입니다.

하스켈

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

생각 해봐! 그것과 같을 것이다 head $ "Hello" ++ (repeat '!'), 즉 그냥 돌아 가야한다 'H'.

하스켈 목록에는 재귀 구조가 있으며 첫 번째 요소가 최상위 요소입니다. 목록에 추가하려면 해당 요소를 모두 풀고 부록을 놓고 들어 올린 요소를 다시 넣어야합니다. 그것은 무한한 목록에서 작동하지 않을 것입니다. 마찬가지로, 무한 목록을 "Hello"되돌 리더라도 마술처럼 등을 돌려 주지 않습니다 . 영원히 걸려요.

Windows에서 Java

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

프로그램은 명령 행에서 걸린 표준 출력 스트림을 사용하여 중단됩니다. Windows의 WinSXS 디렉토리에는 긴 이름을 가진 수천 개의 파일이 있으므로 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;
}

이상한 주석 스타일이 트릭입니다. 힌트 : 3 부작.

자바

나는 자동 박스 최적화의 부작용을 특히 좋아합니다.

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객체는 거의 일반처럼 행동 int한 가지를 제외하고, 여기의 다음 i != max의 for루프는 비교 참조 의 (정체성) Integer개체를하지 가치 (평등). 그럼에도 불구하고 최대 100까지의 값은 JVM의 최적화로 인해 놀랍게도 "작동"합니다. Java Integer는 "가장 일반적인 값"에 대한 객체를 사전 할당 하고 오토 박싱시 재사용합니다. 따라서 최대 100까지의 값은 동일성 <==> 항등입니다.

루비 / 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 에서 올바르게 작동 하며 STDOUT에서 9에서 1로 카운트 다운됩니다. Ruby에서 실행될 때 종료되지 않습니다.

Ruby에서는 0이 잘못된 값이 아닙니다.

자바 스크립트

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

두 루프 모두 동일한 루프 변수를 사용하므로 입력에 따라 내부 루프는 외부 루프가 끝나는 것을 막을 수 있습니다.

씨

0에서 255까지의 모든 ASCII 문자에 대한 코드 테이블을 인쇄해야합니다. 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()파이썬 인터프리터를 종료하는 명령입니다. 이 경우 호출은 함수가 아닌 함수의 표현입니다. exit-discussion을 참조하십시오 . 또는 break더 나은 선택이 될 것입니다.

C ++

고전적인 C ++ 프로그래머의 함정은 어떻습니까?

int main()
{
   bool keepGoing = false;

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

   return 0;
}

자바 스크립트

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

첫 번째 및 세 번째 줄에 사용 된 변수는 두 번째 및 세 번째 줄에 사용 된 변수와 다릅니다.
하나는 사용 (U + 0061)을, 다른 하나는 사용하는 반면 а을 (+ 0430 U)

자바:

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함수 를 호출 합니다.

하스켈

Ackermann 함수의 주어진 값을 계산하기위한 코드입니다. 매우 낮은 값의 경우 일반적으로 종료됩니다. 내 컴퓨터에서 매우 낮은 값은 컴파일 된 코드 및으로 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 계산이 동일한 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 를 종료하지 않는 값으로 재설정하는 간단한 범위 오버런입니다 . 컴파일러들은 할당 여부에 다를 수 있습니다 난을 위 또는 아래 스택에, 그래서 나는 두 방향에서 오버런을 포함 시켰습니다.

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 ++'이어야합니다). 이것은 비열한 속임수가 아니라 과거에 내가 실제로 만든 오류에 가깝습니다.) 조심해야 할 것이 있습니다.

씨#

다음은 백그라운드 스레드를 사용하여 큰 입력 배열에서 산술 연산 (합계)을 수행하는 간단한 클래스입니다. 샘플 프로그램이 포함되어 있습니다.

그러나 매우 간단하지만 종료되지 않습니다. 손이 얇지 않습니다 (캐릭터 모양, 세미콜론 / 숨겨진 세미콜론, ;-) 등).

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”사용 하여 시도했습니다 .)