Saída este texto exato:

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

Uma única nova linha à direita é aceitável, mas nenhuma outra alteração de formatação é permitida.

Regras e E / S

• Sem entrada
• A saída pode ser fornecida por qualquer método conveniente .
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

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);}

Experimente online!

Explicação

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

Experimente online!

R , 64 bytes

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

Experimente online!

• -3 bytes graças a @ Giuseppe
• -5 bytes graças a @ J.Doe

05AB1E (herdado) , 16 bytes

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

Experimente online!

-1 graças a Kevin Cruijssen .

Python 2 , 80 bytes

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

Experimente online!

QBasic, 72 bytes

Baseado na submissão de Taylor Scott .

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

Explicação básica

Em cada linha, imprimimos a sequência completa 123456789abcdefghi. Depois voltamos e substituímos parte dele com espaços.

Explicação completa

Com código um pouco não-destruído:

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

Os retornos são apenas para legibilidade.

Tentei muitas outras variações, incluindo tabelas numéricas, essa foi a mais curta.

05AB1E , 20 bytes

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

Experimente online!

Japonês , 20 bytes

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

Intérprete Japt

Saída como uma matriz de matrizes de caracteres. O -Rsinalizador não é necessário para o trabalho, apenas torna a saída mais agradável.

Explicação:

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íæß╝╖

Execute e depure

Explicação:

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 bytes

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

Experimente online!

↑ converter em uma matriz (blocos automáticos com espaços)

• ,\ os prefixos de

• 1↓ o primeiro elemento caiu

• ⎕d essa string '0123456789'

• Isso fornece a matriz de caracteres

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concatenado com

• ⌽ o invertido

• ↑ matrificado

• ,\ prefixos de

• ⌽ o invertido

• 819⌶ e em minúsculas

• 9↑ primeiros 9 elementos de

• ⎕a essa string 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

• Isso fornece a matriz de caracteres

        Eu
       Oi
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

e nesse resultado

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

execute o seguinte trem (⊢⍪1↓⊖)

⊢ o argumento certo

⍪ concatenado verticalmente com

1↓ a primeira linha caiu (isso evita a repetição da linha do meio)

⊖ o argumento certo inverteu verticalmente

Outras soluções

33 bytes

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

Experimente online!

33 bytes

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

Experimente online!

Carvão , 22 17 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｇ↗↓←⁹β

Desenhe um triângulo inferior direito e preencha-o usando o alfabeto em minúsculas. (O preenchimento é baseado no ladrilho do avião com o alfabeto e, em seguida, na cópia da área desenhada.)

←

Mova para a esquerda para desenhar o triângulo numérico.

Ｇ↖↓⁹⭆χι

Desenhe um triângulo inferior esquerdo e preencha-o usando os dígitos. (Como o triângulo é desenhado à esquerda da origem, os dígitos são justificados à direita, para que apenas os dígitos de 1 a 9 sejam usados.)

‖Ｏ↓

Reflita para completar a metade inferior.

V , 25 , 21 bytes

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

Experimente online!

2-4 bytes salvos graças a nmjcman101!

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

Experimente online!

Tentei gerar numericamente uma máscara de 1 e zero para usar na indexação, mas o custo de se livrar da linha extra era alto e desisti:

   (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

Experimente online!

Japt, 24 bytes

Retorna uma matriz de linhas

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

Teste-o

Explicação

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

Alternativas

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

Teste-o

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

Teste-o

QBasic , 87 bytes

Uma função anônima que não recebe entrada e saída para o console.

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

Esta resposta é tecnicamente poliglota e funcionará no VBA

Tela , 13 bytes

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

Experimente aqui!

Befunge-93 , 314 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_            ^
                             >:#,_@#:<

Experimente online!

Golfou 6 bytes colocando um >com a pinstrução

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

Experimente Online!

PowerShell 5.1, 70 69 64 57 bytes

^{Obrigado Mazzy por -7 bytes}

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

Acontece que colá-lo manualmente salva um byte. Tornar tudo isso uma mega-junção também economiza mais 5. Também funciona transformando um intervalo de ints em um char [] para obter o ai. Usar um intervalo acima das letras reais é 5 bytes melhor.

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (sinalizadores do compilador) bytes

-1 byte substituindo OR lógico por operador bit a bit.

-5 bytes graças ao Logern.

+9 bytes para corrigir a linha mediana, que foi emitida duas vezes.

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;}

Sinalizador do compilador:

-DG=g(i,j)

Essa macro fatora as ocorrências de g(i,j): declaração de função e chamadas.

Experimente online!

Abordagem diferente da grande resposta de Pietu1998 mais direta (e legível), mas mais alta.

Ponto de entrada é função f(); funçãog() lida com a impressão de cada linha consecutiva.

Pode ser feito um programa completo renomeando fparamain , mas ainda assim aumentaria a pontuação.

Versão bonita, macro Gexpandida:

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 bytes

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

Experimente 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

Experimente online!

Lança muitos erros ignoráveis.

VBA, 75 bytes

Uma função de janela imediata anônima do VBE que não recebe entrada nem saída no console.

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

Geléia , 22 21 bytes

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

Experimente online!

Baseia-se no comportamento (não provável) não intencional de que, quando Ṡ(sinal) age em um personagem, ele gera o Python None. Por causa disso, Ṡé uma verificação de um byte para saber se o argumento é um número inteiro diferente de zero, uma vez que Noneé falsey no Python. Se esse comportamento for alterado, também OƑfuncionará para mais um byte.

Função que retorna uma lista de linhas.

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);}

Porto da resposta C de @ Pietu1998 , por isso não deixe de vota-lo!

Experimente online.

Python 2 , 97 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

Experimente online!

Somente postado como uma alternativa ao uso eval()e porque finalmente cheguei abaixo de 100. Basicamente, começa com a linha do meio e depois trabalha para cima e para baixo ao mesmo tempo.

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

Experimente 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.

Experimente online!