Quipus adalah perangkat kuno yang digunakan oleh suku Inca di era Pra-Polandia untuk mencatat angka dalam sistem posisi sepuluh basis simpul pada tali, yang berfungsi sebagai berikut:

Setiap kelompok simpul adalah angka, dan ada tiga jenis utama simpul: simpul terbuka sederhana; "long knots", terdiri dari simpul overhand dengan satu atau lebih putaran tambahan; dan angka delapan knot.

• Kekuatan sepuluh ditunjukkan oleh posisi sepanjang string, dan posisi ini selaras antara untaian beruntun.
• Digit pada posisi untuk 10 dan kekuatan yang lebih tinggi diwakili oleh kelompok simpul sederhana (misalnya, 40 adalah empat simpul sederhana dalam satu baris dalam posisi "puluhan").
• Digit dalam posisi "yang" diwakili oleh simpul panjang (mis., 4 adalah simpul dengan empat putaran). Karena cara simpul diikat, angka 1 tidak dapat ditunjukkan dengan cara ini dan diwakili dalam posisi ini oleh angka delapan simpul.
• Nol diwakili oleh tidak adanya simpul di posisi yang sesuai.

Detail

Untuk tantangan ini, setiap helai quipu mewakili angka tunggal (meskipun, seperti yang dinyatakan dalam artikel Wikipedia, Anda dapat mewakili banyak angka pada satu helai, dalam tantangan ini, kami tidak akan).

Simpul

Setiap simpul akan diwakili oleh karakter ASCII tunggal.

• . mewakili simpul sederhana
• : mewakili satu putaran ikatan panjang
• 8 mewakili simpul angka delapan
• | mewakili tidak adanya simpul serta pembatas antara digit.

Membangun Quipus

Quipu dibangun mengikuti aturan-aturan ini.

1. Helai berjalan dari atas ke bawah dalam urutan posisi yang menurun (seperti dalam, satuan digit akan berada di ujung bawah untai). Digit sepanjang untai dipisahkan oleh karakter ( |).
2. Kekuatan 10 digit mewakili ditentukan oleh posisinya di sepanjang untai dengan cara yang sama kekuatan digit 10 akan dihitung menggunakan indeksnya dalam angka dengan sistem angka kami. Yaitu, 24dengan a 2di tempat puluhan dan 4di tempat unit, akan diwakili oleh dua knot, pembatas ( |), lalu empat knot.
3. Digit dalam posisi yang sama disejajarkan ke arah bawah untai. Jika satu digit pada suatu posisi akan memiliki simpul lebih sedikit daripada digit lain dari angka lain di posisi yang sama, tidak adanya simpul tersebut diwakili oleh ( |).
4. Simpul sederhana berturut-turut ( .) menunjukkan nilai pada posisi mereka.
5. Setiap digit diwakili oleh setidaknya 1 karakter. Ketika nilai digit adalah 0 untuk semua angka dalam quipu, itu diwakili oleh tidak adanya simpul ( |).
6. Tempat unit diperlakukan secara khusus. Satu di tempat satuan diwakili oleh simpul angka-delapan ( 8). Nilai dua atau lebih di tempat unit diwakili oleh simpul panjang berturut-turut ( :).
7. Ketika digit satuan adalah 0 untuk semua angka dalam quipu tidak ada simpul tidak dicetak tetapi, pembatas trailing untuk puluhan digit dipertahankan.
8. Tidak ada pembatas yang mengikuti digit unit.

Aturan

• Input akan terdiri dari daftar bilangan bulat non-kosong yang dapat diterima melalui salah satu metode input default . Anda dapat mengasumsikan bahwa bilangan bulat ini semuanya kurang dari atau sama dengan 2147483647atau 2^31-1. Sementara kasus uji dibatasi oleh ruang, format input Anda dapat memisahkan input dengan cara apa pun yang nyaman untuk bahasa Anda, apakah itu dipisahkan koma, dipisahkan oleh baris baru, dalam array, dan sebagainya.
• Keluaran terdiri dari satu Quipu yang dibangun sesuai dengan aturan yang dijelaskan di atas. Output dapat diberikan melalui salah satu metode output default .
• Kode Anda harus berupa program atau fungsi, meskipun tidak harus berupa fungsi yang disebutkan.
• Knot perlu waktu untuk diikat sehingga menghemat waktu, kode Anda sesingkat mungkin.

Seperti biasa, jika masalahnya tidak jelas, beri tahu saya. Semoga berhasil dan bermain golf dengan baik!

Contohnya

Memasukkan:

5 3 1 0

Keluaran:

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

Memasukkan:

50 30 10 0

Keluaran:

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

Memasukkan:

330

Keluaran:

.
.
.
|
.
.
.
|

Memasukkan:

204 1

Keluaran:

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

Memasukkan:

201 0 100 222

Keluaran:

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

Memasukkan:

1073741823 2147483647

Keluaran:

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

Memasukkan:

0

Keluaran:

|

Kasus uji yang lebih panjang

Bacaan lebih lanjut

• Skrip Ancients: Quipu
• The Quipu, Pre-Inca Data Structure

Pyth, 64 byte

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

Cobalah online!

Bagaimana itu bekerja

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

Tidak dapat dibaca , 3183 3001 byte

Ini adalah tantangan yang menyenangkan untuk dikerjakan, hidup dan mati, di antara perayaan Natal. Terima kasih telah memposting! Golf ini menarik karena spesifikasinya penuh dengan perkecualian dan case khusus, yang membutuhkan banyak syarat. Selain itu, walaupun saya tidak perlu mengonversi ke dan dari desimal kali ini, saya memang membutuhkan fungsi "maks" untuk menentukan jumlah digit terbesar di setiap angka dan nilai digit terbesar di setiap tempat.

Versi pertama ini adalah 4844 bytes, hanya untuk memberi Anda gambaran tentang seberapa banyak saya bermain golf ini.

Program mengharapkan input sebagai daftar bilangan bulat yang dipisahkan koma . Tidak ada spasi atau baris baru. Menggunakannya akan menghasilkan perilaku yang tidak terdefinisi.

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

Penjelasan

Saya akan memandu Anda melalui cara program bekerja dengan menunjukkan kepada Anda bagaimana ia memproses input spesifik 202,100,1.

Pada awalnya, kita membangun beberapa nilai yang kita perlukan nanti - kebanyakan kode ASCII dari karakter yang akan kita hasilkan.

Seperti yang Anda lihat, '8'dan '.'sudah tersedia. '|', bagaimanapun, benar-benar 124, bukan 14. Kami menggunakan loop sementara untuk menambahkan dua kali nilai sementara di slot # 1 ke atasnya untuk mendapatkan 124 (yaitu 14 + 55 × 2, karena loop sementara berjalan untuk 56−1 = 55 iterasi). Ini menghemat beberapa byte karena literer bilangan bulat besar seperti 124 sangat panjang. Dalam diagram berikut, saya menunjukkan lokasi setiap variabel yang digunakan program.

Selanjutnya, kami ingin memasukkan semua karakter dan menyimpannya di kaset mulai dari sel # 12 ( p adalah pointer berjalan untuk ini). Pada saat yang sama, kami ingin tahu berapa lama angka terpanjang (berapa digit). Untuk mencapai hal ini, kita menyimpan total running di unary ke kiri mulai dari sel # −1 (kita menggunakan q sebagai pointer berjalan). Setelah nomor input pertama ( 202), rekaman sekarang terlihat seperti ini:

Anda akan memperhatikan bahwa angka-angka dimatikan oleh 4. Nah, ketika kami pertama kali memasukkan mereka, mereka adalah nilai ASCII mereka, jadi mereka "mati" dengan 48 dan koma adalah 44. Untuk setiap karakter, kami menyalin 46 dari '.'ke dalam r dan kemudian kurangi dengan loop sementara (yang mengurangkan 45) dan kemudian kita tambahkan 1. Kita melakukannya sehingga koma (pemisah kita) adalah 0, sehingga kita dapat menggunakan kondisional untuk mengenalinya.

Juga, Anda akan memperhatikan bahwa kami meninggalkan sel # 11 di 0. Kami membutuhkannya untuk mengenali batas nomor pertama.

Karakter selanjutnya adalah koma, jadi kami menyimpan 0 di # 15, tapi tentu saja kali ini kami tidak maju q . Sebagai gantinya, kita mengatur q kembali ke 0 dan mulai “menimpa” 1 yang telah kita tempatkan.

Setelah semua karakter yang tersisa diproses, kami mendapatkan ini:

Seperti yang Anda lihat, angka 1 yang ditulis oleh q sekarang menunjukkan (secara unary) panjang angka terpanjang.

Kami sekarang menggunakan loop sementara untuk memindahkan q ke paling kiri, dan kemudian menempatkan pointer lain di sana yang akan saya panggil r2 . Tujuan dari r2 akan menjadi jelas nanti.

Pada titik ini, izinkan saya mengklarifikasi terminologi yang akan saya gunakan selama ini.

• Dengan angka , maksud saya salah satu nomor input yang dipisahkan oleh koma. Dalam contoh kita, mereka adalah 202, 100 dan 1.
• Dengan digit , maksud saya satu digit di salah satu angka. Angka pertama memiliki 3 digit.
• Menurut tempat , maksud saya tempat yang, puluhan tempat, ratusan tempat, dll. Jadi jika saya mengatakan "digit di tempat saat ini", dan tempat saat ini adalah tempat yang, angka itu adalah 2, 0, dan 1 di dalamnya memesan.

Sekarang kembali ke pemrograman reguler kami. Seluruh sisa program adalah loop besar yang bergerak q maju hingga mencapai sel # 0. Setiap sel di sepanjang jalan mewakili suatu tempat, dengan yang ditempatkan di paling kanan, dan q akan mulai dari yang paling signifikan. Dalam contoh kita, itu adalah ratusan tempat.

Kami melanjutkan dengan menambah titik sel q di (yaitu, * q ).

Kami sekarang berada di "tahap 2" untuk ratusan tempat. Pada tahap ini, kita akan mengetahui digit terbesar di antara semua digit di ratusan tempat. Kami menggunakan trik penghitungan unary yang sama untuk ini, kecuali kali ini penunjuk disebut r dan penunjuk r2 menandai posisi awal yang harus diatur ulang setiap kali kami beralih ke nomor berikutnya.

Mari kita mulai dengan angka pertama. Kita mulai dengan mengatur p ke 11 (posisi awal yang dikodekan dari semua angka). Kami kemudian menggunakan loop sementara untuk menemukan ujung angka dan mengatur p2 di sana untuk menandai posisi. Pada saat yang sama, kami juga mengatur q2 ke 0:

Jangan terganggu oleh fakta bahwa q2 menunjuk ke dalam vars. Kami tidak memiliki lapisan sel kosong di sana karena kami dapat mendeteksi sel # 0 hanya karena itu nomor nol.

Selanjutnya, kita pergi melalui angka saat ini dengan mengurangi p dan q2 bersama-sama sampai * p nol. Di setiap tempat, nilai * q2 memberi tahu kita apa yang perlu kita lakukan. 1 berarti "tidak melakukan apa-apa", jadi kami terus berjalan. Akhirnya kita menemukan 2 dalam sel # −3. Setiap kali * q2 tidak sama dengan 1, q2 selalu sama dengan q .

Seperti yang sudah saya nyatakan, tahap 2 adalah "menentukan digit terbesar di tempat ini". Jadi kita atur r ke r2 , gunakan loop sementara untuk mengurangi * p dan pindahkan r ke kiri dan isi rekaman dengan 1s, dan kemudian gunakan loop sementara lainnya untuk memindahkan r kembali ke kanan dan naikkan * p lagi untuk mengembalikan nilai. Ingat bahwa setiap while dijalankan untuk satu iterasi yang lebih sedikit daripada nilai yang kita gunakan; karena ini, jumlah 1s yang ditulis akan menjadi 3 lebih (daripada 4 lebih) dari nilai digit, dan nilai akhir yang disimpan kembali dalam * p akan menjadi 2 lebih. Dengan demikian, ini telah dikurangi secara efektif * p oleh 2.

Setelah itu, kita menetapkan p ke nilai p2 dan kemudian kita melakukan semua itu lagi. Untuk kedua kalinya, atur q2 ke 0, cari ujung angka dengan memindahkan p ke kanan, dan kemudian pergi melalui digit angka ini dengan menurunkan p dan q2 bersamaan. Sekali lagi kita akan menjumpai 2 dalam sel # −3 dan menulis bahwa 1s tersisa dari * r .

Dalam kasus angka ketiga, kita akhirnya tidak melakukan apa-apa karena tidak memiliki ratusan tempat (jadi q2 tidak pernah mencapai q ), tapi tidak apa-apa karena itu tidak mempengaruhi perhitungan nilai digit maksimum.

Kami juga mengatur sel * (r - 4) , yang telah saya tandai dengan panah yang tidak berlabel di sini, menjadi 1 (meskipun sudah pada 1). Saya tidak akan memberi tahu Anda mengapa, tapi mungkin Anda sudah menebaknya?

Peningkatan * q berikutnya membawa kita ke tahap 3, yaitu "kurangi angka maksimum dari semua digit di tempat saat ini". Seperti sebelumnya, kita mengatur ulang p ke 11 dan q2 ke 0 dan kemudian melewati semua angka seperti yang kita lakukan pada tahap sebelumnya; kecuali saat ini, * q = 3 bukannya 2. Setiap kali q2 memenuhi q dan p ada di ratusan tempat, kami menggunakan loop while untuk mengurangi * p sebanyak yang ada 1s di blok kiri * r2 (5 dalam contoh kita) dengan menggunakan rsebagai pointer berjalan. Kami sebenarnya menurunkannya sekali lagi sehingga angka terbesar berakhir pada −2, untuk alasan yang akan menjadi jelas nanti:

Setelah kami memproses semua angka, kami sekarang berada di akhir tahap 3. Di sini kami melakukan dua hal tunggal.

• Pertama, kita juga mengurangi ukuran r -block (plus 1) dari * q , tetapi menggunakan pointer r2 , yang meninggalkannya di sebelah kiri. * q menjadi negatif dengan cara ini. Dalam kasus kami, r -block memiliki lima 1s, jadi * q menjadi −3.
• Kedua, kita menetapkan variabel keluar ke nilai non-nol untuk menunjukkan bahwa kita sekarang memasuki tahap output. (Secara teknis, fakta bahwa * q negatif sudah menunjukkan tahap output, tetapi ini terlalu sulit untuk diperiksa, maka variabel tambahan.)

Anda sekarang mengerti bahwa kami terus menelusuri angka-angka, menemukan tempat saat ini (ditunjukkan oleh nilai non-1 * q ) dalam setiap angka, dan melakukan sesuatu tergantung pada nilai * q . Kita melihat bahwa * q mula-mula bertambah menjadi 2 (= menghitung nilai digit maksimum), lalu 3 (kurangi nilai digit maksimum dari setiap digit di tempat ini) dan kemudian kita kurangi dari itu untuk membuatnya negatif. Dari sana, itu akan terus naik hingga mencapai 1, sehingga mengembalikan nilai yang berarti "tidak melakukan apa-apa". Pada saat itu, kami pindah ke tempat berikutnya.

Sekarang, ketika * q negatif, kita mengeluarkan. * q berada pada nilai yang tepat sehingga kita akan menampilkan jumlah baris karakter yang benar sebelum mencapai 1; jika digit terbesar adalah 2, kita perlu menghasilkan 3 baris. Mari kita lihat apa yang terjadi pada setiap nilai * q :

• * q = −2:
  • Untuk angka pertama, * p adalah −2, yang menunjukkan bahwa kita perlu menampilkan '.'(titik) atau ':'(titik dua). Kita memutuskan mana dengan melihat q : jika −1, kita berada di tempat yang sama, jadi output a ':'(yang kita hitung sebagai '8'+2), jika tidak a '.'.
  • Untuk angka kedua, * p adalah −3. Apa pun yang bukan −2 berarti kita mengeluarkan '|'(pipa) dan kemudian menambah nilainya. Dengan cara ini akan mencapai −2 di tempat yang tepat dan kemudian kita output '.'s / ':'s untuk sisa digit itu.
  • Dalam setiap kasus, kami juga mengatur pd variabel menjadi 0 sebelum kami memproses angka, dan mengatur pd (= "dicetak") ke nilai bukan nol untuk menunjukkan bahwa kami telah mencetak karakter.
  • Untuk angka ketiga, tidak ada pemrosesan yang terjadi karena angka ketiga tidak memiliki ratusan tempat. Dalam hal ini, pd akan tetap 0 setelah memproses angka, yang menunjukkan bahwa kita masih perlu menampilkan a '|'(tetapi hanya jika keluar adalah nol, karena kalau tidak kita masih dalam tahap 2 atau 3).
  • Setelah memproses semua angka, jika keluar adalah nol, buat baris baru. Perhatikan bahwa kita membutuhkan variabel keluar sehingga kita tidak menampilkan baris baru di tahap 2 atau 3.
• * q = −1: Sama seperti sebelumnya, kecuali bahwa * p adalah −2 untuk kedua angka pertama, sehingga keduanya menghasilkan a'.'(dan keluaran ketiga a'|'seperti sebelumnya).
• * q = 0: Ketika * q adalah 0, ini berarti "tidak melakukan apa-apa jika kita berada di tempat, jika tidak, output deretan'|'s terlepas dari * p ". Dengan cara ini kita mendapatkan lapisan di antara digit.

Sekarang kita menambah q untuk pindah ke tempat berikutnya, puluhan tempat, dan kenaikan * q di sana. Di awal Tahap 2, rekaman itu terlihat seperti ini:

Kemudian kami melakukan Tahap 2 seperti sebelumnya. Ingat ini secara efektif mengurangi 2 dari setiap digit di tempat ini dan juga meninggalkan angka unary kiri * r2 yang menunjukkan digit maksimum. Kami meninggalkan nomor unary sebelumnya sendirian dan terus memperpanjang kaset ke kiri; itu hanya akan membutuhkan kode tambahan yang tidak perlu untuk "membersihkan". Ketika kita selesai dan kita bertambah * q , pada awal Tahap 3 rekaman itu sekarang:

Sebenarnya, ini bohong. Ingat sebelumnya di mana saya mengatakan kami menetapkan * (r - 4) ke 1 dan saya tidak memberi tahu Anda mengapa? Sekarang saya akan memberi tahu Anda alasannya. Ini untuk kasus-kasus seperti ini, di mana digit terbesarnya adalah 0, artinya semua digit di tempat ini adalah 0. Pengaturan * (r - 4) , ditunjukkan oleh panah tanpa label di atas, ke 1 memperpanjang angka unary dengan 1, tetapi hanya dalam kasus khusus ini. Dengan cara ini kita berpura-pura seolah digit terbesar adalah 1, yang berarti kita akan menghasilkan satu baris tambahan.

Setelah Tahap 3 (kurangi digit maksimum dari semua digit di tempat saat ini), termasuk langkah ekstra yang membuat * q negatif, rekaman itu terlihat seperti ini. Terakhir kali digit terbesar diwakili oleh −2 di blok * p , tapi kali ini mereka semua −3 karena mereka semua benar-benar nol tetapi kami berpura-pura seolah-olah digit maksimumnya adalah 1.

Sekarang mari kita lihat apa yang terjadi ketika * q berlanjut ke 1:

• Ketika * q = −1, nilai * p semuanya −3, yang berarti kita mengeluarkan '|'dan menambahnya.
• Ketika * q = 0, kita menghasilkan '|'karena itulah yang selalu kita lakukan ketika * q = 0, terlepas dari * p .

Jadi, kami mendapat dua baris pipa.

Akhirnya, kita memindahkan * q ke tempat seseorang. Yang ini menjadi menarik karena kita perlu menampilkan ':'s jika digit sebenarnya adalah 1 tetapi 1 '8'jika 1. Mari kita lihat bagaimana hasil program. Pertama, kami menambahkan * q untuk memulai Tahap 2:

Setelah Tahap 2 ("hitung nilai digit maksimum"), kita tinggal dengan ini:

Setelah Tahap 3 (“kurangi nilai digit maksimum dari semua digit di tempat saat ini”) rekaman itu terlihat seperti ini:

Sekarang mari kita lihat setiap iterasi * q secara bergantian:

• * q = −2:
  • Angka pertama: sudah di −2, jadi output a ':'(daripada a '.'karena q = −1).
  • Angka kedua: −4, jadi output a '|'dan increment.
  • Angka ketiga: pada −3, jadi keluaran a '|'. Namun, kali ini, alih-alih bertambah, kasus khusus memicu. Hanya jika kita mengeluarkan tempat terakhir ( q = −1), dan kita berada di baris kedua-terakhir untuk itu ( * q = −2), dan digit sebenarnya adalah 1 ( * p = −3) , lalu alih-alih menambahkannya ke −2, kami menetapkannya ke −1. Dengan kata lain, kita menggunakan −1 sebagai nilai khusus untuk menunjukkan bahwa pada iterasi berikutnya, kita perlu output '8'sebagai gantinya ':'.
• * q = −1:
  • Nomor pertama: sudah di at2, jadi keluaran a ':'.
  • Angka kedua: pada −3, jadi keluaran a '|'. Kondisi khusus tidak terpicu karena * q tidak lagi −2. Karena itu, increment.
  • Angka ketiga: pada −1, jadi keluaran '8'.
• * q = 0: Biasanya, kita akan menampilkan baris bantalan'|'s di sini, tetapi dalam kasus khusus di mana kita berada di tempat yang ( q = −1), kita lewati itu.

Setelah ini, q bertambah menjadi 0 dan loop sementara besar berakhir.

Sekarang Anda tahu bagaimana input suka 202,100,1bekerja. Namun, ada satu lagi kasus khusus yang belum kami bahas. Anda mungkin ingat bahwa ketika kami sedang memproses tempat terakhir, ketika * p −3 kita atur ke −1 untuk 1(alih-alih menambahnya menjadi −2) sehingga iterasi berikutnya akan menghasilkan sebuah '8'gantinya. Ini hanya berfungsi karena kami memiliki iterasi di mana * p adalah −3 dan kami membuat keputusan apakah akan menambahnya atau menetapkannya ke −1. Kami tidak memiliki iterasi seperti itu jika semua digit di tempat yang adalah 0 atau 1. Dalam kasus seperti itu semua nilai * p untuk 1s akan dimulai pada −2; tidak ada kesempatan untuk memutuskan untuk mengaturnya ke −1daripada menambahnya dari −3 . Karena itu, ada kondisi casing khusus lain di dalam Tahap 3 ("kurangi digit maksimum dari setiap digit di tempat saat ini"). Saya mengklaim bahwa setelah mengurangkan nilai digit maksimum dari setiap digit (pada titik mana digit maksimumnya berada pada −1), kami hanya menguranginya sekali lagi, tetapi sebenarnya ada kondisi yang menyatakan sebagai berikut:

Jika digit yang kita lihat sama dengan digit maksimum di tempat ini ( * p = −1), dan tempat ini adalah tempat yang ( q = −1), dan digit maksimum adalah 1 ( * (r + 5) = 0, yaitu blok unary di paling kiri hanya 5 sel panjang), hanya kemudian kita meninggalkan * p di −1 untuk menunjukkan bahwa satu-satunya iterasi dari output harus menghasilkan suatu '8'. Dalam semua kasus lain, kami menurunkannya sekali lagi.

Selesai Selamat Tahun Baru!

• Sunting 1 (3183 → 3001): Beberapa golf Selamat Tahun Baru! Saya berhasil menyingkirkan variabel p2 dan r2 sepenuhnya! p sekarang berlari bolak-balik untuk terus menemukan awal dan akhir angka, tetapi tampaknya lebih pendek dalam kode. Saya mencoba untuk menghilangkan q2 juga, tetapi saya tidak bisa membuat kode lebih pendek seperti itu.

  Saya juga menemukan beberapa tempat lagi di mana saya bisa menerapkan trik golf yang tidak dapat dibaca seperti menggunakan kembali nilai terakhir dari loop sementara. Untuk memberi Anda contoh, alih-alih

  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
  

  Saya dapat menyimpan '""""(lakukan yang pertama, kemudian yang kedua) dan '"""(konstan 1) dengan menulisnya dengan cara yang seperti

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

  Tentu saja, ini hanya berfungsi jika saya tahu bahwa loop sementara akan berjalan untuk setidaknya satu iterasi, tetapi jika itu terjadi, nilai kembalinya adalah pd sehingga saya dapat menggunakannya sebagai syarat untuk if.

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

Saya baru mengenal PPCG dan berpikir saya mungkin mencoba yang ini dan berpikir itu agak sederhana. Wah, ternyata aku salah !! Saya sudah mengusahakannya untuk sementara waktu dan saya harus banyak bermain golf ...
Saran sangat dianjurkan! - Meskipun masuk akal ini tidak akan menjadi tugas yang mudah.

Keluaran tali ketika input adalah array angka (misalnya:) [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)

Penjelasan

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
)

Contoh

Input: Array angka: [4,8,15,16,23,42]
Output:

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

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

Yah, karena pertanyaan ini membutuhkan jawaban, saya telah memberikan satu di sini, di mana input harus berupa string angka yang dipisahkan oleh spasi, seperti "204 1". Wah, itu panjang. Saran golf (atau jawaban yang lebih baik) dipersilakan.

Sunting: Bytes disimpan dengan mencampur tab dan spasi.

Sunting: Saya menyimpan banyak byte dengan mengubah cara saya memperoleh digit angka (membuat daftar dari string angka nol, kemudian di badan kode, transpos untuk mendapatkan ratusan digit, sepuluh digit, dll. .)

Sunting: Dan saya menyimpan lebih banyak dengan memasukkan :8loop terakhir ke dalam loop quipu utama. Sekarang seandainya saya bisa mengetahui mengapa b=d[j*v+i]==m(d[i::v])tidak berhasil. Mencari tahu dan solusinya mengambil terlalu banyak byte. (Juga jumlah byte turun karena entah bagaimana tab kembali menjadi empat spasi. Mungkin pemformatan blok kode di situs ini)

Sunting: Saya mengatur ulang cara membuat quipus. Sekarang ia membuat satu untai pada satu waktu, kemudian transpos untuk dicetak.

Sunting: Mengubah jawaban saya kembali menjadi program Python 3 untuk menyimpan lebih banyak byte.

Sunting: Saya menemukan bug dalam kode saya yang membuatnya sehingga tidak mencetak nol di tengah angka dengan benar (lihat kotak uji di 204 1atas). Dalam memperbaiki ini, saya berhasil golf :)

Sunting: Saya mengubah pencetakan untuk menghemat 10 byte. Dan saya meletakkan semua hitungan byte lama kembali, hanya karena.

Sunting: Memotong tugas vpenggunaan mapselama empat byte. Penghargaan untuk CarpetPython , karena saya mendapat ide dari jawaban mereka di sini .

Sunting: Mengubah tengah "untuk loop di dalam for loop", menjadi hanya satu untuk loop selama enam byte.

Edit: Sekarang menggunakan enumerate. Tidak lagi menggunakan l=len(z). Mengubah terner if-elsemenjadi daftar terner. Lihat di bawah untuk detailnya.

Sunting: Sp3000 menyarankan sunting printdan sunting ke kondisi ternary yang masing-masing menyimpan satu byte.

Tidak Disatukan:

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

Mengandalkan C preprocessor untuk membuat kode sesingkat mungkin. Sebagai efek samping, juga membuatnya cukup banyak tidak terbaca.

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

Pada Ubuntu 14.04, Anda dapat mengkompilasi kode dengan lugas gcc quipu.c(abaikan peringatan). Contoh menjalankan executable:

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

Diuji terhadap semua kasus uji OP.

Kode sumber tidak digabungkan:

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

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

Di atas

• Memecah setiap bilangan bulat menjadi daftar angka, menggunakan IntegerDigits; bantalan setiap angka dengan nol di sebelah kiri (untuk memastikan jarak yang sama); setiap nomor input, sekarang didekomposisi menjadi digit, sesuai dengan deretan array; setiap kolom mewakili nilai tempat. Array dipindahkan.
• Mengganti digit dengan daftar simpul dengan bantalan. Rutin pencocokan pola yang sedikit berbeda digunakan untuk unit.

Contoh

g[Range[0, 50]]

R - 446 444

Saya melihat belum ada solusi R, jadi di sini ada satu. Fungsi ini mengambil vektor dengan bilangan bulat.

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

Tidak disatukan

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