Inspiré par la sortie boguée de la réponse Clojure de @Carcigenicate pour le défi Print this diamond .

Imprimer ce texte exact:

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

(Du milieu vers l'extérieur dans les deux sens, chaque chiffre est séparé par un espace de plus que la ligne précédente.)

Règles du challenge:

• Il n'y aura aucune entrée ( ou une entrée vide non utilisée ).
• Les espaces de fin sont facultatifs.
• Une nouvelle nouvelle ligne est facultative.
• Les espaces de début ou les nouvelles lignes ne sont pas autorisés.
• Renvoyer un tableau de chaînes n'est pas autorisé. Vous devriez soit sortir le texte, soit avoir une fonction qui renvoie une seule chaîne avec un résultat correct.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
• Les règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type de retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Ajoutez également une explication si nécessaire.

SOGL V0.12 , 12 octets

9{SUē↕∑}¹№╬«

Essayez-le ici! Explication:

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 octets

i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17

Essayez-le en ligne!

@Leaky Nun a beaucoup aidé à jouer au golf, @Praind a suggéré une méthode pour sauvegarder 1 octet, ce à quoi j'avais pensé auparavant, mais j'avais oublié de l'éditer, @CotyJohnathanSaxman a suggéré de changer la boucle.

Explication

• i=8- Attribue la valeur 8à une variable appelée i.

• exec"..."*17- Exécutez ce bloc de code ( ...) 17 fois.

• print(...) - Affiche le résultat.

• ' '*abs(i)- Créez une chaîne avec un espace répété plusieurs |i|fois.

• .join('1234567890')- Entrelacez la chaîne créée ci-dessus avec 1234567890, de telle sorte que des |i|espaces soient insérés entre les chiffres.

• i-=1- Décrémente i, et en l'exécutant 17 fois, il atteint -8ce qui crée un motif répétitif à l'aide de abs().

Vim, 35 octets:

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

Explication:

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 octets

17F9ÝÀN8αð×ý,

Essayez-le en ligne!

Explication

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 octets (102 octets compilés avec basicstub)

Ceci est le plus proche que je pourrais obtenir en raison de limitations évidentes:

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

(Pourrait probablement être optimisé un peu)

TSQL, 220 148 octets

Amélioration publiée par 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 @

Sortie:

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 octets

↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D

Essayez-le en ligne!

⎕D D igits de zéro à neuf

1⌽ tourner un pas à droite (met zéro à la fin)

⊂ joindre (à traiter comme une unité)

(… )↑¨¨ Pour chacun de ces chiffres, prenez autant de caractères de chacune des lettres:

 ⍳17 un à dix-sept

 ¯9+ soustraire neuf

 | trouver les valeurs absolues

 1+ ajoute un

∊¨ enrôler (aplatir) chaque

↑ changer une couche de profondeur en un niveau de rang (matrifier)

Haskell , 58 55 octets

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

Essayez-le en ligne!

Ceci est fondamentalement la solution de @nimi :)

Java 11 (JDK) , 98 octets

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

Essayez-le en ligne!

• -14 octets en passant à JDK 11, qui a maintenant un natif String::repeat.

Réponse précédente ( Java (OpenJDK 8) ), 113 112 octets

o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}

Essayez-le en ligne!

Des explications

Je construis essentiellement les String17 fois suivants ( Nest une variable, pas une valeur réelle):

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

Ce sont tous les chiffres attendus, joints par %1$Nsoù Nest le nombre d'espaces entre chaque chiffre.

%1$Nssignifie fondamentalement "prendre le premier argument et le patiner jusqu'à ce que sa longueur soit au moins N". En outre, %1$0sn'est pas pris en charge, donc un cas particulier %1$sest fait pour 0.

Enfin, je formate cette chaîne en utilisant un seul argument "":, le formateur réutilise donc toujours la même chaîne vide en la complétant avec des espaces, le cas échéant.

Enregistre

• 1 octet grâce à Kevin Cruijssen

Japt -R , 19 18 16 14 13 octets

Aõ%A
£qYçÃÔÅê

Testez-le ou essayez-le en ligne

Explication

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 octets

Merci Shaggy pour la sauvegarde de 10 octets. Merci Craig d' avoir sauvé 1 octet. Merci arcs pour la sauvegarde de 4 octets.

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 octets

Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ

Essayez-le en ligne!

Un octet enregistré grâce à Leaky Nun .

Explication

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

Charbon de bois , 18 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

Remarque: Cast(1)prend le même nombre d’octets car "1"il faudrait un séparateur avant ":"(ce qui fait que le déverbosifiant ne parvient pas à insérer).

R , 108 octets

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

Il suffit de coller et de réduire les chaînes.

Essayez-le en ligne!

Edit: merci à Challenger5 pour avoir signalé un problème. Fixé maintenant.

Edit 2: sauvegardé un octet grâce à Bouncyball.

Python 3 , 58 57 54 octets

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

Essayez-le en ligne!

(merci à @flornquake pour les trois derniers octets; j'ai complètement oublié d'utiliser seppour sauver vs .join)

Pyth , 14 à 13 octets

1 octet grâce à Mnemonic.

V17j*da8NeMST

Essayez-le en ligne!

Java 8, 235 234 206 163 octets

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

Mise à jour : -28 octets grâce à Leaky Nun!
Mise à jour 2 : -43 octets à nouveau grâce à Leaky Nun!

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

Essayez-le en ligne

EDIT: Le code précédemment était faux! Faites une erreur en jouant au code, cela devrait fonctionner comme prévu maintenant!

Coque , 21 octets

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

Ceci est un programme complet qui s’imprime sur STDOUT. Essayez-le en ligne! Il y a beaucoup d'espaces de fuite.

Explication

Il manque encore à Husk beaucoup de choses essentielles, comme une fonction de plage à deux arguments, de sorte que certaines parties de cette solution sont un peu hacky.

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 octets

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @

Mis à jour pour utiliser:

• master..spt_valuesgénérer des nombres ( WHERE type = 'P'ils sont toujours consécutifs à partir de 0)
• L' TOP 17idée de @ ZLK
• PRINT (pour obéir aux règles - pas de listes de chaînes)
• La bonne idée de @ JanDrozen d'inclure le retour chariot dans la chaîne (je l'ai compté comme un seul octet - Windows CRLF quoi?)
• Idée de @Bridge à utiliser simplement @ pour le nom de variable - toutes ces astuces !!

Résultats:

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

(Merci @JanDrozen pour l'idée de remplacer)

Clojure, 126 à 99 octets

-27 en corrigeant quelques bêtises. L'utilisation extérieure de an'était pas nécessaire, j'ai donc pu m'en débarrasser acomplètement et écrire apply strune seule fois. Cela m'a également permis d'utiliser une macro de fonction pour la fonction principale, qui économisait quelques octets. J'ai également ajouté l'appel à Math/absau lieu de renvoyer un appel n-spaces.

Fondamentalement, un portage Clojure de l’idée Python de @ Mr.Xcoder. Rétrospectivement, j'aurais dû utiliser la méthode abs/ rangepour le challenge diamant à l'origine, mais je n'aurais peut-être pas produit la sortie avec un bug!

Assez simple. Joint la chaîne numérique avec un nombre d'espaces dépendant de la ligne en cours.

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

Gelée , 15 octets

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

Essayez-le en ligne!

Mathematica, 92 octets

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

Essayez-le en ligne

copier / coller du code avec ctrl-v,
appuyez sur Maj + Entrée pour exécuter

C, 97 octets

i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}

Votre compilateur va probablement se plaindre beaucoup de ce code; le mien a jeté 7 avertissements de 4 types différents. Peut améliorer le code plus tard.

Essayez-le en ligne!

C (gcc) , 76 octets

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

Essayez-le en ligne!

Il génère des espaces de fin, ce qui est supposé être OK.

Il imprime les nombres en utilisant des champs de longueur dynamique justifiés à gauche - c'est à cela que %-*dsert la chaîne de formatage .

La boucle interne a une initialisation amusante (commence à 10; tout multiple de 10 conviendrait) pour "simplifier" sa condition de terminaison.

Charbon de bois , 21 20 19 18 octets

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

Essayez-le en ligne!

Lien vers la version commentée . Fondamentalement, je crée la partie inférieure du dessin puis reflète le texte.

CJam , 21 octets

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

Essayez-le en ligne!

Explication

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

Lot, 163 octets

@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%%%

Remarque: la première ligne se termine par 9 espaces. Explication: Utilise la numérotation de ligne de création! La première boucle doit être exécutée 9 fois et supprimer un espace à chaque fois, tandis que la deuxième boucle doit être exécutée 8 fois et ajouter un espace à chaque fois. Le premier est obtenu en le lançant 7 fois et en échouant pour la 8ème fois, tandis que le dernier est obtenu en ajoutant deux espaces et en supprimant l'un d'entre eux.

SOGL V0.12 , 14 octets

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

Essayez-le ici!

Explication:

ā               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 octets

for(;$i<17;)echo join(str_pad("",abs($i++-8)),range(1,9)+[9=>0]),"
";

Essayez-le en ligne!

PowerShell , 30 octets

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

Essayez-le en ligne!

Construit une plage de 8,7,6...2,1,0,1,2...8puis boucle à travers chaque nombre. A l' intérieur de la boucle , nous construisons une gamme de 1..9concaténé avec 0puis -joinles chiffres dans la plage ainsi que le nombre approprié d'espaces. Chaque chaîne est laissée sur le pipeline et la sortie est implicite à la fin du programme.