ฉันคิดว่า "ส่วนโค้ง" เป็นวิธีที่ดีที่สุดในการอธิบายรูปแบบของตัวเลขนี้:

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

ที่กำหนดไว้อย่างเป็นทางการแต่ละบรรทัดประกอบด้วยตัวเลข 1 ถึง9-n, (n-1)*2การเว้นวรรคและตัวเลขที่9-nผ่าน 1 (ที่nเป็นบรรทัดปัจจุบัน)

งานของคุณคือการเขียนโดยใช้รหัสที่สั้นที่สุดที่เป็นไปได้สคริปต์ / โปรแกรมขนาดเล็กที่พิมพ์รูปแบบข้างต้นภายใต้ข้อ จำกัด ดังต่อไปนี้:

1. คุณไม่สามารถ hardcode รูปแบบทั้งหมดได้ คุณอาจ hardcode บรรทัดเดียวของรูปแบบสูงสุด
2. โปรแกรมของคุณจะต้องพิมพ์ขึ้นบรรทัดใหม่ (การรวมกันของ\nหรือ\r) ในตอนท้ายของแต่ละบรรทัด

พร้อม ... ตั้ง .... ไปกันเลย!

Python 2, 65 55 53 51

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

ย่อความคิดของ ugoren ให้สั้นลง

GolfScript (25 ตัวอักษร)

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

APL (18)

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

คำอธิบาย:

• 1↓⎕D: สตริงของตัวเลข ("0123456789") ลบองค์ประกอบแรก
• ↑∘(1↓⎕D)¨⌽⍳8: เลือกอักขระ [8..1] ตัวแรก ('12345678', '1234567' ... )
• ↑: จัดรูปแบบเป็นเมทริกซ์ (เติมอักขระที่ไม่ได้ใช้ด้วยช่องว่าง)
• k,⌽k←: เก็บในkและแสดงkตามด้วยการมิรเรอร์ตามแนวตั้งของk

Ruby: 61 50 ตัวอักษร

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

วิ่งตัวอย่าง:

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

ฉันรู้สึกว่าฉันต้องทำอะไรบางอย่างด้วยการบีบอัดมันนานเกินไปแล้วตั้งแต่ฉันใช้มันครั้งสุดท้าย ปัญหานี้รู้สึกว่าเหมาะสมที่สุดสำหรับภาษา

มันช้าอย่างน่ากลัวเนื่องจากการวนรอบการพิมพ์ที่ใช้เวลาประมาณ 8 การกระทำต่อตัวละคร

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 ตัวอักษร

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

มันจะไม่ชนะคำตอบของความผันผวน แต่นี่เป็นอีกวิธีการหนึ่งโดยใช้สตริงที่ไม่แน่นอนของ python ( bytearray):

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

แก้ไข

ฉันพบรุ่นที่สั้นกว่าโดยใช้str.replace:

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

Perl, 41

บวก-Eสวิตช์ อักขระทั้งหมดบนบรรทัดคำสั่ง: 50

ต้องการอย่างน้อย perl5, เวอร์ชัน 10

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

Mathematica 92 85 67 54 51

วิธีที่ # 1 : (54 ตัวอักษร) ทำให้อาร์เรย์ใช้แถว #, col # และระยะทางจากขอบซ้ายขวา

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

วิธีที่ # 2 : (67 chars) ช่วงที่สั้นลงเรื่อย ๆ

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

วิธีที่ # 3 : (85 ตัวอักษร) เลือกแต่ละแถวของอาร์เรย์

เริ่มต้นด้วยรายการอักขระเว้นวรรค 8 ตัว แทนที่ตำแหน่งที่ 1 และ 16 ด้วย "1"; แทนที่ "2" ที่ตำแหน่ง 2 และ 15 เป็นต้น

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

วิธีที่ # 4 : (86 ตัวอักษร) เลือกว่างในแต่ละแถวของอาร์เรย์

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

วิธีที่ # 5 : การใช้สตริง (92 ตัวอักษร)

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

PHP, 68

(ได้แรงบันดาลใจจากคำตอบของ HamZa)

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

เล่นกับข้อเท็จจริงที่ว่า str_replace ของ PHP สามารถยอมรับอาร์เรย์สำหรับการค้นหาและสตริงสำหรับแทนที่มันจะแทนที่ทุกรายการในอาร์เรย์ด้วยสตริงที่กำหนด หลังจากการวนซ้ำแต่ละครั้งหมายเลขปัจจุบันจะถูกเพิ่มไปยังอาร์เรย์การค้นหาลบออกจากลูปถัดไป

ตัวอย่างของรหัสที่ใช้งานอยู่: 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 ตัวอักษร

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"

คุณสามารถพูดคุยทั่วไปสำหรับ 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 ตัวอักษร

ได้รับคำตอบโดย steveworley (ฉันจะแสดงความคิดเห็นหากฉันสามารถทำได้):

ข้อมูลโค้ด

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>

การปรากฏตัวของ newline สุดท้ายไม่เป็นไปตามกฎ

ปรับปรุง: ตัด 2 ตัวอักษรโดยการลบวงเล็บ (ลำดับความสำคัญของผู้ให้บริการ) และ 1 โดยการลบพื้นที่ที่ไม่จำเป็นออก

ดูเหมือนว่ามันเป็นการหลอกหลอนฉันเพราะไม่ว่าฉันจะพยายามย่อหรือลดความซับซ้อนของวิธีต่าง ๆ โดยการถอดรหัสฮาร์ดโค้ดส่วนความยาวยังคงเหมือนเดิมจนกว่าฉันจะอนุญาตให้ใช้กฎ "ฉันคิดว่าจำนวนนี้" ด้านล่าง

(หากการพิมพ์นับเป็นสิ่งที่กลับมาเมื่อดำเนินการในคอนโซลโครเมี่ยม)

Brainfuck: 542 ไบต์

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

Mathematica , 59

61 ใช้ความคิดของฉัน:

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

หรือ 59 ยืมมาจากคำตอบของเดวิด:

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

จุดเริ่มต้นสำหรับบางคนในการปรับปรุง:

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

ส่วนที่เป็นไปได้มากที่สุดคือการทำให้l++reverse lจุดนั้นเป็นอิสระช่วยให้เรากำจัดสถานะlet- แต่ฉันจะหาได้apซึ่งต้องมีการนำเข้า

PostScript: 105 ตัวอักษร

การจัดการสตริงไม่ใช่เรื่องง่ายใน PS แต่สามารถสร้างรหัสที่ค่อนข้างง่ายได้

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

เวอร์ชันที่ยาวกว่าเล็กน้อยที่ 120 chars แต่สามารถสร้าง arches ตัวเลขที่แตกต่างกันโดยแทนที่ 8 ที่จุดเริ่มต้นของบรรทัดที่สองด้วยหมายเลขใด ๆ ในช่วง 1 ถึง 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 ตัวอักษร

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

Ungolfed

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

แก้ไข: ลงไปที่ 148 ด้วยคำแนะนำของ manatwork และปรับแต่งเป็น ORDER BY

อ่านได้:

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

แข็งแรงเล่นกอล์ฟ:

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

เอาท์พุท:

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

สิ่งนี้ทำงานโดยการแทนที่อักขระ> n ด้วย' 'โดยที่อักขระ n มาจาก "87654321" (ซึ่งเกิดขึ้นเป็นหางของสตริงเพื่อดำเนินการทดแทน)

PHP: 61 ตัวอักษร (หรือ 60 ตัวอักษรหากคุณแทนที่ \ n ด้วยบรรทัดใหม่ ASCII จริง)

(ได้แรงบันดาลใจจากคำตอบของ GigaWatt และ HamZa)

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

http://ideone.com/FV1NXu

PowerShell: 38

รหัส Golfed

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

เกมส์

8..1|%{... }ไปป์จำนวนเต็มตั้งแต่ 8 ถึง 1 ไปยังวน ForEach-Object
-join(... )รวมเอาท์พุทของรหัสที่ซ้อนกันในสตริงเดียวโดยไม่มีตัวคั่น
1..$_เอาต์พุตจำนวนเต็มเรียงจาก 1 ถึงจำนวนเต็มปัจจุบันในลูป
+" "*(8-$_)เพิ่มช่องว่างสองครั้งคูณด้วยความแตกต่างระหว่าง 8 และจำนวนเต็มปัจจุบันไปยังเอาท์พุท
+$_..1เพิ่มจำนวนเต็มจากมากไปที่ 1 ถึงเอาต์พุต

Javascript กับ 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")

สามารถตรวจสอบได้ใน Firefox

CJam, 22 ตัวอักษร

ไม่ใช่คำตอบที่ถูกต้อง (เนื่องจากภาษาได้รับการพัฒนาหลังจากคำถาม) และไม่ใช่คำตอบที่สั้นที่สุด แต่จะไปที่:

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

ลองออนไลน์ได้ที่นี่

ลัวะอายุ 62 ปี

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