Inspiriert von der fehlerhaften Ausgabe in @Carcigenicates Clojure-Antwort für die Herausforderung " Diesen Diamanten drucken " .

Drucken Sie genau diesen Text aus:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(Von der Mitte nach außen in beide Richtungen wird jede Ziffer durch ein Leerzeichen mehr als in der vorherigen Zeile getrennt.)

Herausforderungsregeln:

• Es wird keine Eingabe ( oder eine leere unbenutzte Eingabe ) geben.
• Nachgestellte Leerzeichen sind optional.
• Eine einzelne nachgestellte neue Zeile ist optional.
• Führende Leerzeichen oder Zeilenumbrüche sind nicht zulässig.
• Die Rückgabe eines String-Arrays ist nicht erlaubt. Sie sollten entweder den Text ausgeben oder eine Funktion haben, die eine einzelne Zeichenfolge mit korrektem Ergebnis zurückgibt.

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.
• Fügen Sie ggf. auch eine Erklärung hinzu.

SOGL V0.12 , 12 Bytes

9{SUē↕∑}¹№╬«

Probieren Sie es hier aus! Erläuterung:

9{     }      9 times do
  SU            push "1234567890"
    ē           push e, predefined with the input, which defaults to 0, and then increase it
     ↕          get that many spaces
      ∑         join the string of digits with those spaces
        ¹     collect the results in an array
         №    reverse the array vertically
          ή  palindromize vertically with 1 overlap

Python 2 , 59 57 56 55 Bytes

i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17

Probieren Sie es online!

@Leaky Nun half beim Golfen, @Praind schlug eine Methode zum Speichern von 1 Byte vor, an die ich früher gedacht hatte, die ich jedoch vergessen hatte, @CotyJohnathanSaxman zu bearbeiten, und schlug vor, die Schleife zu ändern.

Erläuterung

• i=8- Weist den Wert 8einer aufgerufenen Variablen zu i.

• exec"..."*17- Führen Sie diesen Codeblock ( ...) 17 Mal aus.

• print(...) - Das Ergebnis ausgeben.

• ' '*abs(i)- Erstellen Sie eine Zeichenfolge mit einem Leerzeichen, das mehrmals |i|verwendet wird.

• .join('1234567890')- Verschachteln Sie den oben erstellten String mit 1234567890, sodass |i|zwischen den Ziffern Leerzeichen eingefügt werden.

• i-=1- Dekrementiere iund führe es 17 Mal aus, um ein sich -8wiederholendes Muster mit Hilfe von zu erzeugen abs().

Vim, 35 Bytes:

i1234567890<esc>qqYP:s/\d/& /g
YGp{q7@q

Erläuterung:

i1234567890<esc>    " insert '1234567890'
qq                  " Record the following into register 'q'
  Y                 "   Yank a line
   P                "   Paste it above us
    :s/\d/& /g      "   Put a space after each number
Y                   "   Yank this line
 G                  "   Move the end of the buffer
  p                 "   Paste the line
   {                "   Move the beginning of the buffer
    q               " Stop recording
     7@q            " Call macro 'q' 7 times

05AB1E ,  14  13 Bytes

17F9ÝÀN8αð×ý,

Probieren Sie es online!

Erläuterung

17F            # for N in [0 ... 16] do
   9Ý          # push [0 ... 9]
     À         # rotate left
      N8α      # compute the absolute difference between N and 8
         ð×    # push that many spaces
           ý   # merge the list of digits with the space string as separator
            ,  # print

C64 ASM, 358 Bytes (102 Bytes mit Basicstub kompiliert)

Dies ist der nächste Punkt, den ich aufgrund offensichtlicher Einschränkungen erreichen könnte:

jsr $E544
lda #9
sta $FD
nl1: jsr dl
jsr il
dec $FD
bne nl1
inc $FD
nl2: ldy $FD
cpy #9
bne nt1
bl: jmp bl
nt1: iny
sty $FD
jsr dl
jsr il
jmp nl2
dl: clc
ldx #$31
ldy #0
lp: txa
sm: sta $0400, y
inx
cpx #$31
bne c1
rts
c1: cpx #$3A
bne nt2
ldx #$30
clc
nt2: tya
adc $FD
cmp #40
bcc c2
rts
c2: tay
jmp lp
il: lda sm+1
adc #39
bcc nc
inc sm+2
nc: sta sm+1
rts

(Könnte wahrscheinlich einiges optimiert werden)

TSQL, 220 148 Bytes

Von ZLK gepostete Verbesserung:

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+'
'FROM sys.objects PRINT @

Ausgabe:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

APL (Dyalog) , 22 Bytes

↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D

Probieren Sie es online!

⎕D D igits von null bis neun

1⌽ einen Schritt nach rechts drehen (Null am Ende setzen)

⊂ beifügen (als Einheit behandeln)

(... nimm )↑¨¨ für jede dieser Zahlen so viele Zeichen aus jedem Buchstaben:

 ⍳17 eins bis siebzehn

 ¯9+ subtrahieren neun

 | finde die absoluten Werte

 1+ füge eins hinzu

∊¨ tragen Sie sich jeweils ein

↑ verwandle eine Ebene der Tiefe in eine Ebene des Ranges (matrify)

Haskell , 58-55 Bytes

unlines["1234567890">>=(:(' '<$[1..abs n]))|n<-[-8..8]]

Probieren Sie es online!

Dies ist im Grunde @nimis Lösung :)

Java 11 (JDK) , 98 Byte

o->{for(int i=-9;++i<9;)System.out.println("".join(" ".repeat(i<0?-i:i),"1234567890".split("")));}

Probieren Sie es online!

• -14 Bytes durch Umschalten auf JDK 11, das jetzt eine native hat String::repeat.

Vorherige Antwort ( Java (OpenJDK 8) ), 113 112 Bytes

o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}

Probieren Sie es online!

Erklärungen

Ich konstruiere im Grunde die folgenden String17 Male ( Nist eine Variable, kein tatsächlicher Wert):

"1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n"

Es ist alle erwarteten Ziffern, zusammen mit %1$Nsdenen Ndie Anzahl der Räume zwischen den einzelnen Ziffern.

%1$Nsbedeutet im Grunde "nimm das erste Argument und fülle es auf, bis die Länge mindestens N". Auch %1$0swird nicht unterstützt so ein Sonderfall %1$swird für 0.

Schließlich formatiere ich diesen String mit einem einzigen Argument "":, damit der Formatierer immer denselben leeren String wiederverwendet und ihn nach Bedarf mit Leerzeichen auffüllt.

Speichert

• 1 Byte danke an Kevin Cruijssen

Japt -R , 19 18 16 14 13 Bytes

Aõ%A
£qYçÃÔÅê

Testen Sie es oder versuchen Sie es online

Erläuterung

A             :10
 õ           :Range [1,10]
  %A         :Modulo each by 10
\n           :Assign to variable U
£            :Map each element at 0-based index Y
 q           :  Join U with
  Yç         :   Space repeated Y times
    Ã        :End map
     Ô       :Reverse
      Å      :Slice off first element
       ê     :Mirror
             :Implicitly join with newlines and output

JavaScript (ES2017), 83 73 72 68 Byte

Danke Shaggy für das Speichern von 10 Bytes. Vielen Dank an Craig für das Speichern von 1 Byte. Dank Bögen für das Speichern von 4 Bytes.

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

console.log(a);

.as-console-wrapper { max-height: 100% !important; top: 0; }
.as-console-row:after { display: none !important; }

Brachylog , 30 29 28 Bytes

Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ

Probieren Sie es online!

1 Byte dank Leaky Nun gespeichert .

Erläuterung

Ị↺                               The string "1234567890"
  {               }ᶠ⁹            Find the first 9 outputs of:
   ∧≜                              Take an integer
       ;Ṣj₍                        Juxtapose " " that number of times
           g;?↔z                   Zip that string of spaces with "1234567890"
                cc                 Concatenate twice into one string
                    ↔            Reverse the resuling list
                     ;XcP↔P      Palindromize the list (concatenate X to it into the list P,
                                   P reversed is still P)
                           ẉᵐ    Map writeln

Kohle , 18 Bytes

Ｆ⁹⪫⁺…Ｉ¹:⟦0¶⟧× ι‖Ｂ↑

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

Ｆ⁹      Repeat 9 times (i = loop variable)
  ⪫       Join
   ⁺       Concatentate
    …Ｉ¹:    All the characters from str(1) below ":" (i.e. to "9") as a list
    ⟦0¶⟧    A list whose element is the string "0\n"
   × ι     With i spaces
‖Ｂ↑     Reflect everything upwards but without duplicating the top line

Hinweis: Nimmt Cast(1)die gleiche Anzahl von Bytes an, da "1"zuvor ein Trennzeichen erforderlich wäre ":"(was der Deverbosifier dann nicht einfügen kann).

R , 108 Bytes

for(i in abs(-8:8))cat(paste0(el(strsplit("1234567890","")),paste(rep(" ",i),collapse=""),collapse=""),"\n")

Einfach die Saiten einfügen und zusammenfalten.

Probieren Sie es online!

Edit: danke für Challenger5 für den Hinweis auf ein Problem. Behebt es jetzt.

Edit 2: Speichert ein Byte dank Bouncyball.

Python 3 , 58 57 54 Bytes

i=8
while i+9:print(*'1234567890',sep=' '*abs(i));i-=1

Probieren Sie es online!

(danke an @flornquake für die letzten drei Bytes; ich habe komplett vergessen mit sepzu speichern vs. .join)

Pyth , 14 13 Bytes

1 Byte dank Mnemonic.

V17j*da8NeMST

Probieren Sie es online!

Java 8, 235 234 206 163 Bytes

interface A{static void main(String[]a){for(int i=-8;i<9;i++){String s="";for(int j=1,k;j<10;j++){s+=j;for(k=0;k<(i>0?i:-i);k++)s+=" ";}System.out.println(s+0);}}}

Update : -28 Bytes dank Leaky Nun!
Update 2 : -43 Bytes nochmal dank Leaky Nun!

Ungolfed:

interface A {
    static void main(String[] a) {
        for (int i = -8; i < 9; i++) {
            String s = "";
            for (int j = 1, k; j < 10; j++) {
                s += j;
                for (k = 0; k < (i > 0 ? i : -i); k++)
                    s += " ";
            }
            System.out.println(s + 0);
        }
    }
}

Probieren Sie es online aus

EDIT: Der Code früher war falsch! Beim Golfen des Codes ist ein Fehler aufgetreten. Der Code sollte nun wie vorgesehen funktionieren.

Schale , 21 Bytes

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9

Dies ist ein vollständiges Programm, das auf STDOUT gedruckt wird. Probieren Sie es online! Es gibt viele nachgestellte Leerzeichen.

Erläuterung

Husk fehlen immer noch viele wichtige Dinge wie eine Range-Funktion mit zwei Argumenten, daher sind Teile dieser Lösung etwas verrückt.

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
              ṁs`:0ḣ9  This part evaluates to the string "1234567890".
                   ḣ9   Range from 1 to 9.
                `:0     Append 0.
              ṁs        Convert each number to string and concatenate.
     §+↔tḣR8'          This part evaluates to a list like ["  "," ",""," ","  "]
                       but with 17 elements instead of 5.
          R8'           A string of 8 spaces.
         ḣ              Take prefixes.
     §+                 Concatenate
       ↔                the reversal and
        t               tail of the prefix list, palindromizing it.
  Ṫ                    Take outer product of the two lists
   `:                  with respect to flipped prepeding.
                       This prepends each digit to each string of spaces.
mΣ                     Map concatenation over the results, computing the rows.
                       Implicitly join with newlines and print.

T-SQL 145 152 Bytes

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @

Aktualisiert, um zu verwenden:

• master..spt_valuesZahlen generieren ( WHERE type = 'P'diese sind immer aufeinanderfolgend, beginnend mit 0)
• @ ZLK's TOP 17Idee
• DRUCKEN (um die Regeln zu befolgen - keine Stringlisten)
• @ JanDrozens großartige Idee, den Wagenrücklauf in die Zeichenfolge aufzunehmen (Ich zählte das als nur ein Byte - Windows CRLF was?)
• Idee von @Bridge, nur @ für Variablennamen zu verwenden - all diese Tricks !!

Ergebnisse:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(Danke @JanDrozen für die REPLACE Idee)

Clojure, 126 99 Bytes

-27 durch Beheben einiger dummer Fehler. Der äußere Gebrauch von awar nicht notwendig, also konnte ich mich ainsgesamt loswerden und nur apply streinmal schreiben . Dadurch konnte ich auch ein Funktionsmakro für die Hauptfunktion verwenden, das einige Bytes sparte. Ich habe auch die Aufforderung zum Math/abserneuten Binden ausgeführt n-spaces.

Grundsätzlich eine Clojure-Portierung von @ Mr.Xcoders Python-Idee. Rückblickend hätte ich ursprünglich die abs/ range-Methode für die Diamant-Herausforderung verwenden sollen, aber dann habe ich möglicherweise nicht die fehlerhafte Ausgabe erstellt!

Ziemlich einfach. Verbindet die Zahlenfolge mit einer Anzahl von Leerzeichen, die von der aktuellen Zeile abhängt.

#(doseq[n(range -8 9)](println(clojure.string/join(apply str(repeat (Math/abs n)\ ))"1234567890")))

(defn bugged []
  (doseq [n-spaces (range -8 9)]
    (println
        (clojure.string/join
          ; "String multiplication"
          (apply str
                 (repeat (Math/abs n-spaces) \space))
          "1234567890"))))

Gelee , 15 Bytes

8ŒRA⁶ẋØDṙ1¤jЀY

Probieren Sie es online!

Mathematica, 92 Bytes

Column@Join[Reverse@(s=Row/@Table[Riffle[Range@10~Mod~10,""<>Table[" ",i]],{i,0,8}]),Rest@s]

Probieren Sie es online aus

Kopieren / Einfügen von Code mit Strg-V
Drücken Sie UMSCHALT + EINGABETASTE , um auszuführen

C 97 Bytes

i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}

Ihr Compiler wird wahrscheinlich beschweren viel über diesen Code; meins warf 7 Warnungen von 4 verschiedenen Typen. Könnte den Code später verbessern.

Probieren Sie es online!

C (gcc) , 76 Bytes

f(x,y){for(y=-9;++y<9;puts(""))for(x=10;x++;printf("%-*d",abs(y)+1,x%=10));}

Probieren Sie es online!

Es werden einige nachgestellte Leerzeichen ausgegeben, von denen angenommen wird, dass sie OK sind.

Es druckt die Zahlen mit linksbündigen Feldern dynamischer Länge - dafür ist die Formatzeichenfolge gedacht %-*d.

Die innere Schleife hat eine lustige Initialisierung (beginnt bei 10; ein Vielfaches von 10 wäre in Ordnung), um ihre Beendigungsbedingung zu "vereinfachen".

Holzkohle , 21 20 19 18 Bytes

Ｆ⁹«Ｆ…¹χ⁺κ… ι0⸿»‖Ｂ↑

Probieren Sie es online!

Link zur ausführlichen Version . Grundsätzlich erstelle ich den unteren Teil der Zeichnung und reflektiere dann den Text nach oben.

CJam , 21 Bytes

A,(+aH*ee{:\8-zS**n}/

Probieren Sie es online!

Erläuterung

A,     e# Get [0 1 2 ... 9].
(+     e# Rotate the 0 to the end.
aH*    e# Wrap in an array and repeat 17 times.
ee     e# Enumerate. This pairs each copy of the array with its index in
       e# the list.
{      e# For each [index array] pair...
  :\   e#   Unwrap the pair and swap its order.
  8-z  e#   Get the absolute difference of the index from 8.
  S*   e#   Get a string of that many spaces.
  *    e#   Riffle the list of digits with the string of spaces.
  n    e#   Print it with a trailing linefeed.
}/

Batch, 163 Bytes

@set s=1 2 3 4 5 6 7 8 9 0
@set t=         
@for %%l in (9 7)do @for /l %%i in (1,1,%%l)do @call:%%l
:7
@set t=  %t%
:9
@set t=%t:~1%
@call echo %%s: =%t%%%

Hinweis: Die erste Zeile endet in 9 Leerzeichen. Erläuterung: Verwendet die Creative-Zeilennummerierung! Die erste Schleife muss 9 Mal ausgeführt und jedes Mal ein Leerzeichen gelöscht werden, während die zweite Schleife 8 Mal ausgeführt und jedes Mal ein Leerzeichen hinzugefügt werden muss. Ersteres wird erreicht, indem man es siebenmal ausführt und zum achten Mal durchfällt, während letzteres erreicht wird, indem man zwei Leerzeichen hinzufügt und durchfällt, um eines von ihnen wieder zu löschen.

SOGL V0.12 , 14 Bytes

ā9{SUčf@*∑Κ}╬Æ

Probieren Sie es hier aus!

Erläuterung:

ā               push an empty array
 9{        }    9 times do
   SU             push "1234567890"
     č            chop into characters
      f@*         get current iteration (0-based) amount of spaces
         ∑        join with that
          Κ       prepend this to the array
            Β  palindromize vertically with 1 overlap

PHP , 69 Bytes

for(;$i<17;)echo join(str_pad("",abs($i++-8)),range(1,9)+[9=>0]),"
";

Probieren Sie es online!

PowerShell , 30 Byte

8..0+1..8|%{1..9+0-join' '*$_}

Probieren Sie es online!

Konstruiert einen Bereich von 8,7,6...2,1,0,1,2...8then-Schleifen durch jede Zahl. Innerhalb der Schleife wir eine Reihe von Konstrukt 1..9verketteten mit 0dann -joinden Zahlen im Bereich zusammen mit der entsprechenden Anzahl von Räumen. Jede Zeichenfolge verbleibt in der Pipeline, und die Ausgabe erfolgt implizit nach Abschluss des Programms.