나는 그것이 아주 멋진 것이라고 생각 직면하게되는 문제점은 만드는 것입니다 통역 A에 대한 튜링 완전한 사용자가 선택한 언어를.

규칙은 간단합니다.

1. 이 도전보다 새로운 언어라도이 언어를 사용하여이 인터프리터를 만들 수 있습니다.
2. 작성중인 언어와 동일하지 않은 한 튜링 완료 언어를 사용할 수 있습니다.
3. 예를 들어 eval 함수를 사용하는 것과 같이 코드를 단순히 평가할 수는 없습니다.
4. 어떻게 접근했는지에 대한 설명은 훌륭하지만 필수는 아닙니다.
5. 바이트 단위로 점수가 매겨집니다.
6. 각 제출물은 완벽하게 작동해야합니다. 즉, 선택한 언어의 모든 기능이 있어야합니다.

간단히 말해서 :

귀하의 임무는 귀하가 선택한 언어로 튜링 완료 언어에 대한 통역사를 만드는 것입니다.

행운을 빕니다!

Brachylog (2) → 통신 후 문제 , 9 바이트

~h=∋ᵐ\cᵐ=

온라인으로 사용해보십시오!

입력은 문자열 목록의 목록입니다. (Wikipedia에 정의 된 Post 서신 문제에서 내부 목록에는 각각 두 개의 요소가 있지만이 프로그램은 실제로 여러 요소에 대한 일반화를 처리 할 수 ​​있습니다.)이 프로그램은 문제에 대한 해결책을 길이 순서대로 해결합니다. 해결책이 발견되었습니다. Post 대응 문제는 Turing-machine을 시뮬레이션 할 수있는 것으로 알려져 있으므로 이에 대한 무차별 강제 해결 솔루션은 Turing complete입니다. 프로그램이 아닌 함수로 실행하면 실제로 의미있는 출력도 생성됩니다.

위의 TIO 링크에있는 프로그램은 [["a","baa"],["ab","aa"],["bba","bb"]]입니다. Wikipedia에서 복사했습니다. 해결책 (프로그램이 상당히 빨리 발견됨)은 ["bbaabbbaa","bbaabbbaa"]입니다.

설명

이것은 Post 서신 문제를 Brachylog로 직접 변환 한 것입니다.

~h=∋ᵐ\cᵐ=
~h         Find {the shortest possible} list which starts with {the input}
  =        and for which all elements are equal
   ∋ᵐ      such that taking an element of each element,
     \cᵐ   and concatenating elements in corresponding positions,
        =  produces a list all of whose elements are equal.

기본적으로, 우리는 반복적으로 입력의 사본을 복사하는 목록을 작성합니다 (가능한 한 적은, 무차별 강요시 가능성을 놓치지 않음을 의미합니다). 각 사본에서 하나의 요소를 가져온 다음 해당 요소를 연결합니다 (Post 서신에서와 같이) 문제).

젤리 → "전치 할 최소값 추가", 5 4 바이트

+"Ṃẞ

온라인으로 사용해보십시오! (시간 초과를 피하기 위해 한 번만 반복 실행)

매우 간단한 Turing-complete 구성 : 정사각형 행렬을 프로그램으로 가져와 사전 반복적으로 가장 작은 행을 식별 한 후 영원히 반복하여 첫 번째 행의 각 요소를 사전 정의 적으로 가장 작은 첫 번째 요소, 두 번째 행의 각 요소를 증가시킵니다. 어휘 적으로 가장 작은 두 번째 요소에 의해 (Jelly 프로그램은 " +"입력에 해당하는 요소를 추가하고 Ṃ{최소 {of 원본}, ẞ루프"입니다. 이것은 이전 프로그램보다 약간 짧은 바이트 Z+ṂZß입니다. 정확히 같은 일을했습니다. 분명히 젤리, 구현 된 언어를 골퍼하는 것이 아닙니다.)

결과 언어는 캥거루 와 거의 같은 이유로 Turing-complete입니다. 각 행의 첫 번째 요소는 건너 뛰기 횟수처럼 작동합니다 (각 명령의 건너 뛰기 횟수는 건너 뛸 때 감소하지만 대신 실행될 때 각 명령의 건너 뛰기 횟수를 늘리고 대신 가장 낮은 건너 뛰기 횟수가있는 명령을 찾습니다) 건너 뛰기 횟수가 0 인 명령보다 똑같습니다). 우리는이 첫 번째 요소가 다른 요소보다 높도록 (각 명령이 각 명령의 다중 집합에 나타나는 횟수를 나타냄) 첫 번째 행이 최소값이되지 않도록합니다. 첫 번째 행의 나머지는 쓰레기 일 수 있습니다. 남아있는 유일한 문제는 동일한 건너 뛰기 횟수를 가진 명령이 주기적으로 순차적으로 실행되는 방식을 모델링하는 것입니다. 그러나 모든 건너 뛰기 횟수에 큰 상수를 곱한 다음 작은 "초기"를 추가하면됩니다. 순위를 매기려면 첫 번째 열로 건너 뜁니다. 이렇게하면 "스킵되지 않은 명령이 순서대로 주기적으로 실행"이 아니라 "첫 번째의 스냅되지 않은 명령 실행"의 순위가 부여되지만 캥거루의 Turing-completeness 구성은 이러한 차이에 신경 쓰지 않습니다.

Conway의 인생 게임을 해석하는 Mathematica, 64 바이트

CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&

Conway의 인생 게임은 튜링 완료된 것으로 알려져 있습니다. 그리고 셀룰러 오토마타는 스티븐 볼프람의 진정한 집착입니다. CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}Conway 's Game of Life의 한 단계에 따라 0과 1의 2 차원 배열을 변환하는 규칙입니다. (기본 배열은이 배열이 가장자리를 감싸고 있기 때문에 실제로는 별개의 원환 체입니다.) ~Nest~##&이 규칙을 함수로 변환 합니다. 이 규칙은 초기 보드 상태 (모든 치수)와 정수 n가 인수로 주어지면 출력합니다. nGame of Life 규칙 의 반복 결과 .

자신의 즐거움을 위해 포장 버전을 사용할 수 있습니다.

b = RandomInteger[1,{50,50}];
Manipulate[ArrayPlot[
  CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&
    [b, n] ]
, {{n,0}, 0, 100, 1}]

50x50 보드에서 100 세대를 스크롤합니다.

Turtlèd 해석 CT , 49 바이트

이 골프를 할 수 있습니다

또한 이것은 유용한 것을 출력하지 않습니다. 주어진 CT 프로그램이 정지하는 경우에만 정지합니다.

이것은 실제로 얼마 전에 만든 것입니다 (지금 골프를 쳤습니다)

!-l[*+.r_]' !l[ l]r[ u.(;d' u)d(1[ r].[ l])( r)+]

작동 방식 :

Turtlèd는 그리드 셀을 사용합니다. "그리드에 무언가 쓰기"라고 말하면 인접한 문자 그룹이 그리드에 배치됩니다. 예

[ ][ ][ ][ ][ ][ ][ ]
[ ][H][E][L][L][O][ ]
[ ][ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ][ ]

프로그램에

데이터가 먼저 입력됩니다 :

!-l[*+.r_]' 

이것은 본질적으로 고양이 프로그램입니다. 입력을 그리드에 씁니다.

그런 다음 명령이 입력됩니다.

!

이 명령으로 수행하는 작업 :

이 명령은 "제작"입니다. 가장 왼쪽의 데이터 비트가 1이면 프로덕션을 데이터 문자열의 끝에 복사합니다. 그렇지 않으면 아무 일도 일어나지 않습니다. 그런 다음 가장 왼쪽에있는 데이터 비트가 제거되고 다음에 가장 왼쪽에있는 데이터 비트가있는 다음 프로덕션을 사용합니다. 데이터 문자열에 비트가 없으면 프로그램이 중지됩니다. 이러한 제작을 수행하는 방법은 제작의 끝과 끝을 개별적으로 처리하는 것입니다. 이것이 우리 프로그램이하는 일입니다. 명령 문자열에서 비트를 데이터 문자열의 끝까지 개별적으로 복사하고 데이터 문자열에서 비트를 개별적으로 삭제합니다.

이 프로그램의 작동 방식에 대해 명령을 입력 한 후 turtle / grid 포인터는 데이터 문자열의 가장 왼쪽 비트로 다시 이동합니다. 그런 다음 루프에 들어갑니다

[ u.(;d' u)d(1[ r].[ l])( r)+]

이 루프에서 수행하는 작업은 가장 왼쪽의 데이터 문자열에서 위로 이동하여 현재 명령 문자 (u.)를 기록합니다. 그것이 프로덕션의 끝인; 인 경우 아래로 이동하여 그 아래 가장 왼쪽에있는 데이터 비트를 삭제하고 위로 이동합니다 ( (;d' u)). 그런 다음 어느 쪽이든 아래로 이동합니다 ( d). 비트가 삭제되지 않았다면 마지막 명령에서 비트를 복사할지 여부를 확인해야합니다. 따라서 가장 왼쪽 데이터 비트이거나이 문자가 1 인 경우 데이터 문자열의 오른쪽 끝으로 이동하고 명령 문자열에서 비트를 복사 한 다음 가장 왼쪽 데이터의 왼쪽 공간으로 다시 이동합니다. 비트 ( (1[ r].[ l])). 이제 가장 왼쪽에있는 데이터 비트 (0) 또는 가장 왼쪽에있는 데이터 비트 중 하나입니다. 그래서 우리는 공간에 있다면 오른쪽으로 움직입니다.( r)). 그런 다음 명령 포인터가 증가하므로 다음 루프 반복에서 다음 명령을 작성합니다. 데이터 문자열이 더 이상 없으면 공간에 있고 루프가 종료된다는 의미입니다. 그렇지 않으면 루프를 다시 실행합니다.

Perl → Three Star Programmer 변형, 26 + 1 = 27 바이트

++$a[$a[$a[$_]]]for@F;redo

온라인으로 사용해보십시오! (이 링크에는 설정된 반복 횟수 후에 프로그램을 종료하고 (TIO가 시간 초과되지 않도록) 헤더가 포함되며, 반복 할 때마다 내부 상태를 인쇄합니다 (관찰 할 수있는 일을합니다).

를 생성 -a하기 전에 (1 바이트 페널티)로 실행하십시오 .-M5.010-aM5.010

특히, 이것은 명령이 공백으로 구분되고 I / O 확장자없이 파일에서 주석이 허용되지 않는 Three Star Programmer를 구현합니다. (이러한 변경 사항은 분명히 언어의 튜링 완성도에 아무런 영향을 미치지 않습니다.) 온라인으로 3 성급 프로그래머에게는 튜링 완성도에 대한 증거는 없지만 튜링 완료입니다 (튜링의 스케치 증명을 공유했습니다) -다른 esoprogrammers와의 완전성,하지만 원래 충격을 얻은 후에 실제로 프로그래밍하는 것이 상당히 쉽다는 것을 알았을 때 언어 작업을 중단했습니다.)

이 프로그램은 실제로 많은 설명이 필요하지 않습니다. Three Star Programmer는 매우 간단한 사양을 가지고 있으며 이는 직접 번역 된 것입니다. 유일한 미묘한 점 @F은 배열 형태의 프로그램에 대한 입력입니다 (이것은 결과입니다 -a). 그리고 redo그것이 암시 루프 (의도 결과에있어로 전체 프로그램을 반복 할 것이다 -a).

x86 어셈블리 (Intel 구문 / MASM) -Brainfuck 2127 바이트.

여전히 골프 가능

.386
.model flat,stdcall
.stack 4096
include \masm32\include\masm32.inc
includelib \masm32\lib\masm32.lib
ExitProcess proto,dwExitCode:dword
.data
bfsrc BYTE 200 dup(0) 
bfcells BYTE 100 dup(0) 
loopStack DD 5 dup(0) 
charBuf BYTE 5 dup(0) 
newline BYTE 10,0 
prompt BYTE "$",0 
hr BYTE 50 dup('-'),0 
space BYTE ' ',0
.code
EvalBf proc
    start:
    invoke StdOut, addr prompt
    invoke StdIn, addr bfsrc,200
    cmp bfsrc,0
    je exit
    mov eax,0 
    mov ebx,0 
    mov ecx,0 
    processInstruction:
    cmp BYTE PTR bfsrc[ebx], '+'
    je plus
    cmp BYTE PTR bfsrc[ebx], '-'
    je minus
    cmp BYTE PTR bfsrc[ebx], '>'
    je fwd
    cmp BYTE PTR bfsrc[ebx], '<'
    je back
    cmp BYTE PTR bfsrc[ebx], '['
    je open
    cmp BYTE PTR bfsrc[ebx], ']'
    je close
    cmp BYTE PTR bfsrc[ebx], '.'
    je dot
    jmp processNextInstruction
    plus:
    inc BYTE PTR bfcells[eax]
    jmp processNextInstruction
    minus:
    dec BYTE PTR bfcells[eax]
    jmp processNextInstruction
    fwd:
    inc eax
    jmp processNextInstruction
    back:
    dec eax
    jmp processNextInstruction
    open:
    mov loopStack[ecx*4],ebx
    inc ecx
    jmp processNextInstruction
    close:
    dec ecx
    cmp BYTE PTR bfcells[eax], 0
    je processNextInstruction
    mov ebx,loopStack[ecx*4]
    inc ecx
    jmp processNextInstruction
    dot:
    mov dl, BYTE PTR bfcells[eax]
    mov BYTE PTR charBuf[0], dl
    mov BYTE PTR charBuf[1],0anything
    push eax
    push ecx
    invoke StdOut, addr charBuf
    pop ecx
    pop eax
    jmp processNextInstruction
    processNextInstruction:
    inc ebx
    cmp BYTE PTR bfsrc[ebx], 0
    je done
    jmp processInstruction
    done:
    invoke StdOut, addr newline
    mov eax, 0
    printNext:
    cmp eax, 100
    jge reset
    push eax
    invoke dwtoa, BYTE PTR bfcells[eax], addr charBuf
    invoke StdOut, addr charBuf
    invoke StdOut, addr space
    pop eax
    inc eax
    jmp printNext
    reset:
    invoke StdOut, addr newline
    invoke StdOut, addr hr
    invoke StdOut, addr newline
    jmp start

    exit:
    invoke ExitProcess,0
EvalBf endp
end EvalBf

순환 태그 시스템을 해석하는 핍 ( 16 바이트)

YqWyyPBg@++vXPOy

stdin에서 태그 시스템의 생성을 명령 행 인수 및 초기 데이터 문자열로 가져옵니다.

위의 코드는 출력을 생성하지 않기 때문에 확인하기가 다소 어렵습니다 (따라서 관찰 가능한 유일한 동작은 "종료"대 "종료하지 않음"). 따라서 각 단계 후에 데이터 문자열을 출력하고 20 단계 후에 종료되는 Tgo는 무한 루프의 수많은 출력을 처리 할 필요가없는 ungolfed 버전입니다. 온라인에서 사용해보십시오!

순환 태그 시스템

순환 태그 시스템은 매우 간단하지만 Turing-complete 계산 모델입니다. 데이터 문자열 에 대한 작업을 정의하는 프로덕션 목록으로 구성됩니다 . 프로덕션 및 데이터 문자열은 1과 0으로 구성됩니다.

각 단계에서 데이터 문자열의 가장 왼쪽 문자가 제거됩니다.

• 문자가 1이면 현재 프로덕션이 데이터 문자열의 오른쪽에 추가됩니다.
• 문자가 0이면 아무것도 추가되지 않습니다.

두 경우 모두 현재 생산이 주기적으로 목록의 다음 생산으로 이동합니다. 마지막 생산 인 경우 첫 생산으로 순환합니다. 데이터 문자열이 비워 질 때까지 실행이 계속됩니다.

설명

                  g is list of cmdline args; v is -1 (implicit)
 q                Read a line of stdin for the data string
Y                 and yank it into the y variable
  Wy              While data string is nonempty:
       g@++v       Retrieve the next production from g (using cyclic indexing)
             POy   Pop the first character of y
            X      String-multiply: result is the production if the first character of y
                   was 1, or empty string if it was 0
    yPB            Push that string to the back end of y

반복 된 일반화 된 Collatz 함수 -> Python 2, 46 바이트

a,b,x,m=input()
while-~x%m:x=x/m*a[x%m]+b[x%m]

이 함수를 m-1 a와 b, 시작 값 x 및 IGCF에 대한 총괄적으로 "프로그램"을 구성하는 제수 m과 함께 호출하십시오. 어떤 모듈러스가 정지되어야 하는지를 표시하기 위해 세 번째 배열을 취하는 대신, 모듈러스가 m-1 일 때마다 정지합니다. 이 단순화는 주어진 Fractran 프로그램을이 변형으로 변환하는 데 약간의 노력이 필요할 수 있지만, 인터프리터에서 몇 바이트를 절약합니다.

온라인으로 사용해보십시오! 이 TIO는이 언어로 5 + 5를 추가하는 방법을 보여줍니다. 프로그램 a = [3], b = [0], m = 2는 더하기를 수행하고 7776 = 2 ^ 5 * 3 ^ 5로 시작하면 결국 59049 = 3 ^ 10이됩니다.

ResPlicate 변형-> Python 2, 47 바이트

l=input()
while l:l=l[2+l[0]:]+l[2:2+l[0]]*l[1]

이 함수는 ResPlicate의 변형을 해석합니다.

• 프로그램은 짝수 인덱스에 짝수 요소가있는 짝수 길이의 파이썬 목록입니다.
• I / O가 없습니다.
• 나머지 큐에있는 것보다 더 많은 값을 복사하려고하면 단순히 큐의 나머지를 복사합니다 (즉, 복사 된 비트는 필요한 길이에 0으로 채워지지 않습니다).

마지막 변경은 첫 번째 조건을 충족하는 일부 ResPlicate 프로그램이이 변형에서 동일하게 작동하지 않지만 BCT 통역사는 제거 된 기능이 필요하지 않으므로 언어는 TC로 유지됩니다.

온라인으로 사용해보십시오! 이 TIO에는 프린트가 작동하고 1 초 후에 프로그램을 종료시키는 헤더와 TIO가 1 초 동안 처리 할 수있는 것보다 많은 출력을 생성하는 예가 표시되어 있습니다.

Perl -a → I / D 머신 , 24 바이트

$p=$a[$p]+=$_ for@F;redo

온라인으로 사용해보십시오! (내부 상태를 인쇄하고 10 회 반복 후 정지되어 동작을 관찰 할 수있는 헤더 포함)

언어에 대하여

지난 며칠 동안 매우 간단한 프로그래밍 언어에 대한 최신 아이디어 중 하나 인 I / D 머신 에서 작업했습니다 . 데이터 스토리지는 무제한 RAM으로 구성되며 처음에는 모두 0입니다. 각 요소는 제한없는 정수를 저장할 수 있습니다 (실제로 대부분의 I / D 머신 프로그램은 대부분 작은 정수만 저장하고 큰 주소를 가진 셀을 주소 지정하는 방법으로 제한되지 않은 정수를 사용합니다). 셀을 가리키는 데이터 포인터도 있습니다 (즉, 주소를 셀로 보유 함). 처음에는 0입니다.

두 가지 명령 만 있습니다 :

• I: 데이터 포인터가 가리키는 셀을 증가시킵니다. 데이터 포인터 자체는 변경되지 않습니다.
• D: 데이터 포인터를 역 참조합니다. 즉, 데이터 포인터가 가리키는 셀의 값을 읽습니다. 그런 다음 읽은 결과 값을 데이터 포인터에 저장하십시오.

실행은 단순히 반복적으로, 반복적으로 프로그램을 실행합니다.

이 단순한 언어가 Turing-complete 언어라는 것이 놀랍습니다. 그래서 나는 그것을 증명하기 위해 노력하고 있습니다. 여기 증거가 있습니다. 이것은 매우 유사한 언어 인 Three Star Programmer의 증거와 비슷하지만 (단순하다) (실제로이 제출물은 실제 명령에서만 다른 프로그램에서 동일한 기본 OISC "쉘"을 사용합니다).

프로그램에 대하여

용법

입력은 표준 입력에 제공되어야하며 주석이없고 RLE / OISC 구문을 사용하는 I / D 머신 프로그램입니다. (I / D 머신에는 서로 다른 두 가지 구문이 있지만 골프에서는이 프로그램 중 하나만 지원합니다.)이 구문에서 프로그램은 I명령 사이의 D명령 실행 길이를 나타내는 10의 숫자 시퀀스입니다 . (두 명령 사이에 " D0 I명령 실행"을 배치하여 둘 이상의 연속 명령을 지정할 수 있으므로 구문은 일반적입니다.)

설명

프로그램에서 볼 수 있듯이 이것은 I및 D명령을 개별적으로 구현하지 않습니다 . 사실, (매우 약간) 최적화 통역사입니다 (순전히 이렇게 작성하는 것이 더 짧기 때문에). 핵심은 n 개의 증가 명령이 데이터 포인터의 목표를 n 번 증가시키는 것 , 즉 n 을 증가시키는 것입니다. 메모리에 0을 추가해도 아무런 영향을 미치지 않으므로 0 증가 명령 실행을 이런 식으로 구현할 수도 있습니다. 따라서 실제로 구현하는 작업은 run-of- Is와 a 구현을 번갈아 수행하는 것 D입니다. 즉, " n을 추가하십시오데이터 포인터가 가리키는 값으로 다시 이동 한 다음 (데이터 포인터가 가리키는 값으로 다시 저장) 데이터 포인터가 가리키는 값을 읽고 데이터 포인터에 저장하십시오. " " 데이터 포인터가 가리키는 값 에 n 을 더한 다음 해당 값을 데이터 포인터의 대상과 데이터 포인터 자체에 저장 하기 위해 이것을 단순화 할 수 있습니다 .

이것이 우리 프로그램의 핵심입니다. 우리는 배열 $a을 사용하여 RAM을 저장 $p하고 데이터 포인터 (배열에 색인화)로 사용합니다.

$p=$a[$p]+=$_
         + $_  add {the run length}
   $a[$p]      to the element of $a pointed to by $p
   $a[$p] =    storing the result back into that element
$p=            and also in the pointer itself

편리하게도 Perl은 초기화되지 않은 배열 요소를 숫자처럼 취급 할 때 0으로 해석하므로 필요한 명시적인 코드없이 배열이 느리게 0으로 초기화됩니다. (하나의 잠재적 인 문제는 숫자가 커질 때 수치 정확도입니다. 그러나 사용되는 배열의 양이 기계의 주소 공간을 초과하는 경우에만 발생합니다 (Perl 정수는 포인터를 보유 할만 큼 충분히 큽니다). 이상적인 기계에서.)

마지막으로이 프로그램을 두 개의 루프에 배치하기 만하면됩니다. for@F과 결합 루프, -a명령 줄 옵션, 표준 입력의 분야에 걸쳐 반복됩니다 ( "필드"의 기본 정의는 여기 공백에 분할됩니다). redo루프 (이외 편리 표준 입력의 판독) 암시 루프에서 전체 프로그램을 배치 할 I / D 시스템의 의미에 의해 요구되는 프로그램이 반복 루프에서 실행하게한다.

젤리 → 2- 태그 시스템 , 8 바이트

µḢị⁴⁸;Ḋß

온라인으로 사용해보십시오!

나는 실용 언어를 선호하는 현상금이 있지만, 원래의 임무를이기려고 할 때 (내 자신의 현상금을 정확하게 얻을 수 없기 때문에) 원래의 과제를 이길 수도 있다고 생각했습니다.

튜링 완전성에 필요하지 않으므로 정지 상태가없는 다양한 태그 시스템을 구현합니다. 상태는 1부터 연속적으로 번호가 매겨지며 초기 문자열은 프로그램 앞에옵니다.

예를 들어, 위키 백과 태그 시스템의 예를 제공 { a, b, c}, { a→ bc, b→ a, c→ aaa} 초기 문자열 aaa; 이 입력 형식에서는 [1,1,1], [[2,3],[1],[1,1,1]]입니다. 태그 시스템에는 고정 된 구문이 없으므로 합리적인 방법으로 보입니다.

TIO 링크에는 Ṅ프로그램이 실제로 작동하고 있음을 보여주기 위해 추가 ( "내부 상태 쓰기 및 stdout에 줄 바꾸기")가 있습니다.

설명

µḢị⁴⁸;Ḋß
           {implicit: initialise internal state from first argument}
µ          Disregard the second command-line argument by default
 Ḣ         Take the first element, removing it from the internal state
  ị⁴       Use the value to index into the second argument
    ⁸;     Prepend (the rest of) the internal state
      Ḋ    Discard the first element of the internal state
       ß   Loop forever

튜링 머신에서 구현 된 BF / P ", 842 바이트

전이 테이블 (길이로 인해 연결됨)

전환 테이블, 덜 골프 버전

내가 사용한 튜링 머신 시뮬레이터

BF는 Turing Machine과 매우 유사하기 때문에 항상 수상하고 싶지는 않지만 항상 원했던 것입니다. 각 셀은 0x0- 의 값을 저장합니다 0xF. 그러나 너비는 Turing Machine 웹 사이트가 브라우저를 손상시키지 않고 멀리 갈 수 있습니다. ,과 .는 약간 더 이상 진정한 BF P '와 같은 그래서 함수 (입력 및 출력)이 정의되지 않는다.

이를 실행하려면 전환 테이블을 Turing Machine 시뮬레이터에 붙여넣고 입력을 일부 BF 코드로 설정 한 후 실행을 누르십시오.

TM의 테이프는 BF 코드와 BF 데이터를 중간에 단일 공백으로 저장합니다. 현재 실행중인 문자 ( [-> (등)와 ^셀 앞의 데이터 위치를 수정하여 코드에서의 위치를 ​​추적 합니다. 명령 문자를 읽으면 캐럿에 도달 할 때까지 이동하고 한 셀을 오른쪽으로 이동 한 다음 적절한 기능을 수행합니다. 그런 다음 BF 코드에서 "수정 된"명령 문자 중 하나를 찾은 후 다음 단계로 이동하여 전체 프로세스를 반복합니다. 코드가 부족하면 중지됩니다.

작동 방식을 이해하는 가장 좋은 방법은 ungolfed 버전을 실행하고, 단계 모드로 설정하고, 어떤 라인이 다른 라인으로 연결되고 각 상태 / 라인 블록이 수행하는 작업을 보는 것입니다.

골프 및 언 골프 버전은 작동 방식 측면에서 정확히 동일하지만 언 골프 버전은 사람에게 친숙한 이름을 가지며 섹션으로 나뉩니다.

C (2,3) Turing Machine 구현 , 236205 바이트 ( 어색한 입력에 신경 쓰지 않으면 46 31 줄임)

-11 바이트의 Appleshell, -12 바이트의 VisualMelon 및 -7 바이트의 Johan du Toit 덕분입니다.

CeilingCat은 144 바이트 만 사용하는 버전을 만들었습니다 ( 여기 참조) .

(여기서 줄 바꿈을 추가 했으므로 스크롤 할 필요는 없지만 일반적으로 대부분 줄 바꿈됩니다)

#define c char
j;i;k;c s,d[256];c main(){c*p=d+128;gets(d);
for(;k<256&&d[k];)d[k++]-=48;for(;++j<256;)
{c t=*p;*p=-t*t+(2-s)*t+1+s;p+=(s^t==0)*2-1;s=s?t%2:!t%3;
for(i=0;++i<256;)printf("%d",d[i]);puts("");}}

온라인으로 사용해보십시오!

사용 방법 : 테이프를 초기화하려면 최대 1, 0, 2의 문자열을 입력하십시오. 초기화되지 않은 값은 0입니다. (0, 1 및 2 이외의 값은 정의되지 않은 동작을 유발할 수 있습니다.) 프로그램은 256 단계를 반복합니다. 코드를 수정하여 반복되는 단계 수를 늘릴 수 있지만 분명히 더 많은 문자가 필요합니다.

꽤 긴 입장이지만, 이것 중 하나를하는 것은 처음이며 나는 전용 골프 언어를 사용하지 않았습니다. 예상보다 길어 지더라도 많은 재미가있었습니다.

많은 바이트가 입력 및 출력을 처리하는 데 있으며 NUL, SOH, STX 대신 0, 1 및 2를 허용하여 전체 42 바이트를 잃었습니다. (이를 변경하려면 k;앞과 for(;k<256&&d[k];)d[k++]-=48;두 번째 줄에서 삭제 하십시오 .)

전이 테이블, 특히 줄 *p=-t*t+(2-s)*t+1+s;(테이프에 값을 설정 하는 행 )을 더 압축 할 수도 있습니다.

로다 구현 Fractran을 , 114 (112) 106 바이트

@fergusq 덕분에 매개 변수를 재정렬하여 1 바이트 절약

f&n,a{x=1{x=0;(a/" ")()|[_/`/`]|[parseInteger(_[0],_1[1])]|{|q,w|{n*=q/w;x=1}if[n%w<1,x<1]}_,_}while[x>0]}

온라인으로 사용해보십시오!

다음과 같이 함수를 호출하십시오 f reference_to_input program. 출력은의 위치에 저장됩니다 input.

클로저, 82 81 바이트 (튜닝 머신)

업데이트 :에서 공백이 제거되었습니다 t{} s.

#(loop[p 0 t{}s 1](if-let[[S M N](%[(or(t p)0)s])](recur(+ p M)(assoc t p S)N)t))

튜링 머신을 루프로 구현하고 정지 상태에 도달하면 테이프를 반환합니다. 상태 전이 규칙에서는 전이 상태를 생략하여 표시됩니다. 이 settins N행 nil이후의 if-let해당 상태 천이와 같은 뜻을 중단 입력 해시 맵에서 발견되지 않는다 %. 실제로이 상태의 값은 :abort, 0 또는 -1과 같습니다.

실시 예 3에서 상태 2 심볼 없음 비버와 Ungolfed 위키 .

(def f #(loop[pos 0 tape {} state 1]
          (if-let [[sym move next-state](%[(get tape pos 0)state])]
            (do (println [pos tape state])
                (recur(+ pos move)(assoc tape pos sym)next-state))
            tape)))

(f {[0 1] [1  1 2]
    [0 2] [1 -1 1]
    [0 3] [1 -1 2] 
    [1 1] [1 -1 3]
    [1 2] [1  1 2]
    [1 3] [1  1]})

{0 1, 1 1, -1 1, -2 1, -3 1, 2 1}

온라인으로 사용해보십시오 .

6700K의 단일 코어에서 이것은 약 29 초 또는 160 만 단계 / 초로 5 개 상태의 2- 기호 바쁜 비버 (47.1 백만 단계)를 실행합니다.

M → 팁 , 4 바이트

Ṅ×ịß

온라인으로 사용해보십시오!

TIO 링크는 Esolang 페이지에 표시된 예제 팁 프로그램을 사용하여 함수를 호출하는 바닥 글을 추가합니다 (M의 "자동 래퍼"는 프로그램이 합리적이거나 고정 소수점 숫자를 처리 할 수 ​​없거나 적어도 내가 가지고있는 것처럼 함수를 호출 함) 방법을 알려주는 방법을 알지 못했기 때문에 함수를 직접 실행할 수 있도록 전체 프로그램으로 기능을 만들어야합니다.)

실제로 유용한 디버그 출력을 인쇄합니다. 정확히 3 개의 다이아 드로 구성된 프로그램이 파서에서 특수한 경우를 트리거하기 때문에 프로그램을 M에서 3 바이트로 쓸 수 없으므로 특수한 경우를 피하기 위해 추가 명령을 추가해야했습니다. 그것을 만들기 Ṅ이상 (개행 문자로 인쇄하는) 그것에게 유용한 목적을 제공합니다.

ı$i=\sqrt{-1}$

정지 / 정지 이외의 I / O를 구현하지 않습니다. I / O는 언어 자체의 일부가 아닌 Tip의 확장이며 Turing-completeness에는 필요하지 않습니다.

설명 / 배경

Ṅ×ịß
Ṅ     Print {the left argument} and a newline; also resolves a parser ambiguity
  ị   {The left argument}th element of {the right argument}, wrapping on OoB
 ×    Multiply {the left argument} by {the chosen element}
   ß  Recursive call; arguments: {the product} and {the same right argument}

[1,2,3][1,2,3,1,2,3,1,2,3,…]$rx+s$는 다항식이며 많은 골프 언어에 내장 된 "기본 변환"은 실제로 가장 일반적인 다항식 평가자입니다. 그래서 우리가해야 할 일은 숫자 목록으로 색인을 작성하고, 그것들을베이스 변환하는 것입니다.

$x$$x$

ḅ$x\oplus(x\otimes y)$$x\otimes y$${\oplus}$. 물론, 우리는 체인 동작을 우리가 원하는 거의 모든 것으로 재정의 할 수는 있지만 전체 바이트가 필요 하며이 질문에 대한 골프 언어 항목이 너무 짧아서 바이트가 많이 있습니다.

그래서 나는 뒤돌아보고 약간 재평가했다. 다항식 평가 대신 사용할 수있는 작업이 있습니까? 이상적으로는 정식적인 것이므로 인수 순서에 대해 걱정할 필요가 없습니까? 그 후 곧 Collatz 기능이 필요 이상으로 복잡하다는 것을 깨달았습니다.

$s$

그리고 물론, 달리 기본 변환 ( ḅ), 곱하기 ( ×) 교환 법칙이 성립하고, 따라서이 인수에 배치 주문할 중요하지 않습니다. 그래서 우리 모두입니다 작성해야 ×ị다음과 무한 재귀으로 프로그램을 배치 ß, 그리고 튜링 완료 언어가 있습니다. 권리?

$(x\odot y)\oplus(x\otimes y)$¹×ịß¹¹Ṅ 유용한 디버그 출력을 생성하기 때문에 좋은 선택입니다.

3 바이트가 가능합니까? 구현 및 구현 언어 의이 특정 선택이 아닌 무언가를 놓치지 않는 한,이 시점에서 어떻게 든 가능할 것 같습니다. 구현할 수있는 언어

C 해석 Brainfuck, 187 바이트

t[999],*p=t,c,i,l;f(char*t){for(i=0;c=t[i];i++){c^62?c^60?c^43?c^45?c^46?c^44?c^91:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==93&&*p)for(l=1;l>0;)c=t[--i],c==91?l--:c==93?l++:0;}}

온라인으로 사용해보십시오

Lua 해석 Brainf ***, 467 바이트

b,r,a,i,n,s=0,io.read,{0},1,1,"><+-.,[]"c,f=r(),{function()n=n+1;a[n]=a[n]or 0;end,function()n=n-1;a[n]=a[n]or 0;end,function()a[n]=a[n]+1;end,function()a[n]=a[n]-1;end,function()io.write(string.char(a[n]))end,function()a[n]=io.read():byte()end,function()i=a[n]~=0 and i or c:find("]",i)end,function()if a[n]~=0 then b,x=1,""repeat i=i-1 x=c:sub(i,i)b=x=="["and b-1 or x=="]"and b+1 or b until b==0 and x=="["end end}repeat f[s:find(c:sub(i,i),1,1)]()i=i+1 until i>#c

나중에 할 수있는 슬리밍이 여전히 있음을 알고 있지만 여기에서 첫 패스가 끝났습니다. 표준 입력에서 brainf 코드를 가져옵니다.

CJam → ResPlicate 변형, 15 14 13 바이트

^{@ ais523 덕분에 -1 바이트}

l~{(/((*+e_}h

변형은 대기열에서 가져온 항목 수가 대기열의 최상위 번호보다 하나가 작다는 점을 제외하고는 이 답변 의 변형과 동일 합니다.

l~{ ... }h일부는 입력으로 배열을 그 배열이 비워 질 때까지 반복한다.

메인 루프에 대한 설명 :

    e# Stack:             | [3 2 1 1 2 2 2 1]
(   e# Pop first element: | [2 1 1 2 2 2 1] 3
/   e# Split chunks:      | [[2 1 1] [2 2 2] [1]]
(   e# Pop first:         | [[2 2 2] [1]] [2 1 1]
(   e# Pop first:         | [[2 2 2] [1]] [1 1] 2
*   e# Repeat array:      | [[2 2 2] [1]] [1 1 1 1]
+   e# Concatenate:       | [[2 2 2] [1] 1 1 1 1]
e_  e# Flatten:           | [2 2 2 1 1 1 1 1]

칩 , 20 + 3 = 23 바이트 (규칙 110)

AZZ
>}/a
`)\'E~Zte*f

깃발 +3 -z

온라인으로 사용해보십시오!

Chip에는 아직 루프 기능이 없기 때문에이 제출물은 완벽하지 않으므로 출력을 다음과 같은 여러 세대를 시뮬레이션하기 위해 입력으로 전달해야합니다 (물론, 루프를 무기한으로 실행할 수 있습니다. Chip은 임의로 긴 입력을 처리 할 수 ​​있으므로이 조합은 Turing Complete입니다.

이 구현은 ASCII 0및 1s 형식으로 입력 및 출력을받습니다 . 여기서 논리는 다음과 같습니다.

p := value of left neighbor cell    AZZ
q := value of current cell          AZ
r := value of right neighbor cell   A

q' := ((r xor q) and p) or          >}/a
      ((r or q) and ~p)             `)\'

나머지 요소는 하우스 키핑 용입니다. e*fASCII 숫자 출력을 발생 E~Zt시키고 입력이 소진 된 후 2 바이트 실행을 종료합니다 (너비가 각 세대마다 2 씩 증가하기 때문에).

클로저, 75 바이트 (사이 클릭 태그 시스템)

업데이트 1 :로 대체 some?되었습니다 nil?.

업데이트 2 :의 S다른 분기에서 누락 된 문제를 해결 했습니다 if s.

#(loop[[p & P](cycle %)[s & S]%2](if(nil? s)S(recur P(if s(concat S p)S))))

순환 태그 시스템을 구현하고 nil프로그램이 중지되면 반환 하고 그렇지 않으면 영원히 반복됩니다. Clojure는 실제로 무한한 게으른 시퀀스 (예 : 사이클 )와 파괴 로 빛납니다 . 1과 0은 true 및 false 값으로 표시됩니다. 데이터 문자열이 소진 s되면이됩니다 nil.

언 골프 드 :

(def f #(loop[[p & P] (cycle %) [s & S] %2 i 5]
          (do
            (pprint [p (concat [s] S)])
            (if (and (some? s) (pos? i))
              (recur P (if s (concat S p) S) (dec i))))))

결과 예 :

(f [[false]] [true true])
[[false] (true true)]
[[false] (true false)]
[[false] (false false)]
[[false] (false)]
[[false] (nil)]

(f [[false true true] [true false] [true false true]] [true])
[[false true true] (true)]
[[true false]      (false true true)]
[[true false true] (true true)]
[[false true true] (true true false true)]
[[true false]      (true false true false true true)]
[[true false true] (false true false true true true false)]

JavaScript 해석 규칙 110 , 131 바이트 (99 바이트?, 28 바이트?)

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}
c=(l,n)=>!n?l:c(b(0+l+0),n-1)

당신이 볼 수 있듯이, 코드는 3 개 기능을 정의하고 a, b하고 c. 아마도 1 함수로 바이트를 결합하여 바이트를 절약 할 수는 있지만 (어떻게 보지는 않습니까?) 각각 이미 어떤 의미 에서이 과제를 수행하기 때문에 별도의 것이 좋습니다.

함수 a는 3 개의 숫자를 입력으로 받아서 이상한 다항식을 계산합니다. 이 3 개 개의 숫자가있는 경우 0또는 1그들은 규칙 110 세포로 볼 벌 수 있습니다. 출력의 패리티 a는 다음 세대의 중간 셀 값으로 볼 수 있습니다. 어떤 의미에서이 간단한 함수는 이미 Rule 110 'interpreter'(28 바이트)입니다.

a=(p,q,r)=>(q+r+q*r+p*q*r)%2

그런 다음 1과 0으로 구성된 문자열의 모든 문자 b를 평가 하는 새로운 함수를 만들 수 있습니다 a. 그러면 이는 규칙 110 해석기 b보다 나은 방법 a입니다. 저장 괄호 (99 바이트)를 평가 한 후 mod 2 사용 :

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}

실제로 Rule 110을 사용하여 함수를 계산하려면 사용자는 시작 상태와 출력이 '표시'되는 이후 세대 수를 지정해야합니다. 우리는 c1과 0의 문자열을 갖는 세 번째 함수 와 양의 정수를 가져 와서 문자열 n을 평가 b합니다 n. 이와 같이 우리는 실제로 규칙 110을 프로그래밍 언어로 볼 수 있는데, 여기서 프로그램은 초기 상태 및 숫자 n이며 출력은 n생성 후 상태 입니다. 이 함수 c는 이제 해당 프로그래밍 언어의 실제 해석기이므로이 과제의 최종 코드는 위에서 제시 한 것입니다.

JS-> 줄 바꿈 854 바이트

(function(d){var b=0;var n=!0;var c=[];var h=[];var e=0;var l=[];var m=0;var f=2;var a=0;var g=!1;var k=function(a){if(a===1)return!1;if(a%2===0&&a!==2)return!1;if(a%3===0&&a!==3)return!1;if(a%5===0&&a!==5)return!1;if(a%7===0&&a!==7)return!1;for(var b=7;b<d.round(d.sqrt(a))+1;b++)if(a%b===0)return!1;return f=a,!0;};var j=0;var i=0;var o=function(q){var o=d.__split(q,'\n');d.println(o);for(var n=0;n<o.length;n++)if(n>=f^2&&n<=f+1^2&&k(n)){f=n;for(var p=0;p<o[n].length;p++){if(o[n]==='+'&&(a+=c[b],b++),o[n]==='-')if(g===!0&&a<=0)break;else a-=c[b],b++;if(o[n]==='*'&&(a*=c[b],b++),o[n]==='/'&&(a/=c[b],b++),o[n]==='s'&&(a=d.sqrt(a)),o[n]==='%'&&(a%=c[b],b++),o[n]==='a'&&l.push(a),o[n]==='g'&&(a=c[b],b++),o[n]==='q'&&c.push(a),o[n]==='i'&&a++,o[n]==='d')if(g===!0&&a<=0)break;else a--;o[n]==='r'&&(g=!0),o[n]==='w'&&(g=!1),o[n]==='['&&(j=n),o[n]===']'&&a>0&&(n=j,h[e]--),o[n]==='{'&&(i=n),o[n]==='}'&&h[e]>0&&(n=i,h[e]--),m=a,o[n]==='k'&&e++;}}};});

구글 덕분에 슈퍼 골프.

클로저, 87 바이트 (규칙 110)

패리티 코드에 대한 크레딧은 Jens Renders로갑니다! 나는 이것을 표현하는 방법에 정말로 어려움을 겪고 있었고 [p q r]바이너리에서 정수 로 변환 하고 룩업 테이블을 사용하려고했습니다.

#(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%)

다음 partition과 Clojure에서의 destructuring는 논리 응용 프로그램은 매우 간단합니다. 이 함수는 무한한 상태 시퀀스를 반환하므로 호출자는 take필요한만큼 또는 nth특정 상태로 건너 뛰어야합니다. 패딩이 0이 아닌 하나의 요소가 아닌 두 개의 요소 인 경우 경계 문제를 피하면서 테이프가 지속적으로 커집니다. 이제 원래 너비를 유지합니다.

예:

(def f #(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%))

(pprint (take 5 (f '(0 0 0 0 0 1 1 1 0 0 1 0 0))))
((0 0 0 0 0 1 1 1 0 0 1 0 0)
 (0 0 0 0 1 1 0 1 0 1 1 0 0)
 (0 0 0 1 1 1 1 1 1 1 1 0 0)
 (0 0 1 1 0 0 0 0 0 0 1 0 0)
 (0 1 1 1 0 0 0 0 0 1 1 0 0))

APL (Dyalog) → Fractran 변형, 15 바이트

(⊃0~⍨××0=1|×)⍣≡

온라인으로 사용해보십시오!

이 함수는 분자와 분모를 포함하는 두 목록이 아니라 숫자 목록으로 유리수를 취하고 프로그램이 종료되면 결과를 출력합니다. 이것은 프로그램 끝에서 유리한 1/1 (= 1)을 갖는 Fractran의 변형을 구현합니다. 1은 Turing-completeness에 영향을 미치지 않습니다 (내가 이해하는 한) 프로그램에 대한 입력은 다른 합리성이 작동하지 않을 때 1에만 도달하기 때문에 입력이 변경되지 않기 때문입니다. 이것은 함수가 종료시기를 알 수 있도록하기 위해서만 사용됩니다.

TIO 링크는 첫 번째 입력에서 2 회 반복 (프로그램이 종료되지 않은 상태에서 출력을 볼 수 있도록)하는 기능을 실행하고 완료 될 때까지 두 번째 입력을 실행 한 후 출력을 반환합니다.

(⊃0~⍨××0=1|×)⍣≡ 합리적 목록을 왼쪽 인수로, ⊣으로, 입력을 오른쪽 인수로, ⊢로

(⊃0~⍨××0=1|×) 기능 기차

• 1|××⊣와 ⊢ 의 곱 의 소수점 (모듈로 1) 뒤 부분을 얻는다

• 0= 0과 같습니까?

• ×× 이 결과에 ⊣ × ⊢를 곱하면 유리수 × ⊢가 정수가 아닌 경우 0으로 대체됩니다

• 0~⍨ 0을 모두 제거

• ⊃ 첫 번째 요소를 얻다

⍣≡입력이 변경되지 않을 때까지 루프 하십시오. 결과 (⊃0~⍨××0=1|×)는 입력으로 재사용되므로 변경이 중지되면 (1의 결과로) 프로그램이 중지됩니다.

자바 스크립트 : Lambda Calculus ( 123114 )

Duples에서 Debruijn 지수를 사용하여 나타냅니다.

V=function b(c,d){if(!isNaN(c)){for(;--c;)d=d[1];return d[0]}return 0==c[0]?e=>b(c[1],[e,d]):b(c[0],d)(b(c[1],d))}

S 결합기는 [0, [0, [0, [[3, 1], [2, 1]]]]]

K는 [0, [0, 2]]

나는 [0, 1]

편집 :로 교체 "number"==typeof c하여 9 바이트 면도!isNaN(c)

APL (Dyalog Unicode) , 15 바이트 ^SBCS

일반화 된 1 차원 셀룰러 오토 마톤 실행기를 구현하는 전체 프로그램. 여기에는 튜링 완료 규칙 110 이 포함 됩니다. 초기 상태, 반복 횟수 (또는 ≡안정 될 때까지 계속하거나 안정 될 때까지 {⍵≡⎕←⍺}모든 중간 값을 표시) 및 규칙 세트를 요구합니다.

⎕∊⍨∘(⊢∘⊂⌺3)⍣⎕⊢⎕

온라인으로 사용해보십시오! (규칙 110의 4 번 반복)

⎕ 초기 상태에 대한 프롬프트 및

⊢ 수율 (반복 횟수와 상태를 분리)

⍣⎕ 반복 횟수를 묻고 다음 기능을 여러 번 적용하십시오.

 (… ) 다음 암묵적 기능을 적용하십시오.

  ⌺3 모든 길이-3 이웃 (가장자리에 있는지 여부에 대한 정보 포함)을 가져 와서 각 쌍에 다음 암묵적 기능을 적용하십시오.

   ⊂ 이웃을 동봉하다

   ∘ 과

   ⊢ 양보하십시오 (가장자리에 관한 정보를 버림)

 ∘ 그때

 ∊⍨ 그들이 회원인지 확인

 ⎕ 다음 반복에서 켜질 이웃 목록을 묻습니다.