Salida de este texto exacto:

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

Una nueva línea final es aceptable, pero no se permiten otros cambios de formato.

Reglas y E / S

• Sin entrada
• La salida se puede dar por cualquier método conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

R , 64 bytes

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

Pruébalo en línea!

• -3 bytes gracias a @Giuseppe
• -5 bytes gracias a @ J.Doe

05AB1E (heredado) , 16 bytes

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

Pruébalo en línea!

-1 gracias 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

Pruébalo en línea!

QBasic, 72 bytes

Basado en la presentación de Taylor Scott .

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

Explicación básica

En cada línea, imprimimos la cadena completa 123456789abcdefghi. Entonces nos volvemos y parte de sobreescritura de la misma con espacios.

Explicación completa

Con un código ligeramente sin golf:

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

Las devoluciones son solo para legibilidad.

Intenté muchas otras variaciones, incluidas las tablas de números, esta fue la más corta.

05AB1E , 20 bytes

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

Pruébalo en línea!

Japt , 20 bytes

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

Intérprete Japt

Salida como una matriz de matrices de caracteres. El -Rindicador no es necesario para funcionar, solo hace que la salida se vea mejor.

Explicación:

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

Ejecutar y depurarlo

Explicación:

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

Pruébalo en línea!

↑ convertir a una matriz (auto pads con espacios)

• ,\ los prefijos de

• 1↓ el primer elemento cayó de

• ⎕d esta cuerda '0123456789'

• Esto le da a la matriz de caracteres

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concatenado con

• ⌽ el reverso

• ↑ matriz

• ,\ prefijos de

• ⌽ el reverso

• 819⌶ y en minúsculas

• 9↑ primeros 9 elementos de

• ⎕a esta cuerda 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

• Esto le da a la matriz de caracteres

        yo
       Hola
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

y sobre este resultado

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

realiza el siguiente tren (⊢⍪1↓⊖)

⊢ el argumento correcto

⍪ concatenados verticalmente con

1↓ la primera fila cayó (esto evita la repetición de la fila del medio)

⊖ el argumento correcto invertido verticalmente

Otras soluciones

33 bytes

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

Pruébalo en línea!

33 bytes

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

Pruébalo en línea!

Carbón , 22 17 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｇ↗↓←⁹β

Dibuja un triángulo rectángulo inferior y llénalo usando el alfabeto en minúsculas. (El relleno se basa en colocar el plano en mosaico con el alfabeto y luego copiar el área dibujada).

←

Mover a la izquierda para dibujar el triángulo numérico.

Ｇ↖↓⁹⭆χι

Dibuja un triángulo inferior izquierdo y llénalo con los dígitos. (Dado que el triángulo se dibuja a la izquierda del origen, los dígitos se toman justificados a la derecha, por lo que solo se utilizan los dígitos 1 a 9).

‖Ｏ↓

Reflexiona para completar la mitad inferior.

V , 25 , 21 bytes

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

Pruébalo en línea!

¡2-4 bytes guardados gracias 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

Pruébalo en línea!

Traté de generar numéricamente una máscara de 1 y cero para usar para la indexación, pero el costo de deshacerme de la fila adicional era alto y me di por vencido:

   (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

Pruébalo en línea!

Japt, 24 bytes

Devuelve una matriz de líneas.

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

Pruébalo

Explicación

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Ãê

Pruébalo

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

Pruébalo

QBasic , 87 bytes

Una función anónima que no lleva entradas y salidas a la consola.

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

Esta respuesta es técnicamente un políglota y funcionará en VBA

Lienzo , 13 bytes.

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

Pruébalo aquí!

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

Pruébalo en línea!

Golfó 6 bytes colocando un >con la pinstrucción

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

Pruébalo en línea!

PowerShell 5.1, 70 69 64 57 Bytes

^{Gracias Mazzy por -7 bytes}

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

Resulta que pegarlo manualmente guarda un byte. Hacerlo todo una megaunión también ahorra 5 más. También funciona convirtiendo un rango de entradas en un carácter [] para obtener el ai. Usar un rango sobre las letras reales es 5 bytes mejor.

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

-1 byte reemplazando OR lógico con operador bit a bit.

-5 bytes gracias a Logern.

+9 bytes para arreglar la línea media, que se emitió dos veces.

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

Indicador del compilador:

-DG=g(i,j)

Esta macro factoriza las ocurrencias de g(i,j): declaración de función y llamadas.

Pruébalo en línea!

Enfoque diferente a la gran respuesta de Pietu1998 , más directo (y legible), pero con mayor puntaje.

El punto de entrada es función f(); funcióng() maneja la impresión de cada línea consecutiva.

Podría hacerse un programa completo renombrándolo famain , pero aún así aumentaría la puntuación.

Versión 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):''

Pruébalo en línea!

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

Pruébalo en línea!

Lanza muchos errores ignorables.

VBA, 75 bytes

Una función de ventana inmediata anónima de VBE que no lleva entradas ni salidas a la consola.

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

Jalea , 22 21 bytes

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

Pruébalo en línea!

Se basa en el (no probable) comportamiento involuntario que cuando Ṡ(signo) actúa sobre un personaje produce el de Python None. Debido a esto, Ṡes una comprobación de un byte para ver si su argumento es un entero distinto de cero ya que Nonees falsey en Python. Si este comportamiento cambia, entoncesOƑ funciona igual para un byte más.

Función que devuelve una lista de líneas.

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

La respuesta C del puerto de @ Pietu1998 , ¡así que asegúrese de votarlo!

Pruébalo en línea.

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

Pruébalo en línea!

Solo se publicó como una alternativa al uso eval()y porque finalmente lo obtuve por debajo de 100. Básicamente comienza con la fila del medio y luego funciona hacia arriba y hacia abajo al mismo tiempo.

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

Pruébalo en línea!

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.

Pruébalo en línea!