Wechselndes Muster

16

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)

*

*#
#*

*##
#**
*##

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

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

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

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

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

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

*#########
########**
***#######
######****
*****#####
#####*****
****######
#######***
**########
#########*
code-golf string ascii-art Kevin Cruijssen
quelle
" Sie können anstelle von * und # zwei beliebige Zeichen verwenden. " - Müssen diese druckbar sein? Können wir NUL und SOH (ASCII-Codes 0 und 1) verwenden?
27.
@ngn Nur druckbare Zeichen. Wird in der Challenge-Beschreibung verdeutlicht.
Kevin Cruijssen

Antworten:

14

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.
Lynn
quelle
17

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.

Lynn
quelle
6

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
Sundar - Setzen Sie Monica wieder ein
quelle
6

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'

ngn
quelle
Aus Neugier. Wie viele Bytes wäre es, einfach die Matrix von Nullen und Einsen ohne Leerzeichen auszugeben? Ich gehe davon aus, ⎕a[...}sie zu konvertieren Aund Bohne Leerzeichen kürzer als sie als zu halten 0und 1ohne Leerzeichen Erwägen Sie , dass verwendet haben, aber nur neugierig , ob es viel Unterschied in Bytes ist , wenn Sie sie halten , wie 0und 1.
Kevin Cruijssen
1
@KevinCruijssen Soweit ich Golf kann, wäre es die gleiche Länge haben - entweder ⎕d[... ]oder ⊃¨⍕¨... In dieser Ausdruck ⍕¨ist „formatiert jeder“ - es jede Zahl in einem verschachtelten char dreht Vektor , also brauchen wir „zuerst jede msgstr "( ⊃¨) um nur Zeichen - Skalare zu erhalten (und daher kein Leerzeichen beim Drucken).
ngn
5

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
Neil
quelle
5

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
Jonathan Allan
quelle
Es sieht so aus, als wäre dies genau mein Algorithmus, aber eine andere Implementierung, die 0s anstelle von 1s ausgibt und umgekehrt.
Erik der Outgolfer
Ja, praktisch dasselbe ... und ich hatte meinen Beitrag nicht aktualisiert, um die Fehlerbehebung anzuzeigen, die ich vorgenommen habe.
Jonathan Allan
4

Gelee , 15 Bytes

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

Probieren Sie es online!

Volles Programm.

*= 1
#=0

Erik der Outgolfer
quelle
4

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
}
OOBalance
quelle
3
Wenn Sie zu Java 11 wechseln, können Sie mit "*".repeat(...)und auf 127 Bytes "#".repeat(...)n-j-1n+~jn->{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;}
golfen
Danke, das ist eine große Einsparung an Bytes. Ich habe es geschafft, eine 145-Byte-Version für Java 10 mit verschachtelten Schleifen zu erstellen. Ich kann es kaum erwarten, Java 11 repeat()herauszubringen. Diese Methode ist wirklich gut zum Golfen.
OOBalance
4

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
Azure Heights
quelle
2
Ich kenne Lua nicht so gut, aber es scheint, dass Sie fünf Bytes sparen können: (n+1)/2bis -~n/2; or n-i+1zu or-~n-i; i%2==0zu i%2<1; und reverse() orzu reverse()or. Außerdem enthalten Ihre TIO-Version und die Anzahl der Bytes ein nachgestelltes Semikolon, das nicht erforderlich zu sein scheint. Gute erste Antwort. +1 von mir. Und willkommen bei PPCG! :)
Kevin Cruijssen
2
Sie brauchen eigentlich nicht jeder des Semikolons. 133 Bytes einschließlich Kevins Vorschläge.
Jo King
@ KevinCruijssen Danke! Könnte ich fragen, was der -~nin Ihren Vorschlägen tut? Es funktioniert definitiv, aber ich verstehe nicht warum.
Azure Heights
1
@ AzureHeights Sicher. ~ist ein unärer bitweiser Negationsoperator. Wichtig für das Codegolfing ist jedoch, dass es ~iden gleichen Wert hat wie -i-1. Wir können daher -~ianstelle von i+1und ~-ianstelle von verwenden i-1. Dies ist in zwei Fällen nützlich, die ich beide in Ihrer Antwort verwenden könnte: Klammern loswerden, weil -und ~Operator Vorrang vor anderen mathematischen Operationen haben, (n+1)/2kann also sein -~n/2. Und der andere nützliche Teil ist, in einigen Fällen Leerzeichen zu entfernen, wie ich es getan habe or-~n-i.
Kevin Cruijssen
1
Hier sind die beiden relevanten Tipps, wenn Sie mehr darüber erfahren~x+1x-1 möchten: Verwenden Sie unary für und und Verwenden Sie unary ~für a-b-1unda+b+1 . Alle allgemeinen Tipps sowie sprachspezifische Tipps ( in diesem Fall Tipps zum Golfen in Lua ) können interessant sein. :)
Kevin Cruijssen
3

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

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

Probieren Sie es online!

Dom Hastings
quelle
3

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 10x-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!

ErikF
quelle
1
Proof of Concept mit Zahlen außerhalb der maximalen nativen Ganzzahlbereiche (mit C # und BigIntegers): Probieren Sie es online aus!
ErikF
3

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=
Algmyr
quelle
2

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'#'
digEmAll
quelle
2

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 "*#"

ngn
quelle