Supuse que un "arco" era la mejor manera de describir este patrón de números:

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

Definida formalmente, cada línea consta de los números del 1 al 1 9-n, los (n-1)*2espacios y los números del 9-n1 al 1 (donde nestá la línea actual).

Su tarea es escribir, utilizando el código más corto posible, un pequeño script / programa que imprima el patrón anterior sujeto a las siguientes restricciones:

1. No puede codificar todo el patrón. Solo puede codificar una sola línea del patrón como máximo.
2. Su programa debe imprimir una nueva línea (cualquier combinación de \no \r) al final de cada línea.

¡En sus marcas, listos, fuera!

Pitón 2, 65 55 53 51

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

Acortado usando algunas de las ideas de ugoren .

GolfScript (25 caracteres)

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

APL (18)

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

Explicación:

• 1↓⎕D: la cadena de dígitos ("0123456789") menos su primer elemento
• ↑∘(1↓⎕D)¨⌽⍳8: seleccione los primeros [8..1] caracteres ('12345678', '1234567' ...)
• ↑: formato como matriz (rellenando los caracteres no utilizados con espacios en blanco)
• k,⌽k←: almacenar ky mostrar kseguido por la duplicación vertical dek

Ruby: 61 50 caracteres

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

Ejecución de muestra:

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

Sentí que tenía que hacer algo con befunge, ha pasado mucho tiempo desde la última vez que lo usé. Este problema se sintió más apropiado para el idioma.

Es terriblemente lento debido al ciclo de impresión que toma alrededor de 8 acciones por personaje (los estilos de conteo difieren).

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 caracteres

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

Pitón 2, 75 62

No superará la respuesta de Volatility, pero aquí hay otro enfoque que utiliza cadenas mutables de python ( bytearray):

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

Editar

Encontré una versión más corta, usando str.replace:

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

Perl, 41

-Einterruptor más Total de caracteres en la línea de comando: 50

requiere al menos perl5, versión 10.

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

Mathematica 92 85 67 54 51

Método n. ° 1 : (54 caracteres) Crea una matriz usando la fila n. °, n. ° col. Y la distancia desde el borde izquierdo-derecho.

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

Método # 2 : (67 caracteres) Alcanzar rangos de acortamiento.

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

Método # 3 : (85 caracteres) Llena selectivamente cada fila de una matriz.

Comience con la lista de 8 caracteres espaciales. Reemplace las posiciones 1 y 16 con "1"; reemplace "2" en las posiciones 2 y 15, etc.

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

Método 4 : (86 caracteres) Vacíe selectivamente cada fila de una matriz.

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

Método # 5 : Usando cadenas (92 caracteres)

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

PHP, 68

(Inspirado por la respuesta de HamZa)

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

Se basa en el hecho de que str_replace de PHP puede aceptar una matriz para búsqueda y una cadena para reemplazar, reemplazará cada elemento de la matriz con la cadena dada. Después de cada iteración, el número actual se agrega a la matriz de búsqueda, eliminándolo del siguiente ciclo.

Ejemplo del código en acción: 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

Pseudocódigo:

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 caracteres

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"

Puedes generalizarlo por 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 caracteres

Inspirado por la respuesta de steveworley (comentaría si pudiera):

Fragmento de código

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 presencia de la última línea nueva sigue las reglas.

actualización: corte 2 caracteres eliminando paréntesis (precedencia del operador) y 1 eliminando un espacio innecesario

Parecía que me estaba molestando, porque no importa cuántas formas diferentes traté de acortar o simplificar al descodificar un segmento de código, la longitud se mantuvo igual hasta que dejé que se aplicara la regla "Creo que esto cuenta" que se escribe a continuación.

(Si la impresión cuenta como lo que vuelve cuando esto se ejecuta en la consola de Chrome)

Brainfuck: 542 bytes

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

Mathematica , 59

61 usando mis propias ideas:

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

O 59, tomando prestado de la respuesta 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 punto de partida para que alguien mejore:

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

La parte más probable sería l++reverse lliberar el punto, permitiéndonos deshacernos de la letdeclaración, pero podría encontrar que era ap, lo que requiere importaciones.

PostScript: 105 caracteres

El manejo de cadenas no es fácil en PS pero puede generar un código relativamente simple:

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

Una versión un poco más larga con 120 caracteres, pero puede generar diferentes arcos de números reemplazando el 8 al comienzo de la segunda línea con cualquier número en el rango de 1 a 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 caracteres

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

Sin 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

Editar: hasta 148 con la sugerencia de manatwork y ajustar a ORDER BY.

Legible:

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

Golfizado:

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

Salida:

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

Esto funciona reemplazando los caracteres> n con ' ', donde los caracteres n provienen de "87654321" (que resulta ser la cola de la cadena para realizar la sustitución).

PHP: 61 caracteres (o 60 caracteres si reemplaza el \ n por una nueva línea ASCII real)

(Inspirado por la respuesta de GigaWatt y HamZa)

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

http://ideone.com/FV1NXu

PowerShell: 38

Código de golf

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

Tutorial

8..1|%{... }canalizar enteros de 8 a 1 en un bucle ForEach-Object.
-join(... )une la salida del código anidado en una sola cadena sin delimitadores.
1..$_emite enteros ascendentes de 1 al entero actual en el bucle.
+" "*(8-$_)agrega un doble espacio, multiplicado por la diferencia entre 8 y el entero actual, a la salida.
+$_..1agrega enteros, descendiendo del entero actual a 1, a la salida.

Javascript con 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")

Se puede verificar en Firefox.

CJam, 22 caracteres

No es una respuesta válida (ya que el lenguaje se desarrolló después de la pregunta), y tampoco la más corta, pero aquí va:

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

Pruébalo en línea aquí

Lua, 62

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