키푸 카운팅 : 신세계의 기초 10


41

QuipusPrecolumbian 시대에 잉카가 사용했던 고대 장치로 코드의 기본 10 위치 매듭 시스템에서 숫자를 기록합니다.

매듭의 각 클러스터는 숫자이며, 세 가지 주요 유형의 매듭이 있습니다 : 간단한 오버 핸드 매듭; "긴 매듭", 하나 이상의 추가 턴을 가진 오버 핸드 매듭으로 구성; 그리고 그림 8 매듭.

  • 10의 거듭 제곱은 스트링을 따라 위치별로 표시되며이 위치는 연속 스트랜드 사이에 정렬됩니다.
  • 10 이상의 거듭 제곱 위치의 자릿수는 간단한 매듭의 군집으로 표시됩니다 (예 : 40은 "tens"위치에서 연속 된 4 개의 간단한 매듭입니다).
  • "1"위치의 숫자는 긴 매듭으로 표시됩니다 (예 : 4는 4 회전의 매듭입니다). 매듭이 묶이는 방식으로 인해 숫자 1은 이런 식으로 표시 될 수 없으며이 위치에서 8 자리 매듭으로 표시됩니다.
  • 0은 적절한 위치에 매듭이 없음으로 표시됩니다.

세부

이 도전에 대해, 퀴즈의 각 가닥은 하나의 숫자를 나타냅니다 (하지만 Wikipedia 기사에서 언급 했듯이이 도전에서는 한 가닥에 많은 숫자를 나타낼 수 있습니다 ).

매듭

각 매듭은 단일 ASCII 문자로 표시됩니다.

  • . 간단한 매듭을 나타냅니다
  • : 긴 매듭의 1 회전을 나타냅니다
  • 8 그림 8 매듭을 나타냅니다
  • | 는 숫자 사이의 구분 기호뿐만 아니라 매듭이 없음을 나타냅니다.

퀴 푸스 구성

Quipu는 이러한 규칙에 따라 구성됩니다.

  1. 스트랜드는 위치의 내림차순으로 위에서 아래로 이어집니다 (단위 숫자는 스트랜드의 맨 아래에 있음). 가닥을 따라 숫자는 문자 ( |) 로 구분됩니다 .
  2. 숫자 10의 거듭 제곱은 숫자 시스템의 숫자를 사용하여 10의 숫자 거듭 제곱을 계산하는 것과 같은 방식으로 스트랜드를 따라 위치에 따라 결정됩니다. 즉, 24210 자리의과 4단위 장소에서, 두 개의 매듭, 구분 기호 (으로 표시됩니다 |다음), 네 개의 매듭.
  3. 같은 위치에있는 숫자는 가닥의 아래쪽을 향해 정렬됩니다. 한 위치의 한 자릿수가 같은 위치에있는 다른 숫자의 다른 자릿수보다 적은 수의 노트를 가질 경우 해당 노트가없는 것은 ( |) 로 표시됩니다 .
  4. 연속적인 간단한 매듭 ( .)은 해당 위치의 값을 나타냅니다.
  5. 모든 숫자는 1 자 이상으로 표시됩니다. quipu의 모든 숫자에 대해 숫자 값이 0 인 경우 매듭 ( |) 이없는 것으로 표시됩니다 .
  6. 단위 장소는 특별하게 취급됩니다. 단위 자리의 1은 8 자 매듭 ( 8)으로 표시됩니다. 단위 위치에서 둘 이상의 값은 연속적인 긴 매듭 ( :)으로 표시됩니다.
  7. quipu의 모든 숫자에 대해 단위 숫자가 0이면 매듭이없는 것이 인쇄되지 않지만 10 자리의 후미 구분 기호는 유지됩니다.
  8. 단위 숫자 다음에 분리 문자가 없습니다.

규칙

  • 입력은 기본 입력 방법 중 하나를 통해 수신 될 수있는 음이 아닌 정수의 비어 있지 않은 목록으로 구성됩니다 . 이러한 정수 모든 미만 또는 같음을 전제로 2147483647하거나 2^31-1. 테스트 사례는 공백으로 구분되지만 입력 형식은 쉼표로 구분되거나 개행으로 구분되거나 배열 등 언어에 편리한 방식으로 입력을 분리 할 수 ​​있습니다.
  • 출력은 위에서 설명한 규칙에 따라 구성된 단일 Quipu로 구성됩니다. 출력은 기본 출력 방법 중 하나를 통해 제공 될 수 있습니다 .
  • 코드는 명명 된 함수일 필요는 없지만 프로그램이나 함수 여야합니다.
  • 매듭은 시간을 절약하기 위해 시간이 걸리므로 코드를 최대한 짧게 만드십시오.

문제가 명확하지 않은 경우 언제든지 알려주십시오. 행운과 좋은 골프!

입력:

5 3 1 0

산출:

:|||
:|||
::||
::||
::8|

입력:

50 30 10 0

산출:

.|||
.|||
..||
..||
...|
||||

입력:

330

산출:

.
.
.
|
.
.
.
|

입력:

204 1

산출:

.|
.|
||
||
||
:|
:|
:|
:8

입력:

201 0 100 222

산출:

.||.
.|..
||||
|||.
|||.
||||
|||:
8||:

입력:

1073741823 2147483647

산출:

|.
..
||
|.
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
..
||
|.
|.
..
||
.|
.|
..
..
..
..
..
..
||
|.
|.
..
..
||
|:
|:
|:
|:
::
::
::

입력:

0

산출:

|

더 긴 테스트 사례

추가 자료


답변:


3

Pyth, 64 바이트

=QjRTQjCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

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

작동 원리

=QjRTQ   Converts each number in input to decimal (as a list)
         123 becomes [1,2,3]

----

jCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

                                              .[L0       Q  0-leftpad each #
                                                  h.MZlMQ   (max length) times

                                             C              transpose

                      mm                    d    for each digit:
                        +                        [convert to] sum of
                         *\|                     "|" repeated
                            -                    the difference of
                             h.MZd               maximum digit in same row
                                  k              and itself.. that many times
                                   *?tk\:\8      and (digit > 1 then ":" or "8") repeated
                                           k     itself many times


the list:
[11,23,52]
->[[1,1],[2,3],[5,2]]
->[[1,2,5],[1,3,2]]
->[["||||8","|||::",":::::"],["||8",":::","|::"]]

                     C      transpose

->[["||||8","||8"],["|||::",":::"],[":::::","|::"]]

  m                          for each number
      +                      [convert to] sum of
                 Pd          every element but the last
       :R"[8:]"\.            with "8" and ":" replaced by "."
                   ed        and the last element
   j\|                       joined with "|"

  C                          transpose
 j                           join (with newlines)

이것은 하나의 문제를 제외하고는 훌륭한 해답입니다. 마지막 매듭이 항상 그림 8 매듭은 아닙니다 8. 실제로, 8마지막 숫자가 1 일 때는 매듭 일뿐입니다 (규칙 6 참조). 모든 최종 노트를 변환하고 있으며 스펙과 일치하지 않습니다. 또한 온라인으로 사용해보십시오! 링크는 여기에 게시 된 코드와는 다른 코드를 가지고 있습니다
Sherlock9

22

읽을 수 없음 , 3183 3001 바이트

이것은 크리스마스 축하 행사 사이에 계속해서 재미있는 도전이었습니다. 게시 해 주셔서 감사합니다! 사양이 예외와 특별한 경우로 가득 차서 많은 if 조건이 필요했기 때문에 이것이 흥미로 웠습니다. 또한 이번에는 십진수로 변환 할 필요가 없었지만 각 숫자에서 가장 큰 자릿수와 각 위치에서 가장 큰 자릿수 값을 결정하기 위해 정렬의 "최대"기능 필요했습니다.

이것의 첫 번째 버전은 4844 바이트로, 내가 얼마나 골프를했는지에 대한 아이디어를 제공합니다.

프로그램은 입력을 쉼표로 구분 된 정수 목록 으로 예상합니다 . 공백이나 줄 바꿈이 없습니다. 그것들을 사용하면 정의되지 않은 동작이 발생합니다.

' "" "" ""' "" ' ""' "" ' "" "" "'" "" "" "" "" "" "" "" ' ""' "" ' "" "" ""' "" ' "" "" "'" " '" "'" " '" "" "" "'" " '" "'" "" "" "" "" "" ' "" "" "" "' "" ' "" "" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "" ""' "" ' "" "" "" " '"" ' "" "" "'" " '" "'" " '" "'" " '" "'" " '" "'" "" "" "" " '" "" "" "" "" "" "" "" " '" ""' "" ' ""' "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "' "" ' "" "" "'" " '" "'" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" ""' "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" ""' "" "" "" "" " '" "'" "" ' "" "" "" "'" " '" "'" " '" "" "" "" "'" "" "" """ "" "" "" ' "" "" "" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "'" "" "" " '" "'" "" "" " '" "" "" "" ""' "" "" "" "" "" ' "" "" "" "" ' "" "" ""' "" ' ""' "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" ' "" "" ""' "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" ' "" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "'" "" ' "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" ' "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" ""' "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" ""' "" " '" "" "" "" ""' "" "" "" "" "" ' "" "'" " '" "'" "" "" " ' "" ' "" "" "'" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" """" "" "" "" " '" ""' "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" " " '" "" ""' "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "' ' "" ' "" "" ""' "" "" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" """ '" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" ""' "" "" "" ' "" "" "" ""' "" ' ""' "" "" "" "" "" "" "" "" "" " ' "" "" "" "'" " '" "'" " '" "'" " '" "" "" "" "" "" "" "" "" "" "'" "" """" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" " '" "'" " '" "'" "" ' "" "" "" "" "'" "" "" ' "" "" "" "" "" "" "" "" "" "' ' "" ' "" "" "" "'" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" """ ' "" "" "" "'" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """""""""""""""""""""""""""""""""""""""""""""""""" '' "" "" "" " '" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" " '" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "" "'" "" "" "" ' "" "" "" "" "" ""' "" "" "" "" "" "" "' "" "" "" "'" "" ' "" "" "" "" ""' "" "" "" "" " '" "'" "" "" "" "" "" "" "" "" "" "" "" " '" "'" " '" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""' "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" " " '" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "'" " '" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ '" "" "" "" "" "'" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "' ' "" "" "" " '" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""' ""' "" ' "" "'" " '" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" " " '" "" "" "'" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " " '" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ '" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" ' "" "" "" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "'" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" ""' "" ' "" "" "" "" "" "" "" "" ""' "" "" "" "" " '" "" "" """ "" "" "" ' "" "" "" "'" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" " "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " " '" "" "" ""' "" " '" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" " '"'"" ' "" "" "'" " '" "'" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "' ' "" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" ""' "" "" "" "" "" "" " ''"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "

설명

특정 입력을 처리하는 방법을 보여줌으로써 프로그램 작동 방식을 안내합니다 202,100,1.

처음에는 나중에 필요한 몇 가지 값, 주로 출력 할 문자의 ASCII 코드를 구성합니다.

여기에 이미지 설명을 입력하십시오

당신이 볼, 수 있듯이 '8''.'이미 사용할 수 있습니다. '|'그러나 while 루프는 14가 아니라 124입니다. 우리는 while 루프를 사용하여 슬롯 # 1에 임시 값의 두 배를 추가하여 124를 얻습니다 (14 + 55 × 2). while 루프는 56-1 = 55에 대해 실행되기 때문에 반복). 124와 같은 큰 정수 리터럴이 실제로 길기 때문에 일부 바이트가 절약됩니다. 다음 다이어그램에서 프로그램이 사용하는 모든 변수의 위치를 ​​보여줍니다.

여기에 이미지 설명을 입력하십시오

다음으로, 모든 문자를 입력하고 셀 # 12에서 시작하는 테이프에 저장하려고합니다 ( p 는 이것에 대한 실행 포인터입니다). 동시에 가장 긴 숫자 (얼마나 많은 자릿수)인지 알고 싶습니다. 이를 달성하기 위해 셀 # -1에서 시작하여 단항 으로 누적 합계 유지합니다 (우리 는 실행 포인터로 q 를 사용 합니다). 첫 번째 입력 번호 ( 202) 다음에 테이프는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

숫자가 4에 의해 해제되어 있음을 알 것입니다. 처음 입력 할 때 ASCII 값이므로 48이 "off"이고 쉼표가 44입니다. 각 문자에 대해 46을 복사합니다. '.'으로 연구 한 다음 (45 뺍니다) 동안 루프를 빼고 우리는 우리는 우리가 조건을 사용할 수 있도록 쉼표 (우리의 분리기), 0 그래서 그것을 인식하는 않는 1을 추가합니다.

또한 셀 # 11을 0으로 남겨둔다는 것을 알 수있을 것입니다. 첫 번째 숫자의 경계를 인식해야합니다.

다음 문자는 쉼표가되므로 # 15에 0을 저장하지만 이번에는 q를 진행하지 않습니다 . 대신, q를 다시 0으로 설정 하고 이미 배치 한 1을 "덮어 쓰기"를 시작합니다.

나머지 모든 문자가 처리되면 다음을 얻습니다.

여기에 이미지 설명을 입력하십시오

보시다시피 q가 쓴 1은 이제 가장 긴 숫자의 길이를 단항으로 나타냅니다.

이제 while 루프를 사용하여 q 를 맨 왼쪽 으로 이동 한 다음 r2 라는 다른 포인터를 배치 합니다. r2 의 목적은 나중에 명확해질 것입니다.

여기에 이미지 설명을 입력하십시오

이 시점에서 내가 사용할 용어를 명확하게 설명하겠습니다.

  • 하여 숫자 , I은 쉼표로 구분되는 숫자 입력 중 하나를 의미한다. 이 예에서는 202, 100 및 1입니다.
  • 에 의해 자리 , 나는 숫자의 특정 하나의 단일 숫자를 의미한다. 첫 번째 숫자는 3 자리입니다.
  • 으로 장소 나는 "현재의 장소에 자리"라고하고, 현재 위치가 사람의 장소 인 경우, I 등 그래서 사람의 자리, 10 자리, 백의 자리를 의미, 그 숫자는 점에서, 2 0, 그리고 1 주문.

이제 정규 프로그래밍으로 돌아갑니다. 프로그램의 나머지 전체는 셀 # 0에 도달 할 때까지 q를 앞으로 이동시키는 큰 루프입니다 . 길을 따라 각 셀은 가장 오른쪽에 장소가있는 장소를 나타내며 q 는 가장 중요하게 시작됩니다. 이 예에서는 수백 곳입니다.

q 포인트를 (즉, * q ) 증분하여 진행합니다 .

여기에 이미지 설명을 입력하십시오

우리는 이제 수백 곳의“2 단계”에 있습니다. 이 단계에서 우리는 가장 큰 숫자가 백 자리의 모든 숫자 중 무엇인지 알아낼 것입니다. 우리는 포인터에 r을 호출 하고 포인터 r2 가 다음 숫자로 이동할 때마다 재설정 해야하는 시작 위치를 표시 한다는 점을 제외하고는 동일한 단항 계산 트릭을 사용합니다 .

첫 번째 숫자부터 시작하겠습니다. p 를 11 (모든 숫자의 하드 코딩 된 시작 위치) 로 설정 하여 시작합니다. 그런 다음 while 루프를 사용하여 숫자의 끝을 찾고 p2를 설정 하여 위치를 표시합니다. 동시에 q2 도 0으로 설정했습니다 .

여기에 이미지 설명을 입력하십시오

q2 가 vars를 가리키고 있다는 사실에 방해받지 마십시오 . 우리는 단순히 셀 번호 0이기 때문에 셀 # 0을 감지 할 수 있기 때문에 빈 셀의 패딩이 없습니다.

다음으로 * p 가 0이 될 때까지 pq2를 함께 줄임 으로써 현재 수를 살펴 봅니다. 각 위치에서 * q2 의 값 은 우리가해야 할 일을 알려줍니다. 1은 "아무것도하지 않음"을 의미하므로 계속 진행합니다. 결국 우리는 셀 # -3에서 2를 만난다. * q2 가 1과 같지 않을 때마다 q2 는 항상 q와 같습니다 .

여기에 이미지 설명을 입력하십시오

이미 언급했듯이 2 단계는“이 장소에서 가장 큰 숫자를 결정합니다”. 따라서 rr2로 설정 하고 while 루프를 사용하여 * p 를 줄이고 r을 왼쪽으로 이동 하고 테이프를 1로 채운 다음 다른 while 루프를 사용하여 r 을 오른쪽으로 다시 이동 하고 * p를 다시 증가 시켜 값을 복원하십시오. 모든 while 루프는 우리가 사용하는 값보다 1 회 적은 반복으로 실행됩니다. 이 때문에 기록 된 1의 수는 숫자 값보다 3이 많고 (4가 아닌) * p에 저장된 최종 값 은 2가 더됩니다. 따라서 이것은 * p 를 2만큼 효과적으로 줄 였습니다.

그런 다음, pp2 의 값으로 설정 한 다음 모든 작업을 다시 수행합니다. 두 번째로 q2 를 0으로 설정 하고 p 를 오른쪽 으로 이동하여 숫자의 끝을 찾은 다음 pq2를 함께 줄임으로써이 숫자의 자릿수를 살펴 봅니다. 다시 한번 우리는 셀 # -3에서 2를 만나고 * r 왼쪽에 그 많은 1을 씁니다 .

세 번째 숫자의 경우 백 자리가 없으므로 ( q2는 절대 q에 도달 하지 않기 때문에) 아무것도하지 않지만 최대 숫자 값의 계산에 영향을 미치지 않기 때문에 괜찮습니다.

여기에 이미지 설명을 입력하십시오

또한 레이블이없는 화살표로 표시된 셀 * (r − 4) 을 1로 설정했습니다 (이미 1 임에도 불구하고). 아직 이유를 말하지는 않겠지 만 이미 추측 한 적이 있습니까?

다음에 * q를 증가 시키면 3 단계로 넘어갑니다. "현재 위치의 모든 숫자에서 최대 자릿수를 뺍니다". 이전과 마찬가지로 p 를 11로 재설정 하고 q2 를 0으로 재설정 한 다음 이전 단계에서했던 것처럼 모든 숫자를 거 칩니다 . 이 시간을 제외시켰다 * Q 3 대신 2 때마다 = Q2가 충족 Qp는 수백 장소입니다, 우리가 사용하는 동안 감소에 루프 * 페이지 의 왼쪽 블록의 1 초 있기 때문에 여러 번 * R2 (5 이 예에서는 r 을 사용하여실행 포인터로. 우리는 실제로 그것을 한 번 더 감소시켜 가장 큰 숫자가 -2로 끝나도록합니다.

여기에 이미지 설명을 입력하십시오

모든 숫자를 처리 한 후 이제 3 단계가 끝났습니다. 여기서 두 가지 특이한 작업을 수행합니다.

  • 첫째, 우리는 또한 의 크기 빼기 R의 에서 - 블록 (플러스 1) * Q를 하지만, 사용 (R2)에 있는 왼쪽에있는 잎을 포인터. 이 방법으로 * q 는 음수가됩니다. 이 경우 r- block은 5 개의 1을 가지므로 * q 는 -3이됩니다.
  • 둘째, 가변 설정 에서 우리가 출력단을 입력하는 것을 나타 내기 위해 0이 아닌 값. (기술적으로 * q 가 음수 라는 사실 은 이미 출력 단계를 나타내지 만 검사하기가 너무 어렵 기 때문에 추가 변수가 있습니다.)

이제, 우리가 숫자를 통해 계속 이해 (의 비-1 값이 나타내는 현재 위치 찾기 * Q 각 번호 내에서)를, 그리고 값에 따라 일을 할 * Q . 우리는 볼 * Q가 다음 3 (이 곳의 모든 자리에서 최대 숫자 값을 뺍니다) 처음 2 (= 계산 최대 숫자 값)으로 증가하고 그것을 부정 할에서 우리는 뺍니다. 여기에서 1에 도달 할 때까지 계속 올라가므로 "아무것도하지 않음"을 의미하는 값을 복원합니다. 그 시점에서 다음 장소로 넘어갑니다.

이제 * q 가 음수이면 출력됩니다. * q 는 정확히 올바른 값에 있으므로 1에 도달하기 전에 올바른 수의 문자 행을 출력합니다. 가장 큰 숫자가 2이면 3 행을 출력해야합니다. * q의 각 값에서 어떤 일이 발생하는지 봅시다 :

  • * q = -2 :
    • 첫 번째 숫자의 경우 * p 는 -2이며, 이는 '.'점 (dot) 또는 ':'콜론 (colon) 을 출력해야 함을 나타냅니다 . 우리는 q 를 보면서 어떤 것을 결정합니다 : 그것이 -1이면 우리는 1 위를 차지하므로 a ':'( '8'+2로 계산)를 출력하고 , 그렇지 않으면 a를 출력 합니다 '.'.
    • 두 번째 숫자의 경우 * p 는 -3입니다. -2가 아닌 것은 '|'(파이프)를 출력 하고 값을 증가시키는 것을 의미 합니다. 이렇게하면 올바른 위치에 -2에 도달 한 다음 나머지 숫자에 대해 '.'s / ':'s를 출력 합니다.
    • 두 경우 모두 숫자를 처리 하기 전에 변수 pd 를 0으로 설정 하고 문자를 인쇄했음을 나타 내기 위해 pd (=“printed”)를 0이 아닌 값으로 설정합니다.
    • 세 번째 숫자의 경우 세 번째 숫자가 백 자리가 없기 때문에 처리가 수행되지 않습니다. 이 경우, PD는 여전히 우리는 여전히 출력 할 필요가 있음을 나타내는 숫자를 처리 한 후 0 일 것이다 '|'(그러나에만 아웃 그렇지 우리가 2 단계 또는 제 3 정지이기 때문에, 비 - 제로).
    • 모든 숫자를 처리 한 후 out 이 0이 아니면 개행을 출력합니다. 2 단계 또는 3 단계에서 줄 바꿈을 출력하지 않도록 out 변수 가 필요합니다 .
  • * q = −1 : 앞의두 숫자 모두에 대해 * p 가 -2이므로 두 가지 모두'.'a'|'를출력하고 세 번째는 a를 이전과 같이출력한다는 점을 제외하면 이전과 동일합니다.
  • * Q = 0 : * q는 0이고,이 의미는 "우리는 사람의 위치에있을 경우의 행 그렇지 않으면 출력을 아무것도하지'|'의에 관계없이 * P ". 이 방법으로 숫자 사이에 패딩을 얻습니다.

이제 q 를 증가 시켜 다음 자리, 10 자리로 이동하고 * q를 증가시킵니다 . 2 단계 시작시 테이프는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

그런 다음 이전과 같이 2 단계를 수행합니다. 이 위치의 모든 자릿수에서 2를 효과적으로 빼고 최대 자릿수를 나타내는 * r2 왼쪽에 단수를 남겨 둡니다 . 우리는 이전 단항 번호를 그대로두고 테이프를 왼쪽으로 계속 확장합니다. "정리"하는 데 불필요한 추가 코드 만 있으면됩니다. 완료되고 * q를 증가 시키면, 스테이지 3 시작시 테이프는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

사실 이것은 거짓말입니다. 앞에서 우리가 * (r-4) 를 1로 설정했다고 말한 것을 기억 하고 왜 그런지 말하지 않았습니까? 이제 그 이유를 알려 드리겠습니다. 가장 큰 숫자가 실제로 0 인이 숫자의 경우는 여기에있는 모든 숫자가 0 임을 의미합니다. 위의 레이블이없는 화살표로 표시된 * (r-4) 를 1로 설정하면 단항 수가 1 씩 확장됩니다. 이 특별한 경우에만 이 방법으로 가장 큰 숫자가 1 인 것처럼 가장하여 하나의 추가 행을 출력합니다.

* q를 음수로 만드는 추가 단계를 포함하여 3 단계 (현재 위치의 모든 숫자에서 최대 자릿수 빼기) 후 테이프는 다음과 같습니다. 마지막으로 가장 큰 숫자는 * p 블록 에서 -2로 표시 되었지만 이번에는 모두 -3이므로 모두 0이므로 최대 자릿수가 1 인 것처럼 가장합니다.

여기에 이미지 설명을 입력하십시오

이제 * q 가 1쪽으로 진행함에 따라 어떻게되는지 보자 .

  • 경우 * Q = -1은 * P의 값은 모두 -3 수단이다 우리는 출력 '|'들과 그들을 증가.
  • * Q = 0, 우리 출력 '|'때문에 우리는 항상 무엇을 그 때 * Q = 0 관계없이 * 쪽 .

따라서 우리는 두 줄의 파이프를 얻습니다.

마지막으로 * q 를 한 장소 로 옮깁니다 . ':'실제 숫자가 1이 아닌 1이면 1 을 출력 하고 1이면 1 을 출력해야하기 때문에 흥미 롭습니다 '8'. 프로그램이 어떻게 진행되는지 봅시다. 먼저 * q 를 증가 시켜 2 단계를 시작합니다.

여기에 이미지 설명을 입력하십시오

2 단계 ( "최대 자릿수 값 계산")가 끝나면 다음과 같이 남습니다.

여기에 이미지 설명을 입력하십시오

3 단계 ( "현재 위치의 모든 숫자에서 최대 숫자 값 빼기") 후에 테이프는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

이제 * q 의 각 반복을 차례로 살펴 보겠습니다 .

  • * q = -2 :
    • 첫 번째 숫자 : 이미 -2에 있으므로 ':'( q = -1 '.'때문에 a 대신)를 출력하십시오 .
    • 두 번째 숫자 : -4에서 a를 출력합니다 '|'.
    • 세 번째 숫자 : -3에 a를 출력하십시오 '|'. 그러나 이번에는 증분 대신 특수한 경우가 트리거됩니다. 단지 우리가 마지막 자리 (출력하는 경우 Q = -1), 그리고 우리는 (이 경우 두 번째 마지막 행에있어 * Q = -2), 디지트는 1 (실제로 * P = -3) , 다음 대신 -2로 증가, 우리는로 설정 -1. 다시 말해, 우리는 -1을 특별한 값으로 사용하여 다음 반복에서 '8'대신에 출력 할 필요가 있음을 나타냅니다 ':'.
  • * q = -1 :
    • 첫 번째 숫자 : 이미 -2에 있으므로 a를 출력하십시오 ':'.
    • 두 번째 숫자 : -3에 a를 출력하십시오 '|'. * q 가 더 이상 -2가 아니기 때문에 특수 조건이 트리거 되지 않습니다. 따라서 증분하십시오.
    • 세 번째 숫자 : -1에 출력 '8'.
  • * q = 0 : 일반적으로'|'여기에서 s의 패딩 행을 출력하지만 특별한 경우 우리가 한 곳에있는 경우 ( q = -1),이를 건너 뜁니다.

그 후에 q 는 0으로 증가하고 큰 while 루프는 종료됩니다.

이제 입력이 어떻게 202,100,1작동 하는지 알았습니다 . 그러나 아직 다루지 않은 특별한 경우가 하나 더 있습니다. 마지막 장소를 처리하는 동안 * p 가 -3 일 때 1다음 반복이 '8'대신 출력되도록 -2로 늘리는 대신 -1로 설정 했다는 것을 기억할 것 입니다. 이것은 * p 가 -3 인 반복이 있고 그것을 증가 시킬지 또는 -1로 설정 할지를 결정 하기 때문에 작동 합니다. 우리는 하지 않는 경우 이러한 반복이 모든 것들의 자리에 숫자가 같은 경우 0 또는 1을 수있는 모든 * P는 것 1 초에 대한 값 밖으로 시작 -2에서; -1로 설정하기로 결정할 기회가 없습니다−3에서 증가시키기보다는 . 이 때문에 3 단계에는 또 다른 특수한 조건이 있습니다 ( "현재 위치의 모든 숫자에서 최대 자릿수 빼기"). 나는 모든 숫자에서 최대 숫자 값을 뺀 후에 (최대 숫자는 -1입니다), 우리는 다시 한 번 감소하지만 실제로는 다음과 같은 조건이 있다고 주장했습니다.

우리가보고있는 자리가이 곳 (에 최대 숫자와 동일한 경우 * P = -1), 그리고 이 곳은 사람의 장소입니다 ( Q = -1), 최대 숫자는 1입니다 ( * (R + 5) = 0, 즉 맨 왼쪽에있는 단항 블록의 길이는 5 셀에 불과 합니다 .) 출력의 유일한 반복이을 출력해야 함을 나타 내기 위해 * p 를 -1로 둡니다 '8'. 다른 모든 경우에는 한 번 더 감소시킵니다.

끝난. 새해 복 많이 받으세요!

  • 1 편집 (3183 → 3001) : 새해 복 많이 받으세요! 변수 p2r2를 완전히 제거했습니다 ! p는 이제 숫자의 시작과 끝을 찾기 위해 앞뒤로 경주하지만 코드가 더 짧은 것 같습니다. q2 도 제거하려고했지만 코드를 더 짧게 만들 수 없었습니다.

    또한 while 루프의 마지막 값을 재사용하는 것과 같이 읽을 수없는 일반적인 골프 트릭을 적용 할 수있는 곳이 몇 군데 더 있습니다. 예를 들어서

    while *(++p) { 1 }         // just increment p until *p is 0; the 1 is a noop
    if (pd) { x } else { y }   // where pd is a variable
    

    비슷한 방식으로 작성 '""""하여 '"""( 첫 번째, 두 번째 작업) 및 (일정한 1)을 저장할 수 있습니다.

    if (while *(++p) { pd }) { x } else { y }
    

    물론 이것은 while 루프가 하나 이상의 반복에 대해 실행된다는 것을 알고있는 경우에만 작동하지만, 그렇지 않으면 반환 값이 pd 이므로 if의 조건으로 사용할 수 있습니다.


"읽을 수 없음"은 확실히 적절한 이름입니다.
Alex A.

9
-1 설명

7

자바 (ES6) 750 744 690 604 498 346 245 234 바이트

나는 PPCG를 처음 접했고 이것이 다소 단순하다고 생각할 수도 있다고 생각했다. 소년은 내가 틀렸다!! 나는 한동안 그것을 위해 노력하고 있고 할 많은 골프 가 있습니다 ...
제안은 권장됩니다! -이것을 이해하는 것은 쉬운 일이 아닙니다.

입력이 숫자의 배열 일 때 로프를 출력합니다 (예 :) [204, 1].

a=>(o=m=s="",l=a.map(n=>(s+="|",l=(n+"").length)>m?m=l:l),h=[],a=a.map((n,i)=>[..."0".repeat(m-l[i])+n].map((d,j)=>d<h[j]?d:h[j]=d)),h.map((n,i)=>{i?o+=s+`
`:0;for(j=n;j--;o+=`
`)a.map(d=>o+="|.:8"[d[i]-j<1?0:i<m-1?1:d[i]-1?2:3])}),o)

설명

a=>(

  o=m=s="",                      // m = max number of digits in a number, s = separator string         
  l=a.map(n=>(                   // l = lengths of each number
      s+="|",                    // set the separator string
      l=(n+"").length                 // convert each number to a string
    )>m?m=l:l                    // get max length
  ),
  h=[],
  a=a.map((n,i)=>
    [..."0".repeat(m-l[i])+n]    // add leading 0s to make all same length
    .map((d,j)=>d<h[j]?d:h[j]=d) // set each digit of h to max
  ),

  h.map((n,i)=>{
    i?o+=s+`
`:0;
    for(j=n;j--;o+=`
`)
      a.map(d=>
        o+=
          "|.:8"[
            d[i]-j<1?0
            :i<m-1?1
            :d[i]-1?2:
            3
          ]
      )
  }),
  o
)

입력 : 숫자 배열 : [4,8,15,16,23,42]
출력 :

|||||.
|||||.
||||..
||....
||||||
|:||||
|:||||
|:|:||
|:::||
::::||
:::::|
::::::
::::::

인상적인 골프 +1 입력 및 출력에 대한 예제를 포함 하시겠습니까?
DavidC

@DavidC 감사합니다! 그리고 예제가 포함되어 있습니다. 콘솔에서 호출하면 문자열이 반환됩니다. :)
Aᴄʜᴇʀᴏɴғᴀɪʟ

7

파이썬 3 624 598 595 574 561 535 532 527 525 426 345 328 324 294 288 286 283 280 267 265 255 251 245 238 235 234 230 228 바이트

z=input().split();v=max(map(len,z));d=''.join(i.zfill(v)for i in z);x=['']*len(z)
for k,c in enumerate(d):j=k%v;m=int(max(d[j::v]));c=int(c);x[k//v]+="|"*(m-c+0**m+(j>0))+":8."[(c<2)|-(j<v-1)]*c
for r in zip(*x):print(*r,sep='')

글쎄,이 질문에 답이 필요했기 때문에 여기에 입력이 공백으로 구분 된 숫자 문자열이어야합니다 "204 1". 소년, 그것은 긴 것입니다. 모든 골프 제안 (또는 더 나은 답변)을 환영합니다.

편집 : 탭과 공백을 혼합하여 저장된 바이트입니다.

편집 : 숫자의 자릿수를 얻는 방법을 변경 하여 많은 바이트를 절약했습니다 (숫자로 채워진 문자열에서 목록을 작성한 다음 코드 본문에서 수백 자릿수, 10 자릿수 등을 바꿉니다. .)

편집 : 그리고 마지막 :8루프를 메인 quipu 루프 에 통합하여 더 많은 것을 저장했습니다 . 왜 내가 효과가 없는지 알아낼 수 있다면 b=d[j*v+i]==m(d[i::v]). 그것을 알아 내고 솔루션에 너무 많은 바이트가 필요합니다. (어쨌든 탭이 4 개의 공백으로 바뀌어 바이트 수가 줄었습니다. 아마도이 사이트의 코드 블록 형식 일 것입니다)

편집 : 나는 어떻게 퀴 푸스를 만들 었는지 재구성했습니다. 이제 한 번에 하나의 가닥을 만든 다음 인쇄를 위해 바꿉니다.

편집 : 더 많은 바이트를 저장하기 위해 대답을 Python 3 프로그램으로 다시 설정했습니다.

편집 : 코드 중간에 숫자 중간에 0이 올바르게 인쇄되지 않도록 버그가 있음을 발견했습니다 ( 204 1위의 테스트 사례 참조). 이 문제를 해결하면서 골프를 쳤습니다. :)

편집 : 10 바이트를 절약하기 위해 인쇄를 변경했습니다. 그리고 나는 이전 바이트 수를 모두 되돌려 놓았습니다.

편집 : 4 바이트 v사용 할당을 골퍼했습니다 map. 내가 그들의 대답 에서 아이디어를 얻었을 때 CarpetPython 에게 감사의 말전한다 .

편집 : 중간 "for 루프 내부 for 루프"를 6 바이트 동안 하나의 for 루프로 바꿨습니다.

편집 : 이제 사용 중 enumerate입니다. 더 이상 사용하지 않습니다 l=len(z). 삼항 if-else을 목록 삼항으로 바꿨습니다. 자세한 내용은 아래를 참조하십시오.

편집 : Sp3000은 print각 바이트를 저장 한 삼항 조건에 대한 편집 및 편집을 제안했습니다 .

언 골프 드 :

s = input()
z = s.split()
v = max(map(len, z))                # the amount of digits of the largest number
d = ''.join(i.zfill(v) for i in z)  # pad zeroes until every number is the same length
                                     # then join the numbers into one string
x = ['']*len(z)                     # a list of strings for the output, one for each number

for k,c in enumerate(d):          # for every digit in every number
    i,j = divmod(k, v)            # i is the index of the number we're on
                                   # j is the index of the digit of the number we're on
    m = int(max(d[j::v]))         # the largest of all the digits in the j-th place
    c = int(c)                    # the digit in j-th place of the i-th number
    x[i] += "|"*(m-c+0**m+(j>0))  # pad | to size m-c, until the knots are correctly spaced
                                  # add a | if m<1, all j-th place digits are 0
                                  # add a | if j>0, if it's not at the start, as delimiters
    x[i] += ":8."[(c<2)|-(j<v-1)] * c
    # this is essentially the following code
    # if j<v-1:
    #     x[i] += "."*c      # . knots if not in the units place
    # else:
    #     if c == 1:
    #         x[i] += "8"*c  # 8 knots for ones in the units place
    #     else:
    #         x[i] += ":"*c  # : knots for something else is in the units place

for r in zip(*x):       # transpose so all the rows (the quipu strings) now hang down
    print(*r, sep='')    # join the strings together at each knot
                         # and print each on a separate line

여기 에 Python 3 에만 해당되는 것이 있습니까? 그렇지 않다면, 파이썬 2로 변환하면 상당히 많은 바이트를 절약 할 수 있습니다
Cyoce

@Cyoce Python 3에만 해당되는 것은 없습니다. 방금 파이썬 3에서 시작했습니다. 그것이 내가 가진 버전이기 때문입니다. 나는 아이디어 나 다른 것에서 파이썬 2 버전을 테스트 할 것이다.
Sherlock9

로 출발하는 입력과 그 작동하지 않음을 @Maltysen 0등, 0 12 4.
Sherlock9

파이썬 2에서 들여 쓰기를 위해 탭과 공백을 번갈아
가면

for r in zip(*x):print(''.join(r))->print(''.join(r)for r in zip(*x))
Leaky Nun

4

C, 238235 바이트

코드를 가능한 짧게 만들기 위해 C 전처리기에 크게 의존합니다. 부작용으로 거의 읽을 수 없습니다.

#define l strlen(a[i])
#define d l<k||a[i][l-k]-48
#define m(e) for(i=1;a[i];e<=r?i++:r++);
#define p(e) {m(!putchar(e?'|':k>1?46:d<2?56:58))puts("");}
k,r;main(int i,char**a){m(l)for(k=r,r=1;k;r=k>1){m(d)for(;r;r--)p(d<r)if(--k)p(1)}}

Ubuntu 14.04에서는 코드를 간단하게 컴파일 할 수 있습니다 gcc quipu.c(경고는 무시하십시오). 실행 파일을 실행하는 예 :

$ ./a.out 1 2 3 2 1
||:||
|:::|
8:::8

모든 OP의 테스트 사례에 대해 테스트되었습니다.

Ungolfed 소스 코드 :

// Standard library; leaving out the includes still gives executable code despite the warnings.
#include <stdio.h>
#include <string.h>

// 4 preprocessor macros.
// Note: some of these actually make use of the fact that parentheses have been left out

// l: length of argument i
#define l     strlen(a[i])

// d: shorthand for a digit
#define d     l<k || a[i][l-k]-'0'

// m: loop across all arguments; calculates r as the maximum of expression e
#define m(e)  for (i=1; a[i]; e<=r ? i++ : r++);

// p: prints one line of output
// note: intentionally does not use the r++ code branch of m;
//       putchar always returns a non-zero number here, so !putchar is zero,
//       which is always <=r (because r is never negative)
// note: the semicolon after m(...) is redundant;
//       the definition of m already contains a semicolon
// note: puts("") outputs a newline
#define p(e)  { m(!putchar(e ? '|' : k > 1 ? '.' : d < 2 ? '8' : ':')); puts(""); }

// k: knot position; 1 for units, 2 for tens, 3 for hundreds...
int k;

// r: input and output value for m
// note: the first time we call m, we need r to be zero;
//       by defining it outside main, it is automatically initialized as such
int r;

// function main
// note: parameter i (normally named argc by convention) is not needed
//       (the last element of argv is known; it is followed by a NULL pointer)
//       but we cannot leave it out (otherwise we cannot access argv)
//       so it serves as a local variable (to loop through arguments; see m)
// note: parameter a (normally named argv by convention)
//       is the array of arguments (starting from index 1)
int main(int i, char **a)
{
    // Determine the longest argument; store its length in r.
    // This is the number of knot positions to consider.
    m(l)

    // Iterate k through the knot positions from top to bottom.
    // Note: k > 0 has been abbreviated to k.
    // Note: for each iteration, we also initialize r with either 0 or 1.
    //       0 = suppress printing when all knots are zero
    //       1 = always print, even when all knots are zero
    for (k = r, r = 1; k > 0; r = k > 1)
    {
        // Determine the highest digit at this knot position.
        // Note: due to the absence of parentheses, d mixes up with <=r into:
        // (l < k) || (a[i][l-k]-'0' <= r)
        m(d)

        // Count the digits down.
        for (; r; r--)
        {
            // Print a single line of output.
            // When d (the digit in the current strand) is less than the counter,
            // then print a '|', otherwise print a knot.
            p(d < r)
        }

        // Decrement k (go to next knot position).
        // If this was not the last iteration...
        if (--k > 0)
        {
            // Print separator line.
            p(1)
        }
    }

    // Return exit code zero; redundant.
    return 0;
}

축하합니다! 바운티 기간 내에 가장 짧은 답변이 게시되었으므로 +50 회 현상금을 받았습니다. 좋은 대답입니다! :)
Alex A.

4

Mathematica 436 453 357352 347 바이트

t=Transpose;y=ConstantArray;a=Table;
g@j_:=(s=t[PadLeft[#,Max[Length/@i]]&/@(i=IntegerDigits@#)]&;p_~u~o_:=(m=Max@p;c=If[o==-2,":","."];w=If[o==-2,"8","."];p//.{0->a["|",Max@{1,m}],1->Join[a["|",{m-1}],{w}],n_/;MemberQ[2~Range~9,n]:>Join[y["|",m-n ],c~y~n]});t[Join@@@t@Join[u[#,0]&/@Most@#,u[#,-2]&/@{#[[-1]]}]]&[Riffle[(s@j),{a[0,Length@j]}]]//Grid)

  • IntegerDigits;를 사용하여 각 정수를 자릿수 목록으로 나눕니다 . 각 숫자를 왼쪽으로 0으로 채 웁니다 (같은 간격을 유지하기 위해). 이제 숫자로 분해 된 각 입력 번호는 배열의 행에 해당합니다. 각 열은 장소 값을 나타냅니다. 배열이 바뀝니다.
  • 패딩이있는 매듭 목록으로 숫자를 대체합니다. 장치에는 약간 다른 패턴 일치 루틴이 사용됩니다.

g[Range[0, 50]]

오십


Transpose@Join? 그게 맞아야합니까?
CalculatorFeline

예. 이것을 잡아 주셔서 감사합니다.
DavidC

그 직전의 공간.
CalculatorFeline

1

446 화 444 호

아직 R 솔루션이 없기 때문에 여기에 하나가 있습니다. 이 함수는 정수가 포함 된 벡터를 가져옵니다.

function(x){r=nchar(max(x));c=length(x);m=matrix(0,r,c);for(i in 1:c){t=as.numeric(strsplit(as.character(x[i]),"")[[1]]);m[(r+1-length(t)):r,i]=t};Q=c();for(i in 1:r){d=m[i,];z=ifelse(max(d)>0,max(d),1);q=matrix("|",z,c);for(j in 1:c){v=m[i,j];if(i==r){if(v==1)q[z,j]=8;if(v>1)q[(z-v+1):z,j]=rep(":",v)};if(i<r){if(v>0)q[(z-v+1):z,j]=rep(".",v)}};if(i!=1&sum(d)>0)q=rbind(rep("|",c),q);Q=rbind(Q,q)};for(i in 1:nrow(Q))cat(Q[i,],sep="",fill=T)}

언 골프

# Some test data
test <- c(201, 0, 100, 222, 53)

# Define function
quipu <- function (x) {

    # Create matrix with a row for each digit and a column for each number
    r=nchar(max(x));c=length(x);m <- matrix(0,r,c)
    for(i in 1:c) {
        t=as.numeric(strsplit(as.character(x[i]),"")[[1]])
        m[(r+1-length(t)):r,i]=t
    }

    # Loop through each row (digit) starting at the top of the quipu
    Q=c() # Empty matrix to store quipu 
    for(i in 1:r){

        d=m[i,]
        z=ifelse(max(d)>0,max(d),1)
        q=matrix("|",z,c)

        # Loop through each column (number in the vector) starting at the leftmost quipu
        for(j in 1:c){

            # The digit
            v=m[i,j]

            # If it is the last segment of the quipu
            if(i==r){
                if(v==1){q[z,j]=8} # If unit digit =1
                if(v>1){q[(z-v+1):z,j]=rep(":",v)} # If unit digit >1               
            }

            # If it is not the last segment of the quipu
            if(i<r){
                if(v>0){q[(z-v+1):z,j]=rep(".",v)} # If non-unit digit >0   
            }
        }

        # Add segment to Q
        if(i!=1 & sum(d)>0){q=rbind(rep("|",c),q)}
        Q=rbind(Q,q)    
    }

    # Print quipu
    for(i in 1:nrow(Q)) {cat(Q[i,], sep="", fill=T)}
}

# Test
quipu(test)

당신 if(v>0)은 당신의 if(i<r)절에 필요 합니까? R은 z+1:z언제 와 같은 범위를 허용합니까 v==0? 그렇게 q[z+1:z,j]해도 전혀 영향을받지 않는다면 생각합니다. 또한 R에는 else키워드와 일종의 else if키워드가 있습니까? 그렇다면 이러한 조건 중 일부를 골프화 할 수 있습니다.
Sherlock9

if(v>0)인 경우 v=0인덱스가 범위를 벗어납니다 (즉, 행 nrow + 1을 얻으려고 시도하기 때문에). R은을 가지고 else실제로 제안을 시도하고 else가능한 경우 사용했지만 동일한 바이트 수로 밝혀졌습니다.
느린 로리
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.