Inspirado na saída com erros na resposta Clojure da @Carcigenicate para o desafio Print this diamond .

Imprima este texto exato:

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

(Do meio para fora em ambas as direções, cada dígito é separado por mais um espaço que a linha anterior.)

Regras do desafio:

• Não haverá entrada ( ou uma entrada não utilizada vazia ).
• Os espaços à direita são opcionais.
• Uma única linha nova à direita é opcional.
• Espaços iniciais ou novas linhas não são permitidos.
• Não é permitido retornar um array de strings. Você deve imprimir o texto ou ter uma função que retorne uma única string com o resultado correto.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

SOGL V0.12 , 12 bytes

9{SUē↕∑}¹№╬«

Experimente aqui! Explicação:

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

Experimente online!

@Leaky Nun ajudou bastante no golfe, o @Praind sugeriu um método para economizar 1 byte, que eu pensava anteriormente, mas esqueci de editar, @CotyJohnathanSaxman sugeriu mudar o loop.

Explicação

• i=8- Atribui o valor 8a uma variável chamada i.

• exec"..."*17- Execute esse bloco de código ( ...) 17 vezes.

• print(...) - Saída do resultado.

• ' '*abs(i)- Crie uma String com um espaço repetido |i|vezes.

• .join('1234567890')- Intercalar a sequência criada acima com 1234567890, de modo que |i|sejam inseridos espaços entre os dígitos.

• i-=1- Decrementa ie, executando-o 17 vezes, alcança -8, o que cria um padrão repetitivo com a ajuda de abs().

Vim, 35 bytes:

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

Explicação:

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

Experimente online!

Explicação

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 compilados com o basicstub)

Este é o mais próximo que pude obter devido a limitações óbvias:

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

(Provavelmente poderia ser otimizado um pouco)

TSQL, 220 148 bytes

Melhoria postada 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 @

Resultado:

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

Experimente online!

⎕D D igits de zero a nove

1⌽ gire um passo para a direita (coloca zero no final)

⊂ incluir (para tratar como unidade)

(… )↑¨¨ Para cada um desses números, use o número de caracteres de cada uma das letras:

 ⍳17 um a dezessete

 ¯9+ subtrair nove

 | encontre os valores absolutos

 1+ Adicione um

∊¨ alistar (achatar) cada

↑ alterar uma camada de profundidade em um nível de classificação (matrificar)

Haskell , 58 55 bytes

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

Experimente online!

Esta é basicamente a solução da @nimi :)

Java 11 (JDK) , 98 bytes

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

Experimente online!

• -14 bytes alternando para o JDK 11, que agora possui um nativo String::repeat.

Resposta 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","");}

Experimente online!

Explicações

Basicamente, estou construindo as seguintes String17 vezes ( Né uma variável, não um valor real):

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

São todos os dígitos esperados, unidos por %1$Nsonde Nestá o número de espaços entre cada dígito.

%1$Nsbasicamente significa "pegar o primeiro argumento e preenchê-lo até que o comprimento seja pelo menos N". Além disso,%1$0s não é suportado por isso um caso especial %1$sé feita para 0.

Por fim, formato-imprimo essa string usando um único argumento: "" :, para que o formatador reutilize sempre a mesma string vazia, preenchendo-a com espaços, conforme necessário.

Economizar

• 1 byte graças a Kevin Cruijssen

Japt -R , 19 18 16 14 13 bytes

Aõ%A
£qYçÃÔÅê

Teste ou experimente online

Explicação

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

Obrigado Shaggy por salvar 10 bytes. Obrigado Craig por economizar 1 byte. Obrigado arcos por salvar 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ẉᵐ

Experimente online!

Salvo um byte graças a Leaky Nun .

Explicação

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

Carvão , 18 bytes

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

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

Ｆ⁹      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)leva o mesmo número de bytes porque "1"precisaria de um separador antes ":"(o que, por acaso, o deverbosifier falha ao inserir).

R , 108 bytes

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

Apenas colando e recolhendo as cordas.

Experimente online!

Edit: obrigado por Challenger5 por apontar um problema. Corrigido agora.

Edit 2: salvou um byte graças ao bouncyball.

Python 3 , 58 57 54 bytes

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

Experimente online!

(obrigado a @flornquake pelos últimos três bytes; esqueci completamente de usar seppara salvar vs. .join)

Pitão , 14 13 bytes

1 byte graças ao Mnemonic.

V17j*da8NeMST

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

Atualização : -28 bytes graças a Leaky Nun!
Atualização 2 : -43 bytes graças a Leaky Nun novamente!

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

Experimente online

EDIT: O código anterior estava errado! Cometi um erro ao jogar o código, ele deve funcionar como pretendido agora!

Casca , 21 bytes

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

Este é um programa completo que imprime em STDOUT. Experimente online! Existem muitos espaços à direita.

Explicação

O Husk ainda está faltando muitas coisas essenciais, como uma função de intervalo de dois argumentos, então partes desta solução são um pouco invasivas.

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 @

Atualizada para usar:

• master..spt_values para gerar números (WHERE type = 'P' , estes são sempre consecutivos, começando em 0)
• @ ZLK's TOP 17 ideia de
• PRINT (para obedecer às regras - sem listas de strings)
• A ótima idéia de @ JanDrozen de incluir o retorno de carro na string (contei isso como apenas um byte - Windows CRLF, o quê?)
• Idéia do @Bridge para usar apenas @ para o nome da variável - todos esses truques !!

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

(Obrigado @JanDrozen pela idéia REPLACE)

Clojure, 126 99 bytes

-27, corrigindo alguns erros estúpidos. O uso externo de anão era necessário, então pude me livrar acompletamente e escrever apenas apply struma vez. Isso também me permitiu usar uma macro de função para a função principal, que salvou alguns bytes. Também inline a chamada para, em Math/absvez de voltar a ligar n-spaces.

Basicamente, uma porta Clojure da idéia Python do @ Mr.Xcoder. Em retrospecto, eu deveria ter usado o abs/range método para o desafio de diamantes, mas talvez não tenha produzido a saída com bug!

Bem simples. Une a sequência numérica a um número de espaços que depende da linha atual.

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

Gelatina , 15 bytes

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

Experimente online!

Mathematica, 92 bytes

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

Experimente online

copiar / colar código com ctrl-v,
pressione Shift + Enter para executar

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

Seu compilador provavelmente reclamará muito sobre esse código; o meu lançou 7 avisos de 4 tipos diferentes. Pode melhorar o código mais tarde.

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

Experimente online!

Ele gera alguns espaços à direita, que deveriam estar OK.

Ele imprime os números usando campos justificados à esquerda de comprimento dinâmico - é isso que a string de formato %-*d serve a .

O loop interno possui alguma inicialização engraçada (começa em 10; qualquer múltiplo de 10 seria bom) para "simplificar" sua condição de terminação.

Carvão , 21 20 19 18 bytes

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

Experimente online!

Link para a versão detalhada . Basicamente, crio a parte inferior do desenho e depois reflito o texto.

CJam , 21 bytes

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

Experimente online!

Explicação

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: A primeira linha termina em 9 espaços. Explicação: Usa numeração de linha criativa! O primeiro loop precisa executar 9 vezes e excluir um espaço a cada vez, enquanto o segundo loop precisa executar 8 vezes e adicionar um espaço a cada vez. O primeiro é alcançado executando-o 7 vezes e caindo pela 8ª vez, enquanto o último é alcançado adicionando dois espaços e caindo para excluir um deles novamente.

SOGL V0.12 , 14 bytes

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

Experimente aqui!

Explicação:

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

Experimente online!

PowerShell , 30 bytes

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

Experimente online!

Constrói um intervalo de 8,7,6...2,1,0,1,2...8loops através de cada número. Dentro do loop, construímos uma série de 1..9concatenada com 0, em seguida, -joinos números na gama juntamente com o número apropriado de espaços. Cada sequência é deixada no pipeline e a saída é implícita na conclusão do programa.