Bir sayı Verilen n , ilk üretmek n bu desen sütunları:

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################ ...

(1-indeksli) n'deki kolonun yüksekliği, n 'in ikili gösterimindeki takip 0bitleri sayısıdır , artı birdir. Sonuç olarak, alt katman doldurulmuş her sütuna, ikinci katman her ikinci sütuna, üçüncü katman her dördüncü sütuna, vb.

kurallar

• Herhangi bir standart yöntemle giriş ve çıkış yapabilirsiniz.
• Girişin, 1 ile 999 arasında bir tam sayı olduğunu varsayabilirsiniz.
• Çıktı, desen sağlam olduğu sürece herhangi bir miktarda boşluk içerebilir.
• Desen 1 dizinli ve burada gösterilen biçimde olmalıdır.
• Yerinde herhangi bir boşluk olmayan tek karakter kullanabilirsiniz #, ancak boşluk karakterini değiştiremezsiniz.

Test durumları

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

7
   #   
 # # # 
#######

32
                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

Birkaç büyük test vakası burada bulunabilir .

puanlama

Bu kod golf , yani her dilde bayt cinsinden en kısa kod kazanır.

Python 2 , 54 bayt

i=n=input()
while i:i-=1;print((' '*~-2**i+'#')*n)[:n]

Çevrimiçi deneyin!

Çok sayıda önde gelen boşlukla yazdırır. Her satırdan igeriye doğru sayma n, bir 2**i-1boşluk bırakıp ardından a #. Bu desen, giriş olan cetvelin genişliğine kadar tekrarlanır n. Bu, desen dizgisini çarparak nve ilk nkarakterleri alarak yapılır [:n].

Desen, eşit uzunluktaki bir alternatif için dize biçimlendirme ile yapılabilir.

i=n=input()
while i:i-=1;print('%%%ds'%2**i%'#'*n)[:n]

Şirin bir dilimleme yöntemi daha uzundur.

n=input();s=~-2**n*' '+'#'
exec"s=s[1::2]*2;print s[:n];"*n

Python 3 , 74 bayt

n=int(input())
a=1
while a<n:a*=2
while a:print(("%%%dd"%a%4*n)[:n]);a//=2

Çevrimiçi deneyin!

V , 17 , 16 bayt

é#Àñä}Är {ñÎÀlD

Çevrimiçi deneyin!

HexDump:

00000000: e923 c0f1 e416 7dc4 7220 7bf1 cec0 6c44  .#....}.r {...lD

Bir bayt tasarrufu için @KritixiLithos için teşekkürler!

Bu algoritma korkunç derecede verimsiz, ancak herhangi bir boyut girişi için teoride çalışması gerekir.

İlk oluşturarak çalışır n aşağıdaki desen tekrarlamalar:

#

 #
##

   #
 # #
####

       #
   #   #
 # # # #
########

               #
       #       #
   #   #   #   #
 # # # # # # # #
################

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

Ve sonra ilk n sütunu hariç hepsini keserek . Dolayısıyla, bu bir ton önde gelen boşluk üretecek, ancak OP şöyle dedi:

Çıktı, desen sağlam olduğu sürece herhangi bir miktarda boşluk içerebilir.

Açıklama:

é#                      " Insert an '#'
  Àñ           ñ        " 'N' times:
    ä<C-v>}             "   Duplicate every line blockwise (duplicating horizontally instead of vertically)
           Ä            "   Duplicate the top line. This conveniently puts us on the first non-whitespace character (that is, '#')
            r           "   Replace this character with a space
              {         "   Move to the beginning of the buffer
                Î       " On every line:
                 Àl     "   Move 'N' characters to the right ('l' for right, makes sense, right?)
                   D    "   And delete everything after the cursor

JavaScript (ES6), 61 58 bayt

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

@ETHProductions sayesinde 1 bayt, daha sonra herhangi bir karakterin kullanılabileceğini görünce 2 bayt daha kaydedildi.

Özyinelemeli bir çözüm.

Test durumları:

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

console.log(f(32));
console.log(f(1));  
console.log(f(5));  
console.log(f(7));  

Animasyon:

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

for(let i = 1 ; i < 64 ; i++) {
  setTimeout(_=>document.querySelector('pre').textContent=f(i), i*40);
}

<pre>

APL (Dyalog) , 21 bayt

'# '[1+⊖0⍪∨⍀⊖2⊥⍣¯1⍳⎕]

Çevrimiçi deneyin!

'# '[… `] Dizeyi dizine ekle

 ⎕ girdi almak

 ⍳ Birçok olduğunu ben ntegers

 2⊥⍣¯1 İhtiyaç duyduğunuz kadar rakam kullanarak (her sütunda bir sayı ) ikili değere dönüştürün

 ⊖ ters çevir

 ∨⍀ dikey birikimli VEYA azaltma

 0⍪ üste sıfır bitiştirmek

 ⊖ ters çevirin (yani tekrar yedekleme)

 1+ bir tane ekle (1 tabanlı dizinleme için)

Jöle , 11 10 bayt

Rọ2‘4ẋz⁶ṚY

Çevrimiçi deneyin!

OP, karakterin olması gerekmeyen bir gevşeme ekledikten sonra kaydedilen 1 bayt #.

Oktav, 45 bayt

@(n)[[sort(cummin(de2bi(g=0:n)'));g|1]+32 '']

Octave Online'da deneyin !

'#'Parmak izi yerine '!'.

PHP , 139 bayt

for($f=array_fill(0,$l=1+log($a=$argn,2)," ");$n++<$a;)for($h=1+strspn(strrev(decbin($n)),$i=0);$i<$h;)$f[$l-++$i][$n]=3;echo join("
",$f);

Çevrimiçi deneyin!

Japt , 20 17 bayt

@Shaggy ve @ETHproductions sayesinde 3 bayt kurtarıldı

õ_¤q1 o Ä ço÷z w

Çevrimiçi deneyin!

Açıklama:

Giriş: 5

õ_¤q1 o Ä ço÷z w
õ           Ã       // Create a range [1...Input] [1,2,3,4,5]
 _                  // Map; At each item:
  ¤                 //   Convert to binary        ["1","10","11","100","101"]
   q1               //   Split on "1"             [["",""],["","0"],["","",""],["","00"],["","0",""]]
      o             //   Get the last item        ["","0","","00",""]
        Ä           //   Add 1                    [["1","01","1","001","1"]]
          ço        //   Fill with "o"            ["o","oo","o","ooo","o"]
             ·      // Join with new-lines        ["o\noo\no\nooo\no"]
              z     // Rotate 90 degrees          ["ooooo\n o o \n o   "]
                w   // Reverse                    ["   o \n o o \nooooo"]

C, 84 74 bayt

f(i,l,m){putchar(32+3*!(i&m));i<l?f(i+1,l,m):m?putchar(10),f(1,l,m>>1):1;}

Ungolfed:

void f(int counter, int length, int mask) {
    putchar((counter&mask) ? ' ' : '#');
    if(counter<length) {
        f(counter+1, length, mask);
    } else if(mask) {
        putchar('\n');
        f(1, length, mask>>1);
    }
}

Şununla test et:

int main() {
    f(1, 32, 1023);
    putchar('\n');
    f(1, 1, 1023);
    putchar('\n');
    f(1, 999, 1023);
    putchar('\n');
}

açıklama

Bir kez daha, özyineleme yinelemeden C'den daha az karakter alır, böylece iki döngü iki özyinelemeli çağrı olarak ifade edilir.

Ayrıca, C, boolean ifadelerle oyun oynuyor bir boş veya koymak isteyip kararını izin verdiği için büyük bir dildir #ifadesi ile ifade edilecek 32+3*!(i&m). Boşluk ASCII değerine 32, #ASCII 35 değerine sahiptir , bu yüzden maskedeki herhangi bir bit ayarlanmışsa boş kalırız i.

Pyth , 15 Bayt

j_.tm*Nhx_.Bd1S

Dene!

açıklama

j_.tm*Nhx_.Bd1S
    m         SQ   # map over the numbers from 0 to the implicit input (lambda variable: d)
          .Bd      # Convert d to a binary string: (12 -> 1100)
         _         # reverse: (1100 -> 0011)
        x    1     # get the location of the first 1 ( 2 )
     *Nh           # make one more than that " quotation marks (""")
 _.t               # transpose the list of quotation mark strings and reverse it
j                  # join on newline

Python 2 , 47 bayt

f=lambda n:n and' '.join(f(n/2))+'\n'+n*'#'or''

Çevrimiçi deneyin!

JavaScript (ES8), 71 bayt

PadStart () fonksiyonu ECMAScript'te 2017 yılında tanıtıldı!

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

console.log(f(+prompt()))

JavaScript (ES6), 77 bayt

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

console.log(f(+prompt()))

Mathematica, 69 bayt

Rotate[Grid["#"~Table~#&/@(IntegerExponent[2*#,2]&/@Range[#])],Pi/2]&

( WESRRMICGSE ): 237 bayt

IF(ROW()<=FLOOR(LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2),1)+2,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2)-ROW()+2),1)-1) &"#",COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),"")

Peki. Splaing zamanı.

Öncelikle, giriş için her birini COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1basitçe değiştirin [i]. belirteç, kendisini içermeyen, formül içeren hücrelerin sayısını sayar ve sonra kendisini içermek üzere bir tane ekler. WESRRMICGSE, verdiğiniz girdilere göre bir formül sürüklediğinden, bu belirteç her zaman girdiyle sonuçlanır.

sahibiz:

IF(ROW()<=FLOOR(LOG([i],2),1)+3,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG([i],2)-ROW()+2),1)-1) &"#",[i]),[i]),"")

Bu çok daha okunur. FLOOR(LOG([i],2),1)Jetonu çok göreceksiniz , bu sadece girdi ( [i]) sayısından daha az olan 2'nin en yakın gücünü almanız anlamına gelir . örneğin: 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. İle değiştireceğimGS[[i]]

IF(ROW()<=GS[[i]]+3,LEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i]),"")

daha iyi. if cümlesini yıkmak, satırın küçük veya eşit olup olmadığını test ediyoruz GS[[i]]+3, çünkü tüm cetvellerin yüksekliği GS [[i]] + 1 değerine eşittir, bu değerin yüksekliğine eşit olan satırları seçer. cetvel. +11 indeksleme satırları +1için ve yine WESRRMICGSE ofseti için.

FALSESonuç boş hücre ( ""), ve gerçek bir sonucu verir verirLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

şu anda hala düzenleme yapıyor, bizi izlemeye devam edin

Haskell , 64 62 bayt

l m=([2..2^m]>>" ")++'#':l m
f n=unlines$take n.l<$>[n,n-1..0]

Çevrimiçi deneyin! Örnek kullanımı: f 10.

k, 33 bayt

`0:|" #"{(1+!x){~y!x}/:(x>)(2*)\1}

Bu sadece AW'nin tercümanında işe yarıyor gibi görünüyor .

OK versiyonunda (çevrimiçi olarak deneyebilirsiniz), çalışması için küçük bir değişiklik gerektiren bir hata var gibi görünüyor:

`0:|" #"{(1+!x){~y!x}/:{x>y}[x](2*)\1}

C #, 174 bayt

Bu yöntemin iki parametresi vardır, cetvel uzunluğu için bir giriş ve cetvel olarak cetvel olan bir çıktı.

golfed:

void R(int n,out string s){var l=new int[++n];int i,x=n,y=0;for(s="";x-->1;)for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y);for(y++;y-->0;s+='\n')for(x=0;++x<n;s+=y<l[x]?'#':' ');}

Girintili'ye:

void R(int n,out string s){                       // Return the result in an out parameter.
    var l=new int[++n];                           // Use a 1-based array.
    int i,x=n,y=0;                                //
    for(s="";x-->1;)                              // For each number x on the ruler
        for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y) // ... find lowest set bit of x, counting the maximum value.
            ;                                     //
    for(y++;y-->0;s+='\n')                        // Count down each line.
        for(x=0;++x<n;s+=y<l[x]?'#':' ')          // Output # for numbers that are tall enough.
            ;                                     //
}

Çevrimiçi deneyin!

Kömür , 27 23 bayt

↶Ｆ…·¹Ｎ«Ｊι⁰#Ｗ¬﹪鲫Ａ÷ι²ι#

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: Geçiş yaparak 4 bayt kaydedildi JumpTo.

J, 38 bayt

3 :'|.|:''#''#~,.(1+|.i.1:)@#:"0>:i.y'

Harika değil. Bayt sayısı kapalıysa, Lmk - Telefonumdayım.

Java (OpenJDK 8) , 91 bayt

n->{int i=10,j;String s="";for(;i-->0;s+="\n")for(j=0;j++<n;)s+=j>>i<<i<j?' ':35;return s;}

Çevrimiçi deneyin!

Ungolfed:

n->{
    int i=10,j; // Since we are allowed extra whitespace, set columns always to 10
    String s = "";
    for(;i-->0;s+="\n")      // Every iteration add a newline, i=9..0
        for(j=0;j++<n;)      // j=1..n+1
            s+= j>>i<<i<j    // if j has less than i trailing 0s in binary form
                ?' '         // add a space else
                :35          // # (java handles ternary return types weirdly)
}

CJam, 34 bayt

ri{2bW%0+0#)}%_'#f*\:e>f{Se]}zW%N*

Meh.

C (gcc) , 70 bayt

f(x,l,n){for(l=512;l/=2;)for(n=0;n++<=x;)putchar(n^x+1?n%l?32:35:10);}

Çevrimiçi deneyin!

Perl 5 , 60 + 1 (-n) = 61 bayt

$n=0|1+(log)/log 2;say(($"x(2**$n-1),X)x($_/2**$n))while$n--

Çevrimiçi deneyin!