Tôi nghĩ rằng một "vòm" là cách tốt nhất để mô tả mẫu số này:

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

Chính thức được xác định, mỗi dòng bao gồm các số từ 1 đến 9-n, (n-1)*2khoảng trắng và các số 9-ntừ 1 (trong đó nlà dòng hiện tại).

Nhiệm vụ của bạn là viết, sử dụng mã ngắn nhất có thể, một tập lệnh / chương trình nhỏ in mẫu trên phải tuân theo các hạn chế sau:

1. Bạn có thể không mã hóa toàn bộ mô hình. Bạn chỉ có thể mã hóa một dòng duy nhất của mẫu.
2. Chương trình của bạn phải in một dòng mới (bất kỳ sự kết hợp nào của \nhoặc \r) ở cuối mỗi dòng.

Sẵn sàng ... đặt .... đi!

Con trăn 2, 65 55 53 51

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

Rút ngắn bằng cách sử dụng một số ý tưởng của ugoren .

GolfScript (25 ký tự)

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

APL (18)

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

Giải trình:

• 1↓⎕D: chuỗi các chữ số ("0123456789") trừ phần tử đầu tiên của nó
• ↑∘(1↓⎕D)¨⌽⍳8: chọn các ký tự [8..1] đầu tiên ('12345678', '1234567' ...)
• ↑: định dạng dưới dạng ma trận (điền vào các ký tự không sử dụng bằng khoảng trắng)
• k,⌽k←: lưu trữ trong kvà hiển thị ktheo sau là phản chiếu dọc củak

Ruby: 61 50 ký tự

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

Chạy mẫu:

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

Tôi cảm thấy mình phải làm gì đó với befunge, đã quá lâu kể từ lần cuối tôi sử dụng nó. Vấn đề này cảm thấy thích hợp nhất cho ngôn ngữ.

Nó chậm kinh khủng do vòng lặp in mất khoảng 8 hành động cho mỗi ký tự (kiểu đếm khác nhau).

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 ký tự

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

Con trăn 2, 75 62

Nó sẽ không đánh bại câu trả lời của Volatility, nhưng đây là một cách tiếp cận khác sử dụng chuỗi có thể thay đổi của python ( bytearray):

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

Chỉnh sửa

Tôi tìm thấy một phiên bản ngắn hơn, sử dụng str.replace:

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

Perl, 41

-Ecông tắc cộng . Tổng số ký tự trên dòng lệnh: 50

yêu cầu ít nhất perl5, phiên bản 10.

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

Toán học 92 85 67 54 51

Phương pháp # 1 : (54 ký tự) Tạo mảng bằng cách sử dụng hàng #, col # và khoảng cách từ cạnh trái phải.

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

Phương pháp # 2 : (67 ký tự) Phạm vi rút ngắn bao giờ.

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

Phương pháp # 3 : (85 ký tự) Chọn lọc điền vào từng hàng của một mảng.

Bắt đầu với danh sách 8 ký tự không gian. Thay thế vị trí 1 và 16 bằng "1"; thay thế "2" tại vị trí 2 và 15, v.v.

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

Phương pháp # 4 : (86 ký tự) Chọn lọc trống mỗi hàng của một mảng.

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

Phương pháp # 5 : Sử dụng chuỗi (92 ký tự)

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

PHP, 68

(Lấy cảm hứng từ câu trả lời của HamZa)

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

Chơi trên thực tế là str numplace của PHP có thể chấp nhận một mảng để tìm kiếm và một chuỗi để thay thế, nó sẽ thay thế mọi mục trong mảng bằng chuỗi đã cho. Sau mỗi lần lặp, số hiện tại được thêm vào mảng tìm kiếm, loại bỏ nó khỏi vòng lặp tiếp theo.

Ví dụ về mã đang hoạt động: 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

Mã giả:

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 ký tự

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"

Bạn có thể khái quát nó cho 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 ký tự

Bị ám ảnh bởi câu trả lời của steveworley (tôi sẽ bình luận nếu tôi có thể):

Đoạn mã

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>

Sự hiện diện của dòng mới cuối cùng không theo quy tắc.

cập nhật: cắt 2 ký tự bằng cách xóa dấu ngoặc đơn (ưu tiên toán tử) và 1 bằng cách xóa khoảng trắng không cần thiết

Có vẻ như nó đang troll tôi, bởi vì dù tôi có cố gắng rút ngắn hay đơn giản hóa bao nhiêu cách khác nhau bằng cách không mã hóa một đoạn mã, độ dài vẫn giữ nguyên cho đến khi tôi áp dụng quy tắc "Tôi nghĩ số đếm này" được viết dưới đây.

(Nếu việc in được tính là những gì quay lại khi điều này được thực thi trong bảng điều khiển chrome)

Brainfuck: 542 byte

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

Toán học , 59

61 sử dụng ý tưởng của riêng tôi:

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

Hoặc 59, mượn từ câu trả lời của 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

Điểm khởi đầu để ai đó cải thiện:

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

Phần lớn khả năng sẽ là làm cho l++reverse lđiểm miễn phí, cho phép chúng tôi thoát khỏi trạng thái let, nhưng tôi có thể tìm thấy là ap, yêu cầu nhập khẩu.

PostScript: 105 ký tự

Xử lý chuỗi không dễ dàng trong PS nhưng có thể tạo mã tương đối đơn giản:

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

Một phiên bản dài hơn một chút ở 120 ký tự nhưng có thể tạo ra các vòm số khác nhau bằng cách thay thế số 8 ở đầu dòng thứ hai bằng bất kỳ số nào trong phạm vi từ 1 đến 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 ký tự

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

Bị đánh cắp

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

Chỉnh sửa: xuống 148 với đề xuất của manatwork và chỉnh sửa để ĐẶT HÀNG B .NG.

Có thể đọc được

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

Chơi gôn

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

Đầu ra:

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

Điều này hoạt động bằng cách thay thế các ký tự> n bằng ' ', trong đó các ký tự n có nguồn gốc từ "87654321" (điều này xảy ra là đuôi của chuỗi để thực hiện thay thế trên).

PHP: 61 ký tự (hoặc 60 ký tự nếu bạn thay thế \ n bằng một dòng mới ASCII thực sự)

(Lấy cảm hứng từ câu trả lời của GigaWatt và HamZa)

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

http://ideone.com/FV1NXu

PowerShell: 38

Mã đánh gôn

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

Hướng dẫn

8..1|%{... Các }số nguyên ống từ 8 đến 1 thành một vòng lặp ForEach-Object.
-join(... )nối đầu ra của mã được lồng vào một chuỗi không có dấu phân cách.
1..$_đầu ra số nguyên tăng dần từ 1 đến số nguyên hiện tại trong vòng lặp.
+" "*(8-$_)thêm một không gian kép, nhân với chênh lệch giữa 8 và số nguyên hiện tại, cho đầu ra.
+$_..1thêm số nguyên, giảm dần từ số nguyên hiện tại xuống 1, vào đầu ra.

Javascript với 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")

Có thể được kiểm tra trong Firefox.

CJam, 22 ký tự

Không phải là một câu trả lời hợp lệ (vì ngôn ngữ đã được phát triển sau câu hỏi) và cũng không phải là câu trả lời ngắn nhất, nhưng đây là:

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

Dùng thử trực tuyến tại đây

Lua, 62

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