Quipus là một thiết bị cổ xưa được người Inca sử dụng trong thời kỳ tiền sử để ghi lại các con số trong hệ thống mười vị trí cơ bản của các nút thắt trên dây, hoạt động như sau:

Mỗi cụm nút thắt là một chữ số, và có ba loại nút thắt chính: nút thắt quá tay đơn giản; "các nút dài", bao gồm một nút thắt quá mức với một hoặc nhiều lượt bổ sung; và hình tám nút thắt.

• Quyền hạn của mười được hiển thị theo vị trí dọc theo chuỗi và vị trí này được căn chỉnh giữa các chuỗi liên tiếp.
• Các chữ số ở các vị trí cho 10 lũy thừa trở lên được biểu thị bằng các cụm nút thắt đơn giản (ví dụ: 40 là bốn nút đơn giản liên tiếp ở vị trí "hàng chục").
• Các chữ số ở vị trí "cái" được thể hiện bằng các nút dài (ví dụ: 4 là một nút có bốn lượt). Do cách thắt nút, chữ số 1 không thể được hiển thị theo cách này và được thể hiện ở vị trí này bằng nút thắt hình số tám.
• Không được đại diện bởi sự vắng mặt của một nút ở vị trí thích hợp.

Chi tiết

Đối với thử thách này, mỗi chuỗi của một quipu đại diện cho một số duy nhất (mặc dù, như bài viết trên Wikipedia nêu, bạn có thể đại diện cho nhiều số trên một chuỗi, trong thử thách này, chúng tôi sẽ không).

Knots

Mỗi nút sẽ được đại diện bởi một ký tự ASCII.

• . đại diện cho một nút thắt đơn giản
• : đại diện cho một lượt của một nút dài
• 8 đại diện cho một nút tám hình
• | đại diện cho sự vắng mặt của một nút thắt cũng như một dấu phân cách giữa các chữ số.

Xây dựng Quipus

Quipu được xây dựng theo các quy tắc này.

1. Các sợi chạy từ trên xuống dưới theo thứ tự vị trí giảm dần (như trong, chữ số đơn vị sẽ ở cuối dưới cùng của một chuỗi). Các chữ số dọc theo một chuỗi được phân tách bằng ký tự ( |).
2. Sức mạnh của 10 chữ số đại diện được xác định bởi vị trí của nó dọc theo chuỗi giống như cách lũy thừa 10 chữ số sẽ được tính bằng chỉ số của nó trong một số với hệ thống số của chúng tôi. Đó là, 24với một 2vị trí hàng chục và một 4vị trí trong đơn vị, sẽ được biểu thị bằng hai nút thắt, một dấu phân cách ( |), sau đó là bốn nút thắt.
3. Các chữ số ở cùng một vị trí được căn chỉnh về phía dưới của chuỗi. Nếu một chữ số ở một vị trí sẽ có ít nút thắt hơn các chữ số khác của các số khác ở cùng vị trí, sự vắng mặt của các nút đó được biểu thị bằng ( |).
4. Các nút đơn giản liên tiếp ( .) đại diện cho một giá trị ở vị trí của chúng.
5. Mỗi chữ số được đại diện bởi ít nhất 1 ký tự. Khi một giá trị chữ số là 0 cho tất cả các số trong một quipu, nó được biểu thị bằng việc không có nút thắt ( |).
6. Các đơn vị nơi được đối xử đặc biệt. Một trong các vị trí đơn vị được đại diện bởi một nút hình tám ( 8). Giá trị từ hai trở lên ở vị trí đơn vị được biểu thị bằng các nút dài liên tiếp ( :).
7. Khi chữ số đơn vị là 0 cho tất cả các số trong một quipu, việc không có nút thắt không được in nhưng dấu phân cách dấu cho chữ số hàng chục được giữ nguyên.
8. Không có dấu phân cách theo chữ số đơn vị.

Quy tắc

• Đầu vào sẽ bao gồm một danh sách các số nguyên không âm có thể được nhận thông qua bất kỳ phương thức nhập mặc định nào . Bạn có thể cho rằng các số nguyên này đều nhỏ hơn hoặc bằng 2147483647hoặc 2^31-1. Mặc dù các trường hợp kiểm tra được phân tách bằng dấu cách, định dạng đầu vào của bạn có thể phân tách các đầu vào theo bất kỳ cách nào thuận tiện cho ngôn ngữ của bạn, cho dù đó là phân tách bằng dấu phẩy, phân tách dòng mới, trong một mảng, v.v.
• Đầu ra bao gồm một Quipu duy nhất được xây dựng theo các quy tắc được mô tả ở trên. Đầu ra có thể được cung cấp thông qua bất kỳ phương thức đầu ra mặc định .
• Mã của bạn phải là một chương trình hoặc một hàm, mặc dù nó không cần phải là một hàm được đặt tên.
• Knots mất một chút thời gian để buộc để tiết kiệm thời gian, mã của bạn càng ngắn càng tốt.

Như mọi khi, nếu vấn đề không rõ ràng, xin vui lòng cho tôi biết. Chúc may mắn và chơi golf tốt!

Ví dụ

Đầu vào:

5 3 1 0

Đầu ra:

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

Đầu vào:

50 30 10 0

Đầu ra:

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

Đầu vào:

330

Đầu ra:

.
.
.
|
.
.
.
|

Đầu vào:

204 1

Đầu ra:

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

Đầu vào:

201 0 100 222

Đầu ra:

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

Đầu vào:

1073741823 2147483647

Đầu ra:

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

Đầu vào:

0

Đầu ra:

|

Trường hợp thử nghiệm dài hơn

Đọc thêm

• Cổ nhân: Quipu
• Cấu trúc dữ liệu Quipu, Pre-Inca

Bình thường, 64 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

=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)

Không thể đọc được , 3183 3001 byte

Đây là một thử thách thú vị để làm việc, bật và tắt, giữa các lễ Giáng sinh. Cảm ơn đã đăng bài viết! Chơi golf này rất thú vị vì đặc điểm kỹ thuật có đầy đủ các trường hợp ngoại lệ và trường hợp đặc biệt, đòi hỏi rất nhiều nếu có điều kiện. Ngoài ra, trong khi tôi không cần phải chuyển đổi sang và từ số thập phân lần này, tôi đã cần một hàm sắp xếp max max để xác định số chữ số lớn nhất trong mỗi số và giá trị lớn nhất của các chữ số ở mỗi nơi.

Phiên bản đầu tiên của cái này là 4844 byte, chỉ để cho bạn biết tôi đã chơi cái này bao nhiêu.

Chương trình dự kiến ​​đầu vào là một danh sách các số nguyên được phân tách bằng dấu phẩy . Không có không gian hoặc dòng mới. Sử dụng những người sẽ tạo ra hành vi không xác định.

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

Giải trình

Tôi sẽ hướng dẫn bạn cách chương trình hoạt động bằng cách chỉ cho bạn cách chương trình xử lý đầu vào cụ thể 202,100,1.

Ban đầu, chúng tôi xây dựng một vài giá trị mà chúng tôi sẽ cần sau này - chủ yếu là mã ASCII của các ký tự mà chúng tôi sẽ xuất ra.

Như bạn có thể thấy, '8'và '.'đã có sẵn. '|'tuy nhiên, thực sự là 124, không phải 14. Chúng tôi sử dụng vòng lặp while để thêm hai lần giá trị tạm thời vào vị trí số 1 vào đó để có được 124 (tức là 14 + 55 × 2, vì vòng lặp while chạy với giá 56−1 = 55 lặp đi lặp lại). Điều này tiết kiệm một số byte bởi vì số nguyên lớn như 124 thực sự dài. Trong sơ đồ sau, tôi hiển thị vị trí của mọi biến mà chương trình sử dụng.

Tiếp theo, chúng tôi muốn nhập tất cả các ký tự và lưu trữ chúng trên băng bắt đầu từ ô số 12 ( p là con trỏ đang chạy cho việc này). Đồng thời, chúng tôi muốn biết số dài nhất là bao lâu (bao nhiêu chữ số). Để đạt được điều này, chúng tôi giữ cho tổng số chạy trong unary đi về phía trái bắt đầu từ ô # 1 (chúng tôi sử dụng q làm con trỏ đang chạy). Sau số đầu vào đầu tiên ( 202), băng bây giờ trông như thế này:

Bạn sẽ nhận thấy rằng các số bị tắt bởi 4. Chà, khi chúng ta lần đầu tiên nhập chúng, chúng là các giá trị ASCII của chúng, vì vậy, chúng bị tắt bởi 48 và dấu phẩy là 44. Với mỗi ký tự, chúng ta sao chép 46 từ '.'vào r và sau đó trừ nó bằng một vòng lặp while (trừ 45) và sau đó chúng ta thêm 1. Chúng ta làm như vậy để dấu phẩy (dấu phân cách của chúng ta) bằng 0, vì vậy chúng ta có thể sử dụng một điều kiện để nhận ra nó.

Ngoài ra, bạn sẽ nhận thấy rằng chúng ta để ô số 11 ở mức 0. Chúng ta cần điều đó để nhận ra ranh giới của số đầu tiên.

Ký tự tiếp theo sẽ là dấu phẩy, vì vậy chúng tôi lưu 0 trong # 15, nhưng tất nhiên lần này chúng tôi không tiến lên q . Thay vào đó, chúng tôi đặt q trở về 0 và bắt đầu ghi đè vào số 1 mà chúng tôi đã đặt.

Sau khi tất cả các ký tự còn lại được xử lý, chúng tôi nhận được điều này:

Như bạn có thể thấy, các số 1 được viết bởi q hiện chỉ ra (bằng unary) độ dài của số dài nhất.

Bây giờ chúng ta sử dụng một vòng lặp while để di chuyển q sang bên trái, và sau đó đặt một con trỏ khác ở đó mà tôi sẽ gọi r2 . Mục đích của r2 sẽ trở nên rõ ràng sau này.

Tại thời điểm này, hãy để tôi làm rõ thuật ngữ mà tôi sẽ sử dụng trong suốt này.

• Theo số , tôi có nghĩa là một trong những số đầu vào được phân tách bằng dấu phẩy. Trong ví dụ của chúng tôi, chúng là 202, 100 và 1.
• Theo chữ số , tôi có nghĩa là một chữ số trong một số cụ thể. Số đầu tiên có 3 chữ số.
• Theo địa điểm , ý tôi là các vị trí, hàng chục, hàng trăm vị trí, v.v ... Vì vậy, nếu tôi nói thì các chữ số ở vị trí hiện tại, và vị trí hiện tại là các vị trí, các chữ số đó là 2, 0 và 1 trong đó đặt hàng.

Bây giờ trở lại chương trình thường xuyên của chúng tôi. Toàn bộ phần còn lại của chương trình là một vòng lặp lớn di chuyển q về phía trước cho đến khi đến ô # 0. Mỗi ô trên đường đi đại diện cho một địa điểm, với các ô ở phía bên phải và q sẽ bắt đầu ở mức quan trọng nhất. Trong ví dụ của chúng tôi, đó là hàng trăm nơi.

Chúng tôi tiến hành bằng cách tăng các ô q điểm tại (nghĩa là, * q ).

Hiện tại chúng tôi đang ở giai đoạn 2, trước đây cho hàng trăm nơi. Trong giai đoạn này, chúng ta sẽ tìm ra chữ số nào lớn nhất trong số tất cả các chữ số ở hàng trăm vị trí. Chúng tôi sử dụng cùng một thủ thuật đếm đơn phương cho việc này, ngoại trừ lần này con trỏ được gọi là r và con trỏ r2 đánh dấu vị trí bắt đầu của nó mà chúng tôi cần đặt lại mỗi khi chúng tôi chuyển sang số tiếp theo.

Hãy bắt đầu với số đầu tiên. Chúng tôi bắt đầu bằng cách đặt p thành 11 (vị trí bắt đầu được mã hóa cứng của tất cả các số). Sau đó chúng tôi sử dụng một vòng lặp while để tìm phần cuối của số và đặt p2 ở đó để đánh dấu vị trí. Đồng thời, chúng tôi cũng đặt q2 thành 0:

Đừng bị phân tâm bởi thực tế là q2 đang chỉ vào các bình. Chúng tôi không có phần đệm của một ô trống ở đó vì chúng tôi có thể phát hiện ô # 0 đơn giản vì đó là số không.

Tiếp theo, chúng ta đi qua số hiện tại bằng cách giảm p và q2 cùng nhau cho đến khi * p bằng không. Tại mỗi nơi, giá trị của * q2 cho chúng ta biết những gì chúng ta cần làm. 1 có nghĩa là không làm gì cả, vì vậy chúng tôi tiếp tục. Cuối cùng, chúng ta bắt gặp 2 trong ô # −3. Mỗi lần * q2 không bằng 1, q2 luôn bằng q .

Như tôi đã nói, giai đoạn 2 là xác định chữ số lớn nhất ở nơi này. Vì vậy, chúng tôi đặt r thành r2 , sử dụng vòng lặp while để giảm * p và di chuyển r sang trái và lấp đầy băng bằng 1s, sau đó sử dụng vòng lặp while khác để di chuyển r trở lại bên phải và tăng * p lần nữa để khôi phục giá trị. Hãy nhớ rằng mỗi vòng lặp while chạy cho một lần lặp ít hơn giá trị chúng ta sử dụng; bởi vì điều này, số lượng 1 chữ viết sẽ nhiều hơn 3 (chứ không phải 4 nhiều hơn) so với giá trị chữ số và giá trị cuối cùng được lưu trữ trong * p sẽ nhiều hơn 2. Do đó, điều này đã giảm hiệu quả * p xuống 2.

Sau đó, chúng tôi đặt p thành giá trị của p2 và sau đó chúng tôi làm lại tất cả. Lần thứ hai, đặt q2 thành 0, tìm điểm cuối của số bằng cách di chuyển p sang phải và sau đó đi qua các chữ số của số này bằng cách giảm p và q2 cùng nhau. Một lần nữa, chúng ta sẽ bắt gặp 2 trong ô # −3 và viết rằng nhiều số 1 còn lại của * r .

Trong trường hợp của số thứ ba, cuối cùng chúng tôi không làm gì cả vì nó không có hàng trăm vị trí (vì vậy q2 không bao giờ đạt đến q ), nhưng điều đó không sao vì điều đó không ảnh hưởng đến việc tính toán giá trị chữ số tối đa.

Chúng tôi cũng đặt ô * (r - 4) , mà tôi đã đánh dấu bằng một mũi tên chưa được gắn nhãn ở đây, thành 1 (mặc dù nó đã ở mức 1). Tôi sẽ không cho bạn biết lý do tại sao, nhưng có lẽ bạn đã đoán ra?

Gia số tiếp theo của * q đưa chúng ta đến giai đoạn 3, tức là trừ đi chữ số tối đa từ tất cả các chữ số ở vị trí hiện tại. Như trước đây, chúng tôi đặt lại p thành 11 và q2 thành 0 và sau đó đi qua tất cả các số giống như chúng tôi đã làm trong giai đoạn trước; ngoại trừ lần này, * q = 3 thay vì 2. Mỗi lần q2 gặp q và p ở vị trí hàng trăm, chúng tôi sử dụng vòng lặp while để giảm * p nhiều lần vì có 1s trong khối còn lại của * r2 (5 trong ví dụ của chúng tôi) bằng cách sử dụng rnhư một con trỏ đang chạy Chúng tôi thực sự giảm nó một lần nữa để chữ số lớn nhất kết thúc ở −2, vì một lý do sẽ trở nên rõ ràng sau:

Sau khi chúng tôi xử lý tất cả các số, bây giờ chúng tôi ở cuối giai đoạn 3. Ở đây chúng tôi thực hiện hai điều kỳ dị.

• Đầu tiên, chúng tôi cũng trừ kích thước của r -block (cộng 1) từ * q , nhưng sử dụng con trỏ r2 , để nó ở bên trái. * q trở nên tiêu cực theo cách này. Trong trường hợp của chúng tôi, r -block có năm 1 giây, vì vậy * q trở thành −3.
• Thứ hai, chúng ta thiết lập một biến ra một giá trị khác không để cho biết rằng bây giờ chúng ta đang bước vào giai đoạn đầu ra. (Về mặt kỹ thuật, thực tế là * q âm đã chỉ ra giai đoạn đầu ra, nhưng điều này quá khó để kiểm tra, do đó biến phụ.)

Bây giờ bạn hiểu rằng chúng tôi tiếp tục xem qua các số, tìm vị trí hiện tại (được biểu thị bằng giá trị không 1 của * q ) trong mỗi số và làm một cái gì đó tùy thuộc vào giá trị của * q . Chúng tôi thấy rằng * q trước tiên được tăng lên 2 (= tính giá trị chữ số tối đa), sau đó 3 (trừ giá trị chữ số tối đa từ mỗi chữ số ở vị trí này) và sau đó chúng tôi trừ đi để làm cho nó âm. Từ đó, nó sẽ tiếp tục tăng cho đến khi đạt 1, do đó khôi phục lại giá trị có nghĩa là không làm gì nữa. Tại thời điểm đó, chúng tôi chuyển sang địa điểm tiếp theo.

Bây giờ, khi * q âm, chúng tôi xuất ra. * q chính xác là đúng giá trị để chúng ta sẽ xuất đúng số lượng hàng ký tự trước khi đạt 1; nếu chữ số lớn nhất là 2, chúng ta cần xuất 3 hàng. Hãy xem điều gì xảy ra ở mỗi giá trị của * q :

• * q = −2:
  • Đối với số đầu tiên, * p là −2, cho biết chúng ta cần xuất ra một '.'dấu chấm (dấu chấm) hoặc ':'dấu hai chấm. Chúng tôi quyết định xem bằng cách xem q : nếu là −1, chúng tôi đang ở vị trí đó, vì vậy hãy xuất a ':'(mà chúng tôi tính là '8'+2), nếu không thì a '.'.
  • Đối với số thứ hai, * p là −3. Bất cứ điều gì không phải là 2 có nghĩa là chúng ta xuất ra một '|'(ống) và sau đó tăng giá trị. Bằng cách này, nó sẽ đạt đến −2 ở đúng vị trí và sau đó chúng ta xuất '.'s / ':'s cho phần còn lại của chữ số đó.
  • Trong mỗi trường hợp, chúng tôi cũng đặt một biến pd thành 0 trước khi chúng tôi xử lý số và đặt pd (= In đã in) thành một giá trị khác không để cho biết rằng chúng tôi đã in một ký tự.
  • Đối với số thứ ba, không có xử lý xảy ra vì số thứ ba không có hàng trăm vị trí. Trong trường hợp này, pd vẫn sẽ là 0 sau khi xử lý số, cho biết rằng chúng ta vẫn cần xuất ra một '|'(nhưng chỉ khi ra là khác không, bởi vì nếu không thì chúng ta vẫn ở giai đoạn 2 hoặc 3).
  • Sau khi xử lý tất cả các số, nếu ra là khác không, hãy xuất một dòng mới. Lưu ý rằng chúng tôi cần biến ngoài để chúng tôi không xuất dòng mới trong giai đoạn 2 hoặc 3.
• * q = 1: Tương tự như trước, ngoại trừ * p là −2 cho cả hai số đầu tiên, vì vậy cả hai đều xuất a'.'(và số thứ ba xuất ra a'|'như trước).
• * q = 0: Khi * q bằng 0, điều này có nghĩa là không làm gì nếu chúng ta ở vị trí đó, nếu không thì xuất ra một hàng'|'s bất kể * p . Bằng cách này, chúng ta có được phần đệm giữa các chữ số.

Bây giờ chúng ta tăng q để chuyển sang vị trí tiếp theo, vị trí hàng chục và tăng * q ở đó. Ở đầu Giai đoạn 2, đoạn băng trông như thế này:

Sau đó, chúng tôi thực hiện Giai đoạn 2 như trước đây. Hãy nhớ điều này một cách hiệu quả trừ 2 từ mỗi chữ số ở vị trí này và cũng để lại một số đơn vị còn lại là * r2 cho biết chữ số tối đa. Chúng tôi để số unary trước đó một mình và chỉ cần kéo dài băng sang bên trái; nó sẽ chỉ tốn thêm mã không cần thiết để dọn dẹp. Khi chúng tôi hoàn thành và chúng tôi tăng * q , khi bắt đầu Giai đoạn 3, băng bây giờ là:

Thật ra, đây là một lời nói dối. Hãy nhớ trước đó tôi đã nói chúng tôi đặt * (r - 4) thành 1 và tôi không nói cho bạn biết tại sao? Bây giờ tôi sẽ cho bạn biết lý do tại sao. Đối với các trường hợp như trường hợp này, trong đó chữ số lớn nhất thực tế là 0, có nghĩa là tất cả các chữ số ở vị trí này là 0. Cài đặt * (r - 4) , được biểu thị bằng mũi tên không được gắn nhãn ở trên, đến 1 kéo dài số đơn vị 1, Nhưng chỉ trong trường hợp đặc biệt này. Bằng cách này, chúng tôi giả vờ như thể chữ số lớn nhất là 1, có nghĩa là chúng tôi sẽ xuất thêm một hàng.

Sau Giai đoạn 3 (trừ chữ số tối đa từ tất cả các chữ số ở vị trí hiện tại), bao gồm cả bước bổ sung làm cho * q âm, băng trông như thế này. Lần trước, chữ số lớn nhất được biểu thị bằng −2 trong khối * p , nhưng lần này tất cả đều là because3 vì tất cả chúng thực sự là số 0 nhưng chúng tôi giả vờ như thể chữ số tối đa là 1.

Bây giờ hãy xem điều gì xảy ra khi * q tiến tới 1:

• Khi * q = −1, các giá trị * p đều là −3, có nghĩa là chúng ta xuất '|'s và tăng chúng.
• Khi * q = 0, chúng tôi xuất ra '|'vì đó là những gì chúng tôi luôn làm khi * q = 0, bất kể * p .

Như vậy, chúng ta có được hai hàng ống.

Cuối cùng, chúng tôi di chuyển * q đến nơi của một người. Điều này trở nên thú vị bởi vì chúng ta cần xuất ':'s nếu chữ số thực là bất cứ thứ gì ngoài 1, nhưng '8'nếu nó là 1. Hãy xem chương trình tiến hành như thế nào. Đầu tiên, chúng tôi tăng * q để bắt đầu Giai đoạn 2:

Sau Giai đoạn 2 (tính toán giá trị chữ số tối đa,), chúng ta còn lại điều này:

Sau Giai đoạn 3 (trừ đi giá trị chữ số tối đa từ tất cả các chữ số ở vị trí hiện tại), băng trông như thế này:

Bây giờ chúng ta hãy lần lượt đi qua mỗi lần lặp của * q :

• * q = −2:
  • Số đầu tiên: đã ở −2, vì vậy đầu ra a ':'(chứ không phải a '.'vì q = 1).
  • Số thứ hai: tại 4, vì vậy đầu ra a '|'và tăng.
  • Số thứ ba: ở 3, do đó đầu ra a '|'. Tuy nhiên, lần này, thay vì tăng, một trường hợp đặc biệt kích hoạt. Chỉ khi chúng tôi xuất ra vị trí cuối cùng ( q = 1) và chúng tôi ở hàng cuối cùng thứ hai cho điều đó ( * q = −2), và chữ số thực sự là 1 ( * p = 3) , sau đó thay vì tăng nó lên −2, chúng tôi đặt nó thành 1. Nói cách khác, chúng tôi sử dụng −1 như một giá trị đặc biệt để chỉ ra rằng trong lần lặp tiếp theo, chúng tôi sẽ cần phải xuất ra '8'thay vì ':'.
• * q = −1:
  • Số đầu tiên: đã ở 2, vì vậy đầu ra a ':'.
  • Số thứ hai: ở 3, nên đầu ra a '|'. Điều kiện đặc biệt không kích hoạt vì * q không còn 2. Do đó, gia tăng.
  • Số thứ ba: tại 1, do đó đầu ra '8'.
• * q = 0: Thông thường, chúng tôi sẽ xuất hàng đệm của'|'s ở đây, nhưng trong trường hợp đặc biệt khi chúng tôi ở vị trí đó ( q = −1), chúng tôi bỏ qua điều đó.

Sau này, q được tăng lên 0 và vòng lặp while lớn kết thúc.

Bây giờ bạn biết làm thế nào một đầu vào như 202,100,1hoạt động. Tuy nhiên, có một trường hợp đặc biệt nữa mà chúng tôi vẫn chưa được bảo hiểm. Bạn có thể nhớ rằng trong khi chúng tôi đang xử lý vị trí cuối cùng, khi * p là −3, chúng tôi đặt nó thành for1 cho 1(thay vì tăng nó thành −2) để lần lặp tiếp theo sẽ xuất ra '8'thay thế. Điều này chỉ hoạt động bởi vì chúng tôi có một lần lặp trong đó * p là −3 và chúng tôi đưa ra quyết định về việc có nên tăng nó hay đặt nó thành 1 hay không. Chúng tôi không có phép lặp như vậy nếu tất cả các chữ số ở vị trí đó là 0 hoặc 1. Trong trường hợp như vậy, tất cả các giá trị * p cho 1 sẽ bắt đầu ở −2; không có cơ hội để quyết định đặt nó thành 1thay vì tăng nó từ −3 . Bởi vì điều này, có một điều kiện vỏ đặc biệt khác trong Giai đoạn 3 (trừ đi chữ số tối đa từ mỗi chữ số ở vị trí hiện tại). Tôi đã tuyên bố rằng sau khi trừ giá trị chữ số tối đa từ mỗi chữ số (tại thời điểm đó chữ số tối đa là −1), chúng tôi chỉ giảm giá trị một lần nữa, nhưng thực tế có một điều kiện như sau:

Nếu chữ số chúng ta đang xem bằng chữ số tối đa ở nơi này ( * p = 1) và vị trí này là vị trí ( q = 1) và chữ số tối đa là 1 ( * (r + 5) = 0, tức là khối unary ở bên trái chỉ dài 5 ô), chỉ sau đó chúng ta để * p ở −1 để chỉ ra rằng lần lặp duy nhất của đầu ra phải xuất ra một '8'. Trong tất cả các trường hợp khác, chúng tôi giảm nó một lần nữa.

Làm xong. Chúc mừng năm mới!

• Chỉnh sửa 1 (3183 → 3001): Chơi golf chúc mừng năm mới! Tôi đã quản lý để loại bỏ hoàn toàn các biến p2 và r2 ! Bây giờ p chạy đua qua lại để tiếp tục tìm đầu và cuối của các số, nhưng dường như mã này ngắn hơn. Tôi cũng đã cố gắng loại bỏ q2 , nhưng tôi không thể làm cho mã ngắn hơn theo cách đó.

  Tôi cũng tìm thấy thêm một vài nơi mà tôi có thể áp dụng các thủ thuật đánh gôn không thể đọc được điển hình như sử dụng lại giá trị cuối cùng của vòng lặp while. Để cho bạn một ví dụ, thay vì

  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
  

  Tôi có thể lưu '""""(thực hiện lần đầu tiên, sau đó lần thứ hai) và '"""(hằng số 1) bằng cách viết nó theo cách tương tự

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

  Tất nhiên, điều này chỉ hoạt động nếu tôi biết rằng vòng lặp while sẽ chạy ít nhất một lần lặp, nhưng nếu có, giá trị trả về của nó là pd vì vậy tôi có thể sử dụng nó làm điều kiện cho if.

Javascript (ES6) 750 744 690 604 498 346 245 234 byte

Tôi mới sử dụng PPCG và nghĩ rằng tôi có thể thử cái này vì nghĩ nó khá đơn giản. Con trai là tôi sai !! Tôi đã làm việc với nó được một thời gian và tôi có rất nhiều việc phải chơi gôn ... Những
gợi ý được khuyến khích! - mặc dù ý nghĩa của việc này sẽ không phải là một nhiệm vụ dễ dàng.

Đầu ra dây khi đầu vào là một mảng các số (ví dụ [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)

Giải trình

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
)

Thí dụ

Đầu vào: Mảng số: [4,8,15,16,23,42]
Đầu ra:

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

Python 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 byte

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='')

Chà, vì câu hỏi này cần một câu trả lời, tôi đã cung cấp một câu hỏi ở đây, trong đó đầu vào phải là một chuỗi số được phân tách bằng dấu cách, chẳng hạn như "204 1". Chàng trai, nó là một cái dài. Bất kỳ đề nghị chơi golf (hoặc câu trả lời tốt hơn) đều được chào đón.

Chỉnh sửa: byte được lưu bằng cách trộn các tab và dấu cách.

Chỉnh sửa: Tôi đã lưu rất nhiều byte bằng cách thay đổi cách tôi có được các chữ số của một số (tạo danh sách từ chuỗi không đệm của số, sau đó trong phần thân của mã, hoán vị để lấy hàng trăm chữ số, mười chữ số, v.v. .)

Chỉnh sửa: Và tôi đã lưu thêm một số bằng cách kết hợp :8vòng lặp cuối cùng đó vào vòng lặp quipu chính. Bây giờ nếu tôi chỉ có thể tìm ra lý do tại sao b=d[j*v+i]==m(d[i::v])sẽ không làm việc. Tìm ra nó và giải pháp mất quá nhiều byte. (Ngoài ra, số byte bị giảm vì bằng cách nào đó các tab quay lại thành bốn khoảng trắng. Đây có thể là định dạng khối mã trên trang web này)

Chỉnh sửa: Tôi tổ chức lại cách làm cho quipus. Bây giờ nó tạo ra một sợi tại một thời điểm, sau đó chuyển đổi để in.

Chỉnh sửa: Biến câu trả lời của tôi trở lại thành chương trình Python 3 để lưu thêm một số byte.

Chỉnh sửa: Tôi đã tìm thấy một lỗi trong mã của mình khiến nó không in các số 0 ở giữa các số một cách chính xác (xem trường hợp thử nghiệm 204 1ở trên). Trong việc sửa lỗi này, tôi đã xoay sở để chơi nó :)

Chỉnh sửa: Tôi đã thay đổi in ấn để tiết kiệm 10 byte. Và tôi đặt lại tất cả các byte cũ, chỉ vì.

Chỉnh sửa: Đánh gôn việc gán vsử dụng mapcho bốn byte. Tín dụng cho RugPython , vì tôi đã có ý tưởng từ câu trả lời của họ ở đây .

Chỉnh sửa: Biến giữa "vòng lặp for bên trong vòng lặp for", thành vòng lặp for cho sáu byte.

Chỉnh sửa: Bây giờ sử dụng enumerate. Không còn sử dụng l=len(z). Biến ternary if-elsethành một danh sách ternary. Xem bên dưới để biết chi tiết.

Chỉnh sửa: Sp3000 đề xuất một chỉnh sửa printvà chỉnh sửa theo điều kiện ternary đã lưu một byte mỗi.

Ung dung:

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

C, 238 235 byte

Dựa nhiều vào bộ tiền xử lý C để làm cho mã càng ngắn càng tốt. Là một tác dụng phụ, cũng làm cho nó khá nhiều không thể đọc đượ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)}}

Trên Ubuntu 14.04, bạn có thể biên dịch mã đơn giản gcc quipu.c(vui lòng bỏ qua các cảnh báo). Một ví dụ về việc chạy tệp thực thi:

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

Đã thử nghiệm đối với tất cả các trường hợp thử nghiệm của OP.

Mã nguồn bị đánh cắp:

// 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;
}

Toán học 436 453 357 352 347 byte

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)

Ở trên

• Chia từng số nguyên thành một danh sách các chữ số, sử dụng IntegerDigits; đệm mỗi số có số không ở bên trái (để đảm bảo khoảng cách bằng nhau); mỗi số đầu vào, bây giờ được phân tách thành chữ số, tương ứng với một hàng của một mảng; mỗi cột đại diện cho một giá trị địa điểm. Mảng được hoán vị.
• Thay thế các chữ số bằng một danh sách các nút bằng đệm. Một thói quen khớp mẫu hơi khác nhau được sử dụng cho các đơn vị.

Thí dụ

g[Range[0, 50]]

R - 446 444

Tôi thấy chưa có giải pháp R nào, vì vậy đây là một giải pháp. Hàm lấy một vectơ với số nguyên.

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)}

Bị đánh cắp

# 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)