젤리 A는 암묵적 우리 자신에 의해, 골프 지향 프로그래밍 언어 데니스 . 여기 에는 자체 코드 페이지 와 강력한 체인 시스템을 사용하여 프로그램을 간결하게 표현 함으로써 Pyth 및 CJam과 같은 다른 골프 언어를 능가하는 대답이 점점 더 자주 나타납니다 .

젤리에서 골프를 치기위한 유용한 팁을 모 읍시다. (항상 그렇듯이, 답변 당 팁 하나만주세요!)

문자열 압축

보다 최적화 된 자동 스트링 컴프레서를 찾고 있다면 이것을 사용해보십시오 .

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

압축 된 문자열은 다음과 같습니다 “...». 여기서 도트는 기본 250 인코딩 된 데이터의 덩어리입니다. 압축 해제 알고리즘은 약간 복잡합니다. 청크는 divmod이 정수의 여러 부분을 분리하고 문자열을 구성하여 "혼합-기본"정수로 해석됩니다 .

젤리 문자열을 압축하기 위해 작은 Python 3 인터페이스를 만들었습니다.

import dictionary
code_page = '''¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”'''

class Compress(list):
    def character(self, c):
        if c in '\n\x7f¶':
            o = 95
        elif ' ' <= c <= '~':
            o = ord(c)-32
        else:
            raise ValueError(c + " is neither printable ASCII nor a linefeed.")
        self += [lambda z: 3*z+0, lambda z: 96*z+o]; return self
    def string(self, s):
        for c in s: self.character(c)
        return self
    def dictionary(self, w):
        ts = bool(self)
        if w[:1] == ' ': w = w[1:]; ts = not ts
        dct = dictionary.short if len(w) < 6 else dictionary.long
        W, sc = (w, 0) if w in dct else (w[:1].swapcase() + w[1:], 1)
        if W not in dct: raise ValueError(w + " isn't in the dictionary.")
        f = ts or sc; j = (2 if sc else 1) if ts else 0; i = dct.index(W)
        self += [lambda z: 3*z+2, lambda z: 3*z+j] if f else [lambda z: 3*z+1]
        self += [lambda z: 2*z+int(len(w) < 6), lambda z: len(dct)*z+i]
        return self
    def go(self):
        compressed = []; z = 0
        for f in self[::-1]: z = f(z)
        while z:
            c = z % 250
            if c == 0: c = 250
            z = (z - c) // 250
            compressed.append(code_page[c - 1])
        return '“{0}»'.format(''.join(compressed[::-1]))

다음과 같이 압축기를 사용하십시오.

print(Compress()
      .dictionary('public')
      .dictionary(' static')
      .dictionary(' boolean')
      .string(' is')
      .dictionary('Power')
      .string('Of')
      .dictionary('Ten')
      .string('(')
      .dictionary('long')
      .dictionary(' input')
      .string(') {\n ')
      .dictionary(' return')
      .string('\n   ')
      .dictionary(' input')
      .string(' ==')
      .go())

Compress 문자열 빌더입니다.

• .string(s) 인쇄 가능한 원시 ASCII 문자를 문자열에 삽입합니다.

  (각 문자는 약 0.827 압축 바이트입니다.)

• .dictionary(w)Jelly의 내장 사전에서 문자열을 찾습니다. 원하는 경우 하나의 공백으로 문자열을 시작할 수 있습니다. 이것이 일반적인 문자열 추가 동작에서 벗어나거나 사전 단어의 대문자를 뒤집어 야하는 경우 그에 따라 플래그를 추가합니다.

  (단어의 경우 약 1.997 바이트, 긴 단어의 경우 2.433 바이트; 플래그가있는 경우 0.199 바이트를 추가하십시오.)

이것은 젤리 위키 튜토리얼 이 된 것 중 일부입니다 .

쇠사슬

(이것은 일종의 Tacit 프로그래밍 에 대한 후속 조치 입니다.)

젤리는 체인을 어떻게 평가합니까? 이전에 설명했듯이,이 체인이 niladically , monadically 또는 dyadically 로 호출되는지 여부는 세 가지 경우가 있습니다.

1. 닐라 딕 체인

이것들은 가장 쉬운 방법입니다. nilad로 시작 하는 niladic chain을 평가하려면 nilad α f g h에서 monadic chain f g h을 평가하십시오 α. (주의 : 전체 체인이 비어 있으면 대신 0이 반환됩니다. nilad α 가 아닌 경우 대신 사용하십시오 α=0.)

예를 들어, 4½그냥 ½에서 평가 4인 2.

2. 모나 딕 체인

고려해야 할 링크가 없을 때까지 수도원 체인은 왼쪽에서 오른쪽으로 세분화됩니다. 또한 ω여기에 몇 가지 논증이 전달 되었습니다. 대답해야 할 두 가지 질문이 있습니다.

이 좌우 평가의 시작 값은 무엇입니까?

• 체인이 nilad로 시작하고 α그 뒤에 0 개 이상의 모나드 (예 ½:), dyad-nilad 쌍 (예 +2:) 및 nilad-dyad 쌍 (예 :)이 4*오는 경우 : 평가 α하여 시작한 다음 나머지 체인을 고려합니다 .

• 그렇지 않으면이 체인에 전달 된 인수에서 시작 ω하여 전체 체인을 고려합니다.

우리는 어떻게 체인을 걸어가 는가?

V현재 값을 호출합시다. 처음에는 위에서 설명한 값이지만 체인을 통과 할 때 업데이트됩니다.

• 자릿수를 사용한 나 일드
• 소문자를 사용하는 모나드,
• 조작 기호를 사용 댓구 +, ×, ÷.

그런 다음 위에서 아래로 다음 패턴이 일치합니다.

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ω)×1 │ *
                                 │ + f ...   │ V+f(ω)  │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ω     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

체인에서 시도해 봅시다 +²×.

• +Nild가 아니므로에서 시작합니다 V = ω.
• 그런 다음 +²두 번째 패턴과 일치하고 잘라냅니다 V = ω+ω².
• 그런 다음 ×다섯 번째 패턴과 일치하고 잘라냅니다 V = (ω+ω²)×ω.
• 체인은 이제 비었으므로 (ω+ω²)×ω최종 결과도 마찬가지 입니다.

3. 이색 체인

이것들은 기본적으로 모나 딕 체인과 같지만 이번에는 λ(왼쪽)과 ρ(오른쪽)의 두 가지 주장이 있습니다 .

시작 가치는 무엇입니까?

• 세 댓구와 체인의 시작이 좋아하는 경우에 + × %, 우리는에서 시작 λ+ρ하고, 체인을 고려 × % ...옆에.

• 그렇지 않으면에서 시작 λ하여 전체 체인을 고려합니다.

우리는 어떻게 체인을 걸어가 는가?

이번에는 패턴이

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ρ)×1 │ *
                                 │ + × ...   │ V+(λ×ρ) │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ρ     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

체인에서 시도해 봅시다 +×÷½.

• 체인은 3 개의 다이아 드 (dyad)로 시작하므로에서 시작하여 V = λ+ρ를 버립니다 +.
• 그런 다음 ×÷두 번째 패턴과 일치하고 잘라냅니다 V = (λ+ρ)×(λ÷ρ).
• 그런 다음 ½여섯 번째 패턴과 일치하고 잘라냅니다 V = sqrt((λ+ρ)×(λ÷ρ)).
• 체인은 이제 비워 졌으므로 끝났습니다.

특수한 숫자 값

다음은 젤리 숫자 파서의 특수한 경우입니다.

• - ~에 평가하다 -1
• . ~에 평가하다 0.5
• ȷ로 평가 1000( ȷ과학 표기법입니다, 예를 들면 2ȷ6이다 2000000)
• ı에 evalulates가 1j( ı복잡한 숫자입니다, 예를 들면 2ı3이다 2+3j)

또한 4ı실제로 같은 것이 4+1j아니라 오히려 주목할 가치가 4있습니다.

예를 들면 다음과 같이 조합하여 사용할 수 있습니다.

• -.이다 -0.5와 -ȷ이다-1000
• -ı이다 -1+1j, ı-이다 -1j그리고 -ı-이다-1-1j
• .ȷ 이다 500.0
• .ı이다 0.5+1j, ı.이다 0.5j그리고 .ı.이다0.5+0.5j
• ȷı이다 1000+1j, ıȷ이다 1000j그리고 ȷıȷ이다1000+1000j

참고 ȷ-이다 0.1, 그러나 어떤이 끝난 바이트 저장이되지 않습니다 .1. 그런 다음 10이있는 내장 변수를 사용하여 해당 바이트 수에서 이미 수행 할 수있는 다음이 ⁵있지만 내장 기능을 사용할 수 없거나 사용 필요성을 저장하는 드문 경우에 유용 할 수 있습니다 ¤.

• ȷ.이다 sqrt(10) ~ 3.162277, .ȷ.이다 sqrt(10)/2 ~ 1.5811그리고 ȷ-.이다1/sqrt(10) ~ 0.31162

최적화 된 스트링 컴프레서

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

Lynn의 포스트 는 이러한 압축 스트링을 생성하는 컴프레서와 함께 압축 스트링이 무엇인지 자세히 설명합니다. 그러나 Jelly의 프로그램을 살펴 보는 동안 가능한 한 가장 짧은 문자열을 얻기 위해 올바른 공간 등의 조합 .dictionary과 결합 해야하는 것이 지쳤습니다 .string.

따라서 사용자의 입력을받는 Lynn의 스크립트 확장을 만들고 사용자가 작업을 수행하지 않고도 압축 할 수있는 가장 짧은 방법을 찾기로 결정했습니다. 스크립트는 상당히 길기 때문에 코드 자체가 아닌 TIO 링크에 추가했습니다.

프로그램이 작동하는 방식은 3 가지 방법을 사용하여 압축하고 가장 짧은 방법을 결정하는 것입니다.

1. 방법 1은 한 번에 입력의 각 바이트를 간단히 인코딩하므로 다른 것보다 가장 긴 결과를 생성하는 경향이 있습니다. 입력이 매우 짧은 경우에도 여전히 긴 대안을 작성합니다. 예를 들어, test압축 할 수있는 가장 짧은 방법 은 “¡ḌY»이지만이 방법은 “¡⁷ƑKʂ»(2 바이트 더 큼)을 반환합니다 . 일반적으로 문자열 길이가 4 자 미만인 경우에만 작동합니다.

2. 두 번째 방법은 문자열을 단어와 문장 부호로 분리합니다. 두 가지 방법이 압축기에 다른 방식으로 추가되기 때문입니다. 사전의 일부인 단어 .dictionary는 Lynn 코드 방법으로 추가됩니다.이 코드는 단순히 코드 포인트로 추가 된 것보다 더 많이 압축합니다. 그러나 구두점은 불행히도 사전의 일부가 아니므로 코드 포인트로 추가해야합니다.

   문장 부호에는 공백이 포함됩니다. 여기에는 방법 번호 3이 사용되지만 방법 2의 첫 번째 평가는 방법 1과 2를 비교하여 문자열을 압축합니다 Hello, World!(단어, 문장 부호 및 공백이 포함되어 있으므로 완벽 함). 문자별로 문자를 압축하면 최종 문자열 “ŒCdẉa÷¹ṂȤƓ(Ẋ)»(15 바이트 길이)이 나오고, Hello, World !: 출력하기 쉬운 방법보다 깁니다 “Hello, World!. 이제 방법 2를 살펴 보겠습니다. 이렇게하면 압축 된 문자열 “Ọƥ⁷Ƭė3⁶»이 9 바이트로 압축되어 이전 문자열 보다 크게 개선됩니다. 그러나 가장 짧은 Hello World! 젤리의 프로그램은 8 바이트 이므로 무언가를 향상시킬 수 있습니다

3. 방법 3이 더 짧아졌습니다. 예상대로 Hello, World의 출력은 물론 “3ḅaė;œ»가장 짧은 프로그램입니다. 그렇다면 방법 3의 기능은 무엇입니까? 방법 3은 고독한 공백을 선행 공백으로 결합하며 젤리 압축 해제 프로그램에는 플래그가 있습니다. 컴프레서와 디 컴프레서를위한 코드에서 if flag_space: word = ' ' + word앞의 공백이 a) 지원되고 b) 바이트 절약이라는 것을 보여주는 코드와 같은 코드를 볼 수 있습니다 . 따라서 방법 2의 문자열 스플리터는 공간 자체가 바로 뒤에 문자열로 결합되어 선행 문자열을 생성하도록 조정됩니다. 이는 압축시 6 바이트 (구분 기호 포함시 8)만으로 Hello, World!구문 분석 됨을 의미합니다 ["Hello", ",", " World", "!"]. 이것은 내가 추가 한 "확장"을 제외하고 거의 항상 가장 짧은 압축 방법입니다.

이것은 프로그램의 대부분이지만 데이터를 더욱 압축하는 데 도움이되는 몇 가지 옵션이 더 있습니다.

• 이 프로그램 은 Jelly가 사용하는 Dennis의 sss 압축 해제 기를 사용하여 각 압축 버전이 올바른지 확인합니다 (소스로 바로 이동).
• --debug가장 짧은 압축 문자열을 표시하는 대신 "This is the shortest"사본과 함께 3을 모두 표시 하는 첫 번째 명령 행 인수를 작성하여 모든 다른 압축 문자열을 볼 수 있습니다.
• 이 프로그램은 "비 단어"를 처리합니다

비 단어

이 메시지를 본 후 Lynn의 압축기에 대한 작업을 시작했으며 , 그것을 압축하고 압축하는 가장 짧은 방법을 찾을 수 없다는 사실에 좌절했습니다 (레코드는 29 또는 32 바이트입니다). 그러나 개선 사항을 테스트하는 동안 knownsJelly의 사전에없는 것과 같은 단어가 있음을 발견했습니다 . 따라서 가능한 한 짧은 Jelly 코드에서 이러한 "단어"를 압축하는 방법을 찾기 시작했습니다.

trim문자열의 적어도 하나가 단어 인 지점으로 문자열을 분할 하는 함수 ( )를 만들었습니다 . 예를 들어 knowns로 분할 될 ["known", "s"]상기 프로그램은 사전에 추가 (통해 제 단어가 추가 .dictionary) 및 비아 워드의 두 번째 부분 .string통화. 그러나 이것은 여전히 ​​두 가지 경우를 남깁니다 : 단어가없는 문자열 (예 :) ajdl과 끝에 단어가있는 비 단어 (예 : 함수에 abctest의해 분리되지 않음) trim.

문자열에 단어가없는 단어를 찾을 수있는 방법이 없기 때문에이를 처리하는 가장 간단하고 짧은 방법은 문자를 .string호출 하여 문자별로 추가하는 것입니다 . 그래서 ajdl추가 얻을 것이다 .string('ajdl'). 인식 된 단어가 아닌 단어 끝에있는 반면, 본질적 트리머 그러나 반대로,인가 및 구현 .dictionary및 .string포워드 트리머 다른 방식 라운드.

이는 처음부터 어느 문자열 트리밍 밝혀 또는 입력에 의해 입증 된 바와 같이 단부가 짧은 압축기 각 문자를 추가하는 대신 물론 바와 같이 abctest this string디버그 출력을 생성,

Original        : abctest this string

Optimised       : “¡J+v(p⁸ụƘ$,»
Seperate spaces : “Ç⁴ṭḍµḄ7oeṂdḷp»
No trimmer      : “¤ɦ?Ɓ¢#fḲOạ⁾¶ɼȥƬ»
All characters  : “µẓþ"Y7_ḣṗḢ))9Þ⁴⁺Ẉ²)ɱ»
Non-compressed  : “abctest this string
Shortest        : “¡J+v(p⁸ụƘ$,»
=====

최적의 출력 (트리머를 사용하는)과 그렇지 않은 출력 (Jelly의 경우) 4 바이트가 다릅니다. 마지막으로, 문자열 자체가 압축 된 버전보다 짧은 경우가 있습니다.

물론, 이것에 대한 많은 신뢰는 원래 압축기를 만드는 것에 대해 Lynn에게갑니다.

³⁴⁵⁶⁷⁸⁹일반적으로 사용되는 일부 값을 골프화 하기 위해 3-9 ( )의 위첨자를 사용할 수 있지만 이는 명령 줄 인수의 양과 링크의 경우 링크의 인수에 따라 다릅니다.

• ³ 100을 반환하고 입력이없는 경우에만 작동합니다.
• ⁴ 16을 반환하고 최대 하나의 입력이있는 경우에만 작동합니다.
• ⁵ 10을 반환하고 최대 두 개의 입력이있는 경우에만 작동합니다.
• ⁶ 최대 3 개의 입력이 있으면 공백을 반환합니다.
• ⁷ 최대 4 개의 입력이있는 경우 새 줄을 반환합니다.

그러나 5 개의 입력이 있다면 운이 나쁘다.

최근에, 언어의 새로운 버전은 값 ³을 100으로 낮추었 고, 값 을 반환하거나 (링크를 위해) 그들의 인수를 나타내는 새로운 원자를 도입했습니다.

• ⁸ 왼쪽 인수가 전달 된 링크를 제외한 모든 위치에 빈 목록을 리턴합니다.
• ⁹ 올바른 인수가 전달 된 링크를 제외한 모든 곳에서 256을 반환합니다.

당신이 링크에 있고, 양쪽에서 논쟁이 전달된다면, 당신은 운이 좋지 않습니다.

남용 문자열 버그

크레딧 을 이용 하여 끈을 탄력있게 만드는 프로그램 작성 에서이 점을 활용 해 Adnan 에게 공헌 합니다 .

젤리는 언젠가 문자 산술을해야하지만, 그 때까지 파이썬은 대부분의 산술 연산자를 오버로드하고 젤리는 타입 검사를하지 않는다는 사실을 이용할 수 있습니다.

예를 들어

“abcd”Ḥ

지금 당장 유용한 것은 아니지만, Ḥ(반쪽)은

lambda z: z * 2

산술 원자는 깊이 0 에서 벡터화됩니다 (즉, 숫자 또는 문자에서 작동). 위의 젤리 코드 수율

['aa', 'bb', 'cc', 'dd']

이것은 실제 파이썬 문자열 (Jelly 타입은 아님)을 생성하므로 모든 상황에서 사용할 수는 없습니다.

마찬가지로, +/동일한 경고로 문자열을 연결하는 데 유용 할 수 있습니다.

최적의 스트링 컴프레서

최근에 나는 물었다 에릭 Outgolfer을 추가하기 위해 최적화 된 문자열 압축기 에 JHT 참조 페이지를 하지만, 그들은 말했다 그

죄송하지만 컴프레서는 완전히 구현하지 않는 것
그것이 말하는 “ugtestslug”가장 짧은 수 ugtestslug있는 동안, “#ṀȮụḄPƇ»또한 작업을 수행

그래서 최적의 스트링 컴프레서를 구현하기로 결정했습니다.

간단한 접근 방식이지만 가능한 가장 작은 값 (따라서 바이트 수)을 찾을 수 있습니다.

에서 입력을 받고 stdin로 출력합니다 stdout. 그냥 원래 압축기, 같은 ¶또는 (리터럴 개행 문자) 개행 문자로 입력 할 수 있습니다.

구두점을 많이 사용하여 (예 : input ¶-----¶) 실행하면 압축되지 않은 문자열이 출력됩니다.

물론, 이것에 대한 많은 크레딧은 Lynn 에게 오리지널 컴프레서 를 만드는 데 공헌 합니다 .

이것은 젤리 위키 튜토리얼 이 된 것 중 일부입니다 .

암묵적인 프로그래밍

젤리는 암묵적인 프로그래밍 언어입니다. 즉 , 관련 인수에 대해 명시 적으로 이야기하지 않고 기존 링크를 chain 에 작성하여 링크 (함수)를 정의합니다 . 이 컴포지션을 통한 "흐름"인수는 링크가 배열 된 패턴에 의해 정의되는 방식입니다. 이에 대한 예는 곧 제공 될 예정이지만 먼저 몇 가지 개념을 소개해야합니다.

링크 의 비결 은 매우 중요한 개념입니다. 의 모든 원자 - 같은 내장 기능, +및 ½-는 arities를 해결했습니다. 링크는 해당 특성에 따라 세 가지 범주로 분류됩니다.

• Nilads 는 논쟁을하지 않습니다 (arity 0); 일부 I / O 및 상태 저장 명령 외에는 대부분 상수 값을 나타냅니다. 예를 들어 리터럴 3은 nilad입니다.

• 모나드 는 하나의 주장을 취합니다 (arity 1). ( 여기서 함수형 프로그래밍 모나드 는 연결되어 있지 않습니다 .) 예를 들어 ½(제곱근)은 모나드입니다.

• Dyads 는 두 가지 주장 (arity 2)을 취합니다. 예를 들어, +dyad입니다.

(형용사를 사용하여 링크는 niladic , monadic 또는 dyadic 입니다.)

프로그램을 작성할 때 정의하는 링크의 특성은 무엇입니까? 기본적으로 변수 는 가변적 입니다. 즉, 사용할 인수 수를 지정하는 것은 호출자 에게 달려 있으며, 주 링크 의 경우 프로그램이 전달되는 인수 수에 따라 다릅니다.

예를 들어, (더하기)와 (제곱근 ) +½의 체인이 있습니다. 이 사슬의 요소들 각각이 2와 1이기 때문에 우리는 이것을 2,1 사슬 이라고 부릅니다 . 인터프리터는 해당 특성에 따라 체인을 분류하는 특정 규칙을 가지고 있습니다. 이러한 규칙은 입력 이있을 때이 새 링크가 계산 하도록 지시 합니다 . (당신은 읽을 수 로 "... 플러스의 제곱근." )+½nn + sqrt(n)+½

따라서 젤리 프로그래밍은 본질적으로 이러한 규칙을 잘 배우고 암묵적으로 작업을 수행하는 영리한 체인을 구성하는 기술입니다 .

이것은 젤리 위키 튜토리얼 이 된 것 중 일부입니다 .

프로그램 구조

Jelly 프로그램의 각 줄은 링크 정의 입니다. 링크는 기본적으로 기능입니다. 결론은 " main"를 나타냅니다 . 명령 줄에 전달 된 인수를 사용하여 평가되는 링크입니다.

마지막 링크를 제외한 모든 링크는 함수 정의입니다. actors를 사용하여 참조 할 수 있습니다 . 예를 들어, ç인 "이진 연산자 (다이 애드) 등이 하나의 상기 링크는," . 인수의 합계의 제곱을 계산하는 다음 예제 프로그램을 고려하십시오 .

+
ç²

이것은 의사 코드와 같습니다.

define f:
    the built-in link +
define main:
    apply the dyad f
    square the result

이것은 젤리 위키 튜토리얼 이 된 것 중 일부입니다 .

멀티 체인 링크

내가 당신 이 다른 링크 체인을 만들어 링크 를 정의 한다고 썼을 때를 기억 하십니까? 나는 모든 진실을 말하지 않았다 : 실제로, 그것은 2 계층 과정이다. 링크는 체인 체인이며 기본적으로 외부 체인은 단순히 단위 길이를 갖습니다.

이 프로그램을 고려하십시오 :

C+H

그것은 더하기 반값 입니다. 입력 값을 받아서 n계산 (1-n)+(n/2)합니다. 너무 신 나지 않습니다. 그러나 구조는 실제로 다음과 같습니다.

우리가 작성한 링크 자체는 실제로 단일 체인을 포함하는 체인입니다.

(1-n)+(1-n)(n/2)대신 계산하려고한다고 가정하십시오 . 이완 체인 +×은 작동합니다. 체인 규칙에 의해 계산됩니다 λ+(λ×ρ). 이는 우리가 필요로하는 것과 매우 비슷합니다. 그러나 단순히 교체 +로 +×하지 않을 것이다 우리의 프로그램은 : C+×H1,2,2,1-체인은 - 보완, 다음 반으로 증식 한 후, (인수)를 추가 - 계산 ((1-n)+n)×(n/2).

우리는 치료에 젤리를 원하는 +×단위로, 서브 체인의 1,2,1 체인을 C, +×하고 H. 멀티 체인 링크를 통해 바로 그렇게 할 수 있습니다! 그것들을 구성하기 위해 우리는 체인 구분 기호를 사용합니다 øµð. 위의 이미지에서, 그들은 각각 파란색 0, 1 및 2의 파란색 사각형을 소개합니다. 우리의 경우 다음과 같이 작성하여 원하는 방식으로 체인을 그룹화 할 수 있습니다 Cð+×µH.

이러한 것들을 더 중첩시킬 방법이 없습니다. 대신 여러 개의 링크를 정의해야합니다.

TMTOWTDI 인 경우 체인에 맞는 것을 선택하십시오.

암묵적 언어의 장점 중 하나는 일반적으로 변수 참조를 사용하지 않고도 벗어날 수 있다는 것 입니다. 그러나 이것은 체인의 링크에 올바른 arities가있는 경우에만 작동합니다.

예를 들어, 2D 배열에서 모든 배열의 합을 취하는 간단한 방법은 다음과 같습니다.

S€

배열의 모든 요소에 합계 원자를 매핑합니다.

이제 원자로 구성된 모나 딕 체인이 있다고 가정 해보십시오.

*

매핑 된 각 X 에 2 차원 어레이의 X ^X를 . 예를 들어 A = [[1, 2], [3, 1], [2, 3]]의 경우 체인을 호출하면 [[1, 4], [27, 1], [4, 27]]이 생성됩니다. .

이제 우리는 각 쌍의 합계를 가져오고 싶습니다. 운수 나쁘게,

*S€

더 이상 후크* 처럼 작동 하지 않으므로 ( A 자체를 올바른 인수로 사용) 포크로 작동합니다 . 즉 , A에 먼저 적용되며 결과는의 올바른 인수입니다 .S€*

이것을 고치는 것은 충분히 쉽다 :

*¹S€
*⁸S€

두 생산 원하는 결과 : *¹A는 포크¹ 식별 함수이며 *⁸이다 꼭대기 여기서, ⁸사슬의 왼쪽 인자 (참조이다 ).

그러나 바이트를 저장하는 방법이 있습니다! 꼭대기 ḅ1(단항 정수 변환)도 각 배열의 합 계산 ^을 하지만 달리 , A는 이항 링크.S€ḅ

체인

*ḅ1

원하는대로 [5, 28, 31]을 반환합니다 . 이후 ḅ이항이다 *대신 포킹 갈고리

정수 압축

문자열 압축은 영어로 텍스트를 생성 할 때 유용하지만 다른 종류의 데이터를 압축해야하는 경우 상당히 효과적이지 않습니다. 따라서 프로그램에 큰 고정 상수를 저장하려는 경우 대부분 정수로 저장하는 것이 가장 좋습니다.

Jelly는 자체 코드 페이지를 상수로 가지고 있으므로 정수 압축 알고리즘은 Jelly 자체로 가장 간단하게 표현됩니다.

ḃ250ịØJ”“;;”’ṄV

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

위의 프로그램에는 정수 압축 해제 값을 표시하는 검사도 포함되어 있습니다.

정수를 정수로 사용하는 것 외에도 기본 변환을 수행 한 다음 문자 알파벳으로 인덱싱하여 문자열을 만들 수도 있습니다. ṃ원자는이 과정을 자동화하고, 단일 바이트 (알파벳 이외로 압축되는) 신장의 전체 과정을 설명 할 수 있기 때문에 매우 유용하다.

외부 곱을 사용하여 유용한 정수 행렬 만들기

다음 은 HTML 테이블 형식이 약간 더 좋은이 게시물의 요지입니다.

외부 제품 퀵 þ은 다이어 드에 부착 될 수 있으며 다이어 드가 왼쪽 및 오른쪽 인수로 각 요소 쌍에 작용합니다. 의 약칭입니다 €Ð€. 예를 들어 코드를 가지고 있다면 코드 [1,2]+€Ð€[0,10]를 짧게 만들 수 [1,2]+þ[0,10] 있고 둘 다 yield [[1,2],[11,12]]합니다. 외부 제품 다이어 드 þ(예 :)가 적용된 다이어 드를 가리 킵니다 +þ.

정수가 외부 제품 dyad의 인수 중 하나 인 경우 Jelly는 해당 숫자의 범위를 먼저 취한 다음 결과를 인수로 사용합니다. 이를 알면 위의 예를 더 짧게 줄일 수 있습니다 2+þ[0,10]. 이것은 외부 제품 다이어 드의 왼쪽 및 오른쪽 인수 모두에 해당됩니다.

정수에 대해 모나드 방식으로 작동 할 때 일부 외부 제품 다이어 드는 골프에 유용하지만 (특히 ASCII 기술 문제), 그렇지 않으면 구성하는 데 많은 바이트가 필요한 특정 정수 매트릭스를 생성합니다. 예를 들어 =þ정수에 적용 n하면 n×n항등 행렬이 생성됩니다. 온라인으로 시도하십시오 =þ!

아래는 다이어 드 및 외부 제품 다이어 드로 변환되고 정수에 대해 모노머 식으로 작동 할 때 생성되는 다이어 드 및 매트릭스 유형의 표입니다. 동일한 행에 나열된 Dyad는 동일한 행렬을 생성합니다. 내가 같은 테이블에 포함되지 않은 댓구있다 &, |, %, w, ẇ및 ḍ도 행렬 정수 생산하지만, 자신의 패턴이 간단하지 않으며 가능성이 적은 상황에서 유용 할 것입니다. 온라인으로 시도하십시오 wþ!

+ ------------------------------------------------- ---- +
| 디아 드 | 결과 행렬 | 예 |
+ ------------------------------------------------- ---- +
| = ⁼ | | 100 0 |
| ċ | 항등 표 | 0 1 0 |
| | | 0 0 1 |
+ ------------------------------------------------- ---- +
| | 대각선 위의 요소는 1, | 0 1 1 |
| <| 다른 모든 요소는 0 | 0 0 1 |
| | | 0 0 0 |
+ ------------------------------------------------- ---- +
| | 대각선 아래 요소는 1, | 0 0 0 |
| > | 다른 모든 요소는 0 | 1 0 0 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| | 대각선 요소는 0, | 0 1 1 |
| n ⁻ | 오프 대각선 요소는 1 | 1 0 1 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| ȧ | | 1 1 1 |
| ṛ ị | 각 요소의 행 인덱스 | 2 2 2 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +
| o ḷ | | 1 2 3 |
| ȯ | 각 요소의 열 색인 | 1 2 3 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | 주 대각선은 0, 상단 | 0 1 2 |
| _ | 대각선은 1, 2 ..., 낮습니다 | -1 0 1 |
| | 대각선은 -1, -2 ... | -2-1 0 |
+ ------------------------------------------------- ---- +
| | 주 대각선은 0, 아래 | 0 -1 -2 |
| _ @ | 대각선은 1, 2 ..., 위 | 1 0 -1 |
| | 대각선은 -1, -2 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | 주 대각선은 0, 상단 | 0 1 2 |
| ạ | 하단 대각선은 1, | 1 0 1 |
| | 2, 3 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | | 2 3 4 |
| + | 행 인덱스 + 열 인덱스 | 3 4 5 |
| | | 4 5 6 |
+ ------------------------------------------------- ---- +
| | 행의 최소 | 1 1 1 |
| «| 및 열 지수 | 1 2 2 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | 행의 최대 | 1 2 3 |
| »| 및 열 지수 | 2 2 3 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +

명령 및 리터럴 나열

당신은 많은 사용하려고하면 비 벡터화 목록 명령 A의 문자 n 또는 리터럴의 목록을 z 목록 명령은 먼저 어떤 종류의리스트로 변환 한 다음 해당 목록에서 명령을 수행합니다.

이 명령 iterable은 jelly.py 의 함수 호출을 사용하는 것으로 보입니다 .

def iterable(argument, make_copy = False, make_digits = False, make_range = False):
    the_type = type(argument)
    if the_type == list:
        return copy.deepcopy(argument) if make_copy else argument
    if the_type != str and make_digits:
        return to_base(argument, 10)
    if the_type != str and make_range:
        return list(range(1, int(argument) + 1))
    return [argument]

다음은 해당 목록 명령이 수행 할 작업의 불완전한 목록입니다.

목록 랩

iterable리스트에서 인수를 랩핑하여 함수에서 처리 할 수 있는 가장 간단한 리턴입니다 . 인수가 아직 목록이 아니고 문자열이고 iterable의 인수가 다른 메소드를 호출하지 않는 경우에 발생합니다.

-------------------------------------------------------------------------------
| Command | Description     | Process                       | Effect          |
-------------------------------------------------------------------------------
| F       | Flattens a list | 4953F -> [4953]F -> [4953]    | Same as W       |
-------------------------------------------------------------------------------
| G       | Format a list   | 4953G -> [4953]G -> [4953]    | Same as W       |
|         | as a grid       |                               |                 |
-------------------------------------------------------------------------------
| I       | Increments      | 4953I -> [4953]I -> <nothing> | Empty list      |
-------------------------------------------------------------------------------
| S       | Sums a list     | 4953S -> [4953]S -> 4953      | Same as ¹       |
-------------------------------------------------------------------------------
| Ṭ       | Boolean array,  | 4Ṭ -> [4]Ṭ -> [0, 0, 0, 1]    | n-1 zeroes,     |
|         | 1s at indices   |                               | 1 at end        |
-------------------------------------------------------------------------------
| Ụ       | Sort indices by | 4Ụ -> [4]Ụ -> [1]             | Yields [1]      |
|         | by their values |                               |                 |
-------------------------------------------------------------------------------
| Ė       | Enumerate list  | 4Ė -> [4]Ė -> [[1, 4]]        | Yields [[1, n]] |
-------------------------------------------------------------------------------
| Ġ       | Group indices   | 4Ġ -> [4]Ġ -> [[1]]           | Yields [[1]]    |
|         | by values       |                               |                 |
-------------------------------------------------------------------------------
| Œr      | Run-length      | 4Œr -> [4]Œr -> [[4, 1]]      | Yields [[n, 1]] |
|         | encode a list   |                               |                 |
-------------------------------------------------------------------------------

밑 10으로 변환

여기에서 호출 iterable하는 함수 는 숫자를 숫자 목록으로 변환 D한 다음 해당 숫자 에서 실행됩니다.

-------------------------------------------------------------------------
| Command | Description     | Process                      | Effect     |
-------------------------------------------------------------------------
| Q       | Unique elements | 299Q -> [2, 9, 9]Q -> [2, 9] | Unique     |
|         | ordered by      |                              | digits     |
|         | appearance      |                              | of n       |
-------------------------------------------------------------------------
| Ṛ       | Non-vectorized  | 4953Ṣ -> [4, 9, 5, 3]Ṛ       | Reverses D |
|         | reverse         | -> [3, 5, 4, 9]              |            |
-------------------------------------------------------------------------
| Ṣ       | Sort a list     | 4953Ṣ -> [4, 9, 5, 3]Ṣ       | Sorts D    |
|         |                 | -> [3, 4, 5, 9]              |            |
-------------------------------------------------------------------------

범위가있는 목록으로 변환

여기의 함수는 숫자를 range로 변환 한 R = [1 ... n]다음 해당 범위에서 실행됩니다.

-----------------------------------------------------------------------------------------
| Command | Description       | Process                             | Effect            |
-----------------------------------------------------------------------------------------
| X       | Random element    | 4R -> [1 ... 4]X -> 2               | Random element    |
|         |                   |                                     |  of R             |
|         |                   |                                     |                   |
-----------------------------------------------------------------------------------------
| Ḋ       | Dequeue from list | 4R -> [1 ... 4]Ḋ -> [2, 3, 4]       | Range [2 ... n]   |
-----------------------------------------------------------------------------------------
| Ṗ       | Pop from list     | 4Ṗ -> [1 ... 4]Ṗ -> [1, 2, 3]       | Range [1 ... n-1] |
-----------------------------------------------------------------------------------------
| Ẇ       | Sublists of list  | 4Ẇ -> [1 ... 4]Ẇ                    | All sublists of R |
|         |                   | -> [[1], [2], [3], [4], [1, 2],     |                   |
|         |                   |     [2, 3], [3, 4], [1, 2, 3],      |                   |
|         |                   |     [2, 3, 4], [1, 2, 3, 4]]        |                   |
-----------------------------------------------------------------------------------------
| Ẋ       | Shuffle list      | 4Ẋ -> [1 ... 4]Ẋ -> [2, 1, 3, 4]    | Shuffles R        |
-----------------------------------------------------------------------------------------
| Œ!      | All permutations  | 3Œ! -> [1, 2, 3]Œ!                  | All permutations  |
|         | of a list         | -> [[1, 2, 3], [1, 3, 2],           | of R              |
|         |                   |     [2, 1, 3], [2, 3, 1],           |                   |
|         |                   |     [3, 1, 2], [3, 2, 1]]           |                   |
-----------------------------------------------------------------------------------------
| ŒḄ      | Non-vectorized    | 4ŒḄ -> [1 ... 4]ŒḄ                  | Bounces R         |
|         | bounce,           | -> [1, 2, 3, 4, 3, 2, 1]            |                   |
|         | z[:-1] + z[::-1]  |                                     |                   |
-----------------------------------------------------------------------------------------
| Œc      | Unordered pairs   | 4Œc -> [1 ... 4]Œc                  | Unordered pairs   |
|         | of a list         | -> [[1, 2], [1, 3], [1, 4], [2, 3], | of R              |
|         |                   |     [2, 4], [3, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| Œċ      | Unordered pairs   | 4Œċ -> [1 ... 4]Œċ                  | Unordered pairs   |
|         | with replacement  | -> [[1, 1], [1, 2], [1, 3], [1, 4], | with replacement  |
|         | of a list         |     [2, 2], [2, 3], [2, 4], [3, 3], | of R              |
|         |                   |     [3, 4], [4, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| ŒP      | Powerset of       | 3ŒP -> [1 ... 3]                    | Powerset of R     |
|         | a list            | -> ['', [1], [2], [3], [1, 2],      |                   |
|         |                   |     [1, 3], [2, 3], [1, 2, 3]]      |                   |
-----------------------------------------------------------------------------------------
| Œp      | Cartesian         | 4,2Œp -> [[1 ... 4], [1 ... 2]]Œp   | Cartesian product |
|         | product of z's    | -> [[1, 1], [1, 2], [2, 1], [2, 2], | of [1 ... z[i]]   |
|         | items             |     [3, 1], [3, 2], [4, 1], [4, 2]] | for i in z        |
-----------------------------------------------------------------------------------------

정확히 두 개의 입력이있을 때 표준 입력에서 읽는 것이 때로는 가치가 있습니다.

Jelly는 명령 줄 인수에서 입력을받는 데 최적화되어 있습니다. 그러나 다이어 드가 아닌 모나드 작성에 최적화되어 있습니다. dyads를 사용하면 각 내장에 대해 가능한 많은 의미가 있으므로 모호하지 않게 문자를 사용해야하는 반면 모나드를 사용하면 일반적으로 같은 말을 할 수있는 방법이 많이 있습니다.

한 번만 두 개의 입력 중 하나를 사용하고, 경우에 따라서, 문제는 쉽게 암시 적으로 읽을 수 없도록이다 ⁴(즉, 당신에게 만드는 중 필요 ⁴명시를, 또는 다른에 문자를 보낼를 }, @등) , Ɠ명령 행에 배치하지 않고 표준 입력에서 읽는 것을 고려하십시오 . Ɠ다른 모든 암시 적 입력을 다른 입력에서 가져 오는 것을 보장하면서 입력을 통해 필요한 곳에 정확하게 입력 할 수 있습니다. 그것은 바이트를 소비하고 바이트를 절약하며, 문제에 따라 코드를 재정렬 할 더 많은 범위를 제공하여 두 번째 바이트를 절약 할 수 있습니다.

를 사용하여 인수의 속성을 확인하는 몇 가지 명백한 방법이 있습니다 Ƒ. 아래는 몇 가지입니다. 나는이 빠른의 사용을 충분히 왼쪽으로 (예를 AƑ, ŒuƑ, 3Ƒ) 그들의 행동을 달성하는 가장 간단한 방법은 이미 때문이다.

OƑ  Is number?
ỌƑ  Is character? (errors on negative numeric input)
ḂƑ  Between 0 and 2? 0<=x<2 (python). <2aAƑƊ or of course ⁼Ḃ$ in Jelly.
ḞƑ  Is integer?
UƑ  Like `ŒḂ`, but checks if all sublists of depth 1 are palindromes.
ṠƑ  Is one of -1, 0, 1? (e-r1¤$)

더 흥미로운 사례를 추가하려면이 부분을 자유롭게 수정하십시오.

Jelly Language 에서 코드를 쉽게 빌드하도록 설계된 온라인 편집기 인 Jelly Balls 를 사용해 볼 수 있습니다 .

기능은 다음과 같습니다.

• 모든 원자 및 구문 문자가 유형별로 구성된 명령 팔레트
• 코드에서 리터럴과 2 바이트 원자를 인식하는 온라인 파서
• 자바 스크립트로 웹 페이지에서 Jelly 코드를 실행할 수있는 간소화 된 브라우저 내 Jelly 인터프리터
• 코드를 TIO 또는 다른 Jelly Balls 세션으로 전송하기위한 직접 링크
• 자동 힌트
• 휴대 기기에 최적화

시도해보십시오 : https://jellyballs.github.io

• 실행 된 모든 단계의 인수 및 결과를 보여주는 자세한 추적 보고서

• 모든 단계에 대한 설명을 보여주는 코드 보고서

• 젤리 예제와 요리법 페이지

• 256 개 젤리 문자의 대화식 코드 페이지