이 과제에서 사용자는 점차 더 오래된 프로그래밍 언어로 세 가지 매우 간단한 코딩 작업을 차례대로 완료하게됩니다.

첫 번째 답변은 2015 년에 작성된 프로그래밍 언어를 사용해야합니다. 2015 년 언어에서 하나 이상의 답변이 있으면 2014 년에 작성된 프로그래밍 언어를 사용할 수 있습니다. 마찬가지로 2013 년의 언어를 사용하는 답변은 허용되지 않습니다. 적어도 2014 년 답변이 될 때까지

일반적으로 Y + 1 년의 언어를 사용한 답변이 제출 될 때까지 Y 년의 프로그래밍 언어를 사용할 수 없습니다. 유일한 예외는 Y = 2015입니다.

언어의 해 찾기

이 질문에 대답하려면 프로그래밍 언어가 "제조 된"연도를 알아야합니다. 물론 이것은 주관적인 용어입니다. 일부 언어는 여러 해에 걸쳐 개발되었으며 매년 많은 언어가 계속 업그레이드되고 있습니다. 언어가 "만들어진"연도가 일반 대중에게 해당 언어의 구현이 처음으로 등장하게하십시오.

예를 들어, 파이썬은 "만들어"한 1991 개발은 1989 년부터 진행되고 있었고, 버전 1.0 1994 년까지 발표되지 않았다 불구하고.

올해가 여전히 주관적이라면, 상식을 사용하여 가장 적합한 연도를 선택하십시오. 연도 선택에 대한 약간의 의견 차이에 얽매이지 마십시오. 귀하의 언어가 언제 만들어 졌는지를 알려주는 링크를 제공하십시오.

프로그래밍 언어 (예 : Python 1, 2, 3)의 다른 버전 또는 표준은 동일한 초기 연도를 가진 동일한 언어로 계산됩니다.

따라서 귀하의 언어 연도가 2015 년이 아닌 한, 귀하의 언어 연도가 귀하의 직전 연도 인 답변이 제출 된 후에 만 ​​답변을 제출할 수 있습니다.

귀하와 같은 연도의 유효한 답변이 이미 존재하는 경우 답변 할 수 있습니다. 귀하의 언어가 그해 초에 개발되었는지는 중요하지 않습니다.

작업

작업 1-3을 완료해야합니다. 작업 0은 선택 사항입니다.

이러한 작업은 프로그래밍의 세 가지 중요한 측면 인 출력 제공 (작업 1), 반복 (작업 2) 및 재귀 (작업 3)에 해당하도록 다소 선택되었습니다.

작업 0-언어 기록 (선택 사항)

선택한 프로그래밍 언어의 역사를 설명하는 단락을 작성하십시오. 언어를 개발 한 사람, 이유, 방법 등. 언어가 등장했을 때 개인적으로 주변에 있었고 심지어 개발에 참여한 경우 특히 권장됩니다. 언어가 당신이나 당신의 직업 또는 그와 유사한 것에 미치는 영향에 대한 개인적인 일화를 자유롭게 느끼십시오.

많은 연구를하지 않고 언어의 역사에 대해 많이 알기에는 너무 어리다면, 나이 많은 사용자에게 게시물을 편집하고 직접 역사에 추가 할 수 있다는 메모를 남기십시오.

작업 1- "Hello, World!" 다른

인쇄하는 프로그램 작성

[language name] was made in [year made]!

언어의 표준 출력 영역 (가장 최근의 언어에 대해서는 표준)으로

예를 들어, 언어가 Python 인 경우 출력은 다음과 같습니다.

Python was made in 1991!

작업 2-ASCII Art N

사용자가 홀수 양의 정수로 입력 할 수있는 프로그램을 작성하고 (입력이 항상 유효하다고 가정 할 수 있음) 문자를 사용하여 작성된 ASCII 아트 문자 N을 인쇄합니다 N.

입력이 1이면 출력은 다음과 같습니다.

N

입력이 3이면 출력은 다음과 같습니다.

N N
NNN
N N

입력이 5이면 출력은 다음과 같습니다.

N   N
NN  N
N N N
N  NN
N   N

입력이 7이면 출력은 다음과 같습니다.

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

패턴은 이와 같이 계속됩니다. 출력에는 후행 공백이 포함될 수 있습니다.

작업 3- GCD

사용자가 두 개의 양의 정수를 입력 할 수있게하는 프로그램을 작성하고 (입력이 항상 유효하다고 가정 할 수 있음) 최대 공약수를 인쇄합니다 . 이것은 나머지를 남기지 않고 두 숫자를 나누는 가장 큰 양의 정수로 정의됩니다. 유클리드 알고리즘을 사용하여 쉽게 계산할 수 있습니다 .

예 :

8, 12→ 4
12, 8→ 4
3, 30→ 3
5689, 2→ 1
234, 876→6

내장 함수를 사용할 수 있지만 언어의 첫 번째 버전에 있는지 확인하십시오. 그렇지 않으면 사용하지 마십시오.

규칙

• 여러 번 답변 할 수 있지만, 각각의 새 답변은 마지막 답변에서 해당 언어보다 5 년 이상 전에 작성된 언어를 사용해야합니다. 따라서 2015 년 언어로 답변 한 경우 2010 년 언어가 허용 될 때까지 다시 답변 할 수 없습니다. 2010 년 답변으로 시작하면 2015 년이 2010 년 이전이 아니므로 2015 년 답변을 두 번째 답변으로 만들 수 없습니다.
• 가능하면 언어의 첫 번째 버전 (또는 가능한 한 오래된 버전)에서 작동하도록 코드를 작성하십시오. (일부 언어의 오래된 컴파일러 / 통역사를 찾는 것이 어려울 수 있으므로 이것은 필수 사항이 아닙니다.)
• 게시 된 답변에 중대한 오류가 있거나 작업을 수행하는 방법이 매우 다른 경우가 아니면 이미 게시 된 언어를 게시하지 마십시오.
• 코드를 골퍼하는 것은 좋지만 필수는 아닙니다.
• 모든 프로그램의 출력에서 ​​후행 줄 바꿈이 좋습니다.
• 작업 2와 3의 경우 2 ¹⁶ 과 같이 합리적인 최대 값 이하의 모든 입력 값 이 작동해야합니다 (최소한 256).
• 이 질문을 게시하기 전에 귀하의 언어가 존재해야합니다.
• 아주 오래된 프로그래밍 언어는 오늘날 우리가 생각하는 것과 다른 형태의 입력 및 출력을 가질 수 있습니다. 이건 괜찮아. 귀하의 언어 상황에서 귀하의 능력을 최대한 발휘하기 위해 과제를 완료하십시오.

채점

제출 점수는 다음과 같습니다.

upvotes - downvotes + (2015 - languageYear) / 2 

따라서 2015 년 이전 매년 투표 수에 0.5가 추가되어 이전 언어에 유리합니다. 가장 높은 점수를받은 제출이 승리합니다.

답변 목록

아래의 스택 스 니펫은 언어 연도에 따라 유효한 모든 답변을 나열합니다.

이 마크 다운 줄로 게시물을 시작해야 올바로 표시됩니다.

#[year] - [language name]

예를 들면 다음과 같습니다.

#1991 - Python

언어 이름은 링크에있을 수 있습니다 (답변 목록에서 동일한 링크가 됨).

#1991 - [Python](https://www.python.org/)

이 형식을 따르지 않거나 아직 허용되지 않은 1 년이 있거나 지난 5 년 동안 이미 응답 한 사용자의 답변은 유효하지 않은 것으로 표시됩니다.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>$(function(){function e(e,r){var a="https://api.stackexchange.com/2.2/questions/48476/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!YOKGPOBC5Yad160RQxGLP0r4rL";$.get(a,r)}function r(e){if(e.items.forEach(function(e){var r=e.link,a=e.owner.display_name,i=e.body.match(/<h1\b[^>]*>(\d{4}) - (.*?)<\/h1>/);if(i&&i.length>=3)var h=parseInt(i[1]),u=i[2];h&&u&&n>=h&&h>=t&&(!d.hasOwnProperty(e.owner.user_id)||d[e.owner.user_id]-h>=p)?(d[e.owner.user_id]=h,h==t&&--t,o.hasOwnProperty(h)||(o[h]=[]),o[h].push({language:u,user:a,link:r,score:e.score+(n-h)/2})):s.push(' <a href="'+r+'">'+a+"</a>")}),e.has_more)runQuery(++a,r);else{for(var i=n,h=[];o.hasOwnProperty(i);){for(var u=$("<tr>").append($("<td>").text(i.toString())),l=$("<td>"),c=$("<td>"),g=$("<td>"),f=0;f<o[i].length;f++){var v=o[i][f];l.append(v.language),c.append($("<a>").html(v.user).attr("href",v.link)),g.append(v.score),f+1<o[i].length&&(l.append("<br><br>"),c.append("<br><br>"),g.append("<br><br>"))}u.append(l).append(c).append(g),h.push(u),--i}$("#answers").find("tbody").append(h),s.length>0?$("#invalid").append(s):$("#invalid").remove()}}var a=1,n=2015,t=n-1,p=5,o={},s=[],d={};e(1,r)})</script><style>html *{font-family: Helvetica, Arial, sans-serif;}table{border: 4px solid #a4a; border-collapse: collapse;}th{background-color: #a4a; color: white; padding: 8px;}td{border: 1px solid #a4a; padding: 8px;}div{font-size: 75%;}</style><table id='answers'> <tr> <th>Year</th> <th>Language</th> <th>User (answer link)</th> <th>Score</th> </tr></table><div id='invalid'><br>Invalid Answers:</div>

2013 년-Dogescript

Dogescript 는 Zach Bruggeman이 2013 년에 만든 언어입니다. 그것은 자바 스크립트가 밈적 시바이 누스 (Shiba Inus)의 내부 독백처럼 읽히도록하는 구문 대체에 지나지 않습니다.

안녕 총독

console dose loge with "Dogescript was made in 2013!"

ASCII 아트

such N much N
          much i as 0 next i smaller N next i more 1
              very doge is ("N" + " ".repeat(N-2) + "N").split('')
              s[i] is "N";
              console dose loge with doge.join('')
                              wow
                                      wow

GCD

such gcd_doge much doge, dooge
    rly dooge
              gcd_doge(dooge, doge % dooge)
  but
    rly doge smaller 0
           -doge
    but
          doge
  wow
        wow

2015- 레티 나

Retina는 정규식 기반 프로그래밍 언어로, 일부 호스트 언어로 정규식을 호출하는 불필요한 오버 헤드없이 정규식 전용 답변으로 PPCG 과제에서 경쟁 할 수 있다고 썼습니다. 망막은 튜링 완료입니다. 이를 입증하기 위해 규칙 110뿐만 아니라 2 태그 시스템 솔버를 구현 했습니다 . C #으로 작성되므로 .NET 플레이버 (기본적으로)와 ECMAScript 플레이버 (플래그를 통해)를 모두 지원합니다.

Retina는 여러 모드에서 작동 할 수 있지만 가장 관련성이 높은 계산 (및 Turing-complete 모드)은 바꾸기 모드입니다. 바꾸기 모드에서는 Retina에 짝수의 소스 파일을 제공합니다. 그런 다음 쌍을 이루고 각 쌍 중 첫 번째는 정규식이고 두 번째는 대체입니다. 그런 다음 순서대로 입력을 조작하여 순서대로 실행됩니다. 정규식 앞에 구성이 올 수도 있습니다 (로 구분 `). 가장 중요한 옵션 (Retina Turing-complete)은 +결과가 변경을 멈출 때까지 Retina가 루프에 교체를 적용하도록합니다. 다음 예제에서는 ;중간 단계의 출력을 억제하는을 사용 하고 있습니다.

다음 각 제출에서 각 라인은 별도의 소스 파일에 들어갑니다. 또는 새 -s옵션을 사용하여 모든 줄을 단일 파일에 넣을 수 있습니다 . 빈 파일 / 줄은로 표시됩니다 <empty>. 단일 공백을 포함하는 파일 / 줄은로 표시됩니다 <space>.

설명은 매우 길기 때문에 글의 끝 부분으로 옮겼습니다.

프로그램

"안녕하세요, 월드!" 다른

<empty>
Retina was made in 2015!

ASCII 아트 N

이것은 STDIN이 개행으로 종료된다고 가정합니다.

;`^
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
N
;`.(?<=(?=(.*\n)).*)|\n
$1
;`N(?=N\n.*\n.*\n`$)
<space>
;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>
;`(?<=^.*\n.*\nN)N
S
;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S
S
<space>

GCD

이를 위해서는 STDIN이 개행으로 종료 되지 않아야 합니다.

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1
;`^(.+)\1* \1+$
$1
;`$
#:0123456789
;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3
#|:.*
<empty>

설명

"안녕하세요, 월드!" 다른

이것은 매우 사소한 것입니다. 입력을받지 않고 (즉, 빈 문자열) 아무것도 일치하지 않고로 대체합니다 Retina was made in 2015!. [\s\S]*예를 들어 패턴을 대체하여 임의의 입력에 적합하게 만들 수도 있습니다 . 그것은 STDIN을 비방하고 모든 것을 출력으로 대체합니다.

ASCII 아트 N

여기에는 많은 단계가 있습니다. 아이디어는 입력을 단항으로 변환하고 Ns 의 N x N 블록을 만든 다음 두 개의 삼각형을 " 개조 "하는 것입니다. 개별 단계를 살펴 봅시다. 기억 ;단지 중간 출력을 억제하지만, +교체가 루프에 적용시킨다.

;`^
#

단순 : #입력 앞에 a 를 붙 입니다. 단항으로 변환 할 때 마커로 사용됩니다.

;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#

한 자리를 단항으로 변환합니다. 이미 변환 된 숫자를 가져 (\d*)와서 10 번 반복합니다. 그런 다음 다음 자리를 가져 와서 적절한 자리 수를 추가합니다. 이 단계에서 숫자의 실제 값은 관련이 없습니다. (가) 때 #숫자의 끝에 도달, 정규식은 더 이상 일치하지 않으며, 변환이 이루어집니다. 예를 들어 숫자 127는 다음과 같이 처리됩니다.

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

마지막 줄은 정확히 127 자리 문자를 포함합니다.

;`#
<empty>
;`\d
N

그것을 없애고 #모든 숫자를로 변환 하는 두 개의 간단한 단계 N. 다음에서는 입력 7을 예로 사용하겠습니다 . 이제 우리는

NNNNNNN

다음 단계

;`.(?<=(?=(.*\n)).*)|\n
$1

각 N문자열을 전체 문자열로 바꾸고 (마지막 줄 바꿈이 포함되어 있음) 후행 줄 바꿈 자체도 제거합니다. 따라서 이것은 단일 행을 사각형 격자로 바꿉니다.

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

이제 위쪽 삼각형입니다. 먼저 오른쪽 하단의 N을 공백으로 바꿔서 시작합니다.

;`N(?=N\n.*\n.*\n`$)
<space>

미리보기를 통해 올바른를 수정하고 N있습니다. 이것은 준다

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

그리고 지금

;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>

N공백 문자의 왼쪽 위 또는 위에있는 것과 일치하는 정규 표현식 으로 공백으로 바꿉니다. 교체가 반복되기 때문에 이는 기본적으로 홍수로 채워져 3 번째 옥탄트를 초기 공간에서 더 많은 공간으로 바꿉니다.

N     N
NN    N   
NNN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

마지막으로 아래쪽 삼각형과 같은 것을 반복하지만 다른 문자를 사용하므로 이미 존재하는 공간으로 인해 잘못된 채우기가 발생하지 않습니다.

;`(?<=^.*\n.*\nN)N
S

씨앗을 설정합니다 :

N     N
NN    N   
NSN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

그때

;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S

홍수로 가득 차 있습니다.

N     N
NN    N   
NSN   N
NSSN  N
NSSSN N
NSSSSNN
NSSSSSN

그리고 마지막으로

S
<space>

그것들 S을 공백으로 바꾸고 우리는 끝났습니다.

N     N
NN    N   
N N   N
N  N  N
N   N N
N    NN
N     N

GCD

단항 GCD는 실제로 정규식에 매우 사소합니다. 이것의 대부분은 10 진수를 1 진수로 변환하고 1 진수를 10 진수로 변환하는 것으로 구성됩니다. 이것은 더 간결하게 수행 할 수 있지만 이것은 코드 골프가 아닙니다. 그래서 ...

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1

이 단계는 두 입력 숫자가 모두 변환되고 결과가 1s 대신 s를 사용한다는 점을 제외하고는 본질적으로 위와 동일 N합니다 (중요하지 않음). 입력 값이 18 24이면

111111111111111111 111111111111111111111111

지금

;`^(.+)\1* \1+$
$1

전체 GCD 계산입니다. 우리는 여러 개의 1s 를 캡처 한 다음 역 참조를 사용하여 해당 문자열을 반복하여 두 숫자를 모두 쓸 수 있도록 공통 제수 를 찾습니다. 정규식 엔진에서 역 추적이 작동하는 방식 (예 : .+욕심 많은)으로 인해 항상 최대 공약수를 자동으로 산출합니다 . 경기는 전체 문자열을 다루므로 GCD를 얻기 위해 첫 번째 캡처 그룹을 다시 작성하기 만하면됩니다.

마지막으로, 단항에서 10 진수로의 변환 ...

;`$
#:0123456789

마커 #, 구분 기호 :및 모든 숫자를 문자열에 추가하십시오. 정규식 대체에서 조건부로 새 문자를 생성 할 수 없기 때문에이 작업이 필요합니다. 조건부 교체를 원하는 경우 문자열 자체에서 문자를 가져와야합니다.

;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3

이것은 단항 확장의 역수입니다. 현재 문자열에 맞는 10의 가장 큰 배수를 찾습니다. 그런 다음 나머지를 기준으로 다음 숫자를 선택하고 숫자를 통해 마커를 이동하면서 배수를 10으로 나눕니다.

#|:.*
<empty>

마지막으로 마커, 구분 기호 및 도우미 숫자를 제거하는 정리 단계입니다.

2013-스냅 !

스냅 ! Berkeley University에서 만든 Scratch 기반 언어입니다 . 일류 데이터와 맞춤형 블록 (기능)을 갖춘 Scratch로 업그레이드되었습니다. 스크래치와 마찬가지로 텍스트 기반이 아니라 시각적 인 "블록"으로 구성됩니다.

스냅 ! 는 JavaScript로 작성되었으며 Squeak Smalltalk로 작성된 BYOB의 후속 버전입니다. 스냅 ! 2013 년 3 월 공개 소 비용 베타 버전이 출시되었습니다 .

스냅 ! 실제로 난해한 언어가 아닙니다. 버클리 등에서 BJC (Beauty and Joy of Computing) AP CS 과정 의 프로그래밍 언어로 사용됩니다 .

나는 테스트와 물건을 도와주었습니다.

"Hello World"변형

ASCII 아트 "N"

이것은 일부 블록에 stdlib를 사용합니다.

꽤 기본적인 반복입니다. 입력을받습니다. 그런 다음 모두 함께 추가하고 말합니다 (n = 5의 결과).

Snap! 때문에 자유 대신 1 대신 2 공백을 사용했습니다. 단일 공간에서 물건을 말하지 않습니다.

GCD

유클리드 알고리즘은 빠르지는 않지만 작동하지만 매우 간단합니다. (죄송합니다. 블록 이름을 오타로 만들었습니다. 이제 저장하지 않고 탭을 닫았습니다. 그대로 두어야합니다.)

이 함수 정의는 다음 블록을 생성합니다.

2007-LOLCODE

언어 역사

LOLCODE는 2007 년 Lancaster University의 연구원 인 Adam Lindsay에 의해 만들어졌습니다. 이 구문은 Cheezburger, Inc.가 대중화 한 막대 사탕 밈을 기반으로합니다.

"안녕하세요, 월드!" 다른

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII 아트 N

HAI

BTW, read n from stdin
GIMMEH n

BTW, convert n from YARN to NUMBR
n R PRODUKT OF n AN 1

BOTH SAEM n AN 1, O RLY?
    YA RLY
        VISIBLE "N"
    NO WAI
        VISIBLE "N"!

        I HAS A butt ITZ 1
        IM IN YR toilet UPPIN YR butt TIL BOTH SAEM butt AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR toilet

        VISIBLE "N"

        I HAS A kat ITZ 2
        IM IN YR closet UPPIN YR kat TIL BOTH SAEM kat AN n
            VISIBLE "N"!
            BOTH SAEM kat AN 2, O RLY?
                YA RLY
                    VISIBLE "N"!
                NO WAI
                    I HAS A doge ITZ 1
                    IM IN YR l00p UPPIN YR doge TIL BOTH SAEM doge AN DIFF OF kat AN 1
                        VISIBLE " "!
                    IM OUTTA YR l00p
                    VISIBLE "N"!
            OIC

            I HAS A brd ITZ 1
            IM IN YR haus UPPIN YR brd TIL BOTH SAEM brd AN DIFF OF n AN kat
                VISIBLE " "!
            IM OUTTA YR haus

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

        I HAS A d00d ITZ 1
        IM IN YR lap UPPIN YR d00d TIL BOTH SAEM d00d AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR lap

        VISIBLE "N"
OIC

KTHXBYE

값을 사용하여 stdin에서 문자열 (YARN)로 읽습니다 GIMMEH. 1을 곱하여 숫자 (NUMBR)로 변환 할 수 있습니다.

를 사용하여 값을 표준 출력으로 인쇄합니다 VISIBLE. 기본적으로 줄 바꿈이 추가되지만 느낌표를 추가하여 줄 바꿈을 억제 할 수 있습니다.

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

I HAS A d00d ITZ 1
IM IN YR food UPPIN YR d00d TIL BOTH SAEM b AN 0
    I HAS A kitty ITZ a
    I HAS A doge ITZ b
    a R doge
    b R MOD OF kitty AN doge
IM OUTTA YR food

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH 문자열 연결을 수행합니다.

1982- 포스트 스크립트

PostScript는 벡터 그래픽을 만들고 인쇄하기위한 언어입니다.

Adobe는 1982 년에 설립되었으며 첫 제품은 PostScript입니다. 프린터에서 사용 된 언어 : 프린터에서 명령을 해석하여 래스터 이미지를 만든 다음 페이지에 인쇄합니다. 1990 년대 레이저 프린터의 매우 일반적인 구성 요소였습니다. 그러나 분명히 프린터에서 CPU를 많이 사용하며 컴퓨터 프로세서가 강력 해짐에 따라 프린터보다 컴퓨터에서 래스터 화를 수행하는 것이 더 합리적이었습니다. PostScript는 여전히 더 많은 고급 프린터에 있지만 소비자 용 프린터에서는 크게 사라졌습니다.

PostScript를 대체 한 표준은 PDF라는 작은 형식입니다.

PostScript는 프로그래밍을 시작할 때 유행을 벗어 났지만 TeX 용 문서를 작성하는 또 다른 방법으로 대학에 다니는 동안 약간 배웠습니다. 내가 사용한 다른 프로그래밍 언어 (역순 표기법, 스택, 콘솔 대신 페이지로 인쇄)와는 상당히 달랐지만이 오래된 언어를 재미있게 털어내는 것이 좋았습니다.

PostScript는 인쇄 언어이므로이를 사용하여 무언가를 인쇄 한 다음 출력을 콘솔로 보내는 것이 더 적절 해 보입니다.

작업 1

/Courier findfont
12 scalefont
setfont
newpath

100 370 moveto
(PostScript was made in 1982!\n) show

처음 몇 줄은 캔버스를 그립니다. 그런 다음이 moveto명령은 PS에게 특정 위치에 그리도록 지시 show하고 문자열을 페이지에 인쇄합니다. 괄호는 따옴표가 아닌 포스트 스크립트에서 문자열을 표시합니다.

작업 2

/asciiartN {% stack: N row col
            % output: draws an "ASCII art" N

  % PostScript doesn't allow you to pass variables directly into a function;
  % instead, you have to pass variables via the global stack. Pop the variables
  % off the stack and define them locally.
  6 dict begin
  /row exch def
  /col exch def
  /N exch def

  % Define how much space will be between each individual "N"
  /spacing 15 def

  % Get the width of the "N". We need this to know where to draw the right-hand
  % vertical
  /endcol col spacing N 1 sub mul add def

  % One row is drawn at a time, with the bottom row drawn first, and working
  % upwards. This stack variable tracks which column the diagonal is in, and so
  % we start on the right and work leftward
  /diagcol endcol def

  % Repeat N times: draw one row at a time
  N {
    % Left-hand vertical of the "N"
    col row moveto
    (N) show

    % Right-hand vertical of the "N"
    endcol row moveto
    (N) show

    % Diagonal bar of the "N"
    diagcol row moveto
    (N) show

    % Advance to the next row. This means moving the row one space up, and the
    % diagonal position one place to the left.
    /row row spacing add def
    /diagcol diagcol spacing sub def

  } repeat

  end
} def

1 100 200 asciiartN
3 150 200 asciiartN
5 230 200 asciiartN

“ASCII art”N을 그리는 함수를 작성했지만 PostScript 함수가 인수를 취할 수있는 방법은 없습니다. 대신 인수를 스택으로 푸시 한 다음 다시 가져옵니다. 그게 /x exch def선입니다.

예를 들어 스택이이라고 가정합니다 8 9 2. 먼저 이름 /x을 스택으로 푸시 하므로 스택은 8 9 2 /x입니다. exch연산자는 두 값을 스택 스왑 이제 스택이다 8 9 /x 2. 그런 다음 def상위 2 개의 스택 값을 팝하고 값 /x을 갖도록 정의 합니다 2. 스택은 이제 8 9입니다.

PostScript를 사용하기 시작했을 때 약간 혼란 스러웠습니다. 나는 스택에 대해 이론적 인 개념으로 읽었지만 실제로 사용하는 것은 이번이 처음이었습니다.

함수의 나머지 부분은 그리기 코드입니다. 오른쪽 하단에서 시작하여 왼쪽에서 오른쪽에서 대각선으로 한 번에 한 줄씩 채 웁니다.

작업 3

/modulo {% stack: x y
         % output: returns (x mod y)
  3 dict begin
  /y exch def
  /x exch def

  % If x = y then (x mod y) == 0
  x y eq {0} {

    % If x < y then (x mod y) == x
    x y lt {x} {

      % If x > y then subtract floor(x/y) * y from x
      /ycount x y div truncate def
      /x x ycount y mul sub def

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

/gcd {% stack: a b
      % returns the gcd of a and b
  2 dict begin
  /b exch def
  /a exch def

  % I'm using the recursive version of the Euclidean algorithm

  % If b = 0 then return a
  b 0 eq {a} {

    % Otherwise return gcd(b, a mod b)
    /a a b modulo def
    b a gcd
  } ifelse

} def

/displaygcd {% stack: a b xcoord ycoord
             % displays gcd(a,b) at position (xcoord, ycoord)
  5 dict begin
  /ycoord exch def
  /xcoord exch def
  /b exch def
  /a exch def
  /result a b gcd def

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

8 12 100 80 displaygcd
12 8 150 80 displaygcd
3 30 200 80 displaygcd
5689 2 250 80 displaygcd
234 876 300 80 displaygcd

다시 한 번 유클리드 알고리즘 형식을 사용했지만 PostScript에는 모듈러스 연산자가 내장되어 있으므로 직접 작성해야한다는 사실을 잊었습니다. 이것은 스택 기반 프로그래밍의 제약 조건을 알려주는 유용한 정보로 판명되었습니다. 내 첫 구현은 modulo재귀를 기반으로했습니다.

modulo(x, y)
    if (x = y) return 0
    elif (x < y) return x
    else return module(x - y, y)

x크거나 y작을 때 (예 : 5689와 2) 실행할 때까지 괜찮습니다 . 스택에는 최대 250 개의 요소 만있을 수 있으므로 스택 제한을 초과하여 불고있었습니다. 죄송합니다. 나는 그것의 그림판으로 돌아 가야했다.

GCD 코드 자체는 매우 간단합니다. 그러나 함수가 인수를 사용할 수없는 것처럼 리턴 값이 없습니다. 대신 결과를 다른 사람이 나중에 튀어 나올 수있는 스택으로 푸시해야합니다. 이것이 바로 라인 a과 b a gcd라인의 기능입니다. 평가가 끝나면 값을 스택으로 푸시합니다.

모든 코드를 문서에 넣고 인쇄하면 다음과 같이 출력됩니다.

2009- > <>

Befunge에서 영감을 얻은> <> (물고기)는 밀교적인 스택 기반 2D 언어입니다. 즉, 프로그램 흐름이 위, 아래, 왼쪽 또는 오른쪽 일 수 있습니다. 의 초기 버전> <> 기능을 갖춘 멀티 스레딩 곳 [과 ]생성 및 스레드를 종료하지만, 단순화를 위해이 지침을 작성하고 각각 새로운 스택을 제거로 변경되었습니다 추론.

> <>의 현재 공식 통역사는 여기 에서 찾을 수 있습니다 . 불행히도 Esolang 위키의 기존 통역사와의 링크가 깨졌습니다.

"안녕하세요, 월드!" 다른

"!9002 ni edam saw ><>"l?!;obb+0.

문자열이 거꾸로 쓰여지는 방식에주의하십시오.> >>에는 기술적으로 문자열이 없으며 char, int 및 float의 이상한 조합 인 데이터 유형 만 있습니다. "문자열 구문 분석을 토글하여 닫기 "가 충족 될 때까지 각 문자를 스택으로 밀어 넣습니다 .

그런 다음 코드의 두 번째 절반은 스택의 길이를 푸시하고 l0인지 확인 ?!하고 프로그램이 종료되는지 확인합니다 ;. 그렇지 않으면 명령 포인터가 계속되어 스택을 o실행하기 전에 스택의 맨 위를 출력합니다. bb+0.이 포인터는 포인터를의 (22, 0)바로 앞에 위치하여 순간 이동하여 l루프를 만듭니다.

ASCII 아트 N

&0 > :&:&:*=?;  :&:&%  :0=?v  :&:&1-=?v  :{:{-&:&,{=?v   " " o   \

                           > ~"N"o                           v    
   +                                  > ~"N"oao              v    
   1                                                 >"N"o   v    

   \                                                         <   /

명확성을 위해 간격이 있습니다. 당신은 새로운 온라인 인터프리터에서 이것을 시도 할 수 있습니다 여기에 와 명령 포인터 주위와 주변을 둘러 볼 - 바로 "초기 스택"텍스트 상자에 숫자를 입력해야합니다. 파이썬 인터프리터를 통해 실행중인 경우 -v플래그를 사용 하여 스택을 초기화하십시오 (예 :

py -3 fish.py ascii.fish -v 5

이 프로그램에서는 입력 n을 레지스터에 입력 &하고 0을 눌러 i"반복"을 호출 합니다. 프로그램의 나머지 부분은 다음과 같은 거대한 루프입니다.

:&:&:*=?;          If i == n*n, halt. Otherwise ...
:&:&%              Push i%n
:0=?v              If i%n == 0 ...
>~"N"o               Print "N"
:&:&1-=?v          Else if i%n == n-1 ...
>~"N"oao             Print "N" and a newline
:{:{-&:&,{=?v      Else if i%n == i//n, where // is integer division...
>~"N"o               Print "N"
" "o               Otherwise, print a space
1+                 Increment i

그런 다음 루프를 처음부터 반복합니다.

화살표 ^>v<는 프로그램 흐름 방향을 변경하고 미러 /\는 프로그램 흐름 방향을 반영합니다.

GCD

>:{:}%\
;n{v?:/
v~@/

다음은 golfed> <> 프로그램의 예입니다. 다시 한 번 온라인 인터프리터에서 (예 : "초기 스택"상자에 쉼표로 구분 된 두 개의 값을 입력 111, 87하거나) -vPython 인터프리터 의 플래그를 사용 하여이 작업을 시도 할 수 있습니다.

py -3 fish.py gcd.fish -v 111 87

이 프로그램은 유클리드 알고리즘을 사용합니다. 이전에 준비한 GIF는 다음과 같습니다.

> <>는 환상적이므로 왼쪽 하단 v명령이 실행될 때 명령 포인터가 아래쪽으로 이동하고 줄 바꿈되어 맨 위에 다시 나타납니다.

편집 : 코드를 오른쪽에서 왼쪽으로 완전히 실행함으로써 @randomra는 3 바이트를 면도했습니다.

<~@v!?:%}:{:
;n{/

나는 그것을 충분히 골프화하지 않았다고 생각한다 :)

2012- 요소

이것은 2012 년 초에 간단한 골프 언어로 발명 된 언어입니다. 이것에 의해 연산자 오버로딩이 거의 없거나 전혀 없음을 의미합니다. 운영자는 또한 대부분의 현대 골프 언어보다 단순하고 수가 적습니다.

이 언어의 가장 흥미로운 특징은 데이터 구조입니다. 거기 두 스택 정보를 저장하는 데 사용되는 해시.

m- 스택은 산술 및 대부분의 다른 작업이 수행되는 기본 스택입니다. 데이터가 입력 또는 인쇄 될 때 데이터가 이동하거나 검색되는 위치입니다.

c- 스택은 제어 스택입니다. 부울 산술이 이루어지는 곳입니다. c- 스택의 최상위 값은 조건으로 If 및 While 루프에서 사용됩니다.

해시는 변수가 저장되는 곳입니다. ;및 ~저장하고 각각 해시에서 데이터를 검색 할 수 있습니다.

요소는 매우 약한 유형의 언어입니다. 그것은 숫자를 문자열로 자유롭게 해석하거나 그 반대로 해석하는 Perl의 기능을 사용합니다.

내가 그 동안, 나는 언어에 대한 모든 문서를 포함 할 수 있습니다. 당신은 찾을 수 있습니다 원래 오른쪽 Perl로 작성 2012 인터프리터를, 여기 . 업데이트 : 더 유용한 버전을 만들었습니다 . 여기에서 찾을 수 있습니다 .

OP    the operator.  Each operator is a single character
STACK tells what stacks are affected and how many are popped or pushed
      "o" stands for "other effect"
HASH  tells if it involves the hash
x & y represent two values that are already on the stack, so the effect of
      the operator can be more easily described

OP     STACK  HASH   DESCRIPTION
text     ->m         --whenever a bare word appears, it pushes that string onto 
                       the main stack
_       o->m         --inputs a word and pushes onto main stack
`       m->o         --output.  pops from main stack and prints
xy;    mm->    yes   --variable assignment.  the top stack element y is assigned 
                       the value x
~       m->m   yes   --variable retrieval.  pops from main stack, pushes contents 
                       of the element with that name
x?      m->c         --test. pops x and pushes 0 onto control stack if x is '0' or 
                       an empty string, else pushes 1
><=     m->c         --comparison. pops two numbers off of stack and performs 
                       test, pushes 1 onto control stack if true and 0 if false
'       m->c         --pops from main stack and pushes onto control stack
"       c->m         --pops from control stack and pushes onto main stack
&|     cc->c         --AND/OR. pops two items from control stack, performs and/or 
                       respectively, and pushes result back onto control stack
!       c->c         --NOT. pops a number off of control stack, pushes 1 if 0 or 
                       empty string, 0 otherwise
[]       c           --FOR statement (view the top number number from control stack 
                       and eval those many times)
{}       c           --WHILE (loop until top number on control stack is 0, also 
                       does not pop)
#       m->          --discard. pops from main stack and destroys
(       m->mm        --pops from main stack, removes first character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
)       m->mm        --pops from main stack, removes last character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
+-*/%^ mm->m         --arithmetic. pops two most recent items, adds/negates
                       /multiplies/divides/modulates/exponentiates them, and places 
                       the result on the stack 
xy@    mm->o         --move. pops x and y and moves xth thing in stack to move to 
                       place y in stack
x$      m->m         --length. pops x and pushs length of x onto the stack
xy:    mm->o         --duplication. pops x and y and pushes x onto the stack y times
xy.    mm->m         --concatination. pops x and y and pushes x concatonated with y
\        o           --escapes out of next character, so it isn't an operator and can
                       be pushed onto the stack
,      m->mm         --character conversion. pops from main stack, coverts it to char
                       and pushes, and converts to num and pushes
Newlines and spaces separate different elements to be pushed 
onto the stack individually, but can pushed onto the stack using \

작업 1-텍스트 인쇄

Element\ was\ made\ in\ 2012\!`

언어의 가장 어색한 부분 중 하나는 문자열 구분 기호가 없기 때문에이 문자열에 이스케이프 문자가 필요한 이유입니다. `끝에 문자열을 인쇄합니다.

작업 2-ASCII Art N

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\ [#N]`"#]\
`]

여기에서는 스택 조작을 목격 할 것입니다. 설명을 좀 더 쉽게 형식화하기 위해 개행을과로 바꾸고 L공백을로 바꿉니다 S.

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\S[#N]`"#]\L`]
_+'      input line, convert to #, move to c-stack
[        FOR loop
 y~1+y;  increment the y-pos
 0       set the x-pos (the top # on the stack) to zero
 [       FOR loop
  1+4:   increment x-pos and make 3 additional copies (4 is total #)
  "2:'   make a copy of the N size on the main stack
  =      if x-pos == size
  1=     or if x-pos == 1
  y~=|   of if x-pos == y-pos
  \S     (always) push a space
  [      the IF body (technically a FOR loop)
   #N    if true, remove the space and push an N
  ]      end IF
  `      output the pushed character
  "#     remove the result of the conditional
 ]       end x-pos FOR
 \L`     output a newline
]        end y-pos FOR

이 답변을 극단적으로 골라 낸 후에 39 바이트 솔루션을 찾았지만 훨씬 더 복잡합니다.

_'1[y~+y;[#1+3:"2:'%2<y~=|\ [#N]`"]\
`]

작업 3-GCD

__'{"3:~2@%'}`

이것은 스택 기반 방법입니다.

__                 input the two numbers
  '                use one of the number as a condition so the WHILE loop starts
   {        }      a WHILE loop. Repeats while the c-stack has a true value on top
    "              get the number back from the c-stack to do operations on it
     3:            make it so that there are threes copies on the stack
       ~           takes one of the copies from earlier and converts it to a zero
        2@         take the top item on the stack and move it behind the other two #s
          %        modulo operation
           '       use this number as the condition
             `     since one number is zero (and on the c-stack) print the 
                   other number, which is on m-stack

2012- 줄리아

언어 역사

Julia는 2012 년 Jeff Bezanson, Stefan Karpinski 및 Viral Shah에 의해 개발되었으며 Jeff는 MIT (Massachussets Institute of Technology)의 학생으로 Alan Edelman 교수의 조언을 받았습니다. 이들은 다양한 응용 분야에서 사용 편의성을 유지하면서 (다른 많은 것들 중에서) 오픈 소스, 빠르고 역동적 인 프로그래밍 언어에 대한 열망에 동기를 부여했습니다. 이 제품은 고성능 과학 컴퓨팅에 대한 새로운 접근 방식 인 Julia였습니다.

"안녕하세요, 월드!" 다른

println("Julia was made in 2012!")

Julia에서 STDOUT으로 인쇄하는 것은 매우 간단합니다!

ASCII 아트 N

function asciin(n)
    # Create an nxn matrix of spaces
    m = fill(" ", (n, n))

    # Fill the first and last columns with "N"
    m[:,1] = m[:,n] = "N"

    # Fill the diagonal elements with "N"
    setindex!(m, "N", diagind(m))

    # Print each row of the matrix as a joined string
    for i = 1:n
        println(join(m[i,:]))
    end
end

코드는 가독성을 위해 들여 쓰기되지만 Julia는 공백에 제한을 두지 않습니다.

GCD

function g(a, b)
    b == 0 ? a : g(b, a % b)
end

함수에 나열된 마지막 것은 암시 적으로 반환됩니다.

1988- 수학

아니면 Wolfram Language 라고해야 합니까?

작업 0

Mathematica의 제작자는 Wolfram Research의 설립자이자 CEO 인 Stephen Wolfram입니다. Mathematica가 개발되기 전에는 물리학 자였습니다. 물리학에는 엄청난 양의 대수 계산이 있었으므로 그는 Macsyma 의 사용자가 되었습니다 .

Wolfram은 1979 년 20 세 때 PHD를 취득했습니다. 그는 물리학을 위해 Macsyma보다 더 나은 CAS가 필요하다고 생각하여 SMP ( "심볼 조작 프로그램") 을 쓰기 시작했습니다 . SMP의 첫 번째 버전은 1981 년에 출시되었습니다. SMP는 Mathematica의 전신입니다. Mathematica에 큰 영향을 미쳤지 만 Mathematica에 사용 된 코드는 없습니다.

1986 년, Wolfram은 "궁극적 인 계산 시스템"을 작성하기로 결정했습니다. 그는 1986 년에 코드 작성을 시작했고 1987 년에 Wolfram Research를 설립했습니다. 마지막으로 Mathematica 1.0은 1988 년 6 월 23 일에 릴리스되었습니다.

Mathematica 1.0을 찾지 못했습니다. 실제로 Mathematica 1.0에는 Windows 또는 Linux 버전이 없었습니다. 하지만 중국 웹 사이트에서 Mathematica 2.0을 찾았습니다. 여전히 Windows XP에서 실행할 수 있습니다.

작업 1

Print["Mathematica was made in 1988!"]

또는 간단히 :

"Mathematica was made in 1988!"

작업 2

오늘의 Mathematica에서는 다음과 같이 쓸 수 있습니다.

asciiArtN[n_] := Print @@@ SparseArray[{i_, 1 | i_ | n} -> "N", {n, n}, " "]

Julia 및 R 과 마찬가지로 이것은 행렬 솔루션입니다. Mathematica에서는 패턴 일치를 사용하여 희소 행렬을 정의 할 수 있습니다.

그러나 SparseArrayMathematica 5.0에 도입되었으므로 Mathematica 1.0에서는 사용할 수 없습니다.

Mathematica 1.0에서 작동하는 솔루션은 다음과 같습니다.

asciiArtN[n_] := Block[{f},
  f[i_, 1]  = "N";
  f[i_, i_] = "N";
  f[i_, n]  = "N";
  f[__]     = " ";
  Apply[Print, Array[f, {n, n}], 1];
]

Mathematica 2.0에 도입 f[i_, 1 | i_ | n] = "N"되었기 때문에 글을 쓸 수 없습니다 Alternatives.

작업 3

내장 함수를 사용할 수 있습니다.

gcd = GCD

또는 GCD의 정의를 사용할 수 있습니다.

gcd = Max[Intersection @@ Divisors[{##}]] &;

또는 LCM을 사용할 수 있지만보다 일반적으로 LCM은 GCD에서 계산됩니다.

gcd = Times[##]/LCM[##] &;

또는 패턴 일치와 함께 유클리드 알고리즘을 사용할 수 있습니다.

gcd[a_, 0] := a
gcd[a_, b_] := gcd[b, Mod[a, b]]

또는 익명 함수로 :

gcd = If[#2 == 0, #1, #0[#2, Mod[##]]] &;

위의 모든 기능은 Mathematica 1.0에 도입되었습니다.

1999- XSLT

월드 와이드 웹 컨소시엄 (W3C) 다음 예는 입력이 묶인 가정 등 HTML, 텍스트,로 XML을 변환하기위한 XSLT를 만들어 <input>..</input>태그입니다.

작업 1

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">XSLT was made in 1999!</xsl:template>
</xsl:stylesheet>

이것은 간단합니다. input최상위 레벨 의 태그 와 일치 하고 원하는 출력으로 바꿉니다.

작업 2

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="loop">
      <xsl:with-param name="i">1</xsl:with-param>
      <xsl:with-param name="n">
        <xsl:value-of select="."/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="loop">
    <xsl:param name="i"/>
    <xsl:param name="n"/>
    <xsl:choose>
      <xsl:when test="$i = 1 or $i = $n">
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$i - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - $i - 1"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="$i &lt; $n">
      <xsl:call-template name="loop">
        <xsl:with-param name="i">
          <xsl:value-of select="$i + 1"/>
        </xsl:with-param>
        <xsl:with-param name="n">
          <xsl:value-of select="$n"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
      <xsl:template name="spaces">
    <xsl:param name="n"/>
    <xsl:if test="$n &gt; 0">
      <xsl:text> </xsl:text>
      <xsl:call-template name="spaces">
        <xsl:with-param name="n">
          <xsl:value-of select="$n - 1"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

이 사람은 2 재귀 템플릿을 정의 loop하고 spaces. loop매개 변수 i와 함께 위치에서 시작 n하여 원하는 출력을 생성합니다 . 매개 변수 를 사용하면 공백 이 생성됩니다 .nispacesnn

작업 3

이 입력은 <input><num>..</num><num>..</num></input>태그로 입력해야 합니다.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="gcd">
      <xsl:with-param name="a"><xsl:value-of select="num[1]"/></xsl:with-param>
      <xsl:with-param name="b"><xsl:value-of select="num[2]"/></xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="gcd">
    <xsl:param name="a"/>
    <xsl:param name="b"/>
    <xsl:choose>
      <xsl:when test="$b = 0"><xsl:value-of select="$a"/></xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="gcd">
          <xsl:with-param name="a"><xsl:value-of select="$b"/></xsl:with-param>
          <xsl:with-param name="b"><xsl:value-of select="$a mod $b"/></xsl:with-param>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

이것은 gcd유클리드 알고리즘을 사용 하는 재귀 템플릿 입니다.

2014-CJam

CJam 은 PPCG 사용자 aditsu에 의해 만들어졌으며 2014 년 4 월경 에 출시되었습니다 .

"안녕하세요, 월드!" 다른

"CJam was made in 2014!"

CJam은 프로그램이 끝날 때 스택의 내용을 자동으로 인쇄합니다

ASCII 아트 N

ri:R'#*a_R2-,{_)S*'#+\R((-zS*+}%+\+R<zN*

코드 설명 :

ri:R                                       "Read the input as integer in R";
    '#*a                                   "Get a string of R # and wrap it in an array";
        _R2-,{                }%           "Copy that string and then run this loop R-2";
                                           "times for the diagonal";
              _)S*                         "Get iteration index + 1 spaces";
                  '#+                      "Append the hash";
                     \R((-zS*+             "Append remaining spaces";
                                +\+        "Append and prepend the initial # string";
                                   R<      "Take only R columns/rows. This is for";
                                           "tackling input 1";
                                     zN*   "Transpose and join with new lines";

STDIN을 통해 입력으로 N의 높이 / 너비를 가져옵니다. 여기에서 온라인으로 사용해보십시오

GCD

l~{_@\%}h;

STDIN을 통해 두 숫자를 입력으로받습니다. 여기에서 온라인으로 사용해보십시오

1990 - 하스켈

Haskell은 인기있는 (또는 가장 인기있는 ?) 순수한 기능 언어입니다. 이 모델은 특이한 평가 모델 (기본적으로 모든 것이 게 으르 거나 기술적으로 엄격하지 않음)과 지금도 여전히 가장 강력한 Hindley-Milner 기반 유형 시스템에 의해 주류에서 튀어 나옵니다.

작업 1

main = putStrLn "Haskell was made in 1990!"

작업 2

-- Infinite list of growing letters 'N'
bigNs :: [[[Char]]]
bigNs = ["N"]
      : ["NN","NN"]
      : [ ins (ins 'N' t) $ map (ins ' ') n | n@(t:_) <- tail bigNs ]

-- Insert a new element after the head (i.e. at the second position).
ins :: a -> [a] -> [a]
ins x (l:ls) = l:x:ls

데모, 전체 무한 목록을 인쇄하십시오 (사용자가 중단되거나 세계가 끝날 때까지 ...)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

N    N
NN   N
N N  N
N  N N
N   NN
N    N

...

물론 무한 목록의 한 요소에만 액세스하면 다음 중 하나를 쉽게 얻을 수 있습니다.

main :: IO ()
main = do
   i <- readLn
   putStrLn . unlines $ bigNs!!i

작업 3

gcd' :: Integer -> Integer -> Integer
gcd' a 0 = a
gcd' a b = gcd' b $ a`mod`b

1972 - INTERCAL

그리고 포트란과 코볼이 이상하다고 생각했습니다. 이건 미친 짓이야!

작업 1

DO ,1 <- #27
DO ,1SUB#1 <- #110
DO ,1SUB#2 <- #32
DO ,1SUB#3 <- #72
PLEASE DO ,1SUB#4 <- #136
DO ,1SUB#5 <- #88
DO ,1SUB#6 <- #136
PLEASE DO ,1SUB#7 <- #64
DO ,1SUB#8 <- #80
DO ,1SUB#9 <- #46
PLEASE DO ,1SUB#10 <- #22
DO ,1SUB#11 <- #104
DO ,1SUB#12 <- #184
PLEASE DO ,1SUB#13 <- #202
DO ,1SUB#14 <- #78
DO ,1SUB#15 <- #48
PLEASE DO ,1SUB#16 <- #96
DO ,1SUB#17 <- #128
DO ,1SUB#18 <- #162
PLEASE DO ,1SUB#19 <- #110
DO ,1SUB#20 <- #32
DO ,1SUB#21 <- #114
PLEASE DO ,1SUB#22 <- #120
DO ,1SUB#23 <- #240
DO ,1SUB#24 <- #128
PLEASE DO ,1SUB#25 <- #208
DO ,1SUB#26 <- #200
DO ,1SUB#27 <- #52
DO READ OUT ,1
DO GIVE UP

INTERCAL의 입력 및 출력 시스템에 대해서는 설명하지 않겠습니다. 방금 읽은 이 당신이 죽지 않는 희망한다.

작업 2

DO WRITE IN 7
DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .8 <- .3
DO .5 <- .7
DO .6 <- .8
DO ,9 <- #2

DO (100) NEXT
DO (1) NEXT

(100) DO (99) NEXT
DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
PLEASE GIVE UP

(99) DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(1) PLEASE DO (3) NEXT
PLEASE DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
PLEASE GIVE UP

(4) DO (8) NEXT
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
DO .6 <- .8
DO .1 <- .5
DO .2 <- #1
DO (1010) NEXT
DO .5 <- .3
DO .1 <- '.5~.5'~#1
PLEASE DO FORGET .1
DO RESUME #1

(8) DO (5) NEXT

(5) PLEASE DO (6) NEXT
PLEASE DO FORGET #1
DO (5) NEXT

(6) PLEASE DO (7) NEXT
DO RESUME #2

(7) DO (10) NEXT
DO .1 <- .6
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(10) DO (11) NEXT
DO (13) NEXT
DO (14) NEXT
DO (15) NEXT

(11) DO (111) NEXT
DO (112) NEXT

(13) DO (113) NEXT
DO (112) NEXT

(14) DO (114) NEXT
DO (112) NEXT

(111) DO .1 <- .6
DO .2 <- .8
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(112) DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO RESUME #3

(113) DO .1 <- .6
DO .2 <- #1
DO (1000) NEXT
DO .1 <- .5
DO .2 <- .3
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(114) DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(15) DO ,9SUB#1 <- #252
DO ,9SUB#2 <- #4
PLEASE DO READ OUT ,9
DO RESUME #2

이런 어. 이것은 나를 알아내는 데 조금 걸렸습니다. 레이블 번호는 엉망이므로이를 반영합니다. 누군가가 묻지 않으면 이것을 설명하려고하지 않을 것입니다.

작업 3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

(1) PLEASE DO (3) NEXT
DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
DO READ OUT .5
PLEASE GIVE UP

(4) DO .1 <- .5
DO .2 <- .6
PLEASE DO (1040) NEXT
DO .1 <- .3
DO .2 <- .6
PLEASE DO (1039) NEXT
DO .2 <- .3
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .6
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

이것은 조금 더 간단합니다. INTERCAL의 이상한 점 때문에 다음과 같이 숫자를 입력해야합니다.

THREE FIVE

예를 들어 42와 16의 GCD를 얻으려면 다음을 입력하십시오.

FOUR TWO
ONE SIX

그것은 또한 당신을 위해 INTERCAL이기 때문에 로마 숫자로 숫자를 인쇄합니다!

1967-APL

1957 년, 하버드 대학교에서 Ken Iverson은 배열 조작을위한 수학적 표기법을 개발하기 시작했습니다. 1960 년대에 그의 표기법은 IBM에서 프로그래밍 언어로 개발되었습니다. 첫 번째 부분 구현은 1963 년에 만들어졌으며, 고등학교에서 학생들에게 초월 적 기능에 대해 가르치기 위해 사용되었습니다. 완전하고 사용 가능한 구현은 1965 년까지 기다려야했습니다. 2 년 동안 IBM은 내부적으로 만 사용했습니다. 1967 년에 IBM은 1966 년에 완성 된 IBM 1130 컴퓨터에서 실행되는 APL 인터프리터를 일반 대중에게 공개했습니다. 올해가 처음으로 전체 구현이 공개되었습니다. 누군가가 실제로 동의하지 않으면 변경할 수 있습니다.

APL \ 360의 소스 코드 는 에뮬레이터와 마찬가지로 온라인 상태 입니다. 이것이이 예제를 테스트하는 데 사용한 것입니다. 1967 년에 시작되었으며 APL \ 1130 (앞서 언급 한 IBM 1130의 경우)과 함께 실제 원본입니다. 예상대로 매우 원시적입니다. 그것은, 어떤 사업자가 소문자와 같은 미묘한에 대한 지원이 부족 에만 내장 기능이 작동을하고, 내장 기능의 설정은 매우 희박한 (특히 ∨입니다 만 or , 그리고 않습니다 하지 로 두 배 gcd). 원래의 완전한 설명은 여기 에서 볼 수 있지만, 내가 가지고있는 버전이 그 문서와 관련하여 완벽하지는 않지만 ⍎다른 것들이 부족하다는 것을 알았 습니다.

프로그램을 유니 코드 형식 (읽을 수 있음)과 원래 인코딩 (에뮬레이터의 APL 창으로 잘라 붙여 넣을 수 있음)으로 제공했습니다.

믿을 수 없을 정도로,이 프로그램들은 최신 버전의 Dyalog, NARS2000 및 GNU APL에서 변경없이 (인코딩 제외) 올바르게 실행됩니다. 따라서 휴대용 APL을 작성하는 방법을 찾았다 고 생각합니다. 1967 년인 척하십시오!

작업 1 :

유니 코드 :

⎕←'APL WAS MADE IN 1967!'

APL \ 360 :

L[Kapl was made in 1967ÝK

작업 2 :

유니 코드 :

⎕←' N'[1+((2⍴N)⍴(⍳N)∊1,N)∨(⍳N)∘.=⍳N←⎕]

APL \ 360 :

L[K nK;1-::2Rn"R:In"E1,n"(:In"J.%In[L'

작업 3 :

나는 이것을 표준 재귀 방식으로 해결했다. 이론적으로 J 응답과 같이 영리하고 배열 지향적 인 작업을 수행 할 수 있습니다. 그러나 실제로는 O (N) 메모리 사용량이 있으며 Flower-Power-era의 하드 및 소프트웨어를 빠르게 압도합니다.

유니 코드 :

∇R←A GCD B
R←A
→(B=0)/0
R←B GCD B|A
∇

⎕←⎕ GCD ⎕

APL \ 360 :

Gr[a gcd b
r[a
{:b%0"/0
r[b gcd bMa
G

L[L gcd L

1996- 오캄

1996 년을 채우는 누군가에게 하루 이상 기다리고 있었기 때문에 Ruby를 채울 수있었습니다. 그렇다면 왜 OCaml을 배우지 않습니까?

안녕하세요 세계

print_endline "OCaml was made in 1996!";;

ASCII

let ascii n =
  let rec ascii' = function
    | 0 -> ()
    | i ->
        let s = "N" ^ String.make (n-2) ' ' ^ "N" in
        String.fill s (n-i) 1 'N';
        print_endline s;
        ascii' (i-1)
  in ascii' n;;

가변 문자열!

GCD

let rec gcd a b = if b = 0 then a else gcd b (a mod b);;

아니 ==와 중위 mod, 그 귀엽다

2005- 전주곡

서곡은 그 소스 코드를 병렬로 실행하고 몇 가지 "목소리"로 구성되어 매우 재미있는 언어입니다 내가 정말 문제를 해결 즐길 수 있습니다 . 이는 자매 언어 Fugue 의 ASCII 표현으로 , 실제로 .midi 파일을 소스 코드로 사용하고 Prelude에있는 명령어를 음색의 멜로디 간격으로 인코딩합니다.

Prelude는 매우 미니멀하지만 튜링이 완료되었습니다 (최소 2 개의 음성을 사용하는 경우). 내가 말했듯이, 음성 (코드 라인)은 열별로 동시에 실행됩니다. 각 음색은 자체 스택에서 작동하며 무한한 0으로 초기화됩니다. Prelude는 다음 지침을 지원합니다.

0-9 ... Push the corresponding digit.
+   ... Add the top two numbers on the stack.
-   ... Subtract the top number from the one beneath.
#   ... Discard the top of the stack.
^   ... Copy the top value from the voice above.
v   ... Copy the top value from the voice below.
?   ... Read a number and push it onto the stack.
!   ... Print the top number (and pop it from the stack).
(   ... If the top of the stack is zero, jump past the matching ')'.
)   ... If the top of the stack is zero, jump to the column after the matching '('.

몇 가지 추가 사항 :

• 음색은 주기적이므로 ^맨 위 음색은 맨 아래 음색에서 복사되며 그 반대도 마찬가지입니다.
• 다중 ?와 !같은 열에는 위에서 아래로 실행됩니다.
• 에 따라 언어 사양 , ?및 !해당 문자 코드 읽기 및 쓰기 문자. 그러나 파이썬 인터프리터 는 코드 자체에 숫자를 대신 인쇄하는 스위치도 있습니다. 테스트 목적으로 실제로 문자 대신 숫자를 읽을 수 있는 수정 된 버전 을 사용 하고 있습니다 . 그러나 여기에서 합의는 숫자 입력 / 출력이 실제로 바이트 값으로 제공 될 수 있으므로 숫자를 다루는 유효한 프로그램을 만드는 데 이러한 수정이 필요하지 않습니다.
• 일치 (하며 )같은 음성 일 필요는 없습니다. 조건에 사용되는 음성은 항상 하나 (가 나타납니다. 따라서의 수직 위치 )는 완전히 관련이 없습니다.
• Prelude의 동시 실행 특성으로 인해 a와 동일한 열에있는 명령 (은 루프가 시작되기 전에 한 번만 실행되며 루프 입력 여부에 관계없이 실행됩니다. 마찬가지로 a와 동일한 열에있는 명령은 )이 반복 후에 루프가 종료되는지 여부에 관계없이 각 반복의 끝에서 실행됩니다.

먼저 많은 설명없이 세 가지 프로그램을 보여 드리겠습니다. 아래에서 광범위한 설명을 찾을 수 있습니다.

프로그램

"안녕하세요, 월드!" 다른

9(1-)v98+^++!9v+!  v88++2+!^  ! ^9-3-! v      !    v2-!55+!
8 8+ !     7v+! 1v+!88+^+!^4-!^ v8-^ !!!9v+  !^9+9+!  v5+!
     ^98++4+! ^8-! ^4-   ^ #!^6-!    ^^  #5+! v    ^2-!1+!

Python 인터프리터를 사용하는 경우 확인하십시오 NUMERIC_OUTPUT = False.

ASCII 아트 N

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

사용하기 쉽도록이 프로그램은 입력을 숫자로 읽는 것이 도움이되지만 출력은 숫자가 아니어야합니다. 따라서 수정 된 Python 인터프리터를 사용하는 경우

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

이것은 모든 숫자 입력 / 출력에 가장 적합합니다.

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

설명

"안녕하세요, 월드!" 다른

이것은 매우 간단합니다. 에있는 모든 문자의 문자 코드를 연속적으로 생성하기 위해 3 가지 음성을 사용하고 Prelude was made in 2005!있습니다. 나는 8 + 9*8 = 80문자 코드 인 컴퓨팅으로 시작합니다 P.

 9(1-)
 8 8+

그 후 나는 주로 이전 문자 코드를 복사하고 다음 코드와의 차이를 더하거나 뺍니다. 다음은 코드이지만 각 !문자는 인쇄중인 문자 ( _공백 및 %숫자) 로 바뀝니다 .

9(1-)v98+^++r9v+u  v88++2+w^  _ ^9-3-a v      _    v2-%55+!
8 8+ P     7v+l 1v+e88+^+_^4-s^ v8-^ de_9v+  n^9+9+%  v5+%
     ^98++4+e ^8-d ^4-   ^ #a^6-m    ^^  #5+i v    ^2-%1+!

마지막 55+!은 더 좋기 때문에 후행 줄 바꿈을 인쇄합니다.

참고로,이 작업에서는 음색의 수가 임의적이지만 3은 모든 음색이 서로 직접 음성에 액세스 할 수있는 최대 숫자이기 때문에 매우 편리합니다.

ASCII 아트 N

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

5 가지 음성을 가진이 프로그램은 지금까지 내가 작성한 가장 복잡한 프로그램 중 하나입니다. 목소리는 대략 다음과 같은 목적을 가지고 있습니다.

1. N-1내부 루프에 사용하기 위해 저장하는 도우미 음성입니다 .
2. 이것은 "메인"음색의 일종으로, 입력을 읽고 중요한 스위치를 포함하고 외부 루프 (예 : 행 위)도 포함합니다.
3. 이것은 32편리한 인쇄 공간을 저장 합니다.
4. 여기에는 내부 루프 (열 위의 루프)가 포함됩니다.
5. 이것은 78편리하게 인쇄하기 위해를 저장합니다 N.

코드를 하나씩 살펴 보도록하겠습니다. 먼저 32as -4 + 9*4와 as를 만들고 78있습니다 6 + 9*8.

9(1-)
4-4+

6 8+

지금은 하나를 인쇄하고있어 N입력을 읽는 동안 (우리는 항상 일을해야하기 때문에) N및 저장 N-1과 N-2처음 두 목소리의 :

      v2-
     ?1-

     v!

다음으로에 "루프"가 설정되어 N-1있습니다. 루프의 끝에서 두 번째 음색은 항상로 줄어들고 0첫 번째 반복 후에 루프가 종료됩니다. 본질적으로 이것은 오직 if(N > 1){...}. 루프 후 우리는 하나의 후행 줄 바꿈을 인쇄합니다. 요약하면 다음과 같은 프레임 워크가 있습니다.

      v2-
9(1-)?1-(                               )55+!
4-4+
     v!
6 8+

이 조건 내에서 첫 번째 N-2공백과 N첫 번째 행을 완성하기 위한 단일 공백을 N-1사용하고 나중에 사용할 수 있도록 첫 번째 음성 에도 저장 합니다.

         (1-)v         
          v!  

             v!

이제 코드의 진정한 고기. 먼저 N-1행 을 인쇄하는 외부 루프가 있습니다. 각 행에 대해 먼저 줄 바꿈을 인쇄합니다 N. 그런 다음 N-2공백이나 Ns를 인쇄하여 시간 을 반복 합니다 (나중에 자세히 설명). 그리고 마지막으로 우리는 다른 것을 인쇄합니다 N:

               1-55+!  

                v1-v!(               )v!
               v#

마지막으로 재미있는 부분은 각 행을 인쇄하고 N오른쪽 위치를 얻는 것 입니다. Prelude에는 실제로 if / else가 없으므로 다른 음색에 두 개의 루프를 사용하여 직접 빌드해야합니다. 내부 및 외부 루프 변수를 빼면 조건을 쉽게 얻을 수 있습니다 . 인쇄하려는 경우 공간을 인쇄하려는 경우 0이 아닌 값 0을 얻습니다 N.

Prelude에서 if / else의 기본 아이디어는 관련 값 뒤에 "if"(또는 0이 아닌) 코드 뒤에 루프를 넣고을 눌러 즉시 종료하는 것 0입니다. 다른 음성에서는 0이 아닌 값을 유지 하고 "if"루프 다음에 또 다른 루프를 유지합니다 . "if"루프 동안 "else"가 실행되지 않도록 다른 음색 위에 0을 놓으십시오. 0이 아닌 값의 맨 위에 0 값을 넣거나 0이 아닌 경우 0이 아닌 값을 버리는 방법에는 약간의 유연성이 있지만 이것이 일반적인 아이디어입니다. 관련 음성을 계속 사용하려면 나중에 정리를 수행해야 할 수도 있습니다. 코드는 다음과 같습니다.

                           0     (0)#
                      v^-#
                      1- ^(#^!0)# v! 

그리고 그게 다야!

GCD

이것은 유클리드 알고리즘의 반복적 인 구현입니다. 그러나 Prelude의 모듈러스는 약간 성가신 데, 주로 숫자가 양수인지 음수인지 쉽게 확인할 수 없기 때문입니다. 이 코드는 signum을 사용합니다 얼마 전에 작성한 구현 합니다. 코드의 큰 부분, 즉 단지에 숫자를 회전 -1, 0또는 1. 그런 다음을 더하거나 빼서 쉽게 양수 또는 음수 조건으로 전환 할 수 있습니다 1.

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

이번에는 4 가지 목소리가 있습니다. 첫 번째 음성은 단순히 b주요 종료 조건을 추적 하고 포함합니다 (예 : 루프가 종료 될 때b 가되면0 ). 두 번째 음색에는 이전과 결과를 교환하기 전에 a3 ~ 4 개의 계산이 포함되어 있습니다 . 마지막으로 때 인쇄합니다 .a % bb!ab == 0

signum 부분을 ​​먼저 살펴 보자 .

     (0 # v   #
     ^^ (##v^v+)#
      1) ^ #  -

입력 번호 n는 해당 음성 중 첫 번째 (전체 프로그램의 두 번째 음성)에 있습니다. 결과는 하단 음색으로 끝납니다. 다른 두 음색은 비어있을 것으로 예상됩니다 (즉, 0으로 채워짐). 인 경우 n == 0두 루프를 모두 건너 뛰고 맨 아래 음색에는 여전히 0원하는 내용이 포함 됩니다.

n0이 아닌 경우 첫 번째 작은 루프가 입력됩니다. 우리는 0을 눌러 즉시 종료하고 두 개의 사본을 n가운데 음색과 1아래쪽 음색에 넣습니다. 이제 기본 아이디어는 n다른 사본을 줄이면서 사본 중 하나 를 늘리는 것입니다.n 중 하나가 0 될 때까지 것입니다. 그렇게하는 동안 1맨 아래의 음색은 항상 부호를 뒤집습니다 ( 0스택의 아래쪽 에서 빼서 쉽게 수행 할 수 있음 ). 이는하도록 설정 하면 숫자 중 하나가 비게, 하단 목소리가 올바른 기호를 포함합니다.

이제 모듈러스는 감산함으로써 구현 b에서a 결과가 부정적이 될 때까지. 그런 일이 발생하면 b다시 추가 합니다. 이 비트입니다.

  (^-  signum         ^+0)#
       signum      0 (0 )   
       signum   1+(#)#

하단의 if / else 구조는 작업 2에 사용한 것과 비슷합니다.

2007-스크래치

스크래치 는 교육 목적으로 MIT에서 만든 언어입니다. 나는 5 년 동안 그 일에 매우 관여 해 왔습니다. 나중에 더 자세히 설명하겠습니다.

이것들은 모두 여기에서 볼 수 있습니다 .

나는 지금 매우 서두르고 나중에 스 니펫을 설명 할 것입니다. 잘만되면 그들은 prety 자기 설명이다.

작업 1

작업 2

작업 3

1972-C

우리는 모두 C에 대해 알고 있습니다. C는 Unix와 함께 Bell Labs에서 만들어졌습니다. 유닉스는 주로 C로 작성되었습니다. 모든 현대 유닉스 파생물은 여전히 ​​C로 작성되었습니다. C의 구문은 많은 프로그래밍 언어에 영향을 미쳤습니다. 아마도 새로운 개발에 여전히 널리 사용되는 가장 오래된 프로그래밍 언어 일 것입니다.

C 자체는 B의 자손 이므로이 목록에서도 끝날 것입니다. 'A'프로그래밍 언어는 없었습니다. B는 BCPL의 변형으로, CPL이 줄어 듭니다. 이 언어들 중 어느 것도 인기가 없었습니다. 그러나 BCPL은 최초의 "Hello World"프로그램이 작성된 언어였습니다. 또 다른 흥미로운 사실은 B가 의견 /* */과 //의견 을 모두 가지고 있었지만 C는 //의견을 삭제 했다는 것입니다 . 그들은 나중에 C99 표준으로 C로 다시 도입되었습니다.

여기에서 C 프로그램은 1974 년부터 Unix V5 C 컴파일러로 테스트되었습니다. 이것은 내가 찾거나 작동 할 수있는 가장 오래된 C 컴파일러였으며이 프로그램은 최신 C 컴파일러에서 컴파일되지 않습니다. (변경된 사항 중 하나는 이전과 같은 돌연변이 연산자 +=가=+ .)

#include <... >아직 존재하지 않았습니다. 표준 라이브러리도 많이 사용하지 않았습니다. 나는 내 자신을 써야했다 atoi. V5 소스 코드 중 일부를 통해 어떤 것이 허용되고 어떤 것이 허용되지 않았는지 알아 냈습니다. 내가 사용한 버전은 structs 를 포함하는 첫 번째 버전 이지만을 사용하지 않았기 때문에 V7 (K & R C와 같은)까지 구문이 크게 바뀌지 않은 것처럼 보였으므로 이전 버전에서도 작동 할 수 있습니다.

V5 소스 코드와 동일한 스타일로 코드를 작성하기 위해 최선을 다했습니다. (그렇지 않다는 것은 굉장히 일관성이 없습니다.)

봐 여기 유닉스 V5, 에뮬레이터에 대한 링크와 현대적인 컴퓨터에서 실행을 얻기에 대한 지침.

작업 1

main()
{
   write(1, "C was made in 1972!\n", 20);
}

작업 2

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';

    }
    return num;
}

N(n)
{
    register x, y;
    for (y=1; y<=n; y++) {
        for (x=1; x<=n; x++) {
            write(1, " N"+(x==1||x==y||x==n), 1);
        }
        write(1, "\n", 1);
    }
}

main(argc, argv)
char *argv[];
{
    N(atoi(argv[1]));
}

작업 3

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';
    }
    return num;
}

gcd(a, b)
{
    return b ? gcd(b, a%b) : a;
}

main(argc, argv)
char *argv[];
{
    printf("%d\n", gcd(atoi(argv[1]), atoi(argv[2])));
}

2009- 이드리스

Idris는 의존형으로 얻을 수있는 매우 엄격한 증명 가능성을 제공하는 것 외에도 실제로 실제 응용 프로그램에 실제로 사용할 수 있음을 강조하는 의존성 유형의 순수 기능 언어입니다.

작업 1

module Main

main : IO ()
main = putStrLn "Idris was made in 2009!"

작업 2

module InN

import Data.Fin
import Data.Vect

genN : Vect n (Vect n Char)
genN = [[ if inN x y then 'N' else ' ' | x<-range ]| y<-range ]

||| Helper function, determines whether the char at coordinate (x,y)
||| is part of the letter:
inN : Fin n -> Fin n -> Bool
inN {n=S _} x y = x==0 || x==y || x==last

이것은 프로그램이 아니라 함수 (보다 정확하게는 종속 값 )이므로 원하는 문자 N을 2 차원 배열로 생성합니다.

$ idris ascii-n.idr 
     ____    __     _                                          
    /  _/___/ /____(_)____                                     
    / // __  / ___/ / ___/     Version 0.9.17.1-
  _/ // /_/ / /  / (__  )      http://www.idris-lang.org/      
 /___/\__,_/_/  /_/____/       Type :? for help               

Idris is free software with ABSOLUTELY NO WARRANTY.            
For details type :warranty.
Type checking ./ascii-n.idr
*ascii-n> genN {n=4}
[['N', ' ', ' ', 'N'],
 ['N', 'N', ' ', 'N'],
 ['N', ' ', 'N', 'N'],
 ['N', ' ', ' ', 'N']] : Vect 4 (Vect 4 Char)

작업 3

module gcd

gcd' : Nat -> Nat -> Nat
gcd' a Z = a
gcd' a b = gcd' b $ a`mod`b

내가 이름을 선택했다는 것을 참고 gcd'로하기 때문에 gcd이 이미 이드리스의 전주곡에 정의되어 있습니다.

Type checking ./gcd.idr
*gcd> gcd' 8 12
4 : Nat
*gcd> gcd' 12 8
4 : Nat
*gcd> gcd' 234 876
6 : Nat

2014-피스

우리는 CJam을 가지고 있기 때문에 완전성을 위해 Pyth도 가질 수 있습니다 :)

Pyth는에 의해 골프를 치는 언어 @isaacg 파이썬 아래로 컴파일합니다. 절차 적이며 접두사 표기법을 사용하는 것으로 유명합니다. Pyth는 2014 년 6 월경에 처음 등장했습니다 .

"안녕하세요, 월드!" 다른

"Pyth was made in 2014!

Pyth 프로그램이 문자열로 끝나는 경우 선택적인 따옴표가 없습니다.

ASCII 아트 N

VQ+\Nt+P++*Nd\N*t-QNd\N

온라인으로 사용해보십시오 . 동등한 파이썬은 다음과 같습니다

Q = eval(input())
for N in range(Q):
    print("N"+((" "*N+"N"+(Q-N-1)*" ")[:-1]+"N")[1:])

또는 확장 (첫 번째 및 세 번째 행은 암시적임) :

Q = eval(input())                                        # 
for N in range(Q):                                       #   VQ
    print(                                          )    # 
          "N"+                                           #     +\N
              (                                )[1:]     #        t
                                           +"N"          #         +              \N
               (                     )[:-1]              #          P
                         +(Q-N-1)*" "                    #           +      *t-QNd
                     +"N"                                #            +   \N
                " "*N                                    #             *Nd

GCD

=GvwWQAGQ,Q%GQ)G

이 프로그램은 유클리드 알고리즘을 사용하며 개행으로 구분 된 두 개의 숫자를 사용합니다. 온라인으로 사용해보십시오 .

Q = eval(input())     #
G = eval(input())     #    =Gvw
while Q != 0:         #        WQ
  G, Q = Q, G % Q     #          AGQ,Q%GQ)
print(G)              #                   G

i.uQ내장 GCD를 사용하면 더 짧아집니다. 이는 print(gcd(*eval(input())))(쉼표로 구분 된 두 개의 숫자를 입력으로 사용)와 같습니다.

1964- 다트머스 베이직

BASIC 은 디자인 철학이 사용 편의성을 강조하는 범용, 고급 프로그래밍 언어의 제품군입니다. 1964 년 John G. Kemeny와 Thomas E. Kurtz는 뉴햄프셔의 Dartmouth College에서 기본 BASIC 언어를 설계했습니다. 그들은 과학 및 수학 이외의 분야의 학생들이 컴퓨터를 사용할 수있게하기를 원했습니다.

나는 1964 년부터 BASIC에 관한 이 매뉴얼 과 Darthmouth Time Sharing System의 에뮬레이터 를보고 있습니다. 서버가 여전히 가동 중이지만 슬프게도 계정 등록이 불가능한 것 같습니다. 현재이 프로그램들은 이론적으로 작동해야합니다.

작업 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

작업 2

10 READ N
15 FOR Y = 1 TO N STEP 1
20 FOR X = 1 TO N STEP 1
25 IF X = 1 THEN 50
30 IF X = N THEN 50
35 IF X = Y THEN 50
40 PRINT " ",
45 GO TO 55
50 PRINT "N",
55 NEXT X
60 PRINT
65 NEXT Y
70 DATA 5
75 END

다음과 같은 출력 :

N                       N
N     N                 N
N           N           N
N                 N     N
N                       N

입력이 프로그램의 일부로 입력되는 방식에 유의하십시오 ( 70 DATA 5). READ상단 의 명령 방식은 거기에서 데이터를 가져옵니다. 문자열 연결은 없지만 매뉴얼의 섹션 3.1에 PRINT결과가 출력의 표 "영역"에 기록되는 방법 이 설명되어 있습니다 .

작업 3

유클리드 알고리즘의 느린 버전 :

10 READ A, B
20 IF A = B THEN 80
30 IF A < B THEN 60
40 LET A = A - B
50 GO TO 20
60 LET B = B - A
70 GO TO 20
80 PRINT A
85 DATA 144, 250
90 END

출력 :

2

2010- WTFZOMFG

WTFZOMFG는 Brainfuck을 기반으로하는 난해한 언어입니다. "WTFZOMFG"는 "그 기능은 무엇입니까? 젠 최적화 된 악성 파일 고퍼!"의 약자입니다. .

* nix 시스템 용 컴파일러 는 다음과 같습니다 .

작업 1

'WTFZOMFG was made in 2010!\n"

작업 2

/&(-.N%3 >&>s-{-(-. ).N}>{-(-. ).N}_0 '\n")

설명:

죄송합니다. 설명을 잘 작성하지 못합니다.

/                                           # read the number and store it in cell 0
 &                                          # copy it to cell 1
  (                                         # loop while cell 0 isn't 0
   -                                        # decrease the value of cell 0
    .N                                      # print "N"
      %3                                    # copy cell 0 to cell 3
                                            # a space must be added after the number. I don't know if it's a bug of the compiler or a feature.
         >                                  # move to cell 1
          &                                 # copy cell 1 to cell 2
           >                                # move cell 2
            s                               # let cell 2 = cell 2 - cell 3
             -                              # decrease the value of cell 2
              {                             # if cell 2 isn't 0
               -                            # decrease the value of cell 2
                (-. )                       # while cell 2 isn't 0, decrease it and print " "
                     .N                     # print "N"
                       }                    # end if
                        >                   # move cell 3
                         {                  # if cell 3 isn't 0
                          -                 # decrease the value of cell 3
                           (-. )            # while cell 3 isn't 0, decrease it and print " "
                                .N          # print "N"
                                  }         # end if
                                   _0       # move to cell 0
                                      '\n"  # print a newline
                                          ) # 

작업 3

/>>/(<<&>dm<s&>>%0 <&>)<<\

유클리드 알고리즘. WTFZOMFG에는 mod 명령이 없으므로 d(나누기), m(곱하기) 및 s(빼기) 를 사용해야 합니다.

2009-이동

Go는 Google에서 개발 한 프로그래밍 언어입니다. 개발은 2007 년에 시작되었지만 Go는 2009 년 11 월에 발표되었습니다.

Go는 C의 영향을받는 정적으로 유형이 지정된 언어로서 간결함, 단순성 및 안전성을 강조합니다.

작업 1 :

package main
import "fmt"

func main(){
    fmt.Println("Go was made in 2009!")
}

첫 번째 줄은 코드 패키지를 선언합니다. 한 줄을 인쇄하는 간단한 예제조차도 한 패키지의 일부 여야합니다. 실행 파일은 항상이라고 main합니다.

작업 2 :

package main

import (
        "fmt"
        "strings"
)

func main(){
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        a := make([]string, n, n)
        for j := 0; j < n; j++ { a[j] = " " }

        a[0] = "N"
        a[i] = "N"
        a[n-1] = "N"

        s := strings.Join(a, "")
        fmt.Println(s)
    }
}

Go는 매우 간결한 변수 선언을 가지며 ( i := 0와 동일 var i int = 0) 컴파일러가 유형을 결정합니다. 이것은 일반적으로 동적 언어에서 더 일반적인 기능입니다. 이 짧은 표기법을 사용하면 변수 ( f := func(x int) int {/* Code */})에 함수를 할당 하고 클로저를 만드는 것도 쉽습니다 .

작업 3 :

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main(){
    var a, b int
    fmt.Scan(&a)
    fmt.Scan(&b)

    fmt.Println(gcd(a, b))
}

여기 a, b = b, a%b구문 이 보입니다 . 정말 좋습니다. 정확한 이름을 모르지만 Python에서는 튜플 압축 풀기라고합니다. 같은 방법으로 함수 ( func f() (int, string) { return 42, "Hallo"}) 에서 여러 값을 반환 할 수 있습니다 .

이 코드에서 발생하는 또 다른 일은 루프입니다. for 루프는 Go에서 유일한 루프입니다. While-loops 또는 do-while-loops는 존재하지 않습니다. 그러나 while 루프 for condition {}나 무한 루프에 해당하는 것을 쉽게 만들 수 있습니다 for {}.

1991- 파이썬

언어 역사

1980 년대 후반, Guido van Rossum은 Python을 취미로 고안하기 시작했습니다. 그 이름은 영국의 TV 쇼인 Rossum이 팬인 Monty Python의 Flying Circus에서 나왔습니다. 최초의 Python 구현은 1989 년에 시작되어 1991 년에 릴리스되었습니다. 수년에 걸쳐 인기가 급증하면서 많은 입문 컴퓨터 과학 과정에서 선택되는 언어가되었습니다.

"안녕하세요, 월드!" 다른

print("Python was made in 1991!")

입력 주위의 괄호를로 확인하십시오 print. 이 구문은 Python 2에서 작동하지만 일반적으로 Python 2에서는 이러한 괄호를 생략합니다. 그러나 Python 3에서는 필수입니다. Zach Gates가 제안한대로 여기에 제시된 코드가 여러 버전에서 작동하도록 괄호가 사용됩니다.

ASCII 아트 N

def asciin(n):
    if n == 1:
        print("N")
    else:
        print("N" + " "*(n-2) + "N")

        for i in range(2, n):
            print("N" + " "*(i-2) + "N" + " "*(n-i-1) + "N")

        print("N" + " "*(n-2) + "N")

기능은을 사용하여 정의됩니다 def. +와 문자열 반복을 사용하여 문자열 연결을 수행 *합니다.

GCD

def gcd(a, b):
    if b == 0:
        return(a)
    else:
        return(gcd(b, a % b))

파이썬에는 구조화 된 공백이 필요합니다.

1968 년 -Algol 68

Algol 68은 IFIP 실무 그룹 2.1에 의해 Algol 60의 후계자로 정의되었습니다.

모든 것이 가치가있는 표현 지향 언어입니다. 또한 어떤 방식 으로든 모든 구성을 사용할 수있는 직교 형입니다. 이는 예를 들어 표현이 과제의 RHS 및 LHS에있을 수 있음을 의미합니다.

모든 제어 구조는 표현식을 사용하여 긴 형식뿐만 아니라 약어 형식도 있습니다. 또한 연산자의 정의를 허용합니다.

언어의 목표는 다음과 같습니다.

ALGOL 68 디자인의 주요 목표와 원칙 :

• 설명의 완전성과 명확성
• 직교 디자인,
• 보안,
• 능률
• 정적 모드 확인
• 모드 독립적 파싱
• 독립적 인 편집
• 루프 최적화
• 표현-최소 및 더 큰 문자 세트

이 프로그램은 언어의 완전한 구현 인 Algol 68 Genie 인터프리터 로 테스트되었습니다 .

현대 프로그래머가 다르게 볼 수있는 일부 기능은 빈 문장은 허용되지 않는다는 것입니다. ;어디에나 추가 할 수는 없습니다 . SKIP명시 적으로 아무 것도 갖지 않으려면 명령문 을 사용해야합니다 . 또한 동시 프로그램을 매우 쉽게 코딩 할 수있었습니다. 특히 Algol 68은 esac , od , fi 등과 같은 키워드를 역 종결 자로 사용했습니다 .

이 언어에는 키워드를 굵게 표시하는 많은 글꼴 과 기울임 꼴로 된 식별자 를 사용하는 코드를 작성하는 데 사용되는 표현이 있습니다 . 당시 그리고 아마도 여전히 컴파일러는 디자인의이 기능을 구현하지 않았습니다. 이 언어는 스트로 핑 모드를 사용하는 여러 가지 구체적인 프로그램 표현을 허용했습니다 . 이를 통해 1960 년대 컴퓨터에서 볼 수있는 것처럼 제한된 문자 세트를 사용하여 프로그램을 준비 할 수있었습니다. 다음과 같이 짧은 프로그램 조각을 고려하십시오.

만약 내가 < 0 후 이동 인터넷을

이는 다음 과 같이 프라임 스트로크 모드 의 컴파일러에 대해 준비 될 수 있습니다 .

'IF' I 'LT' 0 'THEN' 'SKIP' 'FI'

에서 점 stropping 모드이 될 것이다 :

.IF I .LT 0 .THEN .SKIP .FI

년 의 경우 stropping 모드이 될 것이다 :

IF i < 0 THEN SKIP FI

컴파일러 구현 중 하나와 수년 동안 독점적으로 프로그래밍을 수행 하면서이 언어를 좋아했습니다.

작업 1

print (( "알골 68은 1968 년에 만들어졌습니다!", 개행 ))

여기서 주목할 점은 이중 괄호입니다. print 는 모든 유형의 공용체의 가변 길이 배열 인 단일 인수를 취하는 함수 이기 때문 입니다. 내부 괄호는 배열 생성자입니다. 이것은 다형성이이 강력한 형식의 언어로 처리되는 방식입니다.

스트로 핑 모드의 경우 :

print (("Algol 68 was made in 1968!", newline))


C:\>a68g HelloWorld.a68
Algol 68 was made in 1968!

작업 2

     int n ;
     읽음 (( n ));
     위한 I 에서 1 행 N은 수행
          을위한 J 에서 1 에 해당 할
               ¢를 우리가 축약 된 IF 절 사용 여기 ¢
               인쇄 ((( J = 1 또는 J = I 또는 j는 = N |
                    "N"
               |
                    ""
               )))
          OD를 ;
     인쇄 (( 개행))
     od

스트로 핑 모드의 경우 :

 INT n;
 read ((n));
 FOR i FROM 1 TO n DO
        FOR j FROM 1 TO n DO
            CO here we use an abbreviated IF clause CO
            print (( ( j = 1 OR j = i OR j = n |
                 "N"
            |
                 " "
            ) ))
        OD ;
        print ((newline))
    OD

C:\>a68g ASCIIart.a68
8
N      N
NN     N
N N    N
N  N   N
N   N  N
N    N N
N     NN
N      N

작업 3

     ¢ 우리는 Algol 68에서 자신의 연산자를 정의 할 수 있습니다. ¢
     op % = ( int a , b ) int :
          (( b = 0 |
               a
          |
               b % ( 모드 B )           )); int i , j ; 읽음 (( i , j )); 인쇄 (( i % j , 줄 바꿈 ))

    
    
    

스트로 핑 모드의 경우 :

COMMENT we can define our own operators in Algol 68 COMMENT
OP % = ( INT a, b) INT:
    ((b = 0 |
        a
    |
       b % (a MOD b)
    ));
INT i,j;
read((i,j));
print(( i % j , newline))


C:\>a68g GCD.a68
4 12
         +4

1962-스노볼

"StriNg 지향 및 symbolic 언어". 처음에는 Symbolic Expression Interpreter (SEXI)라고 불 렸는데, 1960 년대 대단한 사람들이 일자리를 제출할 때 홍조가 생기지 않도록 변경해야했습니다. 실화.

이것은 기본적으로 문자열과 패턴을 다룰 수있는 최초의 언어 중 하나였습니다. 실제로 SNOBOL의 첫 번째 버전은 문자열을 유일한 데이터 유형으로 사용했습니다. 그런 다음 파싱하여 수학을 수행했습니다. 초기 구현은 IBM 7090에서 수행되었습니다. 적어도 그것을 찾을 수 없었습니다. 내가 찾은 것은 현대 컴퓨터에서 실행할 수있는 Java 의 SNOBOL3 인터프리터와이 문서를 설명하는 원본 논문 이었습니다 .

첫 번째 SNOBOL은 패턴 매칭과 기본 산술 만을 거의 사용했습니다 . SNOBOL 3은 기능을 추가하고 I / O를 변경했지만 이전 버전과 호환되는 것으로 보입니다. SNOBOL 4는 구문을 변경 한 후 아이콘으로 개발되어 패턴 일치를 유지하지만 그렇지 않으면 "정상적인"프로그래밍 언어처럼 보입니다.

필자가 작성한 프로그램은 원래 백서에 설명 된 기능 만 사용하므로 Java 인터프리터가 실행할 수 있도록 SNOBOL3 스타일로 수행 한 I / O를 제외하고 원래 SNOBOL과 함께 작동해야합니다. 이 논문에서 SNOBOL1은 특수 SYS변수 와 패턴 일치를 사용하는 반면 SNOBOL3은 입력 및 출력 변수를 사용 한다는 차이점이 있습니다 .

• 입력:
  • 1 SYS .READ *DATA*
  • 삼 DATA = SYSPPT
• 산출:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 삼 SYSPOT = 'A STRING' AND VARIABLES

이러한 대체물을 만들면 '실제'SNOBOL 1을 얻게됩니다. 물론 실행할 수는 없습니다.

작업 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

작업 2

수학, 문자열 처리 및 흐름 제어를 보여줍니다. SNOBOL3에는 EQ평등을 확인하는 것과 같은 유용한 기능이 있습니다 . 원래 SNOBOL은 사용하지 않았으므로 사용하지 않았습니다.

* READ N FROM INPUT
START   SYSPOT = 'SIZE?'
        SZ = SYSPPT

* INITIALIZE
        CS = ''
        ROW = '0'

* OUTPUT PREVIOUS ROW AND START NEXT ONE
ROW     COL = '0'
        SYSPOT = CS
        CS = ''

COL     SUCC = 'N'
        EQ1 = COL
        FAIL = 'CHKE'
        EQ2 = '0'         /(EQUAL)
CHKE    FAIL = 'CHKR'
        EQ2 = SZ - '1'    /(EQUAL)
CHKR    FAIL = 'SPACE'
        EQ2 = ROW         /(EQUAL)

* CONCATENATE THE RIGHT CHARACTER TO THE CURRENT LINE         
SPACE   CS = CS ' '       /(NEXT)
N       CS = CS 'N'       /(NEXT)

* FOR NUMBERS, SUBSTRING MATCH IS ENOUGH IF IT IS KNOWN A<=B
NEXT    COL = COL + '1'
        COL SZ            /F(COL)
        ROW = ROW + '1'
        ROW SZ            /F(ROW)S(FIN)

* THERE SEEMS TO BE NO EQUALITY CHECK, JUST SUBSTRING MATCHING
* OF COURSE, EQ1 == EQ2 IFF EQ1 CONTAINS EQ2 AND VICE VERSA
* THIS ALSO ILLUSTRATES INDIRECTION
EQUAL   EQ1 EQ2           /F($FAIL)
        EQ2 EQ1           /S($SUCC)F($FAIL)

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

작업 3

먼저, 지루한 것. 주목할 것은 문자열 지향 SNOBOL이 실제로 얼마나 정확한지를 보여주는 검사보다 작은 것입니다. (B - A) '-'"BA의 결과에 마이너스가 포함되어 있습니까?"를 의미합니다. SNOBOL3도 할 수 LE(B,A)있지만 SNOBOL 1은 할 수 없습니다 (적어도 종이는 언급하지 않았습니다).

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* GCD LOOP
STEP    '0' (A - B)          /S(DONE)
        (B - A) '-'          /S(AB)F(BA)
AB      A = A - B            /(STEP)
BA      B = B - A            /(STEP)
DONE    SYSPOT = 'GCD: ' A

물론 문자열과 패턴 일치를 전적으로 기반으로하는 언어를 사용하는 경우 실제로 패턴 일치 및 대체를 사용하지 않는 것이 부끄러운 일입니다. 따라서 단항으로 변환하거나 단항으로 변환하는 루틴을 포함하여 단항 기반 GCD 중 하나입니다.

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* CONVERT TO UNARY
        UNA.IN = A
        UNA.FIN = 'ADONE'          /(UNA)
ADONE   A = UNA.R
        UNA.IN = B
        UNA.FIN = 'BDONE'          /(UNA)
BDONE   B = UNA.R


* USE STRING MATCHING TO FIND GCD
STEP    '' B                       /S(GDONE)
MATCH   A B =                      /S(MATCH)
        C = B
        B = A
        A = C                      /(STEP)

* CONVERT BACK TO DECIMAL
GDONE   DEC.IN = A
        DEC.FIN = 'DONE'           /(DEC)
DONE    SYSPOT = 'GCD: ' DEC.R     /(FIN)

***************************** 
* DECIMAL TO UNARY SUBROUTINE
UNA     UNA.R =
UNA.DGT UNA.IN *.DGT/'1'* =        /F($UNA.FIN)
        .X = UNA.R
        UNA.R =
UNA.MUL .X *.Y/'1'* =              /F(UNA.ADD)
        UNA.R = UNA.R '##########' /(UNA.MUL)
UNA.ADD '1' .DGT                   /S(UNA.1)
        '2' .DGT                   /S(UNA.2)
        '3' .DGT                   /S(UNA.3)
        '4' .DGT                   /S(UNA.4)
        '5' .DGT                   /S(UNA.5)
        '6' .DGT                   /S(UNA.6)
        '7' .DGT                   /S(UNA.7)
        '8' .DGT                   /S(UNA.8)
        '9' .DGT                   /S(UNA.9)
        '0' .DGT                   /S(UNA.DGT)
UNA.1   UNA.R = UNA.R '#'          /(UNA.DGT)
UNA.2   UNA.R = UNA.R '##'         /(UNA.DGT)
UNA.3   UNA.R = UNA.R '###'        /(UNA.DGT)
UNA.4   UNA.R = UNA.R '####'       /(UNA.DGT)
UNA.5   UNA.R = UNA.R '#####'      /(UNA.DGT)
UNA.6   UNA.R = UNA.R '######'     /(UNA.DGT)
UNA.7   UNA.R = UNA.R '#######'    /(UNA.DGT)
UNA.8   UNA.R = UNA.R '########'   /(UNA.DGT)
UNA.9   UNA.R = UNA.R '#########'  /(UNA.DGT)

*****************************
* UNARY TO DECIMAL SUBROUTINE
DEC     DEC.R =
DEC.DGT '' DEC.IN                  /S($DEC.FIN)
        .X = DEC.IN
        DEC.IN =
DEC.DIV .X '##########' =          /F(DEC.ADD)
        DEC.IN = DEC.IN '#'        /(DEC.DIV)
DEC.ADD '' .X                      /S(DEC.0)
        '#' .X                     /S(DEC.1)
        '##' .X                    /S(DEC.2)
        '###' .X                   /S(DEC.3)
        '####' .X                  /S(DEC.4)
        '#####' .X                 /S(DEC.5)
        '######' .X                /S(DEC.6)
        '#######' .X               /S(DEC.7)
        '########' .X              /S(DEC.8)
        '#########' .X             /S(DEC.9)
DEC.0   DEC.R = '0' DEC.R          /(DEC.DGT)
DEC.1   DEC.R = '1' DEC.R          /(DEC.DGT)
DEC.2   DEC.R = '2' DEC.R          /(DEC.DGT)
DEC.3   DEC.R = '3' DEC.R          /(DEC.DGT)
DEC.4   DEC.R = '4' DEC.R          /(DEC.DGT)
DEC.5   DEC.R = '5' DEC.R          /(DEC.DGT)
DEC.6   DEC.R = '6' DEC.R          /(DEC.DGT)
DEC.7   DEC.R = '7' DEC.R          /(DEC.DGT)
DEC.8   DEC.R = '8' DEC.R          /(DEC.DGT)
DEC.9   DEC.R = '9' DEC.R          /(DEC.DGT)

FIN     START

2012-TypeScript

TypeScript는 Microsoft에서 개발하고 유지 관리하는 무료 오픈 소스 프로그래밍 언어입니다.

주요 목표는 모든 브라우저입니다. 모든 호스트. 모든 OS. 오픈 소스. 2012 년 10 월 에 발매되었습니다

안녕하세요 TypeScript

Task1(name:string,year:number) {
    return name + " was made in "+ year +"!";
}

ASCII 아트

Task2(n:number,separator:string,space:string) {
    var result:string = "";
    for (var k = 0; k < n; k++)
    {
        for (var j = 0; j < n; j++)
        {
            var i = ((n * k) + j) % n;
            result+=(i == 0 || i == n - 1 || i == k) ? "N" : space;
        }
        result+=separator;
    }
    return result;
}

GCD

Task3(a:number,b:number) {
    while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        if (a == 0)
            return b;
        else
            return a;
}

온라인으로 시도 하고, 스크린 캐스트 그것의.

2011-다트

Dart는 Google이 개발 한 오픈 소스 프로그래밍 언어로 Javascript를 대체하기 위해 개발되었습니다 (Javascript로 컴파일 됨). 2011 년 GOTO 컨퍼런스에서 Google에 의해 공개되었습니다.

"Hello World!" 다른:

main() {
  print('Dart was made in 2011!');
}

ASCII 아트 N :

Bruteforce 방법은 0 (n²)에서 실행되지만 큰 숫자를 사용하지 않으면 실제로 중요하지 않습니다.

asciiN(int number){
    if(number == 1){
        print('N');
    }else{
        for(var i = 1; i <= number; i++){
            String currentLine = "";
            for(var j = 1; j <= number; j++){
                if(j==1 || j == number || j == i){
                    currentLine = currentLine + "N";
                }else{
                    currentLine = currentLine + " ";
                }
            }
            print(currentLine);
        }
    }
}

GCD

Snap에서 이식 된 간단한 유클리드 방법! 위의 예.

int gcd(int first, int second){
if(second > first){
   return gcd(second, first);
    }else{
        if(first == 0){
            return second;
        }else{
            if(second ==0){
                return first;
            }else{
                return gcd(second, first-second);
            }
        }
    }
}

2010- 녹

Rust는 Mozilla Research에서 개발 한 범용 다중 패러다임 컴파일 프로그래밍 언어입니다. 이 기능은 "안전하고 동시적인 실제 언어"로 설계되어 순수 기능, 동시 행위자, 명령형 절차 및 객체 지향 스타일을 지원합니다. 위키 백과

작업 1

fn main()
{
    println!("Rust was made in 2010!");
}

작업 2

fn main()
{
    // get commandline arguments
    // "test 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd argument to integer
    let n = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    print_n( n );
}

fn print_n( n: u32 )
{
    for y in range( 0, n )
    {
        for x in range( 0, n )
        {
            if x == 0 || x == y || x + 1 == n
            {
                print!("N");
            }
            else
            {
                print!(" ");
            }
        }
        println!("");
    }
}

설명:

if x == 0 || x == y || x + 1 == n

세로 (왼쪽 및 오른쪽 |) 및 대각선 ( \) 만 인쇄합니다.

작업 3

Euclidean_algorithm의 간단한 구현

fn main()
{
    // get commandline arguments
    // "test 453 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd and 3rd argument to integers
    let a = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    let b = u32::from_str_radix( args[2].as_ref(), 10 ).unwrap();
    let g = gcd( a, b );
    println!( "GCD of {} and {} is {}", a, b, g );
}

fn gcd( mut a: u32, mut b: u32 ) -> u32
{
    while b != 0
    {
        let c = a % b;
        a = b;
        b = c;
    }
    return a;
}

2015-머핀 MC

머핀 MC 는 2015 년 2 월 중순 에 프랑크 포쳐 (Franck Porcher) ( http://franckys.com ) 가 튜링이 완전하고, 재미 있지만 (심각한) 기능적이며 미니멀 한 매크로 언어로 , 새로운 Tahitian 패션 브랜드의 Prestashop 기반 판매자 사이트와 관련된 모든 재고 관련 작업을 시험하고 추진하기위한 유일한 프론트 엔드 컨트롤러로 사용되는 스프레드 시트 : Mutiny Tahiti ( http://mutinytahiti.com을 곧 수 - 시작).

머핀 MC는 약자입니다 MU 작은 F unctional F의 lexible IN 라인 M 아크로 C ommand 언어.

머핀 MC 의 핵심 기능은 이터레이터 , 지연 평가 , 다중 펑터 및 스트링 제품 과 같이 유연하고 효율적인 1 급 내장 시맨틱 구성을 중심으로 설계되었습니다 .

머핀 MC 는 (실용적인) 기능 프로그래밍 인 FLisp 및 Perl에 기반을두고 있습니다. 그것은 (최적화없이) 재귀를 완전히 지원하고 동적으로 유형이 지정되고 동적으로 범위가 지정됩니다 (얕은 바인딩). 기본 데이터 유형 원자 (원자, 문자열, 숫자)를 제외하고 사용자에게 하나의 데이터 구조 만 제공합니다.

머핀 MC 목록 시맨틱 (종류)은 다음과 같이 전원 설정 시맨틱을 빌립니다 .

1. 모든 Muffin MC 작업은 목록을 생성하며 비어있을 수 있습니다.
2. 개별 목록 요소에 대한 액세스는 항상 해당 요소로 구성된 단일 값 목록을 생성합니다 (단일 톤으로 생각).
3. 빈 목록은 목록 작업의 중립 요소입니다.

이를 조정하기 위해 다음이 도움이 될 수 있습니다.

• 카디널리티가 가장 큰 목록의 전원 집합 요소로 목록을 시각화 할 수 있습니다.
• 목록의 요소를 해당 요소로 구성된 싱글 톤 인 목록의 전원 집합 요소로 시각화합니다.
• 빈 목록을 빈 세트로 시각화하십시오. 즉, 빈 세트의 전원 세트의 유일한 요소입니다.

따라서 빈 목록 요소에 액세스하면 빈 목록이 생성되고 오류는 발생하지 않습니다! 실제로, Muffin MC 는 많은 전통적인 작업의 의미를 확장하여 가능한 적은 오류를 발생 시키려고 노력합니다.

작업 1

#(say "MuffinMC was born in 2015 out of necessity !")

#(...)Perl에서 빌려온 내장 함수 인 평가되지 않은 인수 목록에 함수를 적용하기위한 Muffin MC 매크로 명령입니다 say.

#(say 1 2 3 ...) 기능적으로 동일하다 map {say $_} (1,2,3,...)

작업 2

기능을 정의하십시오 ascii-art():

=(ascii-art
    '( =(*  x   #(2- $(_1))
        I   I( *($(x) " ") N)
            foo '( #(. #(I $(x))) ))
    #(say ?( #(== $(_1) 1) N "N#(map foo #(.. 1 $(_1)))N" ))
 ))

Ascii-art()가장 짧은 작업 양식 (88 바이트) :

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))

• =(var val...)변수를 정의하거나 재 할당 하는 Muffin MC 매크로 명령입니다.

• $(var)변수 값에 액세스하기위한 머핀 MC 매크로 명령입니다. $(v1 v2 ...)한 번에 많은 변수에 액세스 하는 형식 을 자연스럽게 받아들 입니다.

• =(* var1 val1 var2 val2 ...)병렬 할당을 처리하기위한 머핀 MC 매크로 명령 의 확장입니다 =(...).

• Variables _1, _2...는 동적으로 범위가 지정되며 (얕은 바인딩 메커니즘) 자동으로 함수의 인수에 바인딩되도록 설정됩니다. Perl5에서 빌려온 시스템 변수 #(인수 수) 및 @(인수 목록)도 자동으로 설정됩니다.

• 함수는 단순히 여러 머핀 MC 문에 바인딩 된 변수 입니다.

이 흥미로운 솔루션은 두 가지 자연 머핀 MC 내장 기능 을 결합한 것입니다 .

1. 머핀 MC I(...) 매크로 명령은 나중에 함수 형태로 사용되는 자전거 - 반복자를 정의하기 위해 #(my-iterator want-number-of-values),

2. 머핀 MC 문자열 제품 구조, 임의의 문자열을 주어진 자연 변수 보간의 확장 "F1 F2 F3..."은 F는 I (S) 중 하나 머핀이다 MC의 문자열 상수 또는 머핀 MC 매크로 명령 (일명 기능적 형태)만큼의 문자열을 생성 할 것이다 제품 기본 (F1) x 기본 (F2) x ...로 제공됩니다.

예를 들어, 2 개의 값을 보유하고있는 xa 변수, a와 b를 말하고, y에 3 개의 값을 보유하고있는 또 다른 변수, 1 2 3을 말하면, 문자열 "x=$(x) y=$(y))"을 평가 하면 6 개의 다른 값, 즉 순서대로 생성됩니다.

• "x = ay = 1"
• "x = ay = 2"
• "x = ay = 3"
• "x = by = 1"
• "x = by = 2"
• "x = by = 3"

이것은 Muffin MC 가 설계된 MUTINY 프로젝트의 매우 바람직한 기능 중 하나입니다 .

그것을 실행하십시오!

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


#(map '( #(ascii-art $(_1))) 5 7 9)

N   N
NN  N
N N N
N  NN
N   N

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

N       N
NN      N
N N     N
N  N    N
N   N   N
N    N  N
N     N N
N      NN
N       N

작동 원리

우리의 알고리즘은 다음을 기반으로합니다.

ascii-art (n)를 호출하면 {n = 2p + 1 | p 정수, p> = 0}에서, 생성하는 기술은 n 개의 n 개의 문자열을 포함하는데, 그 중 가장 왼쪽과 오른쪽 중 두 개는 고정되고 항상 동일하다 : 'N'. 이렇게하면 중간 줄만 생성하는 문제를 줄일 수 있습니다. 예를 들어, n = 5이면 각각 n-2 개의 문자로 구성된 5 개의 다음 중간 문자열을 생성 할 수 있습니다 (보다 나은 시각화를 위해 공백을 '_'로 바꿨습니다).

    The 5 strings :
        _ _ _
        N _ _ 
        _ N _
        _ _ N
        _ _ _

    can be seen as resulting from splitting in groups of 3 characters
    the following infinite sequence of 4 characters :


        /---- < _ _ _ N > ----\
       |                       |
        \---------------------/    


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _

• 이러한 중간 줄은 ('_' '_' '_' 'N')5 개 그룹의 3 개 그룹에서 4 개 요소 시퀀스 를 순환하여 쉽게 생성 할 수 있습니다 . n이 주어지면 함수의 입력과 같은 시퀀스는 n-2 문자로 구성 '_'되고 그 뒤에 문자 가옵니다 'N'. 이 시퀀스를 순환하는 것은 머핀 MC I(sequence) 내장 반복기 (초기 값 시퀀스를 영원히 순환하는 반복기) 내에 시퀀스를 포함시키는 것 외에는 아무것도 필요하지 않습니다 .

• 그런 다음 반복자에게 다음 n-2 값 (n-2 문자)을 제공하도록 요청하여 길이 n-2의 중간 문자열을 간단히 생성합니다.이 문자열은 함께 연결되어 예상 중간 문자열을 생성합니다.

• n 개의 중간 문자열은 맵을 사용하여 n 개의 결과 (n 개의 n-2 개의 문자열)를 수집하여 위의 프로세스를 n 번 반복하여 생성됩니다.

• n 개의 최종 문자열을 생성하기 위해 또 다른 강력한 Muffin MC 내장 구성, 즉 문자열 곱을 사용합니다 "N#(map...)N".

• 그리고 그게 다야 !

  Commented script  
  
  =(ascii-art                    Define the 'ascii-art' variable to hold
                                 the function's definition.
                                 When called, its argument, the actual
                                 value of n, will be bound to the system
                                 variable _1, accessed as $( _1 ).
  
      '(                         '(...) quote macro-command -- protects 
                                 its arguments, here the function 
                                 definition, from being evaluated.
                                 We want to keep it literally for further evaluation.
  
         =(*                     =(*...) // assignment macro-command.
                                 Similar to the Lisp (let (...)...),
                                 not the let* !
  
             x #(2- $(_1))       Define the variable x to hold the value 
                                 n-2.   
  
             I I(                Define I to be an iterator over the 
                                 the x+1 characters sequence :
                  *( $(x) " ")   . x white-space characters
                  N              . 1 'N' character (here the atom N)
               )
  
             foo '(              Define the variable foo as a function 
                    #(.          to catenate ( #(. s1...) )
                       #(I $(x)) the iterator's next x elements.
                     )            
             )
         )                       End of =(*...
  
      #(say                      Print each element of:
         ?(                      If
            #(== $(_1) 1)        n equals 1
    N                    the atom N,
    "N#(map foo #(.. 1 $(_1)))N" else the n strings as a string-product 
                                 resulting from foo-computing the  
         )                       n middle-strings.
       )
   ))
  

작업 3

기능을 정의하십시오 gcd():

=(gcd '( ?( #(== $(_2) 0)
        $(_1)
            #(self $(_2) #(mod $(_1) $(_2)))) ))

gcd()의 실제 짧은 형태 (37 바이트 - 2 바이트가 Rodolvertice 덕분에 이득)

=(g'(?(#(z$(_2))$(_1)#(g$(_2)#(mod)))))

그것을 실행하십시오!

#(gcd 225 81)

수율 9.

그게 다야.

멋진 게임과 관심에 감사드립니다. 이 언어는 놀거나 사용하거나 확장하려는 모든 사람이 사용할 수 있습니다. 그냥 물어 보면 기꺼이 보내 드리겠습니다.

건배

프랭크

추신. 머핀 MC 의 현재 구현은 Perl5에 있습니다. 소스 코드는 주석을 포함하여 약 2000 줄의 최신 Perl이며, 회귀가 아닌 테스트 슈트와 함께 제공되는데, 이는 실제 머핀 MC 구조와 의미 를 배우기에 좋습니다 .