Gib genau diesen Text aus:

1                i
12              hi
123            ghi
1234          fghi
12345        efghi
123456      defghi
1234567    cdefghi
12345678  bcdefghi
123456789abcdefghi
12345678  bcdefghi
1234567    cdefghi
123456      defghi
12345        efghi
1234          fghi
123            ghi
12              hi
1                i

Eine einzelne nachgestellte Zeile ist zulässig, andere Formatierungsänderungen sind jedoch nicht zulässig.

Regeln und I / O

• Keine Eingabe
• Die Ausgabe kann auf jede bequeme Weise erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

C 87 85 81 80 Bytes

j;main(i){for(;++i<19;)for(j=19;j--;)putchar(j?j<i^j<20-i?32:106-j-j/10*39:10);}

Probieren Sie es online!

Erläuterung

j; // same as int j;
main(i){ // same as int main(int i){, where i = argc (1 with no arguments)
  for(;++i<19;) // loop over rows, i = 2..18
    for(j=19;j--;) // loop over chars, j = 19..0
      putchar(j?j<i^j<20-i?32:106-j-j/10*39:10); // output characters:
      //      j?                           :10 // on last char (j=0), output \n
      //        j<i                            // check for top/left half
      //            j<20-i                     // check for bottom/left half
      //           ^                           // 1 if only one half matched
      //                  ?32:                 // if so, output space
      //                      106              // char code for j
      //                         -j            // get desired letter
      //                           -j/10*39    // subtract 39 for j>9 (numbers)
}

Python 2 , 73 Bytes

i=9
exec"i-=1;a=abs(i);print'123456789'[:9-a]+'  '*a+'abcdefghi'[a:];"*17

Probieren Sie es online!

R , 64 Bytes

for(i in abs(8:-8))cat(intToUtf8(c(57-8:i,32*!!-i:i,97+i:8,13)))

Probieren Sie es online!

• -3 Bytes dank @Giuseppe
• -5 Bytes dank @ J.Doe

05AB1E (Legacy) , 16 Byte

9L©A9£S«®Âì×ζRû»

Probieren Sie es online!

-1 dank Kevin Cruijssen .

Python 2 , 80 Bytes

j=i=1
exec"print'123456789'[:i]+'  '*(9-i)+'abcdefghi'[-i:];i+=j;j-=2*(i>8);"*17

Probieren Sie es online!

QBasic, 72 Bytes

Gestützt auf Taylor Scotts Vorlage .

FOR y=-8TO 8
z=ABS(y)
?"123456789abcdefghi";
LOCATE,10-z
?SPC(2*z)"
NEXT

Grundlegende Erklärung

In jeder Zeile wird die gesamte Zeichenfolge gedruckt 123456789abcdefghi. Dann gehen wir zurück und überschreiben einen Teil davon mit Leerzeichen.

Vollständige Erklärung

Mit Code leicht ungolfed:

FOR y = -8 TO 8           ' Loop for 17 rows
 z = ABS(y)               ' z runs from 8 to 0 and back to 8
 ? "123456789abcdefghi";  ' Print the full string and stay on the same line (important!)
 LOCATE , 10-z            ' Go back to column 10-z on that line
 ? SPC(2*z); ""           ' Print 2*z spaces
                          ' (SPC keeps the cursor on the same line unlesss you print
                          ' something after it, so we'll use the empty string)
NEXT                      ' Go to the next y value

T-SQL, 108 Bytes

DECLARE @ INT=8a:
PRINT STUFF('123456789abcdefghi',10-abs(@),2*abs(@),SPACE(2*abs(@)))
SET @-=1IF @>-9GOTO a

Rücksendungen dienen nur der Lesbarkeit.

Versuchte viele andere Variationen, einschließlich der Nummerntabellen, dies war die kürzeste.

05AB1E , 20 Bytes

9LJη.BA9£.sí.Bí)øJû»

Probieren Sie es online!

Japt , 20 Bytes

9Æ9Ç>YÃê1 Ë?S:°EsH
ê

Japt Interpreter

Ausgabe als Array von Arrays von Zeichen. Das -RFlag ist nicht notwendig, um zu funktionieren, es macht die Ausgabe nur schöner.

Erläuterung:

9Æ9Ç                    create a 9x9 2D array 
    >YÃ                 fill bottom left triangle with "false", upper right with "true"
       ê1               mirror horizontally
          Ë?S           replaces "true" with a space
             :°EsH      replaces "false" with the horizontal index + 1 converted to base 32
                  \n    Store the result in U (saves bytes by not closing braces)
                    ê   palindromize vertically

Stax , 18 Bytes

â4+╤jo♂▐▀3bkWíæß╝╖

Führen Sie es aus und debuggen Sie es

Erläuterung:

9R$|[|<Va17T|]r|>\|pm Full program
9R$                   Produce "123456789"
   |[|<               Left-aligned prefixes (["1        ", "12       ", ...])
       Va17T          Produce "abcdefghi"
            |]        Suffixes (["abcdefghi", "bcdefghi", ...])
              r|>     Reverse and left-align (["        i", "       hi", ...])
                 \    Zip both arrays (["1                i", "12              hi", ...])
                  |p  Palindromize array
                    m Map over array, printing each with a newline                        

APL (Dyalog Unicode) , 30 Byte

(⊢⍪1↓⊖)(↑,\1↓⎕d),⌽↑,\⌽819⌶9↑⎕a

Probieren Sie es online!

↑ in eine Matrix konvertieren (Auto-Pads mit Leerzeichen)

• ,\ die Präfixe von

• 1↓ das erste Element fiel aus

• ⎕d diese Saite '0123456789'

• Dies ergibt die Zeichenmatrix

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, verkettet mit

• ⌽ das Gegenteil

• ↑ matrixiert

• ,\ Präfixe von

• ⌽ das Gegenteil

• 819⌶ und klein geschrieben

• 9↑ Die ersten 9 Elemente von

• ⎕a diese Saite 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

• Dies ergibt die Zeichenmatrix

        ich
       Hallo
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

und zu diesem Ergebnis

1 i
12 hi
123 ghi
1234 fghi
12345 efghi
123456 defghi
1234567 cdefghi
12345678 bcdefghi
123456789abcdefghi

Führen Sie den folgenden Zug aus (⊢⍪1↓⊖)

⊢ das richtige argument

⍪ vertikal verkettet mit

1↓ die erste Reihe fiel aus (dies vermeidet das Wiederholen der mittleren Reihe)

⊖ das richtige Argument ist vertikal umgekehrt

Andere Lösungen

33 Bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⎕ucs 106-q←⍳9

Probieren Sie es online!

33 Bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⌽⎕ucs 96+q←⍳9

Probieren Sie es online!

Holzkohle , 22 17 Bytes

Ｇ↗↓←⁹β←Ｇ↖↓⁹⭆χι‖Ｏ↓

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

Ｇ↗↓←⁹β

Zeichnen Sie ein rechtes unteres Dreieck und füllen Sie es mit dem Kleinbuchstaben. (Die Füllung basiert auf dem Kacheln der Ebene mit dem Alphabet und dem anschließenden Kopieren des gezeichneten Bereichs.)

←

Bewegen Sie sich nach links, um das numerische Dreieck zu zeichnen.

Ｇ↖↓⁹⭆χι

Zeichnen Sie ein unteres linkes Dreieck und füllen Sie es mit den Ziffern. (Da das Dreieck links vom Ursprung gezeichnet ist, werden die Ziffern rechtsbündig verwendet, sodass nur die Ziffern 1 bis 9 verwendet werden.)

‖Ｏ↓

Nachdenken, um die untere Hälfte zu vervollständigen.

V , 25 , 21 Bytes

¬19¬ai8ñHÄ/á
r ge.YGp

Probieren Sie es online!

Dank nmjcman101 werden 2-4 Bytes gespart!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp

J , 44 Bytes

(m]\u:49+i.9),.(m=.,}.@|.)]\&.(|."1)u:97+i.9

Probieren Sie es online!

Ich habe versucht, numerisch eine Maske von 1 und Null für die Indizierung zu generieren, aber die Kosten für das Entfernen der zusätzlichen Zeile waren hoch und ich habe aufgegeben:

   (9-.~i.18){0<:-/~(,|.)i.9
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

Perl 5+ -M5.010, 49 Bytes

say 1..9-abs,"  "x abs,(a..i)[-9+abs..-1]for-8..8

Probieren Sie es online!

Japt, 24 Bytes

Gibt ein Array von Zeilen zurück

9Æ´AçXÄ
c¡A°îYd#a
Vù y ê

Probier es aus

Erläuterung

9Æ            :Map each X in the range [0,9)
  ´A          :  Prefix decrement A (initially 10)
    ç         :  Repeat
     XÄ       :  X+1
\n            :Assign to variable U
 ¡            :Map each element at index Y in U
  A°          :  Postfix increment A
    î         :  Repeat
      d       :  The character at codepoint
     Y #a     :  Y+97
c             :Concatenate with U
\n            :Assign to variable V
Vù            :Left pad each element in V to the length of the longest element
   y          :Transpose
     ê        :Palindromise

Alternativen

9õÈîZqÃú Ë+EòdEn#i)¬ù9Ãê

Probier es aus

9ÇòdZn#i)cZòÄ)¬Ãú ®éJ´Ãê

Probier es aus

QBasic , 87 Bytes

Eine anonyme Funktion, die keine Ein- und Ausgaben für die Konsole vornimmt.

For y=-8To 8:z=Abs(y):a$="123456789abcdefghi":?Mid$(a$,1,9-z)Spc(2*z)Mid$(a$,10+z):Next

Diese Antwort ist technisch gesehen mehrsprachig und funktioniert in VBA

Canvas , 13 Bytes

９Ｒ［］ｚ９ｍ±［］±＋─

Probieren Sie es hier aus!

Befunge-93 , 314 308 Bytes

<p0+3*67p0+4*77p0+3*77p0-7*88p0-6*88"#v#v>"
"i        "11g1-21p56+1g1+56+1p28*1g1+28*1p  ^       >25*
"        1"92g1+82p56+2g1-56+2p28*2g1-28*2p91g00g`#v_^   >
"ihgfedcba "93p26*3g1-26*3p">^"88*7-0p88*7-4pv     >25*
"987654321 "14p26*4g1+26*4p26*4g12g`#v_            ^
                             >:#,_@#:<

Probieren Sie es online!

Golfed 6 Bytes durch Platzieren eines >mit der pAnweisung

Matlab, 122 Bytes

function[r]=f,s=[49:57,'a':'i'];r=[];for i=1:9,r=[r;s(1:i),repmat(' ',[1,18-2*i]),s(19-i:18)];end,r=[r;flip(r(1:8,:))];end

Probieren Sie es online!

PowerShell 5.1, 70 69 64 57 Bytes

^{Danke Mazzy für -7 Bytes}

1..9+8..1|%{-join(1..$_+'  '*(9-$_)+' ihgfedcba'[$_..1])}

Es hat sich herausgestellt, dass das manuelle Zusammenkleben ein Byte spart. Ein einziger Mega-Join spart außerdem 5 weitere. Funktioniert auch, indem Sie eine Reihe von Ints in ein Zeichen [] umwandeln, um das ai zu erhalten. Die Verwendung eines Bereichs über den tatsächlichen Buchstaben ist 5 Byte besser.

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (Compiler-Flags) Bytes

-1 Byte durch Ersetzen des logischen ODER durch einen bitweisen Operator.

-5 Bytes dank Logern.

+9 Bytes zur Korrektur der Medianlinie, die zweimal ausgegeben wurde.

char*s="123456789abcdefghi";G{for(;j<18;++j)putchar(i>j|j>17-i?s[j]:32);puts("");}f(){int i=0,j=0;for(;i++<8;)G;g(i+1,j);for(;i-->1;)G;}

Compiler-Flag:

-DG=g(i,j)

Dieses Makro faktorisiert die Vorkommen von g(i,j): Funktionsdeklaration und Aufrufen.

Probieren Sie es online!

Anderer Ansatz als Pietu1998's großartige Antwort , direkter (und lesbarer), aber höhere Punktzahl.

Einstiegspunkt ist Funktion f(); Die Funktion g()verarbeitet den Druck jeder aufeinanderfolgenden Zeile.

Könnte durch Umbenennen fin ein vollständiges Programm gemacht werdenmain , aber es würde die Punktzahl noch erhöhen.

Hübsche Version, Makro Gerweitert:

char *s = "123456789abcdefghi";
int g(int i, int j) {
    for(; j < 18; ++j)
        putchar((i > j | j > 17 - i) ? s[j] : 32);
    puts(""); // Break the line -- shorter than putchar(10) or printf("\n")
}
int f() {
    int i = 0, j = 0; // j is constant, declared here to not have to declare and init it inside g()
    for(; i++ < 8;) // Upper half of the tie
        g(i, j);
    g(i + 1, j); // Median line
    for(; i-- > 1;) // Lower half; --i > 0 would also work for the condition
        g(i, j);
}

JavaScript (ES6), 76 Byte

f=(x=y=0)=>y<17?(x>y^x++<17-y?x.toString(36)+[`
`[x%=18]]:' ')+f(x||!++y):''

Probieren Sie es online!

Wolfram Language (Mathematica) , 81 79 Bytes

a=Table[" ",17,18];Do[a[[i;;-i,i]]=a[[1-i;;i-1,i]]=i~IntegerString~35,{i,18}];a

Probieren Sie es online!

Wirft viele ignorierbare Fehler.

VBA, 75 Bytes

Eine anonyme VBE-Direktfensterfunktion, die keine Ein- und Ausgaben an die Konsole annimmt.

For y=-8To 8:z=Abs(y):a="123456789abcdefghi":Mid(a,10-z)=Space(2*z):?a:Next

Jelly , 22 21 Bytes

9R€z⁶Zµạ106Ọ$Ṡ¡€Uṭ)ŒḄ

Probieren Sie es online!

Beruht auf dem (wahrscheinlich) unbeabsichtigten Verhalten, dass, wenn Ṡ(sign) auf ein Zeichen einwirkt, es Pythons ergibt None. Aus diesem Grund Ṡwird mit einem Byte überprüft, ob das Argument eine Ganzzahl ungleich Null ist, da Nonees in Python falsch ist. Wenn dieses Verhalten geändert wird, OƑfunktioniert es auch für ein weiteres Byte.

Funktion, die eine Liste von Zeilen zurückgibt.

Java 8, 107 Bytes

v->{for(int i=1,j;++i<19;)for(j=19;j-->0;)System.out.printf("%c",j>0?(j<i)!=(j<20-i)?32:106-j-j/10*39:10);}

Port von @ Pietu1998 C Antwort , so stellen Sie sicher , ihn zu upvote!

Probieren Sie es online aus.

Python 2 , 97 bis 94 Bytes

i=o="123456789abcdefghi";c=8
while c:i=i[:c]+' '*(9-c)*2+i[-c:];o=i+'\n'+o+'\n'+i;c-=1
print o

Probieren Sie es online!

Nur als Alternative zur Verwendung gepostet eval()und weil ich es endlich unter 100 habe. Grundsätzlich fängt die mittlere Reihe dann sowohl auf als auch ab gleichzeitig an.

Yabasic , 103 Bytes

a$="123456789abcdefghi"
For y=-8To 8
z=Abs(y)
?Mid$(a$,1,9-z);
For i=1To z?"  ";Next
?Mid$(a$,10+z)Next

Probieren Sie es online!

Pascal (FPC) , 110 105 Bytes

var i:int32;begin for i:=-8to 8do writeln('123456789'[1..9-abs(i)],'abcdefghi'[abs(i)+1..9]:abs(i)+9)end.

Probieren Sie es online!