Herausforderung:

Eingabe: Eine positive ganze Zahl $n$

Ausgabe:

Erstellen Sie eine Liste im Bereich und fügen Sie sie zu einer Zeichenfolge zusammen (dh wäre die Zeichenfolge ). $[1,n]$ $n=13$ 12345678910111213

Jetzt geben wir ein Dreieck mit den Präfixen oder Suffixen dieser Zeichenfolge in einer der folgenden vier Ausrichtungen aus, die auf der Ganzzahl der Eingabe basieren:

Wenn $n\equiv 0\pmod 4$ , wird es in der Dreiecksform ◣ ausgegeben
Wenn $n\equiv 1\pmod 4$ , wird es in der Dreiecksform ◤ ausgegeben
Wenn $n\equiv 2\pmod 4$ , wird es in der Dreiecksform ◥ ausgegeben
Wenn $n\equiv 3\pmod 4$ , wird es in der Dreiecksform ◢ ausgegeben

Beispiel:

Eingabe: $n=13$

Da $13\equiv 1\pmod 4$ , ist die Form ◤. Hier drei mögliche gültige Ausgaben:

12345678910111213    11111111111111111    12345678910111213
1234567891011121     2222222222222222     2345678910111213
123456789101112      333333333333333      345678910111213
12345678910111       44444444444444       45678910111213
1234567891011        5555555555555        5678910111213
123456789101         666666666666         678910111213
12345678910          77777777777          78910111213
1234567891           8888888888           8910111213
123456789            999999999            910111213
12345678             11111111             10111213
1234567              0000000              0111213
123456               111111               111213
12345                11111                11213
1234                 1111                 1213
123                  222                  213
12                   11                   13
1                    3                    3

Herausforderungsregeln:

Wie Sie an den drei oben genannten gültigen Ausgaben sehen können, ist nur die richtige Form und die Verwendung aller Ziffern in der richtigen Reihenfolge wichtig. Abgesehen davon können Sie Präfixe oder Suffixe verwenden. kehrt um / reflektiert; Diagonaldruck; usw. usw. Jede der sechs möglichen Ausgaben für jede Form ist zulässig (siehe Testfall unten, um alle gültigen Ausgaben basierend auf der Form anzuzeigen). Auf diese Weise können Sprachen mit integrierten Rotationsfunktionen verwendet werden. Wenn Sie jedoch keine Rotationsfunktionen verwenden, können Sie alternativ die Präfixe in der richtigen Größe von oben nach unten oder die Präfixe für zwei der Formen, aber die Suffixe für die beiden anderen Formen verwenden . Die Auswahl der am besten geeigneten Ausgabeoptionen für Ihre Sprache ist Teil des Golfprozesses. :)
Die Eingabe ist garantiert eine positive Ganzzahl. Für wir einfach aus . $n=1$ 1
Es sind beliebig viele führende / nachfolgende Zeilen / Leerzeichen zulässig, solange das richtige Dreieck (ohne vertikale oder horizontale Begrenzer!) Irgendwo auf dem Bildschirm gedruckt wird.

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 mit Standard-E / A-Regeln. 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 (z. B. TIO ).
Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Eingabe: Alle möglichen gültigen Ausgaben: $n=5$

12345    54321    12345    54321    11111    55555
1234     5432     2345     4321     2222     4444
123      543      345      321      333      333
12       54       45       21       44       22
1        5        5        1        5        1

Eingabe: Alle möglichen Ausgaben: $n=6$

123456    654321    123456    654321    111111    666666
 12345     65432     23456     54321     22222     55555
  1234      6543      3456      4321      3333      4444
   123       654       456       321       444       333
    12        65        56        21        55        22
     1         6         6         1         6         1

Eingabe: Alle möglichen Ausgaben: $n=7$

      1          1          7          7          7          1
     12         21         67         76         66         22
    123        321        567        765        555        333
   1234       4321       4567       7654       4444       4444
  12345      54321      34567      76543      33333      55555
 123456     654321     234567     765432     222222     666666
1234567    7654321    1234567    7654321    1111111    7777777

Eingabe: Alle möglichen Ausgaben: $n=8$

1           1           8           8           8           1
12          21          78          87          77          22
123         321         678         876         666         333
1234        4321        5678        8765        5555        4444
12345       54321       45678       87654       44444       55555
123456      654321      345678      876543      333333      666666
1234567     7654321     2345678     8765432     2222222     7777777
12345678    87654321    12345678    87654321    11111111    88888888

Eingabe: Nur mögliche Ausgabe: $n=1$

Eingabe: Alle möglichen Ausgaben: $n=2$

12    21    12    21    11    22
 1     2     2     1     2     1

— Kevin Cruijssen
quelle

Können wir andere Werte für verschiedene Dreiecke verwenden, wie 1 für ◤ usw.?

— Verkörperung der Ignoranz

@EmbodimentofIgnorance Unglückliches Beispiel, da das ist, was die Spezifikation sagt. Ich denke, Sie wollten fragen, ob wir die Reihenfolge der vier Arrangements ändern können, solange wir sie konsistent halten (ich denke, das wäre ein Nein).

— Erik der Outgolfer

1

Wenn n==13ja, kann die oberste Zeile '33333333333333333'(oder gleichwertig '31211101987654321') sein?

— Chas Brown

@EmbodimentofIgnorance Sorry, aber ich würde in diesem Fall nein sagen. Die Formen und ihre Entsprechung mod 4sind strenge Paare für diese Herausforderung. Sie können also die vier Formen für die vier mod 4Fälle nicht wechseln . Aber trotzdem eine gute Frage.

— Kevin Cruijssen

@ChasBrown Ja, beide sind in Ordnung. Ich habe nur drei mögliche Beispiele für , aber alle sechs Optionen (wie der Testfall ) sind gültige Ausgaben.

n = 13

$n=13$

n = 5

$n=5$

— Kevin Cruijssen

9

JavaScript (ES6), 93 bis 89 Byte

Gibt eine Zeichenmatrix zurück.

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((d,y,a)=>a.map(_=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

Probieren Sie es online!

Alternatives Muster (gleiche Größe):

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((_,y,a)=>a.map(d=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

Probieren Sie es online!

Kommentiert

n =>                 // n = input
  [...               // split the result of ...
    ( g = n =>       //   ... a call to the recursive function g, taking n
      n ?            //     if n is not equal to 0:
        g(n - 1)     //       append the result of a recursive call with n - 1
        + n          //       append n
      :              //     else:
        ''           //       stop recursion and return an empty string
    )(n)             //   initial call to g
  ].map((d, y, a) => // for each digit d at position y in this array a[]:
    a.map(_ =>       //   for each character in a[]:
      y -            //     we test either y < 0 if (n AND 2) is not set
      (n & 2)        //     or -y < 0 (i.e. y > 0) if (n AND 2) is set
      * y-- < 0      //     and we decrement y afterwards
      ?              //     if the above condition is met:
        ' '          //       append a space
      :              //     else:
        d            //       append d
    )                //   end of inner map()
  )                  // end of outer map()
  .sort(_ => -n % 2) // reverse the rows if n is odd

Formzusammenfassung

Nachfolgend finden Sie eine Zusammenfassung der Grundform (generiert durch die verschachtelten mapSchleifen) und der endgültigen Form (nach der sort) für jedes : $n\bmod 4$

 n mod 4  | 0     | 1     | 2     | 3
----------+-------+-------+-------+-------
 n & 2    | 0     | 0     | 2     | 2
----------+-------+-------+-------+-------
 test     | y < 0 | y < 0 | y > 0 | y > 0
----------+-------+-------+-------+-------
 base     | #.... | #.... | ##### | #####
 shape    | ##... | ##... | .#### | .####
          | ###.. | ###.. | ..### | ..###
          | ####. | ####. | ...## | ...##
          | ##### | ##### | ....# | ....#
----------+-------+-------+-------+-------
 n % 2    | 0     | 1     | 0     | 1
----------+-------+-------+-------+-------
 reverse? | no    | yes   | no    | yes
----------+-------+-------+-------+-------
 final    | #.... | ##### | ##### | ....#
 shape    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

— Arnauld
quelle

1

Vielen Dank für Ihr Detail zu erklären.

— Chau Giang

9

Python 2 , 94 Bytes

n=0;s=''
exec"n+=1;s+=`n`;"*input()
K=k=len(s)
while k:k-=1;print s[k^n/-2%-2:].rjust(n%4/2*K)

Probieren Sie es online!

— xnor
quelle

7

Japt , 8 Bytes

Gibt ein Array von Zeilen zurück.

õ ¬å+ zU

Versuch es

2 Bytes gespart dank Kevin .

õ ¬å+ zU     :Implicit input of integer U
õ            :Range [1,U]
  ¬          :Join to a string
   å+        :Cumulatively reduce by concatenation
      zU     :Rotate clockwise by 90 degrees U times

— Zottelig
quelle

1

Ist das únötig? Es scheint, dass die Drehung dies implizit tut?

— Kevin Cruijssen

@ KevinCruijssen, hmm ... so ist es. Das vergesse ich immer; selten zu benutzen bekommen z.

— Shaggy

1

Nun, ich kenne Japt überhaupt nicht. War nur neugierig, wie die Ausgabe ohne die Polsterung zum Spaß aussah, und sah, dass es genauso funktionierte ..;)

— Kevin Cruijssen

4

Canvas , 8 Bytes

ŗ］∑［］⁸［↷

Probieren Sie es hier aus!

— dzaima
quelle

4

Perl 6 , 94 Bytes

{[o](|(&reverse xx$_/2+.5),|(*>>.flip xx$_/2+1))([\~](my@a=[~](1..$_).comb)>>.fmt("%{+@a}s"))}

Probieren Sie es online!

Anonymer Codeblock, der eine Nummer annimmt und eine Liste von Zeilen zurückgibt.

— Scherzen
quelle

3

Kohle , 17 Bytes

Ｎθ≔⭆θ⊕ιηＧLＬηη⟲⊗θ‖

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Eingabe n.

≔⭆θ⊕ιη

Erstellen Sie eine Zeichenfolge , die durch die Nummern verketten 1zu n.

ＧLＬηη

Füllen Sie ein Dreieck dieser Länge mit der Zeichenfolge.

⟲⊗θ

Dreieck um n*90Grad gegen den Uhrzeigersinn drehen.

‖

Reflektieren Sie alles und erhalten Sie ein Dreieck, das um n*90Grad im Uhrzeigersinn gedreht wird .

— Neil
quelle

3

C # (Visual C # Interactive Compiler) , 128 Byte

n=>{var s="";int i=0,j,p;for(;i<n;s+=++i);for(p=j=s.Length;;)Write("{0,"+(n%4>1?p:0)+"}\n",new string(s[--j],-~n%4>1?j+1:p-j));}

Probieren Sie es online!

— Verkörperung der Ignoranz
quelle

3

Ruby , 95 82 79 Bytes

->n{r=(0...z=/$/=~s=[*1..n]*'').map{|i|" "*n[1]*i+s[0,z-i]};-n&2>0?r:r.reverse}

Probieren Sie es online!

3 Bytes gespeichert von G.

— Kirill L.
quelle

3

R , 152 139 137 134 Bytes

function(n,N=nchar(s<-Reduce(paste0,1:n,'')),A=!n%%4%%3)for(i in 1:N)cat(rep('',(M=c(N-i+1,i))[1+!A]*(n%%4>1)),substr(s,1,M[1+A]),'
')

Abgerollter Code:

function(n){
  s = Reduce(paste0,1:n,'')      # concat the digits from 1 to n into a string s

  N = nchar(s)                   # store the length of s

  A = !n%%4%%3                   # A = TRUE if n MOD 4 == 1 or 2 

  for(i in 1:N){                 # for 1 to N (length of s)

    M = c(N-i+1,i)               # store N-i+1 and i into a vector

    nSpaces = M[1+!A]*(n%%4>1)   # if n MOD 4 == 1 or 2 then nSpaces = i else nSpaces = N-i+1, 
                                 # but if n MOD 4 == 0 or 1, then force nSpaces = 0

    nDigits = M[1+A]             # if n MOD 4 == 1 or 2 then nDigits = N-i+1 else nDigits = i

    prfx = rep('',)              # create a character vector repeating '' nSpaces times

    sufx = substr(s,1,M[1+A])    # substring s by taking the first nDigits characters

    cat(pr,su,'\n')              # print prfx and sufx using space as separator for the values 
                                 # contatenation (cat function default) and append a newline
  }

Probieren Sie es online!

— digEmAll
quelle

... es war eindeutig nicht mein Tag zum Golfen.

— Giuseppe

@ Giuseppe: ahah war da ... und dann hast du mich normalerweise überrumpelt: P

— digEmAll

2

APL + WIN, 45 Bytes

Fordert zur Eingabe einer Ganzzahl auf

m←⊃(⍳⍴s)↑¨⊂s←(⍕⍳n←⎕)~' '⋄⍎(' ⊖⍉⌽'[1+4|n]),'m'

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

— Graham
quelle

2

PowerShell , 108 Byte

param($n)0..($y=($x=-join(1..$n)).length-1)|%{' '*(0,0,$_,($z=$y-$_))[$n%4]+-join$x[0..($_,$z,$z,$_)[$n%4]]}

Probieren Sie es online!

Ein bisschen rau an den Rändern, aber funktioniert. Verbindet die Ziffern 1 zu neiner Zeichenfolge und iteriert dann von 0 bis zur Länge dieser Zeichenfolge-1. Jedes Mal wird eine Listenindizierung verwendet, um auf die richtige Abstandsmethode und den richtigen Nummernbereich zu wechseln, die zum Schneiden der neuen Zeichenfolge verwendet werden.

— Veskah
quelle

2

Gelee , 12 Bytes

D€Ẏ;\z⁶U$⁸¡Y

Probieren Sie es online!

— Erik der Outgolfer
quelle

2

05AB1E (Legacy) , 14 12 10 Byte

Aus irgendeinem Grund ist es extrem langsam, die alte Version für das Neuschreiben zu verwenden.

2 Bytes dank Kevin Cruijssen gespeichert

LSηsFRζ}J»

Probieren Sie es online!

Erläuterung

L           # push range [1 ... input]
 S          # split to list of individual digits
  η         # calculate prefixes
   sF  }    # input times do:
     R      # reverse list
      ζ     # and transpose it
        J   # join to list of strings
         »  # and join on newlines

— Emigna
quelle

Sie können 2 Byte zu ändern speichern LJη€Szu LSη, da Simplizit abflacht.

— Kevin Cruijssen

@ KevinCruijssen: Oh ja, danke! Das hatte ich vergessen. Ich habe versucht, €Swas nicht sehr gut

— geklappt hat

2

Stax , 10 Bytes

Ç√çZ╟84Γó║

Führen Sie es aus und debuggen Sie es

— rekursiv
quelle

2

PowerShell , 105 101 95 Byte

-4 Bytes danke Arnauld für den Trick mit Sort .

param($n)($x=1..$n-join'')|% t*y|%{($s+="$_")}|sort -d:($n%4-in1,2)|% *ft($x.Length*($n%4-ge2))

Probieren Sie es online!

Weniger golfen:

param($n)
$x=1..$n-join''
$x|% toCharArray |% {
    ($s+="$_")
} | sort -Descending:($n%4-in1,2) |% PadLeft ($x.Length*($n%4-ge2))

— mazzy
quelle

2

R , 175 172 154 Bytes

function(n)write(c(" ",0:9)[1+(x=utf8ToInt(Reduce(paste0,1:n,""))-47)*!upper.tri(diag(y<-sum(x|1)))["if"(n%%4>1,1:y,y:1),"if"(!n%%4%%3,y:1,1:y)]],1,y,,"")

Probieren Sie es online!

Ein schreckliches Durcheinander!

-3 Bytes durch Ändern der Rotationsbedingung

-17 Bytes dank digEmAlls Vorschlag und ein weiteres Byte nach dem Golfspielen

— Giuseppe
quelle

Ich mag diesen Ansatz des oberen Dreiecks und kann auf 155 Bytes verkürzt werden ... vielleicht sogar mehr, ich bin sicher, ich vermisse etwas Offensichtliches ...

— digEmAll

@digEmAll ah, viel verbessert, aber immer noch lange :-(

— Giuseppe

1

Wolfram Language (Mathematica) , 137 Byte

(t=Table[Table[" ",If[(m=#~Mod~4)>1,Tr[1^s]-k,0]]<>ToString/@s[[;;k]],{k,Length[s=Join@@IntegerDigits/@Range@#]}];If[0<m<3,Reverse@t,t])&

Probieren Sie es online!

— J42161217
quelle

1

Python 2 , 116 Bytes

n=input()
s=''.join(map(str,range(1,n+1)));L=len(s)
p=-~n/2%2;i=~-L*p+1
exec'print s[:i].rjust(n/2%2*L);i+=1-2*p;'*L

Probieren Sie es online!

— Chas Brown
quelle

1

Rot , 155 Bytes

func[n][b: copy""repeat i n[append b i]repeat i l:
length? b[t:[l - i + 1]set[k m]pick[i t[l t][l i]]n % 4 + 1
print pad/left copy/part b do do m do do k]]

Probieren Sie es online!

— Galen Ivanov
quelle

1

Perl 5, 117 Bytes

$p=$_++&2?'/ ':'$/';$s='(.*\d.\n)';$r=$_--&2?$s.'\K$':"^(?=$s)";$_=(join"",1..$_).$/;1while s,$r,'$1=~s/\d'."$p/r",ee

TIO

— Nahuel Fouilleul
quelle

1

PHP ,116 111 109 Bytes

for($m=$l=strlen($s=join(range(1,$n=$argn)));$l--;)printf('%'.($n&2?$m:-$l).'.'.($n-1&2?$m-$l:$l+1)."s
",$s);

Probieren Sie es online!

Mit php -nFEingabe von ausführen STDIN.

$ echo 6|php -nF t.php

— 640 KB
quelle

1

Java (JDK) , 247 209 188 186 160 148 Bytes

i->{String s="";int l=0,w;for(;l<i;s+=++l);for(w=s.length(),l=0;l<w;)System.out.printf("%"+(1>i%4/2?1:w)+"s\n",s.substring(0,1>~-i%4/2?w-l++:++l));}

Probieren Sie es online!

-38 bytesdanke an @KevinCruijssen,
-21 bytesindem ich printfdie Polsterung handhabe.
-2 bytesDurch Ausführen von Teilzeichenfolgen vor dem Ersetzen können wir an leiner Stelle anstatt an zwei inkrementieren .
-26 bytes- Mit printfdem Auffüllen war die Zeichenfolge mit Leerzeichen nicht mehr erforderlich, und die Ziffernfolgen konnten anscheinend kürzer generiert werden.
-12 bytesindem wir nicht mit einzelnen Ziffern herumspielen, anstatt Teilzeichenfolgen der perfekt zu verwendenden Zeichenfolge zu drucken, die wir bereits haben.

Ungolfed

input->{
    // Lambda expression with target type of IntConsumer
    String allDigits = "";
    int lineLength, line = 0;

    // Collect a list of all digits in order.
    for (;line < input; allDigits += ++line) {}

    // Save the max length of a line, and create a string of that many spaces.
    for (lineLength=allDigits.length(), line=0; line < lineLength;) {
        System.out.printf(   "%" // construct a format string to handle the padding
                           + (   1 > input%4/2
                               ? 1 // No padding
                               : w // Yes padding
                             )
                           + "s\n"
                         , allDigits.substring( 0
                                              ,   1 > (i-1)%4/2
                                                ? w - l++
                                                : ++l
                                              ) // A string containing only the digit we want.
                         );
    }
}

— Sara J
quelle

1

Gute Antwort. Es gibt jedoch eine Reihe von Dingen zum Golfen: Die Zwischenräume nach dem for(können entfernt werden. new String(new char[w=s.length()]).replace('\0',' ')kann " ".repeat(w=s.length())Java 11+ verwenden. Sie können die Klammern um die Ternär-Checks entfernen. 1>(i-1)%4/2kann sein 1>~-i%4/2. w-1-l++kann sein w+~l++. Und Sie müssen das abschließende Semikolon nicht in der Byteanzahl zählen. Das alles zusammen ergibt 209 Bytes .

— Kevin Cruijssen

Die stelligen Dreiecke

Herausforderung:

Herausforderungsregeln:

Allgemeine Regeln:

Testfälle:

JavaScript (ES6), 93 bis 89 Byte

Kommentiert

Formzusammenfassung

Python 2 , 94 Bytes

Japt , 8 Bytes

Canvas , 8 Bytes

Perl 6 , 94 Bytes

Kohle , 17 Bytes

C # (Visual C # Interactive Compiler) , 128 Byte

Ruby , 95 82 79 Bytes

R , 152 139 137 134 Bytes

APL + WIN, 45 Bytes

PowerShell , 108 Byte

Gelee , 12 Bytes

05AB1E (Legacy) , 14 12 10 Byte

Stax , 10 Bytes

PowerShell , 105 101 95 Byte

R , 175 172 154 Bytes

Wolfram Language (Mathematica) , 137 Byte

Python 2 , 116 Bytes

Rot , 155 Bytes

Perl 5, 117 Bytes

PHP ,116 111 109 Bytes

Java (JDK) , 247 209 188 186 160 148 Bytes

Ungolfed