Inspirado por la salida con errores en la respuesta Clojure de @Carcigenicate para el desafío Imprimir este diamante .

Imprime este texto exacto:

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

(Desde el centro hacia afuera en ambas direcciones, cada dígito está separado por un espacio más que la línea anterior).

Reglas de desafío:

• No habrá entrada ( o una entrada vacía sin usar ).
• Los espacios finales son opcionales.
• Una nueva línea final es opcional.
• No se permiten espacios iniciales ni líneas nuevas.
• No se permite devolver una matriz de cadenas. Debe generar el texto o tener una función que devuelva una sola cadena con el resultado correcto.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

SOGL V0.12 , 12 bytes

9{SUē↕∑}¹№╬«

Pruébalo aquí! Explicación:

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

Pruébalo en línea!

@Leaky Nun ayudó mucho a jugar golf, @Praind sugirió un método para guardar 1 byte, que antes pensaba, pero olvidé editar, @CotyJohnathanSaxman sugirió cambiar el ciclo.

Explicación

• i=8- Asigna el valor 8a una variable llamada i.

• exec"..."*17- Ejecute ese bloque de código ( ...) 17 veces.

• print(...) - Salida del resultado.

• ' '*abs(i)- Crear una cadena con un espacio repetido |i|veces.

• .join('1234567890')- Intercalar la cadena creada anteriormente con 1234567890, de modo que |i|se inserten espacios entre los dígitos.

• i-=1- Disminuya i, y al ejecutarlo 17 veces, alcanza -8, lo que crea el patrón repetitivo con la ayuda de abs().

Vim, 35 bytes:

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

Explicación:

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αð×ý,

Pruébalo en línea!

Explicación

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

ASM C64, 358 bytes (102 bytes compilados con basicstub)

Esto es lo más cerca que pude llegar debido a limitaciones obvias:

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

(Probablemente podría optimizarse bastante)

TSQL, 220 148 bytes

Mejora publicada por ZLK:

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 @

Salida:

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

Pruébalo en línea!

⎕D D igita de cero a nueve

1⌽ girar un paso a la derecha (pone cero al final)

⊂ adjuntar (para tratar como unidad)

(... )↑¨¨ para cada uno de estos números, tome esa cantidad de caracteres de cada una de las letras:

 ⍳17 uno a diecisiete

 ¯9+ restar nueve

 | encontrar los valores absolutos

 1+ Agrega uno

∊¨ alistar (aplanar) cada

↑ cambiar una capa de profundidad a un nivel de rango (matrificar)

Haskell , 58 55 bytes

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

Pruébalo en línea!

Esta es básicamente la solución de @nimi :)

Java 11 (JDK) , 98 bytes

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

Pruébalo en línea!

• -14 bytes cambiando a JDK 11, que ahora tiene un nativo String::repeat.

Respuesta anterior ( 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","");}

Pruébalo en línea!

Explicaciones

Básicamente estoy construyendo las siguientes String17 veces ( Nes una variable, no un valor real):

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

Son todos los dígitos esperados, unidos por %1$Nsdonde Nestá el número de espacios entre cada dígito.

%1$Nsbásicamente significa "tomar el primer argumento y rellenarlo hasta que la longitud sea al menos N". Además, %1$0sno se admite por lo que un caso especial %1$sse hace para 0.

Finalmente, imprimo en formato esa cadena usando un solo argumento:, ""por lo que el formateador reutiliza siempre la misma cadena vacía, rellenándola con espacios según sea necesario.

Ahorra

• 1 byte gracias a Kevin Cruijssen

Japt -R , 19 18 16 14 13 bytes

Aõ%A
£qYçÃÔÅê

Pruébalo o pruébalo en línea

Explicación

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 bytes

Gracias Shaggy por guardar 10 bytes. Gracias Craig por guardar 1 byte. Gracias arcos por guardar 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ẉᵐ

Pruébalo en línea!

Salvado un byte gracias a Leaky Nun .

Explicación

Ị↺                               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

Carbón , 18 bytes

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

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

Ｆ⁹      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

Nota: Cast(1)toma el mismo número de bytes porque "1"necesitaría un separador antes ":"(lo que sucede que el desverbosificador no puede insertar).

R , 108 bytes

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

Solo pegando y colapsando las cuerdas.

Pruébalo en línea!

Editar: gracias por Challenger5 por señalar un problema. Lo arregló ahora.

Edición 2: guardado un byte gracias a bouncyball.

Python 3 , 58 57 54 bytes

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

Pruébalo en línea!

(gracias a @flornquake por los últimos tres bytes; olvidé completamente usar seppara guardar vs. .join)

Pyth , 14 13 bytes

1 byte gracias a Mnemonic.

V17j*da8NeMST

Pruébalo en línea!

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

Actualización : -28 bytes gracias a Leaky Nun!
Actualización 2 : -43 bytes gracias a Leaky Nun nuevamente.

Sin golf:

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

Pruébalo en línea

EDITAR: ¡ El código anterior estaba equivocado! Cometió un error al jugar el código, ¡debería funcionar como se esperaba ahora!

Casco , 21 bytes

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

Este es un programa completo que imprime en STDOUT. Pruébalo en línea! Hay muchos espacios finales.

Explicación

A Husk todavía le faltan muchas cosas esenciales, como una función de rango de dos argumentos, por lo que partes de esta solución son un poco extravagantes.

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 @

Actualizado para usar:

• master..spt_valuespara generar números ( WHERE type = 'P'siempre son consecutivos, comenzando en 0)
• @ ZLK de TOP 17idea
• IMPRIMIR (para obedecer las reglas, sin listas de cadenas)
• La gran idea de @ JanDrozen de incluir el retorno de carro en la cadena (lo conté como un solo byte: ¿CRLF de Windows qué?)
• Idea de @Bridge para usar solo @ para el nombre de la variable: ¡todos estos trucos!

Resultados:

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

(Gracias @ JanDrozen por la idea REEMPLAZAR)

Clojure, 126 99 bytes

-27 arreglando un par de errores tontos. El uso externo de ano era necesario, así que pude deshacerme por acompleto y solo escribir apply struna vez. Eso también me permitió usar una macro de función para la función principal, que ahorró algunos bytes. También incluí la llamada en Math/abslugar de volver a vincular n-spaces.

Básicamente un puerto Clojure de la idea de Python de @ Mr.Xcoder. En retrospectiva, debería haber usado el método abs/ rangepara el desafío del diamante originalmente, ¡pero es posible que no haya producido la salida con errores!

Bastante simple. Une la cadena de números con varios espacios que dependen de la fila actual.

#(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"))))

Jalea , 15 bytes

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

Pruébalo en línea!

Mathematica, 92 bytes

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

Pruébalo en línea

copiar / pegar código con ctrl-v
presione shift + enter para ejecutar

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

Su compilador probablemente se quejará mucho sobre este código; el mío lanzó 7 advertencias de 4 tipos diferentes. Podría mejorar el código más tarde.

Pruébalo en línea!

C (gcc) , 76 bytes

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

Pruébalo en línea!

Produce algunos espacios finales, que se supone que están bien.

Imprime los números usando campos de longitud dinámica justificados a la izquierda, para eso es la cadena de formato %-*d.

El bucle interno tiene una inicialización divertida (comienza desde 10; cualquier múltiplo de 10 estaría bien) para "simplificar" su condición de terminación.

Carbón , 21 20 19 18 bytes

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

Pruébalo en línea!

Enlace a la versión detallada . Básicamente creo la parte inferior del dibujo y luego reflejo el texto hacia arriba.

CJam , 21 bytes

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

Pruébalo en línea!

Explicación

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.
}/

Lote, 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%%%

Nota: La primera línea termina en 9 espacios. Explicación: ¡Utiliza la numeración de líneas creativas! El primer ciclo debe ejecutarse 9 veces y eliminar un espacio cada vez, mientras que el segundo ciclo debe ejecutarse 8 veces y agregar un espacio cada vez. El primero se logra ejecutándolo 7 veces y cayendo por octava vez, mientras que el segundo se logra agregando dos espacios y cayendo para eliminar uno de ellos nuevamente.

SOGL V0.12 , 14 bytes

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

Pruébalo aquí!

Explicación:

ā               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]),"
";

Pruébalo en línea!

PowerShell , 30 bytes

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

Pruébalo en línea!

Construye un rango de 8,7,6...2,1,0,1,2...8luego recorre cada número. Dentro del bucle construimos una serie de 1..9concatenada con 0entonces -joinlos números en el rango junto con el número apropiado de espacios. Cada cadena se deja en la tubería y la salida está implícita al finalizar el programa.