Problem

Inspiriert von einer vorherigen Herausforderung ähnlich , etwas zu tun

Bei einer positiven Ganzzahleingabe nwird eine Form ausgegeben, die diesem Muster folgt:

Eingabe n=1:

* *
 *
* *

Eingabe n=2:

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

Eingabe n=3:

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

und so weiter...

Es hat diese Eigenschaften:

n*2+1 Linien groß

Die "Arme" sind nweit, außer wenn sie sich vereinigen

Die Mittellinie ist nbreit

Wenn nja, sind die Linien über und unter der Mitte n*2breit

Wenn nungerade ist, sind die Linien über und unter der Mitte n*2-1breit

Regeln

• Abschließende Zeilenumbrüche akzeptiert
• Es gelten Standardlücken
• Kürzeste Bytes gewinnen
• Die Ausgabe kann ein Ausdruck oder eine Zeichenfolge oder ein Array von Zeichenfolgen sein

Bearbeitungen

• n=0 muss nicht behandelt werden
• Leerzeichen erlaubt

Kohle , 13 12 Bytes

Vielen Dank an @ErikTheOutgolfer für ein Byte

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

Probieren Sie es online!

Dies ist meine erste Antwort auf Charcoal, und ich bin mir ziemlich sicher, dass es nicht so gut ist, wie es sein könnte, aber ich dachte, ich würde irgendwo anfangen.

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

MATL , 16 Bytes

EQXyG:Y+tP+g42*c

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 2als Beispiel. Stapelinhalte werden mit neueren unten gezeigt.

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: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Gelee , 15 Bytes

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

Probieren Sie es online!

V , 18 17 Bytes

Dank des @ DJMcMayhem-Eingabeticks wurde ein Byte gespeichert.

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

Probieren Sie es online!

Erläuterung

Àé*ÄJÀäl

Dies fügt ein [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

Jede Iteration der Schleife, aus der der Puffer stammt

|**   ***

Zu

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

Wo |ist der Cursor mit einem *darunter?

05AB1E , 18 Bytes

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

Probieren Sie es online!

Erläuterung

Beispiel für 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 Bytes

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

Probieren Sie es online!

Hexdump:

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

Aus irgendeinem Grund ist diese Herausforderung in V bedeutend schwieriger als in der letzten. Wachsen Sie seit unserem allgemeinen Ansatz von n-mal ein 'x' hier nicht funktioniert, konstruieren wir stattdessen die Oberseite des X, kopieren es und spiegeln es und fügen dann die beiden Teile zusammen.

Erläuterung:

Àé*Ä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.

Indem Sie den Einzug am Ende der Schleife ausführen, können Sie implizite Endungen nutzen . Auf diese Weise werden bequemerweise auch n + 1 Linien erstellt, dh genau die obere Hälfte des 'X'. Angenommen, die Eingabe war 4. An diesem Punkt sieht der Puffer folgendermaßen aus:

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

Und wir sind in der letzten Zeile. Also dann wir:

                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 #, 139 130 115 Bytes

-1 Byte durch Erstellen einer Zeichenfolge und Aufrufen WriteLine , wodurch die Prüfung für die neue Zeile gespeichert wird.
-6 Bytes dank Kevin und seinen meisterlichen Golftechniken!
-2 Bytes durch Ersetzenn*3-n durch n*2.
-15 Bytes, nachdem Kevin mich freundlich in die richtige Richtung geleitet hat: Ich kann die Zeichenfolge einfach zurückgeben, anstatt sie zu drucken, und so den Aufruf von speichern System.Console.WriteLine(). Und noch ein paar andere Tipps ...

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

Probieren Sie es online!

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

Es iteriert nur entlang der Zeilen und Spalten des Platzes, der zum Drucken des großen X benötigt wird, und druckt entweder a '*'' ' je nach Bedingung oder a .

Haskell , 88 87 86 Bytes

-1 danke an @Laikoni

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

Probieren Sie es online!

Jelly , 24 23 16 Bytes

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

Probieren Sie es online!

MATLAB, 153 126 Bytes (17,6% ↓)

Dank des Kommentars von @ LuisMendo kann die Funktion disp()Zeichen ohne einfache Anführungszeichen ausgeben, so dass ich die Verwendung von fprintfwith verhindern formatsund einige Bytes weglassen konnte. Außerdem erinnert mich sein Kommentar daran, dass ich char(32)ein Leerzeichen anstelle von char(0)(null) verwenden muss.

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

Probieren Sie es online!

MATLAB, 153 Bytes

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

Ergebnisbeispiel: n = 10

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

Python 2 , 93 90 89 83 Bytes

^{-3 Bytes dank Leaky Nun
-1 Bytes dank Zachary T
-6 Bytes dank xnor}

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

[Online testen!] [TIO-j3xwsktf]

Beginnt mit einer Zeichenfolge wie '*** 'für n=3. Wenden Sie diese map/maxan, um die *Leerzeichen für jede Position auszuwählen. Fügen Sie dann ein Leerzeichen hinzu, entfernen Sie das letzte Zeichen aus der Zeichenfolge und wiederholen Sie den Vorgang.

Haskell , 70 Bytes

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

Probieren Sie es online!

Gibt eine Liste von Zeichenfolgen aus.

Verwendet für jede Position von Zeile r, Spalte ceine Formel, um zu bestimmen, ob sie in eines der beiden diagonalen Bänder fällt und so ist *.

Java 8, 119 118 Bytes

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

Hafen von @CarlosAlejo 's erstaunlicher C # Antwort , nachdem ich ihm geholfen hatte, ein paar Dinge zu spielen. Also stelle sicher, dass du ihn auch positiv bewertest!

Probieren Sie es hier aus.

Javascript (ES2017), 155 157 Bytes

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

Gibt ein Array von Zeichenfolgen zurück. Ich führe Operationen an Arrays durch und spiegele sie dann. Dies könnte wahrscheinlich mit Matrizen wie den anderen Antworten optimiert werden, aber ich wollte einzigartig sein.

Bearbeiten: Wie Neil betonte n, war die Mittellinie für gerade Werte von nicht nbreit, daher habe ich einen Modul hinzugefügt, um gerade / ungerade beim Schneiden der Spalte zu erkennen.

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
}

Quadrant

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

Horizontal gespiegelt

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

Vertikal gespiegelt

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

Mathematica, 148 Bytes

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 Bytes

Code:

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)

Prüfung:

> 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 Bytes

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

Dies ist ein Block, der eine Zahl aus dem Stapel entnimmt und eine Liste von Zeilen an den Stapel ausgibt.

Erläuterung:

{                        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 Bytes

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)

Dieses Programm unterteilt jede Zeile in 4 Teile, erste Leerzeichen, erste Sterne, zweite Leerzeichen und dann zweite Sterne. Für jede horizontale Linie des X wird berechnet, wie viele Sterne oder Leerzeichen für jeden der 4 Abschnitte der Linie benötigt werden. Anschließend wird diese Zeichenfolge konstruiert und gedruckt.

Netzhaut , 144 Bytes

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

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

Probieren Sie es online! Erläuterung:

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

Fügen Sie 2n + 1 Leerzeichen vor dem Eingabewert hinzu (eines für jede Ausgabezeile).

$`#$'¶

Ersetzen Sie jedes Leerzeichen mit einem #und sammeln Sie die Ergebnisse. Dies ergibt eine diagonale Linie von #s, wobei der Eingabewert durch ein Suffix ergänzt wird.

¶\d+$

Löschen Sie den ursprünglichen Eingabewert, da wir jetzt in jeder Zeile eine Kopie haben.

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

Bauen Sie zwei diagonale Linien von n *s auf, wobei eine Trennsäule aus nLeerzeichen in ein Paar von #s eingeschlossen ist.

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

*Vertauschen Sie die beiden Hälften an den Linien, an denen sich das s näher an der Mitte befindet. Dies ergibt ein ähnliches Erscheinungsbild > | | <.

+` (# +#)
$1 

Bewegen Sie die | |s so weit wie möglich nach links, um ein >> > <Erscheinungsbild zu erhalten.

+` #...
#

#Löschen Sie für jedes Leerzeichen zwischen den Zeichen die folgenden drei Zeichen. Dies verbindet die > <in eine X.

##

Löschen Sie die jetzt nicht mehr benötigten #s.