Quipu Sayma: Yeni Dünyadaki Temel 10


41

Quipus , Precolumbian döneminde İnka tarafından kullanılan ve bir kablo üzerindeki 10 pozisyonel düğüm sistemine sayıları kaydetmek için kullanılan eski bir cihazdır.

Her düğüm kümesi bir rakamdır ve üç ana düğüm tipi vardır: basit elle çizilmiş düğümler; bir veya daha fazla ilave dönüşe sahip bir üst düğmeden oluşan "uzun düğümler"; ve rakam sekiz düğüm.

  • Onluk güçler sicim boyunca konumlarına göre gösterilir ve bu pozisyon ardışık iplikler arasında hizalanır.
  • 10 ve daha yüksek güçler için pozisyonlardaki rakamlar basit düğümlerin kümeleriyle temsil edilir (ör. 40, "onlarca" pozisyonunda üst üste dört basit düğümdür).
  • "Olanlar" pozisyonundaki rakamlar uzun düğümlerle gösterilir (ör. 4, dört turlu bir düğümdür). Düğümlerin bağlanma şeklinden ötürü, 1 rakamı bu şekilde gösterilemez ve bu konumda sekiz düğüm şeklinde gösterilir.
  • Sıfır, uygun konumda bir düğüm olmamasıyla temsil edilir.

ayrıntılar

Bu zorluk için, bir quipu'daki her bir tel tek bir sayıyı temsil eder (Wikipedia makalesinde belirtildiği gibi, bir tel üzerinde birçok sayıyı temsil edebilirsiniz , bu zorlukla biz değiliz).

düğümler

Her düğüm tek bir ASCII karakteri ile temsil edilecektir.

  • . basit bir düğümü temsil eder
  • : uzun bir düğümün bir dönüşünü temsil eder
  • 8 bir rakam sekiz düğüm temsil eder
  • | rakamlar arasında bir düğümün yanı sıra bir sınırlayıcının yokluğunu gösterir.

Quipus'un Oluşturulması

Quipu bu kurallara uyarak inşa edilmiştir.

  1. İplikler aşağıya doğru pozisyon sırasına göre yukarıdan aşağıya doğru koşar (olduğu gibi, birimler basamağı bir tutamın alt ucunda olacaktır). Bir iplikçik boyunca rakamlar ( |) karakteriyle ayrılır .
  2. 10 basamağın temsil ettiği güç, iplikçik boyunca konumuyla belirlenir; aynı şekilde, 10'luk bir basamağın, sayı sistemimizdeki bir sayıdaki endeksi kullanılarak hesaplanması gerekir. Diğer bir deyişle, 24bir ile 2on yerine ve bir 4adet yerine, iki düğüm, bir ayırıcı (ile temsil edilecektir |sonra), dört mil.
  3. Aynı pozisyondaki rakamlar telin dibine doğru hizalanır. Bir pozisyondaki bir hane aynı pozisyondaki diğer sayıların diğer hanelerinden daha az knot içerecekse, bu knotların yokluğu ( |) ile gösterilir.
  4. Ardışık basit düğümler ( .), konumlarındaki bir değeri temsil eder.
  5. Her rakam en az 1 karakter ile gösterilir. Bir basamaktaki tüm sayılar için bir rakam değeri 0 olduğunda, bir düğümün ( |) olmaması ile temsil edilir .
  6. Birimler yer özel olarak ele alınır. Birimlerdeki yerlerden biri, bir rakam sekiz düğümü ( 8) ile temsil edilir . Birimlerdeki iki veya daha fazla bir değer ardışık uzun düğümlerle ( :) gösterilir.
  7. Bir birim basamak, bir kipindeki tüm sayılar için 0 olduğunda, bir düğümün yokluğu basılmaz, ancak onlarca basamağın son sınırlayıcısı korunur.
  8. Birim basamağı takip eden sınırlayıcı yoktur.

kurallar

  • Giriş, varsayılan giriş yöntemlerinden herhangi biriyle alınabilecek boş olmayan, negatif olmayan bir tam sayı listesinden oluşur . Bu tamsayılar tüm az olan veya eşit olduğunu varsayabiliriz 2147483647veya 2^31-1. Test senaryoları boşlukla sınırlandırılmış olsa da, giriş biçiminiz, girişleri virgülle ayrılmış, yeni satırla ayrılmış, bir dizide vb. Olsun, dilinize uygun herhangi bir şekilde ayırabilir.
  • Çıktı yukarıda açıklanan kurallara göre inşa edilmiş tek bir Quipu'dan oluşur. Çıktı, varsayılan çıkış yöntemlerinden herhangi biriyle verilebilir .
  • Kodunuzun bir program veya işlev olması gerekir, ancak adlandırılmış bir işlev olması gerekmez.
  • Düğümlerin, zamandan kazanmak için kodunuzu mümkün olduğunca kısa tutması biraz zaman alır.

Her zaman olduğu gibi, sorun açık değilse, lütfen bana bildirin. İyi şanslar ve iyi golf!

Örnekler

Giriş:

5 3 1 0

Çıktı:

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

Giriş:

50 30 10 0

Çıktı:

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

Giriş:

330

Çıktı:

.
.
.
|
.
.
.
|

Giriş:

204 1

Çıktı:

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

Giriş:

201 0 100 222

Çıktı:

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

Giriş:

1073741823 2147483647

Çıktı:

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

Giriş:

0

Çıktı:

|

Daha uzun test durumları

Daha fazla okuma


Yanıtlar:


3

Pyth, 64 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

Bu bir problem dışında mükemmel bir cevap. Son düğüm her zaman bir rakam sekiz düğüm değildir 8. Aslında, 8son rakam 1 olduğunda sadece bir düğüm (bkz. Kural 6). Tüm son düğümleri dönüştürüyorsun ve bu şartnameye uymuyor. Ayrıca, Çevrimiçi Deneyin! bağlantının burada gönderilen koddan farklı bir kodu var, görünüşe göre
Sherlock9

22

Okunamayan , 3183 3001 bayt

Bu, Noel kutlamaları arasında, üzerinde ve dışında çalışmak için eğlenceli bir mücadele oldu. Gönderdiğiniz için teşekkür ederiz! Golf oynamak ilginçti, çünkü şartnamede birçok koşul gerektiren özel durumlar ve istisnalar vardı. Bu zamana ve ondalık dönüştürmek gerek yoktu Ayrıca, süre, ben yaptım her sayıda basamak en çok sayıda ve her yerde basamak büyük değerini belirlemek için bir çeşit “max” fonksiyonu gerekir.

Bunun ilk sürümü 4844 bayttı , sadece size ne kadar golf oynadığımı anlamanız için.

Program girdiyi virgülle ayrılmış bir tamsayı listesi olarak bekliyor . Boşluk veya yeni satır yok. Bunları kullanmak tanımsız davranışlar üretecektir.

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

açıklama

Belirli bir girişi nasıl işlediğini göstererek programın nasıl çalıştığını anlatacağım 202,100,1.

Başlangıçta, daha sonra ihtiyaç duyacağımız birkaç değer oluşturuyoruz - çoğunlukla çıktı alacağımız karakterlerin ASCII kodları.

görüntü tanımını buraya girin

Gördüğünüz gibi '8've '.'zaten hazırsınız. '|'Ancak, aslında 14 değil, 14'tür. 124'ü almak için # 1 yuvasına geçici değeri iki kez eklemek için bir süre döngüsü kullanıyoruz (bu süre 14 + 55 × 2'dir, çünkü süre döngüsü 56−1 için = 55 iterasyon). Bu, bazı baytları kurtarır, çünkü 124 gibi büyük tamsayı değişmezleri gerçekten uzundur. Aşağıdaki diyagramda, programın kullandığı her değişkenin konumunu gösteriyorum.

görüntü tanımını buraya girin

Daha sonra, tüm karakterleri girmek ve bunları # 12 hücresinden başlayarak kasette depolamak istiyoruz ( p bunun için çalışan göstericidir). Aynı zamanda, en uzun sayının ne kadar olduğunu bilmek istiyoruz (kaç basamak). Bunu başarmak için, # −1 hücresinden başlayarak sola doğru giden bir toplamı tutarız ( çalışma işaretçisi olarak q kullanırız ). İlk giriş numarasından ( 202) sonra, şerit şu şekilde görünür:

görüntü tanımını buraya girin

Sayıların 4 ile kapalı olduğunu fark edeceksiniz. Peki, ilk girdiğimizde, ASCII değerleridir, bu nedenle 48 ile "kapalı" olurlar ve virgül 44'dür. Her karakter için, 46 '.'içine r ve daha sonra (45 çıkarır) bir süre döngü ile çıkarma ve sonra biz biz koşullu kullanabilmesi virgül (bizim ayırıcı), 0'dır böylece onu tanımak için emin 1. ekleyin.

Ayrıca, # 11 hücresini 0'da bıraktığımızı fark edeceksiniz. İlk sayının sınırlarını tanımamız gerekiyor.

Bir sonraki karakter virgül olacaktır, bu nedenle # 15'te 0 saklıyoruz, ama elbette bu sefer q ilerlemiyoruz . Bunun yerine, q'yı 0'a geri ayarladık ve yerleştirdiğimiz 1'lerin “üzerine yazmaya” başladık.

Kalan tüm karakterler işlendikten sonra, şunu elde ederiz:

görüntü tanımını buraya girin

Gördüğünüz gibi, q ile yazılan 1'ler şimdi (unary) en uzun sayının uzunluğunu gösterir.

Şimdi q'yi en sola hareket ettirmek için bir while döngüsü kullanıyoruz ve sonra r2 olarak adlandıracağım başka bir işaretçiyi yerleştiriyoruz . R2'nin amacı daha sonra netleşecektir.

görüntü tanımını buraya girin

Bu noktada, bunun boyunca kullanacağım terminolojiyi açıklayayım.

  • Tarafından sayısı , bir virgül ile ayrılmış giriş numaralarının bir ortalama. Örneğimizde, 202, 100 ve 1'dir.
  • By rakam , ben numaralarının belirli birinde tek bir rakamı anlamına gelir. İlk rakamın 3 rakamı var.
  • By yerde ben “Mevcut yerde rakam” demek ve mevcut yer olanları yer ise, ben vb So olanlar yer, onlarca yer, yüzlerce yerde, Yani o rakam ki, 2 0, ve 1 sipariş.

Şimdi düzenli programlamaya geri dönelim. Programın geri kalanının tamamı, # 0 hücresine ulaşana kadar q ileri hareket eden büyük bir döngüdür . Yol boyunca hücrelerin her biri, en sağda olanlar yer olan bir yeri temsil eder ve q en belirgin şekilde başlayacaktır. Örneğimizde, burası yüzlerce yer.

Hücre q puanlarını artırarak devam ediyoruz (yani, * q ).

görüntü tanımını buraya girin

Şimdi yüzlerce yer için “aşama 2 ”'deyiz. Bu aşamada, yüzlerce yerdeki tüm basamaklar arasında en büyük hanenin ne olduğunu bulacağız. Bunun için aynı unary sayma hilesini kullanıyoruz, ancak bu sefer işaretçi r olarak adlandırılır ve işaretçi r2 bir sonraki sayıya geçtiğimizde sıfırlamak zorunda olduğumuz başlangıç ​​konumunu işaretler.

İlk numaradan başlayalım. Biz ayarlayarak başlar p 11 (tüm sayıların sabit kodlanmış başlangıç pozisyonu) için. Daha sonra sayının sonunu bulmak için bir while döngüsü kullanıyoruz ve konumu işaretlemek için p2'yi oraya ayarlıyoruz . Aynı zamanda, q2'yi 0'a ayarladık :

görüntü tanımını buraya girin

Q2'nin varları gösterdiği gerçeğinden rahatsız olmayın . Orada boş bir hücre dolgusu yok, çünkü # 0 hücresini yalnızca sıfır olduğu için tespit edebiliyoruz.

Daha sonra, * p sıfır olana kadar p ve q2 'yi azaltarak mevcut sayıdan geçiyoruz . Her yerde, * q2 değeri bize ne yapmamız gerektiğini söyler. 1 “hiçbir şey yapma” anlamına gelir, bu yüzden devam ediyoruz. Sonunda # 2 numaralı hücrede 2 ile karşılaşıyoruz. Her seferinde * q2 1'e eşit değildir, q2 her zaman q'ya eşittir .

görüntü tanımını buraya girin

Daha önce de belirtildiği gibi, 2. aşama “bu yerdeki en büyük basamağı belirlemek” dir. Belirlediğimiz Yani r için r2 , eksiltme için bir while döngüsü kullanmak * p ve hareket r leftwards ve hareket etmek döngü sırasında başka kullanmak sonra 1'ler bandı dolgu ve r sağ ve artım için arka * p değeri tekrar geri yükleyin. Her while döngüsünün, kullandığımız değerden daha az yinelemeyle çalıştığını unutmayın; Bu nedenle, yazılan 1 sayısı rakamdan daha fazla 3 (4 yerine) olacak ve * p olarak geri kaydedilen son değer 2 olacak. Böylece, bu etkili bir şekilde * p'yi 2'ye düşürmüştür .

Ondan sonra p'yi p2 değerine ayarladık ve sonra hepsini tekrar yaptık. İkinci kez, q2'yi 0'a ayarlayın , p'yi sağa hareket ettirerek sayının sonunu bulun ve ardından p ve q2'yi birlikte azaltarak bu sayının rakamlarını izleyin . Bir kez daha 2 numaralı hücrede 2 ile karşılaşacağız ve 1 r'den * kalanını yazacağız .

Üçüncü sayı söz konusu olduğunda, yüzlerce yeri olmadığı için hiçbir şey yapmayız (böylece q2 asla q'ya ulaşmaz ), ancak bu tamamdır, çünkü bu maksimum rakam değerinin hesaplanmasını etkilemez.

görüntü tanımını buraya girin

Ayrıca burada etiketlenmemiş bir okla işaretlediğim hücreyi * (r - 4) 1 olarak ayarladık ( zaten 1 olsa bile). Nedenini henüz söylemeyeceğim, ama belki de çoktan tahmin etmişsindir?

Bir sonraki * q artışı bizi “o anki yerdeki tüm rakamlardan maksimum basamağı çıkarmak” olan 3. aşamaya götürür. Daha önce olduğu gibi, p'yi 11 ve q2'yi 0'a sıfırlıyoruz ve ardından önceki aşamada yaptığımız gibi tüm sayıları geçiyoruz; bu süre dışında, 2 yerine * q = 3, q2 q ile her karşılaştığında ve p yüzlerce yerde olduğunda, * p'yi * r2 (5) ' in kalan bloğunda 1s olduğu kadar * p azaltmak için bir süre döngüsü kullanırız. Örneğimizde) r kullanarakçalışan bir işaretçi olarak. Aslında bunu bir kez daha azalttık, böylece en büyük rakam −2'de biter, daha sonra netleşecek bir neden için:

görüntü tanımını buraya girin

Tüm sayıları işledikten sonra, şimdi aşama 3'ün sonundayız. Burada iki tekil şey gerçekleştiriyoruz.

  • İlk olarak, aynı zamanda büyüklüğü çıkarma r dan -bloku (artı 1) * q , fakat r2 olan solda yaprakları bu işaretçi. * q bu şekilde negatif olur. Bizim durumumuzda, r- bloğunun beş 1'i vardır, yani * q −3 olur.
  • İkinci olarak, bir değişken set üzerinden şimdi çıkış safhaya giriyoruz belirtmek için sıfır olmayan bir değere. (Teknik olarak, * q değerinin negatif olması zaten çıktı aşamasını gösterir, ancak bunun kontrol edilmesi çok zordur, dolayısıyla ekstra değişken.)

Artık, biz numaralar geçiyor tutmak olduğunu anlamak (olmayan 1 değeri ile gösterilen cari yer bulmak * q Her numara içinde) ve değerine bağlı olarak bir şeyler yapmak * q . Biz görüyoruz * q , ardından 3 (buradaki tüm rakam maksimum haneli değerini çıkarmak) ilk 2 (= hesapla maksimum rakam değeri) artırılır ve bunun olumsuz yapmak için gelen sonra çıkarma. Oradan, 1'e ulaşana kadar artmaya devam eder, böylece “hiçbir şey yapmaz” anlamına gelen değeri geri kazanır. Bu noktada, bir sonraki yere geçiyoruz.

Şimdi, * q negatif olduğunda, çıkıyoruz. * q tam olarak doğru değerdedir, böylece 1'e ulaşmadan önce doğru sayıda satır satırı çıktısını alacağız; en büyük rakam 2 ise, 3 satır çıkmamız gerekir. Her bir q * değerinde ne olduğunu görelim :

  • * q = −2:
    • İlk sayı için, * p −2'dir, bu bir '.'(nokta) veya bir ':'(iki nokta) çıkmamız gerektiğini belirtir . Hangisine q ile bakarak karar veriyoruz : if1 ise, o sırada biziz, yani a ':'( '8'+2 olarak hesapladığımız ), yoksa a '.'.
    • İkinci sayı için, * p −3'tür. −2 olmayan herhangi bir şey bir '|'(boru) çıktığı ve ardından değeri artırdığımız anlamına gelir . Bu şekilde doğru yerde −2 değerine ulaşacak ve daha sonra bu rakamın geri kalanı için '.'s / ':'s çıktısı alacağız .
    • Her durumda, sayıyı işlemeden önce pd değişkenini 0 olarak ayarladık ve bir karakter yazdırdığımızı belirtmek için pd'yi (= “yazdırıldı”) sıfır olmayan bir değere ayarlayın.
    • Üçüncü sayı için, üçüncü sayı yüzlerce yere sahip olmadığından işlem gerçekleşmez. Bu durumda, pd hala biz hala çıkış bir gerek olduğunu belirten numarayı işledikten sonra 0 olacaktır '|'(ama sadece dışarı aksi takdirde evre 2 veya 3'te hala, çünkü, bir sıfır olmayan).
    • Tüm numaraları işledikten sonra eğer dışarı sıfırdan, çıktı bir satır olduğunu. Not ihtiyacımız olduğunu dışarı sahneye 2 veya 3 çıkış içinde satırsonu yok ki değişkeni.
  • * q = −1: Her ikisi de ilk iki sayı için * p −2olması dışında, öncekiyle aynıdır, bu nedenle her ikisi de a çıkışını verir'.'(ve üçüncü çıkış'|'eskisi gibi olur).
  • * q = 0: Ne zaman * q 0, bu vasıta “Biz olanları yerdesiniz eğer bir satır aksi takdirde çıkışı hiçbir şey'|'s bakılmaksızın * p ”. Bu sayede rakamlar arasındaki dolguyu yakalarız.

Şimdi q , bir sonraki yere, onlarca yere ve orada * q olana ilerlemek için artarız . Aşama 2'nin başında, kaset şöyle görünür:

görüntü tanımını buraya girin

Ardından 2. Aşama'yı önceki gibi yaparız. Unutmayınız ki, bu yerdeki her haneden 2'yi çıkarır ve ayrıca * r2'den kalan tek bir sayıyı azami haneyi belirten bırakır . Önceki tekli sayıyı yalnız bırakırız ve sadece bandı sola doğru uzatırız; sadece “temizlemek” için gereksiz ekstra kod maliyeti olacaktır. İşimiz bittiğinde ve * q artışını yaptığımızda , Aşama 3'ün başlangıcında bant şimdi:

görüntü tanımını buraya girin

Aslında, bu bir yalan. Daha önce hatırlıyorum ki * (r - 4) ' ü 1'e ayarladık ve nedenini söylemedim. Şimdi size nedenini söyleyeceğim. Bu anlam, büyük basamaklı aslında 0 olduğu bu uçak durumlar için var hepsi bu yerde basamak 0. Ayar vardır - * (4 r) 1 1 ile tekli sayı uzanır için, yukarıda etiketsiz okla gösterilen, ama sadece bu özel durumda. Bu yolla en büyük basamak 1miş gibi davranıyoruz, bu da bir ekstra satır çıkacağımız anlamına geliyor.

Aşama 3'ten sonra (geçerli yerdeki tüm basamaklardan maksimum basamağı çıkar), * q negatif yapan ek adım dahil , kaset bu şekilde görünür. En son rakam * p bloğunda −2 ile temsil edildi , ama bu sefer hepsi −3 çünkü hepsi aslında sıfırlar ama maksimum rakam 1miş gibi yapıyoruz.

görüntü tanımını buraya girin

Şimdi, q'nun 1'e doğru ilerledikçe ne olduğunu görelim :

  • Zaman * q = -1, * p değerleri tüm -3, araçlardır biz çıkış '|'ler ve bunları artırmak.
  • Ne zaman * q = 0, biz çıkış '|'nedeniyle her zaman yaptığımız şey bu en zaman * q = 0 bakılmaksızın * p .

Böylece iki sıra boru alıyoruz.

Sonunda, * q'yu birisinin yerine götürürüz. Bu ilginç bir hal alır çünkü ':'asıl rakam 1'den başka bir şeyse, ancak 1 ise s çıkmamız gerekir '8'. Programın nasıl ilerlediğini görelim. İlk olarak, 2. Aşama'yı başlatmak için * q artışını yaparız :

görüntü tanımını buraya girin

Aşama 2’den sonra (“maksimum hane değerini hesapla”), bundan ayrıldık:

görüntü tanımını buraya girin

Aşama 3'ten sonra (“geçerli yerdeki tüm basamaklardan maksimum basamak değerini çıkar”) kaset şöyle görünür:

görüntü tanımını buraya girin

Şimdi sırayla * q'nın her yinelemesinden geçelim :

  • * q = −2:
    • İlk sayı: zaten −2 değerinde, bu nedenle a çıkışı ':'( '.'çünkü q = −1 değil).
    • İkinci sayı: −4'te, bu nedenle çıktı a '|'ve artır.
    • Üçüncü sayı: −3'te, yani çıktı a '|'. Bununla birlikte, bu kez, artış yerine, özel bir durum tetiklenir. Sadece son yeri çıkarıyorsak ( q = −1) ve bunun için ikinci satırdayız ( * q = −2) ve rakam aslında 1 ( * p = =3) , o zaman bunun yerine -2 için artan nedeniyle, ayarlayın -1. Başka bir deyişle, i1'i bir sonraki yinelemede '8'bunun yerine çıktı almamız gerektiğini belirtmek için özel bir değer olarak kullanırız ':'.
  • * q = −1:
    • İlk sayı: zaten −2'de, bu yüzden çıktı a ':'.
    • İkinci sayı: −3'te, yani çıkış a '|'. Özel durum tetiklenmez çünkü * q artık −2 değildir. Bu nedenle, artış.
    • Üçüncü sayı: −1'de, yani çıkış '8'.
  • * q = 0: Normalde,'|'burada s 'nindoldurma sırasını çıkartacağız, ama o sırada bulunduğumuz özel durumda ( q = −1), bunu atlıyoruz.

Bundan sonra, q 0'a yükseltilir ve döngü biterken büyük olur.

Artık bir girdinin nasıl 202,100,1çalıştığını biliyorsunuz . Ancak, hala ele almadığımız özel bir dava daha var. Son yeri işlerken, * p −3 olduğunda , i1 olarak 1(we2'ye çıkarmak yerine) için −1 olarak ayarladığımızı, böylece bir sonraki yinelemenin '8'yerine geçeceğini hatırlarsınız . Bu sadece işe yarar, çünkü * p'nin −3 olduğu bir tekrarlamaya sahibiz ve onu arttırmaya ya da a1'e ayarlamaya karar veririz. Biz yok eğer böyle bir yineleme sahip tüm olanları yerinde basamak Böyle bir durumda 0 veya 1. tüm * p olur 1'ler için değerler başlar -2 °; −1’e koymaya karar verme imkanı yoktur.−3'ten artırmak yerine . Bu nedenle, Aşama 3'ün içinde bir başka özel muhafaza koşulu vardır (“geçerli yerdeki her bir rakamdan maksimum rakamı çıkar”). Her basamaktan maksimum basamak değerini çıkardıktan sonra (bu noktada maksimum basamak −1’de), sadece bir kez daha azalttığımızı iddia ettim, ancak gerçekte şu şekilde devam eden bir koşul var:

Baktığımız rakam bu yerdeki maksimum rakama eşitse ( * p = −1) ve burası olan yer ( q = −1) ve maksimum rakam 1 ( * (r +) 5) = 0, yani en soldaki unary blok sadece 5 hücre uzunluğundadır), ancak o zaman çıktının tek yinelemesinin bir çıktı vermesi gerektiğini belirtmek için p1'de * p bırakırız '8'. Diğer tüm durumlarda bir kez daha azaltırız.

Bitti. Mutlu Yıllar!

  • Düzenleme 1 (3183 → 3001): Yeni Yılınız Kutlu Olsun golf! P2 ve r2 değişkenlerinden tamamen kurtulmayı başardım ! p , sayıların başlangıcını ve sonunu bulmaya devam etmek için ileri geri koşar, ancak kodda daha kısa görünmektedir. Q2'den de kurtulmaya çalıştım , ancak kodu bu şekilde kısaltamam.

    Ayrıca bir süre döngüsünün son değerini tekrar kullanmak gibi tipik Okunamayan golf oyunlarını uygulayabileceğim birkaç yer daha buldum. Size bir örnek vermek yerine

    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
    

    '""""(İlk önce, sonra ikinci) ve '"""(sabit 1) 'i benzer şekilde yazarak kurtarabilirim

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

    Tabii ki, bu, sadece while döngüsünün en az bir yineleme için çalışacağını bildiğimde işe yarar, ancak eğer öyleyse, dönüş değeri pd olur, böylece bunu if için koşul olarak kullanabilirim.


"Okunamayan" kesinlikle uygun bir isim ...
Alex A.

9
-1 yeterli açıklama yok
Şapkalı Adam

7

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

PPCG'de yeniyim ve bunun basit olduğunu düşünmeyi deneyebileceğimi düşündüm. Çocuk yanılmışım !! Bir süredir üzerinde çalışıyorum ve yapacak çok golf oynadım ...
Önerilerim teşvik edildi! - Bunu anlamamıza rağmen kolay bir iş olmayacak.

Giriş bir sayı dizisi olduğunda ipleri çıkarır (örneğin:) [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çıklama

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
)

Örnek

Giriş: Sayı dizisi: [4,8,15,16,23,42]
Çıkış:

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

+1 etkileyici golf. Girdi ve çıktıya bir örnek ekler misiniz?
DavidC

@DavidC Teşekkürler! Ve örnek dahil edilmiştir. Konsoldan çağırın ve bir dize döndürür. :)
Aᴄʜᴇʀᴏɴғᴀɪʟ

7

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 bayt

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

Eh, bu sorunun cevabına ihtiyaç duyduğundan, burada bir girdi verdim, girişin boşlukla ayrılmış bir sayı dizisi olması gerektiği gibi "204 1". Evlat, uzun bir tane mi. Herhangi bir golf önerisi (veya daha iyi cevaplar) açıktır.

Düzenleme: Sekmeleri ve boşlukları karıştırarak kaydedilen bayt.

Düzenleme: Bir sayının hanelerini nasıl elde ettiğimi değiştirerek çok sayıda bayt kurtardım (sayının sıfır dolgulu dizesinden bir liste yapın, sonra kodun gövdesinde yüzlerce rakam, on rakam, vb. .)

Düzenleme: Ve bu son :8döngüyü ana quipu döngüsüne ekleyerek biraz daha tasarruf ettim . Şimdi, neden b=d[j*v+i]==m(d[i::v])işe yaramayacağını anlayabilsem . Anladım ve çözüm çok fazla bayt alıyor. (Ayrıca bayt sayısı düştü, çünkü bir şekilde sekmeler dört alana geri döndü. Muhtemelen bu sitedeki biçimlendirme kod bloğuydu.)

Düzenleme: Quipus nasıl yapılır yeniden düzenledi. Şimdi bir seferde bir iplik oluşturuyor, sonra baskıya geçiyor.

Düzenleme: Daha fazla bayt kaydetmek için cevabımı Python 3 programına geri döndürdüm.

Düzenleme: Kodumda, sayıların ortasına doğru sıfır girmemesi için bunu yapan bir hata buldum ( 204 1yukarıdaki test durumuna bakın ). Bunu düzeltirken, golf oynamayı başardım :)

Düzenleme: 10 bayt kaydetmek için yazdırma değiştirdim. Ve sadece eski bayt sayımlarını geri koydum, çünkü.

Düzenleme: atama golfed vkullanılarak mapdört bayt için. Kredi CarpetPython , onların cevabını fikrim var olarak burada .

Düzenleme: Orta "bir for döngüsü içinde döngü", altı bayt için sadece bir döngü içine döndü.

Düzenleme: Şimdi kullanarak enumerate. Artık kullanma l=len(z). Üçlüyü if-elsebir liste üçlüsüne dönüştürdüm. Detaylar için aşağıya bakınız.

Düzenleme: Sp3000 print, her biri bir bayt kaydeden üçlü duruma bir düzenleme ve düzenleme önerdi .

Ungolfed:

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

Burada Python 3'e özgü bir şey var mı?
Olmazsa

@Cyoce Çok özel bir şey Python 3 yok. Python 3'te daha yeni başladım, çünkü sahip olduğum sürüm bu. Bir Python 2 sürümünü ideone veya başka bir şey üzerinde test edeceğim.
Sherlock9

İle başlayan bir girişli O does not çalışmalarını @Maltysen 0gibi 0 12 4.
Sherlock9

Python 2'deki girintilere yönelik sekme ve boşlukları değiştirerek bazı baytları kaydedebilirsiniz. Python'un girintisi çözümleyicisine göre 1 sekme karakterinin == 8 boşluk olduğuna inanıyorum
Cyoce

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

4

C, 238 235 bayt

Kodu olabildiğince kısa yapmak için C önişlemcisine yoğun şekilde güvenerek. Yan etkisi olarak, aynı zamanda onu hemen hemen okunamaz hale getirir.

#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'te, kodu basit bir şekilde derleyebilirsiniz gcc quipu.c(lütfen uyarıları dikkate almayın). Yürütülebilir dosyayı çalıştırmanın bir örneği:

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

Tüm OP test vakalarına karşı test edilmiştir.

Ungolfed kaynak kodu:

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

Tebrikler! Ödül süresi içinde gönderilen en kısa cevap olarak, +50 rep ödülü aldım. Güzel cevap! :)
Alex A.

4

Mathematica 436 453 357 352 347 bayt

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)

Yukarıdaki

  • IntegerDigits; Kullanarak her bir tam sayıyı bir basamaklar listesine böler ; Her bir sayıyı sıfırla sola doğru doldurur (eşit boşluk sağlamak için); şimdi basamaklara ayrılan her giriş numarası, bir dizinin bir satırına karşılık gelir; her sütun bir yer değerini temsil eder. Dizi aktarıldı.
  • Rakamları, dolgulu bir düğüm listesi ile değiştirir. Birimler için biraz farklı desen eşleştirme rutini kullanılır.

Örnek

g[Range[0, 50]]

elli


Transpose@Join? Olmalı, değil mi?
CalculatorFeline

Evet. Bunu yakaladığın için teşekkürler.
DavidC

Ondan hemen önce boşluk.
Hesap MakinesiFeline,

1

R - 446 444

Görüyorum ki henüz R çözümü yok, işte bir tane. İşlev tamsayıları olan bir vektör alı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)}

Ungolfed

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

İhtiyacınız mı if(v>0)sizin de if(i<r)fıkra? R z+1:zne zaman olduğu gibi bir aralık kabul ediyor mu v==0? Öyle q[z+1:z,j]etkilenmezse, düşünürdüm. Ayrıca, R’nin bir elseanahtar kelimesi ve bir tür else ifanahtar kelimesi var mı? Öyleyse, bu koşulların bir kısmını golf oynayabilirsin.
Sherlock9

if(v>0)gereklidir, çünkü v=0endeks sınırların dışına çıkar (yani, satır + 1 almaya çalışır). R, var elseve ben aslında önerinizi denedim ve elsemümkün olduğunda kullandım , ancak aynı sayıda bayt olduğu ortaya çıktı.
Yavaş loris
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.