In einer nun gelöschten Stapelüberlauf-Frage hat jemand Folgendes gepostet:

Schreiben eines Programms oder der Funktion zum Drucken in alternierenden Muster *und #basierend auf einer vorgegebenen ganzen Zahl n. Einige Beispiele:

Eingabe: n=1
Ausgabe:

*

Eingabe n=5
Ausgabe:

*####
###**
***##
###**
*####

Eingabe: n=8
Ausgabe:

*#######
######**
***#####
####****
****####
#####***
**######
#######*

Da es wie eine ziemlich coole Code-Golf-Herausforderung aussah, ist es hier.

Wie sind diese Muster aufgebaut?

Die erste Zeile beginnt mit einer einzelnen *, gefolgt von der n-1Anzahl der nachfolgenden Zeilen #.
Die zweite Zeile enthält dann zwei Zeilen *mit der n-2Anzahl der führenden Zeilen #.
Die dritte Zeile beginnt mit drei *, gefolgt von einem n-3Nachlauf #.
etc.

Sobald wir die Mitte ( n/2) erreicht haben, zählen wir wieder mit dem Betrag von zurück *, der in den obigen Beispielen zu sehen ist.

HINWEIS: Bei ungeraden Eingaben ist das invertierte Zeilenpaar (also zuerst und zuletzt; zweitens und vorletztes usw.) genau dasselbe. Im n=5Beispiel sind die erste und letzte Zeile *####; Die vorletzte und die vorletzte Zeile sind ###**.
Bei geraden Eingaben wird jedoch das umgekehrte Zeilenpaar umgekehrt. Im n=8Beispiel sind die erste und letzte Zeile *#######und #######*; die vorletzte und die vorletzte Zeile sind ######**und **######; etc.

Herausforderungsregeln:

• Sie können anstelle von und zwei verschiedene druckbare Zeichen verwenden . Sie können und verwenden ; und ; und ; usw. Bitte geben Sie in Ihren Antworten an, was Sie verwendet haben.*#AB37<>
• Sie können davon ausgehen, dass nes sich um eine positive Ganzzahl handelt ( >= 1)
• Sie können eine Liste / ein Array von Zeichenfolgen für jede Zeile oder eine 2D-Zeichenmatrix ausgeben, anstatt sie an STDOUT zu drucken.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle (zuerst n=1durch n=10)

*

*#
#*

*##
#**
*##

*###
##**
**##
###*

*####
###**
***##
###**
*####

*#####
####**
***###
###***
**####
#####*

*######
#####**
***####
###****
***####
#####**
*######

*#######
######**
***#####
####****
****####
#####***
**######
#######*

*########
#######**
***######
#####****
*****####
#####****
***######
#######**
*########

*#########
########**
***#######
######****
*****#####
#####*****
****######
#######***
**########
#########*

Gelee , 9 Bytes

>þµoṚUÐeY

Probieren Sie es online!

Erläuterung

>þ           Create a table of (x>y) over [1…n]×[1…n]:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 0 0 1]
               [0 0 0 0 0]
  µ          Take this array, and...
   oṚ        OR it with its reverse:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 1 1 1]
               [0 1 1 1 1]
    UÐe      Apply U (reverse) to even-indexed rows.
       Y     Join by newlines.

Python 2 , 62 Bytes

lambda n:["%*s"%(i%2*2*n-n,"x"*min(i+1,n-i))for i in range(n)]

Probieren Sie es online!

Gebrauch xund Raum.

Die Zeilen werden folgendermaßen berechnet:

"%-5s" % "x"      == "x    "
"%5s"  % "xx"     == "   xx"
"%-5s" % "xxx"    == "xxx  "
"%5s"  % "xx"     == "   xx"
"%-5s" % "x"      == "x    "

Verwenden Sie den %*sBezeichner, um zwischen nund zu wählen -n.

Perl 6 , 57 Bytes

{map ^$^a: {fmt -$a*(-1)**$_=>\*x($_+1 min$a-$_): "%*s"}}

Probieren Sie es online!

Verwendet die gleiche Methode wie Lynns Python-Antwort . Ausgaben mit *und Leerzeichen.

MATL, 34 31 18 Bytes

:t!>tPY|!"@X@oQ&P!

Probieren Sie es auf MATL Online aus

Verwendet 0 für * und 1 für #. Beyogen auf Lynns Gelee Antwort .

Ältere Antwort, 31 Bytes:

2/tk:wXk:Ph"X@ot~XHh@Gy-hHQ&PY"

Probieren Sie es auf MATL Online aus

Verwendet 1 für * und 0 für #.

         % implicit input, say 5
2/       % divide input number by 2 [2.5]
tk       % make a copy and floor that [2.5, 2]
:        % create range 1 to the floored value [2.5, [1, 2]]
wXk      % bring out the division result and this time ceil it
         %  [[1, 2], 3]
:        % create range 1 to that [[1, 2], [1, 2, 3]]
Ph       % flip the last array and concatenate horizontally 
         %  [[1, 2, 3, 2, 1]]
"        % loop through the array
  X@o    % Is the current loop index odd? 1 for odd, 0 for even
  t~     % duplicate and logical negate that
  XH     % copy that value to clipboard H
  h      % and concatenate the values ([1 0] on odd iterations, [0 1] on even) 
  @      % push current value from array (say 2, then stack is [[0 1], 2)
  G      % push input again
  y-     % subtract current array value from input [[0 1], 2, 3]
  h      % concatenate those two [[0 1], [2, 3]]
  H      % get the stored value from clipboard H (1 for even iterations, 0 for odd) 
  Q      % increment that
  &P     % flip the array in that dimension: in even iterations, this flips
         %   across columns and hence inverts the two values. [[0 1], [3, 2]]
         %   in odd iterations, it's a no-op
  Y"     % run-length decoding - repeat the element from first array the number of times
         %  specified in the second array
         % implicit loop end, implicit output

APL (Dyalog Classic) , 18 Byte

⎕a[↑⊢∘⌽\(⊂>⊢⌊⌽)⍳⎕]

Probieren Sie es online!

Ausgänge ABstatt*#

⎕ ausgewerteter Eingang n

⍳⎕ der Vektor 0 1 ... n-1

⊢⌊⌽min ( ⌊) zwischen sich ( ⊢) und ihrem Rückwärtsgang ( ⌽) - siehe Züge

⊂>⊢⌊⌽Dabei ist der ⍳Vektor als Ganzes ( ⊂) kleiner als jeder seiner ⊢⌊⌽- Rückgabe eines Vektors aus booleschen (0/1) Vektoren

⊢∘⌽\ kehre jeden anderen Vektor um

↑ in eine Matrix mischen

⎕adas englische Alphabet in Großbuchstaben, 'AB...Z'

⎕a[ ]ersetzen 0 1mit'A' 'B'

Holzkohle , 21 Bytes

≔⮌…⁰ＮθＥθ⭆蛧⟦μλ⟧κ⌊⟦κι

Probieren Sie es online! Verwendet 0und 1. Der Link ist eine ausführliche Version des Codes und beinhaltet, §*#welche die Ausgabe in das *und #in der Frage übersetzt. Erläuterung:

    Ｎ                   Input number
  …⁰                    Range from 0
 ⮌                      Reversed
≔    θ                  Assign to `q`
      Ｅθ                Map over reversed range
        ⭆θ              Map over reversed range and join
           §⟦μλ⟧κ       Alternate between range and reversed range column
                 ⌊⟦κι   Minimum of range and reversed range row
          ›             Greater
                        Implicitly print each row on its own line

Jelly ,  12  15 Bytes

+3 Fixing n=1Edge-Case Bug :(

R«Ṛ$‘r⁸ṬUÐe0YE?

Ein vollständiges Programm eine ganze Zahl zu akzeptieren , die die Ausgabe druckt wie im OP unter Verwendung definiert 0und 1für *und #verbunden.

Probieren Sie es online!

Wie?

R«Ṛ$‘r⁸ṬUÐe0YE? - Main Link: integer, n
R               - range -> [1,2,3,4,...,n]
   $            - last two links as a monad:
  Ṛ             -   reverse -> [n,...,4,3,2,1]
 «              -   minimum (vectorises) -> [1,2,3,4,...,4,3,2,1]
    ‘           - increment (vectorises) -> [2,3,4,5,...,5,4,3,2]
      ⁸         - chain's left argument, n
     r          - inclusive range (vectorises) -> [[2,3,...,n],[3,4,...n],[4,5,...n],[5,...n],...,[5,...n],[4,5,...n],[3,4,...n],[2,3,...,n]]
       Ṭ        - untruth (vectorises) -> [[0,1,1,...,1],[0,0,1,1,...,1],[0,0,0,1,...,1],[0,0,0,0,1,...,1],...,[0,0,0,0,1,...,1],[0,0,0,1,...,1],[0,0,1,1,...,1],[0,1,1,...,1]]
         Ðe     - apply to entries with even indices:
        U       -   upend              -> [[0,1,1,...,1],[1,1,...,1],[0,0,0,1,...,1],[1,...,1,0,0,0,0],...]
              ? - if...
             E  - ...condition: all equal? (only true when n=1, where we have [1,1])
           0    - ...then: zero
            Y   - ...else: join with newline characters
                - implicit print

Gelee , 15 Bytes

r1«RR;ṬṖɗ€‘UÐeY

Probieren Sie es online!

Volles Programm.

*= 1
#=0

Java 10, 145 Bytes

n->{var r=new char[n][n];for(int j=0,k;j<n;++j)for(k=0;k<n;)r[j][k]=k++<(j<n/2?j%2<1?j+1:n+~j:j%2>0?j:n-j)?j%2<1?'*':'#':j%2>0?'*':'#';return r;}

All das Ternäre macht es ein bisschen chaotisch, aber es funktioniert gut. Ich habe versucht, die verschachtelte Schleife und verschiedene andere Dinge zu reduzieren, aber sie haben nur die Byteanzahl erhöht. Probieren Sie es hier online aus .

Ungolfed:

n -> { // lambda taking an integer as output and returning a char[][]
    var r = new char[n][n]; // the output array; we make use of Java 10's var here (replace with char[][] for another 4 bytes to make this work in Java 8)
    for(int j = 0, k; j < n; ++j) // iterate over the lines
        for(k = 0; k < n; )       // iterate over the j'th line
            r[j][k] = // set the current character
                      k++ < // determine if we're in the first or second portion of the line:
                            (j < n/2 ? // for the first half of the output:
                                 j%2 < 1  // on even lines ...
                                 ? j + 1  // ... print the first symbol j+1 times ...
                                 : n + ~j // ... on odd lines, print it n-j-1 times.
                             : j%2 > 0 ?  // for the second half of the output, on odd lines ...
                                 j :      // ... print the first symbol j times ...
                                 n - j)   // ... on even lines, print it n-j times.
                      ? j%2 < 1 ? '*' : '#'  // for the first part of the line, use '*' on even lines, '#' otherwise
                      : j%2 > 0 ? '*' : '#'; // for the second part of the line, use '*' on odd lines, '#' otherwise
    return r; // return the completed array
}

Java 8 11, 179 127 Bytes

n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}

Probieren Sie es hier online aus (TIO verfügt noch nicht über Java 11, daher wird eine benutzerdefinierte Methode verwendet, die dieselbe Byteanzahl ergibt wie String#repeat()).

Vielen Dank an Kevin Cruijssen für die unglaublichen 52 Bytes!

Ungolfed:

n -> { // lambda taking an int argument and returning a String
    String r = "", // the output String
           a,      // temporary String containing the '*'s
           b;      // temporary String containing the '#'s
    for(int j = 0; j < n; // loop over the lines
        b = "#".repeat( // repeat the '#' character ...
            j < n/2 ? n + ~j // ... n-j-1 times in the first half of the output ...
            : j), // ... j times in the second half
        r += (j++ % 2 < 1 ? a + b : b + a) + "\n") // assemble the j'th line and append it to the output: on even lines, the '*'s go first; on odd lines, the '#'s go first
        a = "*".repeat( // repeat the '*' character ...
              j < n/2 ? j + 1 // ... j+1 times in the first half of the output ...
              : n - j); // n-j times in the second half
    return r; // return the completed output
}

Lua ,  148  133 Bytes

function(n)t,a,b={},".","#"for i=1,n do r=i<n/2+1 and i or-~n-i s=a:rep(r)..b:rep(n-r)t[i]=i%2<1 and s:reverse()or s end return t end

Probieren Sie es online!

-15 Bytes dank @KevinCruijssen und @JoKing.

function(n)
   t = {}; a = "."; b = "#"          -- initialize variables, output is in table
                                     -- strings are needed in variables for
                                     --   the str:rep and str:reverse syntax

   for i = 1, n do                          -- build the rows of the table
      r = i<=(n+1)/2 and i or n-i+1         -- logic used to count up then down
      str = a:rep(r)..b:rep(n-r)            -- append correct number of '.'s, fill
                                            --   in the rest with '#'s
      t[i]=i%2==0 and str:reverse() or str  -- logic used to control reversing
   end
   return t                                 -- return table
end

Kotlin , 86 Bytes

{n:Int->for(i in 0..n)println("%${i%2*2*n-n}s".format("x".repeat(Math.min(i+1,n-i))))}

Probieren Sie es online!

Verwendet xund Leerzeichen als Ausgabesymbole. Derivate von Lynn Answer

Perl 5+ -pa -MPOSIX -M5.010, 58 Bytes

say+sort{$|--}1x abs,2x("@F"-abs)for(1..ceil$_/=2),-$_..-1

Probieren Sie es online!

C (GCC) , 104 99 Bytes

h,j,k;f(i){char s[h=i++];for(j=0;k=++j>i/2?i-j:j,j<i;memset(memset(s,42,h)+j%2*k,35,h-k),puts(s));}

Probieren Sie es online!

C (GCC) , 118 108 Bytes

Dieser wird nicht gewinnen, aber es ist ein anderer Ansatz (oder zumindest glaube ich das!) Anstatt Saitenmanipulationen durchzuführen, nutze ich die Tatsache, dass $10^x-1$ Über $[1..n] = \{9, 99, 999, ...\}$, die dann multipliziert werden können, um das entsprechende Muster zu erhalten; printf()Dann erfolgt das Auffüllen mit Nullen zur Rechtfertigung.

Leider intreicht der Bereich nur für bis zu 9 Stellen (auf 32-Bit-Plattformen), sodass Sie zu gehen müssenlong größere Muster verwenden müssen. Eine Sprache, die MP-Arithmetik von Haus aus beherrscht, könnte dies für etwas verwenden.

Danke an ceilingcat für den Vorschlag.

h,j,k;p(h){h=h?10*p(--h):1;}f(i){for(j=0,h=i++;k=++j>i/2?i-j:j,j<i;printf("%0*d\n",h,~-p(k)*p(j%2*(h-k))));}

Probieren Sie es online!

Beweis des Konzepts, dass dies mit MP-Arithmetik funktioniert:

C # (Mono C # -Compiler) , 187 Byte

(143 Bytes + 22 Bytes für das using System.Numerics;im Header)

q=>{var r="";for(int j=0,h=q+1,k;j<q;r+=((BigInteger.Pow(10,k)-1)*BigInteger.Pow(10,j%2*(q-k))).ToString("D"+q)+"\n")k=++j>h/2?h-j:j;return r;}

Probieren Sie es online!

Vim, 99 Tastenanschläge

Es ist immer interessant, mit Eingabeargumenten zu experimentieren. Es ist sehr unnatürlich, also wird es nicht erstaunlich kurz sein. Hierfür gibt es wahrscheinlich andere gute Ansätze.

Es wird davon ausgegangen, dass sich die Eingabe in einem Puffer befindet. Es wird angenommen, dass die Register leer sind. Es wird davon ausgegangen, dass der Editor groß genug ist, um das Ergebnis ohne Scrollen aufzunehmen (dies könnte technisch auf Kosten einiger Tastenanschläge vermieden werden).

"nD@ni<cr><esc>MmaGddM
<c-v>'aI*<esc>qwgvjokoI*<esc>@wq@w<esc>
:set ve=all<cr>@nlh<c-v>@nkr#
:%s/ /#/g<cr>o<esc>
2Gqqdt#$p2j0@qq@q

Erläuterung

 | Buffer state (odd and even case):
 | 5                    6

"nD              read input into register n
@ni<cr><esc>     add n newlines
MmaGddM<c-v>'a   visual block select center row(s)
I*<esc>          prepend a column of *
qw               record macro w
  gvjoko         expand selection up and down
  I*<esc>
  @w             recurse
q
@w<esc>          run macro w and exit visual block select

 | Buffer state:
 | *                    *
 | **                   **
 | ***                  ***
 | **                   ***
 | *                    **
 |                      *

:set ve=all<cr>  move anywhere!
@nlh<c-v>@nkr#   add last column of #s

 | Buffer state:
 | *   #                *    #
 | **  #                **   #
 | *** #                ***  #
 | **  #                ***  #
 | *   #                **   #
 |                      *    #

:%s/ /#/g<cr>      replace spaces with #

 | Buffer state:
 | *####                *#####
 | **###                **####
 | ***##                ***###
 | **###                ***###
 | *####                **####
 |                      *#####

o<esc>2G           prep and jump to line 2
qqdt#$p2j0@qq@q    (effectively) flip every other onward

 | Buffer state:
 | *####                *#####
 | ###**                ####**
 | ***##                ***###
 | ###**                ###***
 | *####                **####
 |                      #####*

Und in base64 mit tatsächlichen Zeichen (Eingabe inputund Tastenanschläge eingeben keysund mit ausführen vim -u NONE -s keys input)

Im5EQG5pDRtNbWFHZGRNFidhSSobcXdndmpva29JKhtAd3FAdxs6c2V0IHZlPWFsbA1AbmxoFkBua3IjOiVzLyAvIy9nDW8bMkdxcWR0IyRwMmowQHFxQHE=

R , 75 Bytes

function(n)outer(1:n,1:n,function(x,y,a=x<y|x>n-y+1)+ifelse(x%%2,a,rev(a)))

Probieren Sie es online!

• Inspiriert von @Lynn Antwort
• Funktion, die nals Parameter abruft und eine Matrix zurückgibt, in der steht, 0/1wo 0entspricht '*'und 1was entspricht'#'

K (ngn / k) , 22 Bytes

{"*#"i|:/'i>/:i&|i:!x}

Probieren Sie es online!

{ } Funktion mit Argument x

!xdie Liste (0;1;...;x-1)

i: zuweisen i

i&|iMinima ( &) von iund sein Gegenteil ( |)

i>/:Vergleiche mit größer als ( >) imit jedem Element aus der Liste auf der rechten Seite ( /:) - gib eine boolesche Matrix zurück (Liste der Listen)

i|:/'kehren Sie für jedes ( ') j in i( |:- wir müssen :erzwingen |, dass es unär ist) das entsprechende Element j mal um ( n f/ xgilt f nmal für x). Tauschen Sie effektiv jede zweite Reihe aus.

"*#" Verwenden Sie Matrixelemente als Indizes in der Zeichenfolge "*#"