บทสรุปผู้บริหาร

ให้ข้อมูลที่เป็นตัวแทนของเวกเตอร์สองตัวและ "น้ำหนัก" ตามลำดับของพวกเขาสร้างผลลัพธ์ที่แสดงถึงผลรวมถ่วงน้ำหนักของเวกเตอร์เหล่านั้น

ท้าทาย

อินพุตจะประกอบด้วยหนึ่งหรือหลายบรรทัดของอักขระต่อไปนี้:

• เกิดขึ้นหนึ่งหลักของ 0 ซึ่งหมายถึงต้นกำเนิดในระนาบสองมิติ;
• ตัวเลขสองหลักอื่น ๆ อย่างแน่นอน (1-9; อาจหรืออาจไม่ใช่ตัวเลขเดียวกัน) ซึ่งตำแหน่งที่สัมพันธ์กับจุดเริ่มต้นเป็นตัวแทนเวกเตอร์และค่าที่เป็นตัวแทนของน้ำหนักที่แนบมากับเวกเตอร์เหล่านั้น
• จำนวน "อักขระพื้นหลัง" บางส่วน ตัวแก้ไขอาจเลือกอักขระพื้นหลังเฉพาะ ตัวอย่างเช่นฉันจะเลือก "." (ส่วนใหญ่สำหรับการอ่านของมนุษย์) อีกวิธีหนึ่งตัวอักษรพื้นหลังสามารถเป็นอะไรก็ได้ที่มีลักษณะเหมือนพื้นที่ว่าง

(ตัวแก้ปัญหาสามารถเลือกได้ว่าอินพุตเป็นสตริงหลายบรรทัดเดียวหรือหลายอาร์เรย์ของสตริงหนึ่งบรรทัด)

ตัวอย่างเช่นการป้อนข้อมูล

....2
.0...
...3.

หมายถึงเวกเตอร์ที่พิกัด (3,1) ที่มีน้ำหนัก 2 และเวกเตอร์ที่พิกัด (2, -1) ที่มีน้ำหนัก 3

เอาต์พุตควรใกล้เคียงกับอินพุตโดยมีการเปลี่ยนแปลงต่อไปนี้:

• "อักขระผลลัพธ์" ซึ่งเลือกโดยตัวแก้จะถูกเพิ่มในตำแหน่งที่ระบุโดยผลรวมถ่วงน้ำหนักของเวกเตอร์อินพุต (เท่ากัน ณ ตำแหน่งที่เป็นการรวมเชิงเส้นที่เหมาะสมของอินพุตเวกเตอร์)
• อักขระพื้นหลังมากที่สุดเท่าที่จำเป็นเพื่อให้พอดีกับจุดเริ่มต้นทั้งสองเวกเตอร์อินพุตและเวกเตอร์ผลลัพธ์ในภาพเดียวกัน สามารถรวมอักขระพื้นหลังเพิ่มเติมได้หากต้องการ ข้อ จำกัด เพียงอย่างเดียวคือถ้าตัวอักษรพื้นหลังเป็นตัวอักษรที่มองเห็นได้แล้วผลลัพธ์ทั้งหมดจะต้องเป็นรูปสี่เหลี่ยมผืนผ้าและตัวละครทุกตัวที่ไม่ได้เป็นตัวแทนของเวกเตอร์จะต้องเป็นตัวละครพื้นหลัง (หากมีการใช้พื้นที่ว่างเป็นอักขระพื้นหลังดังนั้นจึงไม่จำเป็นต้องบังคับใช้ข้อ จำกัด เหล่านี้)

(โดยทั่วไปถ้าเรามีเวกเตอร์หนึ่งตัว (v, w) ที่มีน้ำหนัก a และเวกเตอร์ที่สอง (x, y) ที่มีน้ำหนัก b ผลรวมถ่วงน้ำหนักของพวกเขาคือ a (v, w) + b (x, y) = (av + BX + AW โดย).)

ในตัวอย่างก่อนหน้าชุดค่าผสมเชิงเส้นที่เหมาะสมคือ 2 * (3,1) + 3 * (2, -1) = (12, -1) หากเราใช้ "X" เป็นอักขระผลลัพธ์ผลลัพธ์จะมีลักษณะ

....2.........
.0............
...3.........X

หรือ

................
...2............
0...............
..3.........X...
................
................

การให้คะแนนโค้ดกอล์ฟแบบปกติ: คำตอบที่สั้นที่สุดเป็นไบต์ชนะ

ตัวอย่างอินพุตและเอาต์พุต

หากใช้ช่องว่างช่องว่างด้านบนจะมีลักษณะดังนี้

    2
 0
   3

และผลลัพธ์ก็จะดูเหมือน

    2
 0
   3         X

อักขระ / บรรทัดช่องว่างนำหน้า / ต่อท้ายไม่เกี่ยวข้อง หากพวกเขามองไม่เห็นผู้อ่านก็ไม่เป็นไร (ที่ถูกกล่าวว่าสำหรับตัวอย่างที่เหลือฉันจะกลับไปใช้ "." สำหรับตัวละครพื้นหลังเพื่อให้อ่านง่ายขึ้น)

หากเวกเตอร์ทั้งคู่มีน้ำหนัก 1 ผลลัพธ์จะมีรูปสี่เหลี่ยมด้านขนาน: อินพุต

.1.
...
1.0

นำไปสู่การส่งออก

X.1.
....
.1.0

หมายเหตุสี่เหลี่ยมด้านขนานนี้สามารถลดลงได้หากเวกเตอร์อินพุตเป็น collinear: อินพุต

0.1..1

นำไปสู่การส่งออก

0.1..1.X

เป็นไปได้สำหรับเวกเตอร์ผลลัพธ์ให้เท่ากับหนึ่งในเวกเตอร์อินพุตหรือต้นกำเนิด ในกรณีนี้มันเขียนทับอักขระอินพุต ตัวอย่างเช่นการป้อนข้อมูล

..2.0.1...

ผลผลิตผลผลิต

..X.0.1...

(โดยที่ในอินพุตและ / หรือเอาท์พุทช่วงเวลานำหน้าและต่อท้ายสามารถลบได้) การป้อนข้อมูล

.....3
......
...0..
......
......
2.....

ผลผลิตผลผลิต

.....3
......
...X..
......
......
2.....

ในที่สุดการป้อนข้อมูล

90
.8

ผลผลิตผลผลิต

........90
.........8
..........
..........
..........
..........
..........
..........
X.........

MATL , 48 ไบต์

tZyyX:UX>*Yat48-tt0>*3#fbbhb~2#fh-*s7M+'X'wZ}4$(

อักขระพื้นหลังคือช่องว่าง อินพุตเป็นอาร์เรย์ถ่าน 2 มิติโดยมีแถวคั่นด้วยเครื่องหมายอัฒภาค ดังนั้นกรณีทดสอบมีอินพุตที่เกี่ยวข้อง:

['    2'; ' 0   '; '   3 ']
[' 1 '; '   '; '1 0']
['0 1  1']
['  2 0 1   ']
['     3'; '      '; '   0  '; '      '; '      '; '2     ']
['90'; ' 8']

เอาท์พุทรวมถึงจำนวนช่องว่างภายในช่องว่างที่สำคัญ

ลองออนไลน์!

Python 3, 374 355 ไบต์

วิธีการแก้ปัญหาของหลามที่ไม่ได้รับการขัดเกลาเกินไปที่เอื้อต่อการขยาย (ใช้ระยะกระดานหมากรุกสูงสุด) อินพุตเป็นบรรทัดเดียวที่แถวถูกคั่นด้วยไพพ์ | (แม้ว่าอัลกอริทึมสามารถใช้อะไรก็ได้ที่ไม่ใช่ตัวอักษรและตัวเลขที่ไม่ใช่บรรทัดใหม่หรือ EOF) สิ่งใดที่ไม่ใช่ตัวอักษรและตัวเลขหรือ | ใช้งานได้ดีกับอินพุตอินพุท, การแพ็ดเอาท์พุทใช้ระยะเวลา ข้อเสนอแนะและการปรับปรุงจากนักหลามหลามช่ำชองมากขึ้นชื่นชม

แก้ไข: การปรับปรุงบางอย่างต้องขอบคุณ @TheBikingViking เพิ่มระยะขอบให้มากขึ้นอีกด้วยเพราะฉันไม่ได้ใจกว้างมากนัก

s=input()
l=[len(s),1+s.find('|')]['|'in s]
P=sorted([int(c),i%l,i//l]for i,c in enumerate(s)if c.isalnum())
L=X=Y=0
P[0][0]=-sum(p[0]for p in P)
for w,x,y in P:L=max(abs(x),abs(y),L);X+=x*w;Y+=y*w
P+=[['X',P[0][1]+X,P[0][2]+Y]]
P[0][0]=0
L=2*max(abs(X),abs(Y),L)
S=[2*L*["."]for _ in[0]*2*L]
for w,x,y in P:S[L+y][L+x]=str(w)
for s in S:print(''.join(s))

JavaScript, 534 528 502 ไบต์

n="indexOf"
J="join"
B=X=>X.split(O)
O='\n'
w=i[n](O)+1
h=B(i).length
Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}
C=[0,0,0]
G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""
o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w
x=y=0
j=i
for(z="1";z<="9";z++){while(p=~j[n](z)){j=j.replace(z," ")
x+=~p%w-l
y+=L(~p)-c}}
I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))
N=Z(I[0].length+1," ",2)
A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))
M=y+c+C[1]
O=""
m=B(A[M])
m[x+l+C[0]/h]="x"
A[M]=m[J]("")
A[J]("\n")

โปรดทราบว่าช่องว่างภายในนั้นเหมาะสมที่สุด โปรแกรมนี้ถือว่าฉันมีสตริงดิบโดยมีบรรทัดคั่นด้วย\nอักขระ xช่องว่างภายในจะทำกับช่องว่างและลักษณะผลที่ได้คือตัวพิมพ์เล็ก

นี่เป็นความพยายามครั้งแรกของฉันในการตีกอล์ฟ

ข้อมูลทางเทคนิค: - ขนาดของโปรแกรมเพิ่มขึ้นเป็นสองเท่า (และความซับซ้อนเพิ่มขึ้นอย่างมาก) เพียงคำนึงถึงอักขระผลลัพธ์เนื่องจากส่วนใหญ่เป็นสตริง JavaScript ที่ไม่เปลี่ยนรูป

บรรทัดคำอธิบายบรรทัด:

n="indexOf"
J="join"
B=X=>X.split(O)

ฉันใช้จำนวนมากดังนั้นการจัดเก็บไว้ในสตริงจึงช่วยประหยัดพื้นที่ได้บ้าง คุณสามารถดูด้านล่างว่าสำหรับsplitฟังก์ชั่นฉันเพิ่งสร้างนามแฝง นี่เป็นเพราะฉันต้องการเพียงอาร์กิวเมนต์หนึ่งอีกอันหนึ่งคงที่ สำหรับindexOfและjoinมันจะได้รับอีกต่อไป

O='\n'
w=i[n](O)+1
h=B(i).length

ไม่มีอะไรซับซ้อนที่นี่ฉันกำลังอ่านความกว้างและความสูงของอาร์เรย์เริ่มต้น โปรดทราบว่าการใช้i[n]การเข้าถึงindexOfในขณะที่splitมีการจัดการแตกต่างกัน

Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}

สิ่งนี้กำลังได้รับความสนใจ ฟังก์ชั่นนี้โดยทั่วไปจะสร้างการเชื่อมต่อ J-1 คูณกับสตริง X และส่งคืน สิ่งนี้ถูกใช้เพื่อสร้างสตริงของช่องว่างสำหรับการขยาย

C=[0,0,0]

อาร์เรย์นี้จะมีจำนวนบรรทัดและคอลัมน์ที่เพิ่มโดยการเติม (ปิดด้วยปัจจัย h ในกรณีแรก) เซลล์สุดท้ายเป็นเซลล์ขยะและป้องกันไม่ให้ฉันมีอาร์กิวเมนต์เพิ่มเติมในฟังก์ชั่นด้านล่าง

G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""

ฟังก์ชั่นนี้เพียงอย่างเดียวจัดการการขยาย (ทั้งบรรทัดและคอลัมน์); มันกำหนดขึ้นอยู่กับการประสานงานของผลเวกเตอร์ (X) และจำนวนของเส้น / คอลัมน์เพื่อสร้าง (E) ไม่ว่าจะมีความจำเป็นในการสร้างหนึ่ง X+E+1+Tเป็นเพียงเคล็ดลับเพื่อประหยัดพื้นที่บางส่วนUเป็นสตริงไส้ (พื้นที่สำหรับคอลัมน์และสายทั้งหมดสำหรับสาย) Rและเราจะกลับมา ฟังก์ชันนี้จะส่งคืนโดยทั่วไปในกรณีของบรรทัดการแพ็ดดิ้งที่ต้องการที่จุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัดดังกล่าวและในกรณีของคอลัมน์จะส่งคืนการเว้นบรรทัดที่ต้องการก่อนหรือหลังบรรทัดต้นฉบับ

o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w

ที่นี่เราอ่านตำแหน่งของจุดกำเนิดและเราดึงพิกัดของมัน L เป็นฟังก์ชันในการแปลงดัชนีเป็นหมายเลขบรรทัด

x=y=0
j=i
for(z="1";z<="9";z++){
    while(p=~j[n](z)){
        j=j.replace(z," ")
        x+=~p%w-l
        y+=L(~p)-c
    }
}

ฉันเพิ่มช่องว่างเพื่อให้อ่านง่ายขึ้น สิ่งที่เกิดขึ้นที่นี่คือสำหรับแต่ละหมายเลขที่เป็นไปได้เราจะหามันในสตริงเดิม ~เคล็ดลับคือค่อนข้างที่พบบ่อยใน Javascript; มันคือโอเปอเรเตอร์ของ bitwise แต่สิ่งที่สำคัญที่นี่คือที่~-1==0ทำให้ฉันสามารถทดสอบการสิ้นสุดของลูป จากนั้นฉันก็ลบอักขระในสตริง (ซึ่งเป็นสาเหตุที่ฉันทำสำเนา) สิ่งนี้ทำให้ฉันสามารถค้นหาต่อไปได้นานเท่าที่ต้องการ จากนั้นฉันก็เพิ่มพิกัดของเวกเตอร์(x, y)โดยใช้การลบแบบง่าย

I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))

ฉันที่นี่แยกสตริงเดิมออกเป็นเส้นและสำหรับแต่ละบรรทัดฉันเรียกGว่าจะสร้างการขยายก่อนและหลังบรรทัด l-w+2และอื่น ๆ มาจากการคำนวณดัชนีง่ายๆที่ช่วยให้ฉันเพื่อทดสอบว่าฉันต้องเพิ่มช่องว่างหรือไม่ ตัวอย่างเช่นถ้าx>0และx+l-w+1>0แล้ว(x+l-w+1)+1พื้นที่จะต้องเพิ่มหลังจากบรรทัด +xจะถูกลบออกเพราะมันเป็นพารามิเตอร์แรกและใช้ในความหมายของX+E+1+TG

สิ่งที่คล้ายกันนั้นทำสำหรับอักขระตัวแรกและจากนั้นสำหรับคอลัมน์ มีการแยกตัวประกอบจำนวนมากที่นี่ทำให้ฉันสามารถใช้ฟังก์ชันเดียวเท่านั้น หมายเหตุพารามิเตอร์สุดท้าย ในกรณีแรกฉันต้องการเขียนเพื่อC[0]ให้สามารถทราบในภายหลังว่ามีกี่คอลัมน์ที่ฉันเพิ่มที่จุดเริ่มต้นของแต่ละบรรทัด สิ่งนี้ทำให้ฉันสามารถดึงตำแหน่งสุดท้ายของอักขระผลลัพธ์ได้ ฉันไม่สนใจคอลัมน์ที่เพิ่มหลังจากบรรทัดเดิมซึ่งเป็นสาเหตุที่การเรียกครั้งที่สองเพื่อGเขียนไปยังเซลล์ขยะC[2]ที่ไม่ได้ใช้

N=Z(I[0].length+1," ",2)

ที่นี่ฉันเพียงแค่อ่านความยาวของเส้นใหม่และสร้างช่องว่างจากมัน สิ่งนี้จะถูกใช้เพื่อสร้างช่องว่างภายในแนวตั้ง

A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))

นี่เป็นสิ่งเดียวกับสองบรรทัดด้านบน ความแตกต่างเพียงอย่างเดียวคือการเขียนไปC[1]ในครั้งนี้และการใช้คั่นและN+O O+Nโปรดจำไว้ว่าOเป็นบรรทัดใหม่และNเป็นช่องว่าง จากนั้นฉันจะใช้Bกับผลลัพธ์เพื่อแยกอีกครั้ง (ฉันต้องดึงข้อมูลบรรทัดที่มีอักขระผลลัพธ์เพื่อแก้ไข)

M=y+c+C[1]

นี่คือดัชนีแนวตั้งของอักขระที่เกิด

O=""
m=B(A[M])
m[x+l+C[0]/h]="x"

ที่นี่ฉันถูกบังคับให้แก้ไขOเพื่อให้สามารถแยกบรรทัดที่เหมาะสมลงในอาร์เรย์ของอักขระ นี่เป็นเพราะสตริง JavaScript นั้นไม่เปลี่ยนรูป วิธีเดียวในการแก้ไขสตริงคือการแปลงเป็นอาเรย์ (ซึ่งเป็นสิ่งที่ฉันทำที่นี่) แก้ไขที่ตำแหน่งที่เหมาะสมและเข้าร่วมสตริงอีกครั้ง ให้สังเกตhปัจจัยซึ่งเป็นเพราะGฟังก์ชั่นถูกเรียกหนึ่งครั้งต่อบรรทัดแรก

A[M]=m[J]("")
A[J]("\n")

ในที่สุดฉันก็แทนที่สตริงใหม่ในอาร์เรย์และเข้าร่วมอีกครั้งเป็นสตริง ดีจัง!