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


41

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

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

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

세부

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

매듭

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

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

퀴 푸스 구성

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

  1. 스트랜드는 위치의 내림차순으로 위에서 아래로 이어집니다 (단위 숫자는 스트랜드의 맨 아래에 있음). 가닥을 따라 숫자는 문자 ( |) 로 구분됩니다 .
  2. 숫자 10의 거듭 제곱은 숫자 시스템의 숫자를 사용하여 10의 숫자 거듭 제곱을 계산하는 것과 같은 방식으로 스트랜드를 따라 위치에 따라 결정됩니다. 즉, 24와 210 자리의과 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이 될 때까지 p 와 q2를 함께 줄임 으로써 현재 수를 살펴 봅니다. 각 위치에서 * q2 의 값 은 우리가해야 할 일을 알려줍니다. 1은 "아무것도하지 않음"을 의미하므로 계속 진행합니다. 결국 우리는 셀 # -3에서 2를 만난다. * q2 가 1과 같지 않을 때마다 q2 는 항상 q와 같습니다 .

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

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

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

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

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

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

다음에 * q를 증가 시키면 3 단계로 넘어갑니다. "현재 위치의 모든 숫자에서 최대 자릿수를 뺍니다". 이전과 마찬가지로 p 를 11로 재설정 하고 q2 를 0으로 재설정 한 다음 이전 단계에서했던 것처럼 모든 숫자를 거 칩니다 . 이 시간을 제외시켰다 * Q 3 대신 2 때마다 = Q2가 충족 Q 및 p는 수백 장소입니다, 우리가 사용하는 동안 감소에 루프 * 페이지 의 왼쪽 블록의 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) : 새해 복 많이 받으세요! 변수 p2 와 r2를 완전히 제거했습니다 ! 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.