Yönetici Özeti

İki vektörünü temsil eden girdiler ve bunların ilgili "ağırlıkları" da, bu vektörlerin ağırlıklı toplamını temsil eden çıktılar üretir.

Meydan okuma

Giriş, aşağıdaki karakterlerin bir veya daha fazla satırından oluşur:

• iki boyutlu bir düzlemde başlangıç ​​noktasını temsil eden 0 basamağının tam olarak bir oluşumu;
• başlangıç ​​noktasına göre konumları vektörleri temsil eden ve değerleri bu vektörlere bağlı ağırlıkları temsil eden tam olarak iki basamak (1-9; aynı basamak olabilir veya olmayabilir);
• bazı "arka plan karakterleri". Çözücü belirli bir arka plan karakteri seçebilir; örneğin, "." (çoğunlukla insan tarafından okunabilirlik için). Alternatif olarak, arka plan karakterleri boşluk gibi görünen herhangi bir şey olabilir.

(Çözücü, girdinin tek bir çok satırlı dize mi yoksa tek satırlık bir dize mi olduğunu seçebilir.)

Örneğin, girdi

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

ağırlık 2 ile koordinatlarda (3,1) bir vektör ve ağırlık 3 ile koordinatlarda (2, -1) bir vektördür.

Çıktı, aşağıdaki değişikliklerle girişle neredeyse aynı olmalıdır:

• çözücü tarafından seçilen ve giriş vektörlerinin ağırlıklı toplamıyla belirtilen konuma (eşdeğer olarak giriş vektörlerinin uygun doğrusal kombinasyonu olan konumda) eklenecek bir "sonuç karakteri";
• aynı resimdeki başlangıç ​​noktasına, iki giriş vektörüne ve çıkış vektörüne uyması için gereken arka plan karakterleri. İstenirse ekstra arka plan karakterleri dahil edilebilir; tek kısıtlama, arka plan karakteri görünür bir karakter ise, tüm çıktının dikdörtgen şeklinde olması ve bir vektörü temsil etmeyen her karakterin arka plan karakteri olması gerektiğidir. (Arka plan karakterleri olarak boşluk kullanılırsa, bu kısıtlamaların uygulanması gerekmez.)

(Genel olarak, a ağırlığına sahip bir vektör (v, w) ve b ağırlığına sahip ikinci vektör (x, y) varsa, ağırlıklı toplamları bir (v, w) + b (x, y) = (av + bx, aw *).)

Önceki örnekte, uygun doğrusal kombinasyon 2 * (3,1) + 3 * (2, -1) = (12, -1) dir. Sonuç karakteri olarak "X" kullanırsak, çıktı şöyle görünebilir

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

veya

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

Her zamanki kod golf skorlaması: bayt cinsinden en kısa cevap kazanır.

Örnek giriş ve çıkış

Boş alan kullanılırsa, yukarıdaki giriş aşağıdaki gibi görünecektir

    2
 0
   3

ve çıktı şöyle görünecekti

    2
 0
   3         X

Satır başı / sondaki boşluk karakterleri / satırları önemsizdir; okuyucuya görünmezlerse, sorun değil. (Bu örneklerin geri kalanı için, okumayı kolaylaştırmak için arka plan karakteri için "." Kullanmaya geri döneceğim.)

Her iki vektörün ağırlığı 1 ise, sonuç paralelkenar gibi görünecektir: giriş

.1.
...
1.0

çıktıya yol açar

X.1.
....
.1.0

Giriş vektörleri eşdoğrusal ise bu paralelkenar dejenere olabilir: giriş

0.1..1

çıktıya yol açar

0.1..1.X

Sonuç vektörünün girdi vektörlerinden veya orijinden birine eşit olması mümkündür; bu durumda, giriş karakterinin üzerine yazar. Örneğin, girdi

..2.0.1...

çıktı verir

..X.0.1...

(giriş ve / veya çıkışta, ön ve sondaki dönemler silinebilir). Girdi

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

çıktı verir

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

Son olarak, girdi

90
.8

çıktı verir

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

MATL , 48 bayt

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

Arka plan karakteri boşluktur. Giriş, satırları noktalı virgülle ayrılmış bir 2B karakter dizisidir. Bu yüzden test senaryolarının ilgili girdileri vardır:

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

Çıktı, önemli miktarda dolgu boşluğu içerir.

Çevrimiçi deneyin!

Piton 3, 374 355 bayt

Dolgu ile çok cömert olan çok rafine olmayan python çözümü (maksimum satranç tahtası mesafesi kullanır). Giriş, satırların borularla ayrıldığı tek bir satırdır | (algoritma, yeni satır veya EOF olmayan alfasayısal olmayan herhangi bir şeyi kolayca kullanabilir). Alfasayısal olmayan veya | giriş dolgusu için çalışır, çıkış dolgusu dönemleri kullanır. Daha deneyimli python golfçülerinden geribildirim ve iyileştirme takdir edilmektedir.

Düzenleme: @TheBikingViking sayesinde bazı iyileştirmeler. Ayrıca dolgu ile yeterince cömert değildi çünkü daha fazla marjlar ekledi.

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 bayt

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

Dolgunun optimal olduğunu unutmayın. Bu program satırları \nkarakterlerle ayrılmış ham i içerdiğini varsayar . Doldurma boşluklarla yapılır ve sonuç karakteri küçük harftir x.

Bu benim ilk kod golf girişimim.

Teknik şeyler: - Programın boyutu, çoğunlukla JavaScript dizelerinin değişmez olduğu için sonuç karakterini dikkate almak için kabaca iki katına çıktı (ve karmaşıklığı önemli ölçüde arttı).

Satır satır açıklama:

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

Bunları çok kullanıyorum, bu yüzden onları dizelerde saklamak bana biraz yer kazandırdı. Aşağıda, splitfonksiyon için basitçe bir takma ad oluşturduğumu görebilirsiniz; çünkü sadece bir argümana ihtiyacım vardı, diğeri sabitti. İçin indexOfve join, bununla birlikte daha uzun olurdu.

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

Burada karmaşık bir şey yok, ilk dizinin genişliğini ve yüksekliğini okuyorum. Farklı bir şekilde ele alınırken , i[n]erişiminin kullanımına dikkat edin .indexOfsplit

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

Bu ilginç bir hal alıyor. Bu işlev temelde X dizesinin J-1 katı ile bitiştirir ve döndürür. Bu, dolgu için boşluk dizeleri oluşturmak için kullanılır.

C=[0,0,0]

Bu dizi, dolgu tarafından eklenen satır ve sütun sayısını içerecektir (ilk durumda h faktörü tarafından kapalı). Son hücre önemsiz bir hücredir ve aşağıdaki işlevde ek bir bağımsız değişkene sahip olmamı engeller.

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

Bu işlev tek başına dolguyu (hem çizgiler hem de sütunlar) işler; sonuç vektörünün (X) koordinatını ve (E) oluşturulacak satır / sütun sayısını temel alarak bir tane oluşturmak gerekip gerekmediğini belirler. bu X+E+1+Tsadece yer kazanmak için bir hile U, dolgu dize (sütunlar için bir boşluk ve çizgiler için tüm bir çizgi), ve biz geri döneceğiz R. Bu fonksiyon temel olarak, bir hat söz konusu olduğunda, söz konusu hattın başında veya sonunda gerekli olan dolguyu döndürür ve bir sütun söz konusu olduğunda, orijinal hatlardan önce veya sonra gerekli olan dolum hatlarını döndürür.

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

Burada kökeninin konumunu okuyoruz ve koordinatlarını alıyoruz. L, bir indeksi satır numarasına dönüştüren bir fonksiyondur.

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

Bunu okumayı kolaylaştırmak için biraz boşluk ekledim. Burada olan şu ki, her olası sayı için, orijinal dizede aramaya devam ediyoruz. ~Hüner JavaScript nispeten yaygındır; Bitsel DEĞİL operatörüdür, ancak burada önemli ~-1==0olan tek şey , döngünün sonunu test etmeme izin veren şeydir . Daha sonra dizedeki karakteri silerim (bu yüzden bir kopya yaptım), bu da gerektiği kadar aramaya devam etmeme izin veriyor. Daha sonra (x, y), basit bir çıkarma kullanarak vektörün koordinatlarını ekliyorum .

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

Burada orijinal dize satırlara bölünmüş ve her satır için, Gsatırlardan önce ve sonra dolgu üretecek çağırıyorum . l-w+2Ve benzeri ben dolgu eklemek veya değil gerekip gerekmediğini test beni olanak tanıyan basit indeks hesaplama gelir. Örneğin, eğer x>0ve x+l-w+1>0, sonra (x+l-w+1)+1satırdan sonra boşluklar eklenmelidir. +xNedeniyle, birinci parametre olmasının kaldırılmakta olduğu, ve X+E+1+Ttanımında kullanılan G.

İlk karakterler ve sonra sütunlar için benzer bir şey yapılır. Burada sadece bir işlevi kullanmama izin veren birçok çarpanlara ayırma var. Son parametreye dikkat edin; ilk durumda, C[0]daha sonra her satırın başına kaç sütun eklediğimi bilmek için yazmak istiyorum ; bu, sonuç karakterinin son konumunu almama izin verir. Ancak orijinal satırdan sonra eklenen sütunları umurumda değil, bu yüzden kullanılmayan Gönemsiz hücreye ikinci çağrı yazar C[2].

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

Burada sadece çizgilerin yeni uzunluğunu okudum ve ondan bir boşluk çizgisi oluşturuyorum. Bu, dikey dolgu oluşturmak için kullanılacaktır.

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

Bu, yukarıdaki iki satırla tamamen aynıdır. Tek fark yazıyor C[1]bu kez, ve ayırıcılar kullanılarak N+Ove O+N. Unutmayın, Obu bir yeni satır ve Nbir uzay çizgisi. Daha sonra Btekrar bölmek için sonuca başvuruyorum (düzenlemek için sonuç karakterini içeren satırı almam gerekiyor).

M=y+c+C[1]

Bu, ortaya çıkan karakterin dikey dizinidir.

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

Burada Ouygun satırı bir karakter dizisine bölmek için değiştirmek zorunda kaldım . Bunun nedeni JavaScript dizelerinin değişmez olmasıdır; bir dizeyi düzenlemenin tek yolu diziyi (burada yaptığım şey) dönüştürmek, doğru konumda düzenlemek ve dizgiye tekrar katılmaktır. Ayrıca h, Gişlevin başlangıç ​​satırı başına bir kez çağrılması nedeniyle faktöre dikkat edin .

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

Sonunda dizideki yeni dizeyi değiştirip tekrar bir dizeye katıyorum. Bravo!