Kelimeleri Görselleştirme


20

Yalnızca küçük harflerden oluşan bir kelime verildiğinde aşağıdakileri yapın:

  1. Her harf için, alfabedeki konumunun ana çarpanlarına ayırmasını sağlayın.
  2. Her asal faktör için, p , yan uzunluğu bir elmas çizmek p ve elmas ortasında mektubu sopa.
  3. En büyük elmas ortadadır, daha sonra daha küçük elmaslar (en büyüğünden en küçüğüne) alta veya yukarı gitme arasında değişir.

Not: Harf için 1 kenar uzunluğu kullanın.

Örnek: kedi

  • c : 3 = 3
  • a : 1 = 1
  • t : 20 = 5 * 2 * 2

Şema:

                 .
                . .
               . t .
                . .
                 .
                 .
                . .
   .           .   .
  . .         .     .
 .   .   .   .       .
.  c  . .a. .    t    .
 .   .   .   .       .
  . .         .     .
   .           .   .
                . .
                 .
                 .
                . .
               . t .
                . .
                 .

Örnek: köpek

  • d : 4 = 2 * 2
  • o : 15 = 5 * 3
  • g : 7 = 7

Diyagram:

                         .
                        . .
           .           .   .
          . .         .     .
         .   .       .       .
  .     .     .     .         .
 . .   .       .   .           .
. d . .    o    . .      g      .
 . .   .       .   .           .
  .     .     .     .         .
  .      .   .       .       .
 . .      . .         .     .
. d .      .           .   .
 . .       .            . .
  .       . .            .
         .   .
        .  o  .
         .   .
          . .
           .

Programınız "[kelimeniz] .txt" adlı bir metin dosyasına çıktı veriyorsa % -20 bonus . Daha sonra, en az 20 harf uzunluğunda ve başka hiç kimse seçmemiş gerçek bir kelime (veya boşluk içermeyen küçük harfli) girin ve çıktıyı yanıtınıza a <pre>ve a arasına yapıştırın </pre>.


Örnekleriniz p + 1 noktalı elmaslar kullanıyor gibi görünüyor ...
Jaykul

3
@Jaykul Güzel soru. Yan uzunluk noktalar arasındaki boşluk sayısına göre belirlenir.
geokavel

Yanıtlar:


8

Matlab, 466 393-20% = 314.4 bayt

Golf: (@ AndreasDeak'in yardımı nedeniyle daha fazla bayt kurtarabilir!)

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));f=fopen([W,'.txt'],'w');for k=1:size(A,1);fprintf(f,[A(k,:),'\n']);end;end

Octave'de (açık kaynak) da çalışmalıdır, ancak sadece çok fazla uyarı ile. Oktav'da (dosya yerine konsola çıktı) denemek istiyorsanız bu sürümü kullanın:

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));disp([A,'']);end

Açık ve açık:

function q(W)
function z=g(l,c) %get a square matrix for one prime factor
[x,y]=ndgrid(abs(-l:l));
z=0*y;
z(~x&~y)=c;    %character in the middle
z(x+y==l)=46;  %dots
end;
w=W-96;                %convert word to the corresponding indices                  
n=numel(w);
R=n*26;                %keeps track of the main row 
C=1;                   %keeps track of the current column
A=zeros(2*R);          %make a 'canvas' matrix that is way to big 
for k=1:n;
    f=sort(factor(w(k)));          %get all the factors of current character
    C=C+max(f)+1;                  %update current column
    d=-1;                          %search direction
    r=R;
    for F=fliplr(f);              
        v=-F:F;
        while norm(A(r+v,v+C));    %go up or down until there is enough space to write the prime factor
            r=r+d;
        end;
        A(r+v,v+C)=g(F,W(k));     %insert all the prime factors
        d=-d;
    end;
    C=C+max(f);
end;
A=A(find(sum(A,2)),find(sum(A))); %truncate all the unneccessary padding
f=fopen([W,'.txt'],'w');     %write to file
for k=1:size(A,1);
    fprintf(f,[A(k,:),'\n']);
end;

end

İstenen kelime: (Ve burada bir dosya olarak: (çok uzaklaştırın): supercalifragilisticexpialidocious.txt )

                       . . .                   
                      . . . . . .                  
                     . . . . . .                 
                    . . . . . .                
                   . . . . . .               
                  . . . . . .              
                 . . . . . .             
                . . . . . .            
               . . . . . .           
              . . . . . . .          
             . . . . . . . .         
            . . . . . . . . . t. . . . .        
           . . . . . . . . . . . . . . . . . . . . . . . . .       
          . . . . . . . r. . l. . r. . . . l. . . . . x. . . . l. . . . .      
         . . . . . s. . . . . . . . . . . . . . . . . . . s. . . . . . . . .     
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
    . s .. u .. p .. e .. r .. c ..a .. l .. i .. f .. r ..a .. g .. i .. l .. i .. s. t .. i .. c .. e .. x .. p .. i ..a .. l .. i .. d .. o .. c .. i .. o .. u .. s .
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
         . . . . . s. . . . . . . . . . . . . . . . . . . . . . . . . . . . . s. . . . . . . . d. . . . . . . . .     
          . . . . . . . . . l. . . . f. . . . . . . . l. . . . . . . . . x. . . . . . l. . . . . . . . . . . . .      
           . . . . . r. . . . ben . . . . r. . . ben . . . . ben . . . . . . ben . . . . . ben . . . . ben . . . . . ben . . . . . .       
            . . . . . . . . . . . . . . . . . . . . t. . . . . . . . . . . . . . . . . . .        
             . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ö . . . . Ö . . . . .         
              . . . . . s. . . . . . . . . . . . . s. . . . . . . . . . . .          
               . . . u. . . . . . x. . . . . . . . u. . .           
                . . . . . . . . . . . . . . . .            
                 . . . . . . . . . . .             
                  . . . . . . . .              
                   . . . . . .               
                    . . . . . .                
                     . . . . . .                 
                      . . . . . .                  
                       . . .                   

A=A(find(sum(A,2)),find(sum(A)));Dolguyu bir adımda çıkarmak için yeterli olmaz mı?
Andras Deak

Çıktı metnini iki <pre>etiket arasına yapıştırdığımda gerçekten mükemmel sonuçlar aldım . Neden denemiyorsun!
geokavel

İhtiyacınız olduğundan emin misiniz sort(factor())? MATLAB'lar factorzaten sıralanmış gibi görünüyor. max(f)Aynı miktarı iki kez kullandığınız için bir değişken tanımlayabilirsiniz .
Andras Deak

1
@geokavel Başka yöne baktığınıza inanıyorum :) [İncil'den] (en.wikipedia.org): MATLAB -> "İlk sürüm - 1984", GNU Octave -> İlk sürüm - 1988 ". Mathworks, ticari ürünlerinin bu kadar küçük ayrıntılara kopyalanmasına izin veriyor mu? Yoksa sadece neden hala karlı olduğunu kastediyorsanız: Mevcut MATLAB araç kutularının ve Octave'nin çok iyi olmasına rağmen (Octave sözdizimi bazen daha zengin olmasına rağmen) eminim! Hızdan bahsetmiyorum bile (sanırım)
Andras Deak

1
@geokavel AndrasDeak'ın dediği gibi: Octave bir Matlab klonudur, ancak maalesef geliştiriciler de dili geliştirmeye çalıştıklarından maalesef mükemmel değildir. İşte çevrimiçi yorumlayıcıda da çalışan biraz değiştirilmiş bir sürüm: goo.gl/Jk7mpV
flawr

6

Funciton , rekabetçi değil, 29199 bayt

Bu zorluğun tadını çıkardım, çünkü bazı çok yararlı kütüphane işlevlerinin acısızlığını vurguladı. Bu işlevlerin tümünü buraya (ve bayt sayısına) dahil edeceğim çünkü bu sorun gönderildikten sonra bunları yazdım.

Tek bir dosyada tam kaynak

açıklama

Her zaman olduğu gibi, javascript:(function(){$('pre,code').css({lineHeight:5/4});})()tarayıcı konsolunuzda yürüterek daha iyi bir görüntü elde edin.

ɹ Geri

Bildiğiniz ya da bilmediğiniz gibi, Funciton, listeler için işlevlerle dolu, tek bir humongo tamsayıda kodlanmış değerler ve tembel değerlendirilmiş diziler için ayrı bir kütüphane ile birlikte gelir. de, kullanım lambda ifadeleri (anonim fonksiyonlar), tembel olmak için. Elbette dize işleme işlevleri için bir kütüphane de vardır.

Bu meydan okuma için, bir dizeyi tersine çevirmek için bir fonksiyona ve tembel olarak değerlendirilmiş bir diziyi tersine çevirmek için bir işleve ihtiyacım vardı. Şaşırtıcı bir şekilde, listeler için sadece bir tane vardı - tam olarak ihtiyacım yoktu. Tembel diziler ( ɹ) ve dizeler ( ) için ters işlevler şunlardır :

              ╓───╖             ╔════╗ ┌────╖        ╓───╖
              ║ ɹ ║             ║ 21 ╟─┤ >> ╟──┐     ║ ⇄ ║
              ╙─┬─╜             ╚════╝ ╘═╤══╝  │     ╙─┬─╜      ┌──┐
          ┌─────┴─────┐                ┌─┴─╖   ├───────┴────────┤  │
        ┌─┴─╖ ┌───╖   │                │ ⇄ ║   │   ╔════╗ ┌───╖ │  │
      ┌─┤   ╟─┤ ɹ ╟─┐ │                ╘═╤═╝   │   ║ −1 ╟─┤ ≠ ╟─┴┐ │
      │ └─┬─╜ ╘═══╝ │ │                ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝  │ │
      │   │   ┌───╖ │ │                │ ‼ ╟─┤ ? ╟──────────┤    │ │
      │   └───┤ ʬ ╟─┘ │                ╘═╤═╝ ╘═╤═╝  ╔═══╗ ┌─┴─╖  │ │
      │       ╘═╤═╝   │                ┌─┴─╖ ╔═══╗  ║ 0 ╟─┤ ≠ ╟──┘ │
      │ ╔═══╗ ┌─┴─╖   │              ┌─┤ ʃ ╟─╢ 1 ║  ╚═╤═╝ ╘═══╝    │
      └─╢ 0 ╟─┤ ? ╟───┘              │ ╘═╤═╝ ╚═══╝    │            │
        ╚═══╝ ╘═╤═╝                  │   └────────────┘            │
                │                    └─────────────────────────────┘

Birinin kullandığı ʬtembel sekanslar, “tembel sekansın sonuna bir eleman eklemek”. Kullanılacak dize ʃ(alt dize) ve (string concatenate) kullanır.

Asal

Her ne kadar n'yi tüm faktörlere sırayla bölmeye çalışarak asal çarpanlara ayırma yapabilseydim, asal sayılar üreten bir kütüphane işlevi istediğime karar verdim. Aşağıdaki fonksiyon n tamsayısını alır ve n'ye kadar tüm asal sayıları üretmek için Eratosthenes Elekini uygular . Bunu tembel bir dizi olarak yapar, bu yüzden gerçekten değerlendirdiğiniz kadar çok primer üretecektir.

                                       ╓───╖
                                       ║ Ṗ ║
                                 ╔═══╗ ╙─┬─╜
                                 ║ 0 ║ ┌─┴─╖
                                 ╚═╤═╝ │ ♭ ║
                          ╔═══╗ ┌──┴─╖ ╘═╤═╝
                          ║ 2 ╟─┤ Ṗp ╟───┘
                          ╚═══╝ ╘══╤═╝
    ┌──────────────┐               │
    │              ├─────────────────────────────────────────┐
    │            ┌─┴─╖                                       │
    │          ┌─┤ · ╟────────────────────────────┐   ╓┬───╖ │
    │          │ ╘═╤═╝                            ├───╫┘Ṗp ╟─┤
    │          │   │           ╔═══╗ ┌────╖     ┌─┴─╖ ╙─┬──╜ │
    │          │   │           ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐  │
    │          │   │  ┌───╖    ╚═══╝ ╘══╤═╝     ╘═╤═╝     │  │
    │          │ ┌─┴──┤ ♯ ╟─────┐    ┌──┴─╖ ┌───╖ │       │  │
    │          │ │    ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐     │  │
    │          │ │          ├─┘ └─┤  ╘══╤═╝ ╘═══╝ ┌─┘     │  │
    │          │ │        ╔═╧═╕ ┌─┴─╖ ┌─┴─╖     ┌─┴─╖     │  │
    │          │ └────────╢   ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐   │  │
    │          │ ┌───╖    ╚═╤═╛ ╘═╤═╝ ╘═╤═╝     ╘═╤═╝ │   │  │
    │        ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖   │   ┌─┴─╖       │   │   │  │
    │        │   ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘   │   │  │
    │ ┌───╖  │  ╔════╗   ╘══╤═╝     │ ╘═╤═╝           │   │  │
  ┌─┴─┤ ÷ ╟──┘  ║ −1 ║   ┌──┴─╖   ╔═╧═╗ │            ┌┴┐  │  │
  │   ╘═╤═╝     ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║              └┬┘  │  │
  │   ┌─┴─╖ ┌────╖ │   │ ╘════╝ │ ╚═══╝               │   │  │
  │   │ × ╟─┤ << ╟─┘ ┌─┴─┐    ╔═╧═╗                   │   │  │
  │   ╘═╤═╝ ╘══╤═╝  ┌┴┐ ┌┴┐   ║ 1 ╟───────────────────┴─┐ │  │
  └─────┘     ┌┴┐   └┬┘ └┬┘   ╚═══╝                     ├─┘  │
              └┬┘    │   └──────────────────────────────┘    │
             ┌─┴─╖ ┌─┴──╖                                    │
             │ ÷ ╟─┤ << ╟─┐                                  │
             ╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
              ┌┴┐         │
              └┬┘         │
      ╔════╗ ┌─┴──╖       │
      ║ −1 ╟─┤ << ╟───────┘
      ╚════╝ ╘════╝

Yardımcı işlevi, Ṗpşunları alır:

  • 0'a ulaşıncaya kadar azalmaya devam eden bir koşu sayacı.

  • Asal olmadığı bilinen her sayı için biraz ayarlanmış olan elek. Başlangıçta, en az anlamlı bit 2 sayısını temsil eder, ancak bu hakkı her yinelemede kaydırırız.

  • Bir dizi n sayı elek olan en düşük bit ile temsil edilir belirtir; bu her yinelemeyle birlikte artar.

Her bir yinelemede, elek en düşük biti 0 ise, asal bir n bulduk . Daha sonra , bir sonraki yinelemeye geçmeden önce elek içindeki her n- biti ayarlamak için bir NxN ızgarasının satırlarını, sütunlarını ve köşegenlerini doldurma bölümünde daha önce açıkladığım formülü kullanıyoruz .

Factor Asal çarpanlara ayırma

                             ╓───╖
                             ║ Ḟ ║
                             ╙─┬─╜
                       ┌───────┴──────┐
                       │ ┌───╖ ┌────╖ │
                       └─┤ Ṗ ╟─┤ Ḟp ╟─┘
                         ╘═══╝ ╘═╤══╝
                                 │
               ┌────────────────────────────────────────────┐
               │                                     ╓┬───╖ │
       ┌───────┴─┐     ┌───────────────────────┐   ┌─╫┘Ḟp ╟─┘
       │ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖      ┌─┴─╖ │ ╙────╜
       │ ║ 0 ╟─┤   ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
       │ ╚═══╝ └─┬─╜ ╘═╤═╝  └┤   ╘═╤══╝  ├─┘ ╘═╤═╝    │
       │       ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
       │       │   └─┤ · ╟─╢   ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
       │       │     ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
       │       │    ┌──┴─╖   │   ┌─┴─╖ ┌─┴─╖   └──────┘   │
       │       │    │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║              │
       │     ┌─┴─╖  ╘══╤═╝     │ ╘═╤═╝ ╘═╤═╝              │
       └─────┤ · ╟─────┘     ╔═╧═╗ │   ╔═╧═╗              │
             ╘═╤═╝           ║ 0 ║     ║ 2 ║              │
               │             ╚═══╝     ╚═══╝              │
               └──────────────────────────────────────────┘

Bu oldukça basittir. Sadece n'ye kadar asalları tekrarlayın ve hangilerinin n'yi böldüğüne bakın . Bir bölünme yaparsa n , ile devam etmeyi unutmayın aynı o böler eğer biz bunu birden çok kez dönmek böylece asal n birden çok kez . Bu, 2'den küçük herhangi bir sayı için boş diziyi döndürür.

bir elmas üret

Bu işlev, bir karakter ve bir yarıçap verilen tek bir elmas üretir. Karakteri sadece elmanın ortasına yerleştirmek için kullanır.

                                   ┌───╖
             ┌─────────────────────┤ ♯ ╟───────────┬─────────┐
             │ ┌───╖ ╔═══╗   ┌───┐ ╘═══╝           │         │
             └─┤ ♫ ╟─╢ 0 ║   │ ┌─┴─╖               │         │
               ╘═╤═╝ ╚═══╝   │ │ ʭ ╟───┐           │         │
               ┌─┴─╖   ┌─────┘ ╘═╤═╝   │           │         │
               │ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗   ╓───╖ │         │
               ╘═╤═╝   └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤         │
                 │ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │         │
                 │ ║ 0 ║                   │     ┌─┴─╖       │
                 │ ╚═╤═╝                   │     │ ♭ ║       │
               ╔═╧═╕ │   ╔════╗            │     ╘═╤═╝       │
           ┌───╢   ├─┘ ┌─╢ 21 ║          ┌─┴─╖   ┌─┴─╖     ┌─┴─┐
           │   ╚═╤═╛   │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
           │   ┌─┴─╖ ┌─┴──╖ ┌───┘        ╘═╤═╝   ╘═╤═╝ ├─┤ = ║ │
           │ ┌─┤ ‼ ╟─┤ >> ║ │              │     ┌─┴─╖ │ ╘═╤═╝ │
           │ │ ╘═══╝ ╘═╤══╝ │              │   ┌─┤ ? ╟─┘   │   │
           │ │   ┌───╖ │ ┌──┘              │   │ ╘═╤═╝     │   │
           │ └─┬─┤ ⇄ ╟─┘ │     ┌─────┐     │   │ ┌─┴─╖     │   │
           │   │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘   │
           │   └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║   ╘═╤═╝  │      │
           │           ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝   ┌─┴─╖  │      │
           │             └─────┘     └─┬───┘ ┌───┤ … ║  │      │
           │               ┌─────┐     │     │   ╘═╤═╝  │      │
           │            ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │      │
           │            ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │      │
           │            ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │      │
           │                   ┌─┴─╖       ╔═╧══╗       │      │
           │               ┌───┤ − ╟───┬─┐ ║ 46 ║       │      │
           │             ┌─┴─╖ ╘═══╝   │ │ ╚════╝       │      │
           └─────────────┤ · ╟─────────┘ └──────────────┘      │
                         ╘═╤═╝                                 │
                           └───────────────────────────────────┘

Bu tembel sekansları yoğun şekilde kullanır. Şöyle çalışır:

  • 0'dan r'ye (dahil) tamsayılar dizisi oluşturun .

  • Böyle bir tamsayı a için , ( r - α ) boşluklarından ( ), ardından bir noktadan, ardından α boşluklarından oluşan bir dize oluşturun - α = r değilse , bu durumda daha az boşluk oluşturur ve harfi ekler. Şimdi elmasın sol üst çeyreğine sahibiz.

  • Bu dizelerin her birine, aynı dizenin başka bir kopyasını ekleyin, ancak karakterler ters çevrilmiş ( ) ve ardından ilk karakter kaldırıldı ( >> 21). Şimdi elmasın üst yarısına sahibiz.

  • Bu sırayı alın ve ona aynı sırayı ekleyin, ancak ters ( ɹ) ve ilk eleman kaldırıldığında ( ʓ). Şimdi elimizde tüm elmas var.

Şimdi elması oluşturan teller var, ama biraz daha bilgiye ihtiyacımız var. Pırlantanın dikey ortasının nerede olduğunu bilmemiz gerekir. Başlangıçta bu elbette r , ancak bunun üstüne ve altına başka elmaslar ekledikten sonra, diğer elmas yığınlarını dikey olarak hizalayabilmemiz için “orta” elmasın konumunu takip etmemiz gerekecek. . Aynı şey elmasın yatay boyutu için de geçerlidir (elmasları üste ve alta eklerken buna ihtiyaç vardır). Ayrıca mektubu takip etmeye karar verdim; Çünkü aksi takdirde (ki biz sonraki bölümde olsun) fonksiyonu dört parametre olması gerekir, ama Funciton sadece üç izin verir.

                             ┌─────────────────┐
                             │  ╓───╖          │
                             ├──╢ ◆ ╟──┐       │
                             │  ╙───╜  │       │
                             │   ┌─────┴───┐   │
                           ┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
                         ┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
                         │ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝ │
                         │ ┌─┴─╖     │   ┌─┴─╖ │
                         │ │ ◇ ╟─────────┤ › ╟─┘
                         │ ╘═╤═╝         ╘═══╝
                         └───┘

[ X , y , c , q ] içeren bir yapı oluşturmak için liste API'sini kullanırız ( bir listenin önüne öğeler ekleriz ); burada x , elmanın yatay merkezinin x koordinatıdır, y , y- taban çizgisinin koordinatı, c harftir ve q , dizelerin tembel dizisidir. Bu yapı, bundan sonraki tüm ara aşamaları içermek için kullanılacaktır.

Diamond Elmasları dikey olarak ekle

Bu işlev varolan bir elmas yığınını, yarıçapı ve yeni elmanın üste (doğru) veya alta (yanlış) eklenip eklenmeyeceğini gösteren bir boole alır.

                 ┌─────────────────────────────────────────────────┐
               ┌─┴─╖         ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
           ┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐   ├─┤ ‹ ╟─┤ ‹ ║
           │   ╘═╤═╝           ║ 1 ║ │ ╓───╖         │   │ ╘═╤═╝ ╘═╤═╝
           │     │             ╚═╤═╝ └─╢ ⬗ ╟─┐       │ ┌─┴─╖ │   ┌─┴─╖
           │     │ ┌───╖ ┌───╖ ┌─┴──╖  ╙─┬─╜ │       └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
           │   ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║    │   │         ╘═╤═╝   │ ╘═══╝ │
           │   │   ╘═╤═╝ ╘═══╝ ╘═╤══╝    │ ┌─┴─╖         │     │       │
           │   │   ┌─┴─╖         └───────┴─┤ · ╟───┐   ┌─┴─╖   │       │
           │   └───┤ ? ╟─┐                 ╘═╤═╝ ┌─┴───┤ · ╟─┐ │       │
           │       ╘═╤═╝ ├───────────────────┘   │     ╘═╤═╝ │ │       │
           │ ┌───╖ ┌─┴─╖ │               ┌─────┐ │ ┌───╖ │   │ │       │
           └─┤ › ╟─┤ › ║ │       ┌───╖ ┌─┴─╖   │ └─┤ − ╟─┘   │ │       │
             ╘═╤═╝ ╘═╤═╝ │     ┌─┤ ‼ ╟─┤ ‼ ║   │   ╘═╤═╝     │ │       │
               │   ┌─┴─╖ │     │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖     │ │       │
               ┌───┤ · ╟─┘     │ ┌─┴─╖   ├───┤ · ╟─┤ … ║     │ │       │
     ┌───┐     │   ╘═╤═╝       └─┤ · ╟───┘   ╘═╤═╝ ╘═╤═╝     │ │       │
     │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖         ╘═╤═╝         │  ╔══╧═╗     │ │       │
     │ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕         │  ║ 32 ║     │ │       │
     │ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢   ├─────────┘  ╚════╝     │ │       │
     │ ┌─┘   ┌─┴─╖       │ ╚═══╝ ╚═╤═╛                       │ │       │
     │ └─┬───┤ ʭ ╟─┐   ┌─┴─╖     ┌─┴─╖                       │ │       │
     │ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║                       │ │       │
     └─┤ · ╟───────┘   ╘═╤═╝     ╘═╤═╝                       │ │       │
       ╘═╤═╝             │       ┌─┴─╖                       │ │       │
         │               └─────┬─┤ ◇ ╟───────────────────────┘ │       │
         │                     │ ╘═══╝                       ┌─┴─╖     │
         │                     └─────────────────────────────┤ · ╟─────┘
         │                                                   ╘═╤═╝
         └─────────────────────────────────────────────────────┘

Bu da oldukça basittir; yapıyı açmak için kullanın ; yeni elmas oluşturmak için kullanın ; ɱyeni elmastaki her dizenin başına ve sonuna boşluk eklemek için (map) öğesini kullanın, böylece her biri aynı genişliğe sahip olur; ʭyeni dizeleri eski (altta ise) üzerine veya eski dizeyi yeni (üstte ise) üzerine ekleyin ; ve son olarak tüm yeni değerleri içeren yapıyı oluşturmak için kullanın . Özellikle, tabana ekliyorsak, y değişmez, ancak zirveye eklersek, y artar ♯(r << 1)( r , yeni elmasın yarıçapıdır).

Sta Yığınları yatay olarak birleştirin

Hepsinin en büyük işlevi bu. Bunu doğru yapmanın oldukça zor olduğunu inkar etmeyeceğim. İki yığın alır ve doğru dikey hizalamaya saygı gösterirken yatay olarak birleştirir.

                           ┌──────────────────────────────────┬───────────────────────┐
                           │     ┌──────────────────┐       ┌─┴─╖                   ┌─┴─╖
                           │     │    ┌───────────┐ └───────┤ · ╟───┬───────────────┤ · ╟─────────────┐
                           │     │  ┌─┴─╖         │         ╘═╤═╝   │               ╘═╤═╝             │
                           │     │  │ ‹ ╟───┐     │         ┌─┴─╖ ┌─┴─╖               │               │
                           │     │  ╘═╤═╝ ┌─┴─╖   └─────────┤ · ╟─┤ · ╟─────────┐     │               │
                           │     │    ├─┐ │ ‹ ╟───┐         ╘═╤═╝ ╘═╤═╝         │     │               │
                           │     │    └─┘ ╘═╤═╝ ┌─┴─╖ ╓───╖ ┌─┴─╖   │           │     │               │
                           │     │          │   │ ‹ ╟─╢ ❖ ╟─┤ ‹ ║   │           │     │               │
                           │     │          │   ╘═╤═╝ ╙───╜ ╘═╤═╝ ┌─┴─╖ ┌─┐     │     │               │
                           │     │          │     │           └───┤ ‹ ║ └─┤     │     │               │
                           │     │          │     │               ╘═╤═╝ ┌─┴─╖   │     │               │
                           │     │          │     │                 └───┤ ‹ ║   │     │               │
                           │     │          │     └─────────────────┐   ╘═╤═╝   │     │               │
                           │     │          │                     ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖             │
                           │     │          │      ┌──────────────┤ · ╟─┤ · ╟─┤ · ╟─┤ · ╟──────┐      │
                           │     │          └──────┤              ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝      │      │
                           │   ┌─┴─╖             ┌─┴─╖            ┌─┴─╖   │     │     │        │      │
                           │ ┌─┤ · ╟─────────────┤ · ╟────────────┤ · ╟───┘     │     │        │      │
                           │ │ ╘═╤═╝             ╘═╤═╝            ╘═╤═╝         │     │        │      │
                           │ │   │                 │         ┌────╖ │         ┌─┴─╖   │        │      │
       ╔═══╗ ┌────╖        │ │   │                 │       ┌─┤ << ╟─┴─────────┤ · ╟─┐ │        │      │
       ║ 1 ╟─┤ << ╟────────┘ │   │                 │       │ ╘═╤══╝           ╘═╤═╝ │ │        │      │
       ╚═══╝ ╘═╤══╝ ╔════╗   │   │               ┌─┴─╖     │ ┌─┴─╖              │   │ │     ┌──┴──┐   │
             ┌─┴─╖  ║ 32 ╟─┐ │   │ ┌─────────────┤ · ╟───┐ │ │ ♯ ║              │   │ │   ┌─┴─╖ ┌─┴─╖ │
             │ ♯ ║  ╚════╝ │ │   └─┤ ┌───╖       ╘═╤═╝   │ │ ╘═╤═╝ ┌───╖ ╔════╗ │   │ │ ┌─┤ ? ╟─┤ < ║ │
             ╘═╤═╝   ┌───╖ │ │     └─┤ − ╟─────────┴─┐   │ │   └───┤ … ╟─╢ 32 ║ │   │ │ │ ╘═╤═╝ ╘═╤═╝ │
               └─────┤ … ╟─┘ │       ╘═╤═╝         ┌─┴─╖ │ └───┐   ╘═╤═╝ ╚════╝ │   │ │ │ ┌─┴─╖   ├───┘
                     ╘═╤═╝   │ ┌───╖ ┌─┴─╖ ┌───────┤ · ╟─┴─┐ ╔═╧═╗ ┌─┴─╖ ┌──────┘   │ │ └─┤ · ╟───┘
                       │   ┌─┴─┤ ʭ ╟─┤ ȶ ║ │ ┌───╖ ╘═╤═╝   │ ║ 1 ║ │ ⁞ ║ │ ┌────────┘ │   ╘═╤═╝
                     ┌─┴─╖ │   ╘═╤═╝ ╘═╤═╝ └─┤ > ╟───┴─┐   │ ╚═══╝ ╘═╤═╝ │ │   ┌──────┘     └────┐
                     │ ⁞ ║ │   ┌─┴─╖ ┌─┴─╖   ╘═╤═╝     │ ┌─┴─╖ ┌───╖ │   │ │ ┌─┴─╖ ┌───╖ ┌───╖ ┌─┴─╖
                     ╘═╤═╝ └───┤ ? ╟─┤ · ╟─────┴─┐     │ │ − ╟─┤ ȶ ╟─┴─┐ │ │ │ + ╟─┤ ♯ ╟─┤ › ╟─┤ › ║
                     ┌─┴─╖     ╘═╤═╝ ╘═╤═╝       │     │ ╘═╤═╝ ╘═╤═╝   │ │ │ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝
┌────────────────────┤ · ╟───────┴───┐ └─┐     ┌─┴─╖   └───┘   ┌─┴─╖   │ │ └───┘           │     │
│                    ╘═╤═╝         ┌─┴─╖ │   ┌─┤ · ╟───────────┤ · ╟───┘ │                       │
│ ┌────────────────┐   │   ┌───────┤ · ╟─┘   │ ╘═╤═╝           ╘═╤═╝     │                       │
│ │ ╔════╗ ┌───╖ ┌─┴─╖ └───┤ ┌───╖ ╘═╤═╝     │   │               │     ┌─┴───┐                   │
│ │ ║ 32 ╟─┤ ‼ ╟─┤ · ╟───┐ └─┤ ʭ ╟───┘       │   │             ┌─┴─╖ ┌─┴─╖ ┌─┴─╖                 │
│ │ ╚════╝ ╘═╤═╝ ╘═╤═╝   │   ╘═╤═╝     ┌─────┘   │             │ ʭ ╟─┤ · ╟─┤ ? ╟─┐               │
│ │        ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖   ┌─┴─╖       │             ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │               │
│ │        │ ‼ ╟─╢   ├─╢   ├─┤ ʑ ╟───┤ ʭ ║     ┌─┴─╖             └─────┘     │   │               │
│ │        ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝   ╘═╤═╝ ┌───┤ · ╟─────────────────────────┘   │               │
│ └──────────┘     │   ╔═╧═╗   │       ├───┘   ╘═╤═╝                             │               │
│                  └───╢ 0 ║ ┌─┴─╖   ┌─┴─╖       └───────────────────────────────┘             ┌─┴─╖ ╔═══╗
│                      ╚═══╝ │ ȶ ╟───┤ · ╟─────────────────────────────────────────────────────┤ › ╟─╢ 0 ║
│                            ╘═╤═╝   ╘═╤═╝                                                     ╘═══╝ ╚═══╝
│                            ┌─┴─╖   ┌─┴─╖
│                      ┌─────┤ ? ╟─┐ │ ɕ ║
│                    ┌─┴─╖   ╘═╤═╝ │ ╘═╤═╝
│            ┌───╖ ┌─┤ < ╟───┬─┘   │   │
└────────────┤ ɕ ╟─┤ ╘═══╝ ┌─┴─╖   │   │
             ╘═══╝ └───────┤ · ╟───┘   │
                           ╘═╤═╝       │
                             └─────────┘

İşte böyle.

  • İlk olarak, her yığın için, her biri yığının genişliğine göre boşluk ( ) içeren sonsuz bir dizgi dizisi ( ) oluşturun .

  • Y yığınlar değerleri bize hangi “aşağı hareket” ve ne kadar tek ihtiyaçlar. ȶDoğru uzunluğa kesilmiş ( ) uygun boşluk sırasını (uygun şekilde y1 - y2 veya y2 - y1 ) ekleyin .

  • Şimdi ɕ, bize yüksekliklerini söyleyen dize dizilerinin ( ) her birinin uzunluğunu belirleyin . Hangisinin daha uzun olduğunu öğrenin.

  • Her iki yığına sonsuz boşluk dizisi ekleyin.

  • ʑBunları bir araya getirmek için zip ( ) kullanın . Her bir dize çifti için, aralarındaki fazladan boşlukla ( ) birleştirin .

  • Sonraȶ bunun sonucunu en yüksek yüksekliğe kesmek için kullanın . Bunu geç yaparak, bunlardan hangisinin dolguya ihtiyacı olduğu umurumda değil.

Son olarak, yapıyı tekrar oluşturun. Bu noktada, elmaslardaki karaktere artık ihtiyacımız yok, bu yüzden bunu 0 olarak ayarladık. X değeri sadece toplanır ve arttırılır (böylece yığının genişliği yine de hesaplanabilir ♯(x << 1)). Y değeri iki yüksek birine ayarlanır.

bir karakter dizisindeki karakterlerin üzerinde Bıkmadan

Bu, kütüphaneye ekleyeceğim başka bir yararlı işlevdir. Bir dize verildiğinde, her karakter kodunu içeren tembel bir sıra verir.

                                        ╓───╖
                                        ║ ↯ ║
                                        ╙─┬─╜
                           ┌──────────────┴────────────────┐
                           │      ┌─┐          ╔═══╗ ┌───╖ │
                           │      └─┤     ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
                    ┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖  ╚═══╝ ╘═╤═╝   │
                    │        ├─┤├─╢   ├─┤ ? ╟──────────┤     │
                    │        │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖   │
                    │ ╔══════╧══╗ ┌─┴─╖   │   ║ −1 ╟─┤ ≠ ╟───┘
                    │ ║ 2097151 ║ │ ↯ ║       ╚════╝ ╘═══╝
                    │ ╚═════════╝ ╘═╤═╝
                    │             ┌─┴──╖ ╔════╗
                    └─────────────┤ >> ╟─╢ 21 ║
                                  ╘════╝ ╚════╝

and2097151 ile bir dize yazmak ilk karakteri döndürür. >>21 ile onu kaldırır. Esolangs sayfasında açıklanan bir nedenle hem 0 hem de −1'i kontrol ediyoruz ; Bu, bu meydan okuma ile ilgili değildir, ancak kütüphane işlevinin doğru olmasını istiyorum.

elmas yığınına dönüştürme karakteri

Bu işlev tek bir karakter alır ve bir karakteri temsil eden dikey yığının yapısını döndürür.

                                   ╔════╗
                                   ║ 96 ║  ╓───╖
                                   ╚══╤═╝  ║ ⬖ ║
                        ┌───╖ ┌───╖ ┌─┴─╖  ╙─┬─╜
                    ┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║    │
                    │   ╘═╤═╝ ╘═══╝ ╘═╤═╝    │
                    │   ┌─┴─╖         ├──────┘  ┌──┐
                    │   │ ɹ ║         │     ┌───┤  │
                    │   ╘═╤═╝   ┌─────┘     │   │  │
                  ╔═╧═╗ ┌─┴─╖ ┌─┴─╖         │  ┌┴┐ │
                  ║ 1 ╟─┤   ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
                  ╚═══╝ └─┬─╜ ╘═╤═╝   ┌─┴─╢   ├─┘ ┌┴┐
            ┌───────────┐ │     └─┐   │   ╚═╤═╛   └┬┘
          ┌─┴─╖         │ │ ┌───╖ │   └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
    ┌─────┤ · ╟───┐     │ └─┤ ◆ ╟─┘   ┌─┴─╢   ├─┤ << ╟─╢ 1 ║
 ┌──┴─┐   ╘═╤═╝   │     │   ╘═╤═╝     │   ╚═╤═╛ ╘════╝ ╚═╤═╝
 │ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖   ┌─┴─╖ ┌─┴─╖        ┌─┴─╖
 │ │ >> ╟─┤ ⬗ ╟─╢   ├─╢   ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
 │ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝        ╘═╤═╝
 │  ╔═╧═╗  ┌┴┐    │   ╔═╧═╗   │       └─────┘          ╔═╧═╗
 │  ║ 1 ╟─┐└┬┘    └───╢ 0 ║                            ║ 0 ║
 │  ╚═══╝ ├─┘         ╚═══╝                            ╚═══╝
 └────────┘

Bu fonksiyon ilginç çünkü elmasların alta ve alta dönüşümlü olarak eklenmesini istiyorduk . İşte böyle yaptım:

  • İlk olarak 96'yı çıkarın (böylece 'a'1 olur), asal faktörleri ( yukarıda) alın, ɗdizi boşsa 1 öğesini eklemek için kullanın ve ardından ɹsırayı tersine çevirin ( ).

  • İlk elemanı çıkarın ve yığını hızlı bir şekilde başlatmak için arayın .

  • Şimdi, 0 ve 1 sayılarını süresiz olarak değiştiren tembel bir sıra oluşturmak için kullanın .

  • Bunun ʑüzerinde (zip) ve kalan ana faktörleri kullanın. Her asal faktör için, onu 1 ve or0/1 sola kaydırın. Şimdi asal sayıları ve üst / alt bilgileri kodlayan bir dizimiz var .

  • Son olarak, kullanın ʩ(sola / toplama katlayın). İlk değer, yukarıdaki ilk öğeden ürettiğimiz yığıntır. Her bir ν değeri için, önceki yığının, asal ( ν >> 1) ve üst veya alt ( ν & 1) olup olmadığını arayın (yeni bir elmas ekleyin ).

Program Ana program

Burada ana işi yapıyoruz.

                       ┌─────┐
                       │   ┌─┴─╖
                       │   │ ⬖ ║
               ╔═══╗ ╔═╧═╕ ╘═╤═╝
               ║ 0 ╟─╢   ├───┘
               ╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
                 └─┐   └───┤ ɱ ╟─┤ ↯ ╟─╢   ║
       ┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
       │       ┌─┴─╖     │ ┌─┴─╖
       │   ┌───┤ · ╟───┐ └─┤   ╟─┐
       │   │   ╘═╤═╝   │   └─┬─╜ │
       │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
       │ │ ❖ ╟─╢   ├─╢   ├─┤ ʩ ╟─┘
       │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
       └───┘   ╔═╧═╗   │   ┌─┴─╖ ┌─┐
               ║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
               ╚═══╝     │ ╘═══╝
                       ┌─┴─╖ ┌─┐
                     ┌─┤ ‹ ╟─┴─┘
                     │ ╘═══╝
      ╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
      ║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
      ╚════╝ ╘═╤═╝ ╘═══╝
               │

İlk olarak, ɱgiriş dizesindeki ( ) karakterlerin ( ) üzerine eşleyin ve kullanarak her birini bir elmas yığını haline getirin . İlk öğeyi bu öğeden çıkarın ve ʩhepsini ( ) birleştirmek için diğerlerini ( ) katlayın . Son olarak, dizelerin sırasına ulaşmak için yapıyı paketinden çıkarın ʝve ayırıcı olarak 10'u (yeni satır) kullanarak hepsine ( ) katılın .

Örnek çıktı

Giriş:

crusaders

Çıktı (hesaplanması 9 saniye sürdü; boyut sınırı nedeniyle buraya yazılamıyor).

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.