J'ai pensé qu'un "arc" était la meilleure façon de décrire ce modèle de nombres:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Formellement définie, chaque ligne se compose des nombres 1 à 9-n, des (n-1)*2espaces et des nombres 9-nà 1 (où nest la ligne actuelle).

Votre tâche consiste à écrire, en utilisant le code le plus court possible, un petit script / programme qui imprime le modèle ci-dessus soumis aux restrictions suivantes:

1. Vous ne pouvez pas coder en dur le motif entier. Vous ne pouvez coder en dur qu'une seule ligne du modèle au maximum.
2. Votre programme doit imprimer une nouvelle ligne (toute combinaison de \nou \r) à la fin de chaque ligne.

Prêt ... prêt ... partez!

Python 2, 65 55 53 51

s=12345678
while s:r='%-8d'%s;print r+r[::-1];s/=10

Raccourci en utilisant certaines des idées d' Ugoren .

GolfScript (25 caractères)

8,{.~10,<1>\' '*.2$-1%n}/

APL (18)

k,⌽k←↑↑∘(1↓⎕D)¨⌽⍳8

Explication:

• 1↓⎕D: la chaîne de chiffres ("0123456789") moins son premier élément
• ↑∘(1↓⎕D)¨⌽⍳8: sélectionnez les premiers [8..1] caractères ('12345678', '1234567' ...)
• ↑: formater comme matrice (remplir les caractères non utilisés avec des blancs)
• k,⌽k←: stockage ket affichage ksuivis de la mise en miroir verticale dek

Rubis: 61 50 caractères

s="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}

Exemple d'exécution:

bash-4.2$ ruby -e 's="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}'
1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Befunge - 3 x 18 = 54

Je sentais que je devais faire quelque chose avec befunge, ça faisait trop longtemps que je ne l'avais pas utilisé. Ce problème semblait le plus approprié pour la langue.

Il est horriblement lent en raison de la boucle d'impression qui prend environ 8 actions par caractère (les styles de comptage diffèrent).

80v >#v"12345678"<
>5 *^ >,#$:_$:1-:v
^2< 0p0+7\*48\_@#<

JavaScript, 71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))

C, 83 caractères

main(a,b,n){
    for(a=12345678,n=1e8,b=n-a-1;a;a/=10)
        printf("%-8d%8d\n",a,b),
        b%=n/=10;
}

Python 2, 75 62

Cela ne battra pas la réponse de Volatility, mais voici une autre approche utilisant les chaînes mutables de python ( bytearray):

s=bytearray('1234567887654321')
for i in range(8):s[8-i:8+i]=i*'  ';print s

modifier

J'ai trouvé une version plus courte, en utilisant str.replace:

s='1234567887654321'
for c in s[8:]:print s;s=s.replace(c,' ')

Perl, 41

plus -Einterrupteur. Nombre total de caractères sur la ligne de commande: 50

nécessite au moins perl5, version 10.

perl -E'say@!=1..8-$_,$"x(2*$_),reverse@!for-0..7'

Mathematica 92 85 67 54 51

Méthode n ° 1 : (54 caractères) Crée un tableau en utilisant la ligne #, le col # et la distance à partir du bord gauche-droite.

Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]

Méthode n ° 2 : (67 caractères) Remplissez les plages toujours plus courtes.

Print@@@Table[Join[k = PadRight[Range@i, 8, " "], Reverse@k], {i, 8, 1, -1}];

Méthode n ° 3 : (85 caractères) Remplissez sélectivement chaque ligne d'un tableau.

Commencez par une liste de 8 caractères d'espace. Remplacez les positions 1 et 16 par "1"; remplacer "2" aux positions 2 et 15, etc.

p = 0; q = 16;
Print @@@Reverse@Rest@NestList[ReplacePart[#, {++p -> p, q-- -> p}]&,Array[" "&,q], 8];

Méthode n ° 4 : (86 caractères) Videz sélectivement chaque ligne d'un tableau.

p=8;q=9;
Print@@@NestList[ReplacePart[#,{p---> " ",q++-> " "}]&,Join[k=Range@8,Reverse@k],7];

Méthode n ° 5 : utilisation de chaînes (92 caractères)

p=8;s="12345678";
Print[#,StringReverse@#]&/@NestList[StringReplace[#,ToString@p-- ->  " "]&,s,7];

PHP, 68

(Inspiré par la réponse de HamZa)

for($n=8;$n;$r[]=$n--)echo str_replace($r," ","1234567887654321\n");

Joue sur le fait que str_replace de PHP peut accepter un tableau pour la recherche et une chaîne pour le remplacer, il remplacera chaque élément du tableau par la chaîne donnée. Après chaque itération, le numéro actuel est ajouté au tableau de recherche, le supprimant de la boucle suivante.

Exemple de code en action: http://ideone.com/9wVr0X

Marbelous 165

@0
08
>0
LN
--
@0
:LN
}0}0}0}0
..SAPSSD0A
{0
:PS
}0
~~09
..//
<<@0
\\>0
&0//
--@1
@020
&0/\&0
@1
:SA
@0
}0
>0!!
--00@1
@0++//
+O/\@1
+O
:SD
}0@0
\\>0\/
--/\+O
@0..+O

Pseudocode:

MB():
    for x in 8..1:
        LN(x)
LN(x):
    SA(x)
    PS(x)
    SD(x)
    print "\n"
PS(x):
    print " "*(8-x)*2
SA(x):
    for n in 1..x:
        print n
SD(x):
    for n in x..1:
        print n

Python 2.x - 73 65 63 61 caractères

c=1;s='87654321'
while c<9:print s[::-1]+s;s=' '*c+s[c:];c+=1

PHP, 76

for($i=9;$i>1;){$r[]=$i--;echo str_replace($r,' ','1234567887654321')."\r";}

K, 28

-1_a,'|:'a:8$'{-1_x}\,/$1+!8

.

k)-1_a,'|:'a:8$'{-1_x}\,/$1+!8
"1234567887654321"
"1234567  7654321"
"123456    654321"
"12345      54321"
"1234        4321"
"123          321"
"12            21"
"1              1"

Vous pouvez le généraliser pour 36: {-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x}

k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 5
"1234554321"
"1234  4321"
"123    321"
"12      21"
"1        1"
q)k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 15
"123456789101112131415514131211101987654321"
"12345678910111213141  14131211101987654321"
"1234567891011121314    4131211101987654321"
"123456789101112131      131211101987654321"
"12345678910111213        31211101987654321"
"1234567891011121          1211101987654321"
"123456789101112            211101987654321"
"12345678910111              11101987654321"
"1234567891011                1101987654321"
"123456789101                  101987654321"
"12345678910                    01987654321"
"1234567891                      1987654321"
"123456789                        987654321"
"12345678                          87654321"
"1234567                            7654321"
"123456                              654321"
"12345                                54321"
"1234                                  4321"
"123                                    321"
"12                                      21"
"1                                        1"

Javascript, 67 caractères

Inspiré par la réponse de steveworley (je commenterais si je pouvais):

Extrait de code

a='1234567887654321\n',b='',c=10;while(--c)b+=a=a.split(c).join(' ')

<a href="#" onclick="javascript:document.getElementById('output').innerHTML = b;">Display</a>
<pre id="output">...</pre>

La présence de la dernière nouvelle ligne suit les règles.

mise à jour: couper 2 caractères en supprimant les parenthèses (priorité de l'opérateur) et 1 en supprimant un espace inutile

Il me semblait que ça me trollait, car peu importe combien de façons différentes j'ai essayé de raccourcir ou de simplifier en décodant un segment de code, la longueur est restée la même jusqu'à ce que je laisse la règle "Je pense que cela compte" écrite ci-dessous s'appliquer.

(Si l'impression compte comme ce qui revient quand cela est exécuté dans la console chrome)

Brainfuck: 542 octets

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.

Mathematica , 59

61 en utilisant mes propres idées:

Grid[Clip[#~Join~Reverse@#&@Range@8,{1,9-#},{," "}]&~Array~8]

Ou 59, empruntant à la réponse de David:

Grid@Array[Join[k=PadRight[Range[9-#],8," "],Reverse@k]&,8]

R: 52

for(i in 8:1)cat(1:i,rep(" ",16-2*i),i:1,"\n",sep="")

Haskell, 84

Un point de départ pour que quelqu'un s'améliore:

mapM_ putStrLn[let l=take(8-i)"12345678"++replicate i ' 'in l++reverse l|i<-[0..7]]

La partie la plus probable serait de faire valoir le l++reverse lpoint gratuitement, nous permettant de nous débarrasser de la letdéclaration, mais je pourrais trouver que c'était ap, ce qui nécessite des importations.

PostScript: 105 caractères

La gestion des chaînes n'est pas facile dans PS mais peut rendre le code relativement simple:

0 1 7{(1234567887654321)dup
8 3 index sub(              )0 6 -1 roll 2 mul getinterval putinterval =}for

Une version légèrement plus longue à 120 caractères mais peut générer des arcs numériques différents en remplaçant le 8 au début de la deuxième ligne par un nombre compris entre 1 et 9:

/D{dup}def/R{repeat}def/P{=print}def
8 D -1 1{1 1 index{D P 1 add}R pop 2 copy sub{(  )P}R D{D P 1 sub}R pop()=}for pop

GoRuby 2.1

36 caractères

8.w(1){|x|a=[*1..x].j.lj 8;s a+a.rv}

Non golfé

8.downto(1) do |x|
  a = [*1..x].join.ljust(8)
  puts a + a.reverse
end

K 20

{x,'|:'x:|x$,\$1+!x}    

q)k){x,'|:'x:|x$,\$1+!x}8    
"1234567887654321"    
"1234567  7654321"    
"123456    654321"    
"12345      54321"    
"1234        4321"      
"123          321"    
"12            21"    
"1              1"    

TSQL, 148

Edit: jusqu'à 148 avec la suggestion de manatwork et ajustez à ORDER BY.

Lisible:

WITH t AS(
    SELECT 1n, CAST(1 AS VARCHAR(MAX)) o
 UNION ALL
    SELECT n+1,o+CHAR(n+49)
    FROM t
    WHERE n<8
)
SELECT o  + SPACE(16-2*n) + REVERSE(o)
FROM t
ORDER BY 1 DESC

Golfé:

WITH t AS(SELECT 1n,CAST(1AS VARCHAR(MAX))o UNION ALL SELECT 1+n,o+CHAR(n+49)FROM t WHERE n<8)SELECT o+SPACE(16-2*n)+REVERSE(o)FROM t ORDER BY 1DESC

Sortie:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Haskell, 79

r n x|x>n=' '|True=x
t="87654321"
main=mapM(putStrLn.(`map`("12345678"++t)).r)t

Cela fonctionne en remplaçant les caractères> n par ' ', où les caractères n proviennent de "87654321" (qui se trouve être la queue de la chaîne pour effectuer la substitution).

PHP: 61 caractères (ou 60 caractères si vous remplacez le \ n par un véritable saut de ligne ASCII)

(Inspiré par la réponse de GigaWatt et HamZa)

for($n=9;$n;$r[$n--]=" ")echo strtr("1234567887654321\n",$r);

http://ideone.com/FV1NXu

PowerShell: 38

Code golf

8..1|%{-join(1..$_+"  "*(8-$_)+$_..1)}

Procédure pas à pas

8..1|%{... }canalisez les entiers de 8 à 1 dans une boucle ForEach-Object.
-join(... )joint la sortie du code imbriqué en une seule chaîne sans délimiteurs.
1..$_renvoie des entiers allant de 1 à l'entier courant dans la boucle.
+" "*(8-$_)ajoute un double espace, multiplié par la différence entre 8 et l'entier courant, à la sortie.
+$_..1ajoute des entiers, descendant de l'entier courant à 1, à la sortie.

Javascript avec lambdas, 147

(s="12345678")[r="replace"](/./g,i=>s[r](RegExp(".{"+(i-1)+"}$"),Array(i*2-1).join(" ")))[r](/\d{1,8} */g,m=>m+(Array(m%10+1).join(m%10+1)-m)+"\n")

Peut être vérifié dans Firefox.

CJam, 22 caractères

Pas une réponse valide (car le langage a été développé après la question), et pas le plus court non plus, mais voici:

8,{S*_,9-~,:)\_2$W%N}%

Essayez-le en ligne ici

Lua, 62

s='1234567887654321'for i=8,1,-1 do print(s)s=s:gsub(i,' ')end