Sorun

Benzer bir şey yapmak için önceki bir meydan okuma

Pozitif tamsayı giriş nçıktısı verildiğinde bu kalıbı izleyen bir şekil verilir:

girdi n=1:

* *
 *
* *

girdi n=2:

**  **
 ****
  **
 ****
**  **

girdi n=3:

***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***

ve bunun gibi...

Şu özelliklere sahiptir:

n*2+1 uzun çizgiler

"kollar" nbirleştikleri zaman geniş

merkez hattı ngeniş

eğer nhatta hatları üzerinde ve merkezinde altındadır olan n*2geniş

Eğer ntek, yukarıda ve merkezi aşağıdaki hatları n*2-1geniş

kurallar

• Sondaki yeni satırlar kabul edildi
• Standart boşluklar geçerlidir
• En kısa bayt kazanma
• Çıktı yazdırılabilir veya bir dize veya dize dizisi olabilir

Düzenlemeler

• n=0 ele alınması gerekmez
• İzin verilen sondaki boşluklar

Kömür , 13 12 bayt

@ErikTheOutgolfer'a bir bayt için teşekkürler

ＦＮ«ＰX⁺*×*Ｉθ→

Çevrimiçi deneyin!

Bu benim ilk Kömür cevabım ve eminim o kadar iyi golf değil, ama bir yerden başlayacağını düşündüm.

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

MATL , 16 bayt

EQXyG:Y+tP+g42*c

Çevrimiçi deneyin!

açıklama

Girişi 2örnek olarak ele alalım. Yığın içeriği aşağıda daha yeni olanlarla gösterilir.

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Jöle , 15 bayt

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

Çevrimiçi deneyin!

V , 18 17 bayt

@ DJMcMayhem'in giriş numarası sayesinde bir bayt kaydetti.

Àé*ÄJÀälÀñ2ÙÀl2x>

Çevrimiçi deneyin!

açıklama

Àé*ÄJÀäl

Bu ekler [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

Tamponun gittiği her döngü yinelemesi

|**   ***

için

***   ***
 |** ***
***   ***

Altında |bir imleç nerede*

05AB1E , 18 bayt

Å4bS{I·ƒDÂ~„ *èJ,À

Çevrimiçi deneyin!

açıklama

İçin örnek n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

V , 23 bayt

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

Çevrimiçi deneyin!

HexDump:

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

Her ne sebeple olursa olsun, bu zorluk V'de sonuncudan önemli ölçüde daha zordur. Genel olarak n kez yaklaşımımız olduğundan , 'x' büyümek burada işe yaramayacak, bunun yerine X'in tepesini inşa edeceğiz, kopyalayıp çevireceğiz, sonra iki parçayı birbirine ekleyeceğiz.

Açıklama:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

En girinti yaparak sonunda döngü, bize sağlayan örtülü sonlar yararlanmak . Bu aynı zamanda 'X'in tam olarak üst yarısı olan n + 1 çizgilerini de oluşturur . Diyelim ki girdi 4 idi. Sonra bu noktada tampon şöyle görünür:

****    ****
 ****  ****
  ********
   ******
    ****

Ve biz son sıradayız. O zaman biz:

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

C #, 139130115 bayt

-1 bayt bir dize oluşturarak ve çağırarak WriteLineyeni satırın çekini kaydederek.
Kevin ve usta golf teknikleri sayesinde -6 bayt!
-2 değiştirerek bayt n*3-nile n*2.
-15 bayt Kevin beni doğru yönde işaret ettikten sonra: Sadece dize yazdırmak yerine geri dönebilir, böylece çağrıyı kaydedebilirim System.Console.WriteLine(). Ve diğer bazı ipuçları da ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

Çevrimiçi deneyin!

Ungolfed:

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

Sadece büyük X'i yazdırmak için gereken alanın satırları ve sütunları boyunca yinelenir ve duruma bağlı olarak a '*'veya a ' 'olarak yazdırılır .

Haskell , 88 87 86 bayt

@Laikoni sayesinde -1

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

Çevrimiçi deneyin!

Jöle , 24 23 16 bayt

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

Çevrimiçi deneyin!

MATLAB, 153126 bayt (% 17.6 ↓)

@ LuisMendo'nun yorumu sayesinde, işlev disp()tek tırnak işaretleri olmadan karakter çıktısı alabilir, böylece birkaç bayt fprintfile kullanmayı engelleyebilir formatsve atlayabilirim. Ayrıca, yorumu bana (boş) char(32)yerine boşluk sunmak için kullanmam gerektiğini hatırlatıyor char(0).

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

Çevrimiçi deneyin!

MATLAB, 153 bayt

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

Sonuç örneği: n = 10

**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

Python 2 , 93 90 89 83 bayt

^{Leaky Nun
-1 -3 byte sayesinde Zachary T -6 byte xnor sayesinde -3 byte}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[Çevrimiçi deneyin!] [TIO-j3xwsktf]

Böyle bir dize ile başlar '*** 'için n=3başvuran, map/maxalmaya *, sonra her pozisyon için boşluklar üzerinde bir boşluk eklemek ve ipten son karakterini kaldırmak ve tüm tekrar yapmak.

Haskell , 70 bayt

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

Çevrimiçi deneyin!

Dizelerin bir listesini çıkarır.

Her satır konumu için rsütun c, iki çapraz banttan birine düşüp düşmediğini belirlemek için bir formül kullanır *.

Java 8, 119118 bayt

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

Port @CarlosAlejo'nun inanılmaz C # cevabından , ona birkaç şey golf yardımcı oldu. Bu yüzden onu da onayladığınızdan emin olun!

Burada deneyin.

JavaScript (ES2017), 155 157 bayt

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

Bir dizgi dizisi döndürür. Diziler üzerinde işlemler yaparım, sonra aynalar. Bu muhtemelen diğer cevaplar gibi matrislerle optimize edilebilir, ancak benzersiz olmak istedim.

Düzenleme: Neil tarafından işaret edildiği gibi, hatta değerleri için n, merkez hattı ngeniş değildi , bu yüzden sütun dilimleme sırasında çift / tek tespit etmek için bir modül ekledim.

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

Ungolfed

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

çeyrek daire

n=5
   *****
  ***** 
 *****  
*****   
****    
***     

Yatay Yansıtılmış

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     

Dikey Olarak Aynalı

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

Mathematica, 148 bayt

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

R, 102 bayt

Kod:

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

Ölçek:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

CJam, 24 bayt

{:T2*){S*T'**+}%_W%..e>}

Bu, yığından bir sayı alan ve yığına bir satır listesi veren bir bloktur.

Açıklama:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

Python 2 , 110 bayt

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

Bu program her satırı 4 parçaya böler, ilk boşluklar, ilk yıldızlar, ikinci boşluklar ve sonra ikinci yıldızlar. X'in her yatay çizgisi için, çizginin 4 bölümünün her biri için kaç yıldız veya boşluk gerektiğini hesaplar, ardından bu dizeyi oluşturur ve yazdırır.

Retina , 144 bayt

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

Çevrimiçi deneyin! Açıklama:

.+
 $&$* $&$* $&

Giriş değerinin önüne 2n + 1 boşluk ekleyin (her çıkış satırı için bir tane).

$`#$'¶

Her alanı a ile değiştirin #ve sonuçları toplayın. Bu #, giriş değeri eklenmiş olarak her iki tarafta da boşluk olan çapraz bir s satırı verir .

¶\d+$

Artık her satırda bir kopyamız olduğu için orijinal giriş değerini silin.

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

Bir çiftin içine sarılmış boşlukların *ayırıcı sütunu ile iki s n çapraz çizgisi noluşturun# s .

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

*S'nin ortaya daha yakın olduğu satırlarda , iki yarıyı değiştirin. Bu, benzeyen bir görünüm verir> | | < .

+` (# +#)
$1 

Leri | |gidecekleri kadar sola hareket ettirin,>> > < görünüm verin.

+` #...
#

#S arasındaki her boşluk için aşağıdaki üç karakteri silin. Bu > <birX .

##

Şimdi gereksiz olanları silin #.