Вступ

При побудові проекту з електроніки схематично може зажадати резистор незвичного значення (скажімо, 510 Ом). Ви перевіряєте свій контейнер для деталей і виявляєте, що у вас немає резисторів 510 Ом. Але у вас є багато загальних значень вище та нижче цього значення. Комбінуючи резистори паралельно та послідовно, ви зможете досить наблизити резистор 510 Ом.

Завдання

Ви повинні написати функцію або програму, яка приймає перелік значень резисторів (резисторів, які ви запасуєте), і цільове значення (яке ви хочете наблизити). Програма повинна враховувати:

• Індивідуальні резистори
• Два резистори послідовно
• Паралельно два резистори

Програма повинна обчислити всі можливі комбінації 1 і 2 резисторів зі списку запасів (включаючи дві копії одного і того ж значення резистора), обчислити їхні серії та паралельний опір, а потім сортувати конфігурації відповідно до того, наскільки вони наближають цільове значення.

Вихідний формат повинен мати одну конфігурацію на рядок, із +позначаючим рядом і |позначаючи паралель, і деякий пробіл або знак = перед чистим опором.

Формули

• Опір одного резистора є R1
• Чистий опір двох резисторів послідовно R1 + R2
• Чистий опір двох резисторів паралельно 1 / (1/R1 + 1/R2)
• Відстань між апроксимувати значенням опору і цільовим значенням може бути обчислено як псевдо-логарифмическим відстань, а не лінійна відстані: dist = abs(Rapprox / Rtarget - 1). Наприклад, 200 ближче до 350, ніж до 100.
• Кращий показник відстані - це справжня логарифмічна відстань dist = abs(log(Rapprox/Rtarget)), але оскільки це не було зазначено в первісному запитанні, ви можете використовувати будь-яке вимірювання.

Оцінка балів

Оцінка оцінюється символами коду, за звичайними правилами гольфу. Виграє найнижчий рахунок.

Приклад

У нас є такі резистори, які [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]бажають націлити 510Ом. Програма повинна вивести 143 конфігурації, приблизно, як показано (ви можете змінити формат, але переконайтесь, що значення легко визначається):

680 | 2200     519.444
1000 | 1000    500.
150 + 330      480.
220 + 330      550.
470            470
680 | 1500     467.89
680 | 3300     563.819
100 + 470      570.
220 + 220      440.
100 + 330      430.
470 | 4700     427.273
680 | 4700     594.052
1000 | 1500    600.
470 | 3300     411.406
680 | 1000     404.762
150 + 470      620.
...
many more rows
...
2200 + 4700    6900.
3300 + 4700    8000.
4700 + 4700    9400.

У цьому прикладі найкраще наближення 510 Ом дають паралельно резистори 680- та 2200 Ом.

Кращий з кожної мови дотепер (1 червня 2014 року):

1. J - 70 char
2. APL - 102 char
3. Mathematica - 122 char
4. Ruby - 154 char
5. Javascript - 156 char
6. Джулія - ​​163 чарів
7. Perl - 185 char
8. Python - 270 char

J - 86 71 70 char

((]/:[|@<:@%~2{::"1])(;a:,<)"0,[:,/(<,.+`|,.+/;+&.%/)"1@;@((<@,.{:)\))

Я не збираюся пояснювати кожну дрібницю, оскільки багато коду витрачається на синхронізацію результатів різних функцій, але ось суть гольфу:

• ;@((<@,.{:)\) робить кожну можливу пару резисторів, які підключаються паралельно або послідовно.

• [:,/(<,.+`|,.+/;+&.%/)"1@ потім з'єднує їх паралельно і послідовно, складаючи великий список можливих з'єднань.

• (;a:,<)"0, додає можливість використання лише одного резистора для наближення.

• (]/:[|@<:@%~2{::"1])сортує список комбінацій резисторів за псевдологічною відстані ( |@<:@%) між ціллю та одержуваним опором від кожної комбінації.

І ось як це використовувати:

   rouv =: ((]/:[|@<:@%~2{::"1])(;a:,<)"0,[:,/(<,.+`|,.+/;+&.%/)"1@;@((<@,.{:)\))
   # 510 rouv 100 150 220 330 470 680 1000 1500 2200 3300 4700      NB. how many?
143
   10 {. 510 rouv 100 150 220 330 470 680 1000 1500 2200 3300 4700  NB. view first 10
+---------+-+-------+
|680 2200 |||519.444|
+---------+-+-------+
|1000 1000|||500    |
+---------+-+-------+
|150 330  |+|480    |
+---------+-+-------+
|220 330  |+|550    |
+---------+-+-------+
|470      | |470    |
+---------+-+-------+
|680 1500 |||467.89 |
+---------+-+-------+
|680 3300 |||563.819|
+---------+-+-------+
|100 470  |+|570    |
+---------+-+-------+
|220 220  |+|440    |
+---------+-+-------+
|100 330  |+|430    |
+---------+-+-------+

Вам не потрібно переглядати лише перші 10, як я робив вище, але це функція, і J REPL урізує дуже великі значення повернення, а повний вихід у цьому прикладі має 287 рядків. Ви можете змусити це STDOUT за допомогою чогось подібного tmoutput toCRLF , LF ,.~ ": blah rouv blahдо Windows - скинути toCRLFна Linux - але rouvце функція і всередині нього існують усі рядки.

Примітка:

Здається, питання було змінено прямо під носом, і тепер відстань журналу визначається як abs(log(Rapprox/Rtarget))замість abs(Rapprox/Rtarget-1). Щоб виправити це в моєму гольфі, ми можемо змінити |@<:@%на |@^.@%: <:є декремент, а ^.це логарифм.

Математика, 151 122 символів

Очікує збереження цільового опору rта список наявних резисторів в l.

SortBy[Join[{#,#}&/@l,Join@@(#@@@Union[Sort/@N@l~Tuples~{2}]&/@{{"+",##,#+#2}&,{"|",##,#*#2/(#+#2)}&})],Abs[#[[-1]]/r-1]&]

Менше гольфу:

SortBy[Join[{#, #} & /@ l,
  Join @@ (# @@@ 
       Union[Sort /@ N@l~Tuples~{2}] & /@ {{"+", ##, # + #2} &, {"|", ##, 
        #*#2/(# + #2)} &})], Abs[#[[-1]]/r - 1] &]

Формат виводу відрізняється від запропонованого, але конфігурації легко визначити. Вихід - це список конфігурацій. Кожна конфігурація має одну з таких форм:

{R1, Total}
{"+", R1, R2, Total}
{"|", R1, R2, Total}

Отже, перші три елементи виводу читаються

{{"|", 680., 2200., 519.444}, {"|", 1000., 1000., 500.}, {"+", 150., 330., 480.}, ...}

Якщо ви добре з раціональними цифрами, я можу врятувати два символи від пропуску N@. Тобто перший елемент (наприклад) буде повернуто як 4675/9замість 519.444.

APL (102)

{V←{⊃¨⍺{⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵}⍺⍺/¨Z/⍨≤/¨Z←,∘.,⍨⍵}⋄K[⍋|¯1+⍺÷⍨0 4↓K←↑('|'{÷+/÷⍺⍵}V⍵),('+'+V⍵),{⍵,'  =',⍵}¨⍵;]}

Це сприймає цільовий опір як лівий аргумент, а список доступних резисторів - як правий аргумент.

Пояснення:

• V←{... }: Vце функція, яка:
  • Z/⍨≤/¨Z←,∘.,⍨⍵: знаходить кожну унікальну комбінацію двох значень у ⍵,
    • Z←,∘.,⍨⍵: приєднати кожне значення ⍵до кожного значення в ⍵, зберігати Z,
    • Z/⍨≤/¨Z: виберіть із Zтих комбінацій, де перше значення менше або дорівнює другому
  • ⍺{... }⍺⍺/¨: а потім застосовує наступну функцію, пов'язану з лівою функцією ( ⍺⍺) праворуч і лівою аргументом ( ⍺) зліва, до кожної пари:
    • ⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵, лівий аргумент, а потім лівий зв'язаний аргумент, а потім правий аргумент, за ним =, а потім права функція ( ⍵⍵), застосована до обох аргументів. (Це функція форматування,. X [configuration] Y [equals] (X [fn] Y))
  • ⊃¨: і потім розпакуйте кожен елемент.
• {⍵,' =',⍵}¨⍵: для кожного елемента в ⍵, зробіть конфігурації для окремих резисторів. ( ⍵Нічого, нічого, =, ⍵).
• ('+'+V⍵): використовуйте Vфункцію для створення всіх послідовних конфігурацій (символ є '+'і функція є +).
• '|'{÷+/÷⍺⍵}V⍵: використовуйте Vфункцію для створення всіх паралельних конфігурацій (символ є '|'і функція є {÷+/÷⍺⍵}, обернена сумою зворотних аргументів).
• K←↑: зробіть це в матрицю і збережіть K.
• 0 4↓K: видаліть з перших 4 стовпців K, залишивши лише значення опору.
• |¯1+⍺÷⍨: обчислити відстань між ⍺та кожною конфігурацією.
• K[⍋... ;]: сортувати Kпо відстані.

Пітон 3 - 250 247 270 байт

from itertools import*
import sys
r=sys.argv[1:]
t=int(r.pop())
p=set(map(tuple,map(sorted,product(r,r))))
a=[('+'.join(b),sum(map(int,b)))for b in p]+[('|'.join(b),1/sum(map(lambda n:1/int(n),b)))for b in p]
for s in sorted(a,key=lambda b:abs(float(b[1])/t-1)):print(s)

Бігайте так:

python resistors.py 100 150 220 330 470 680 1000 1500 2200 3300 4700 510

(тобто список резисторів, обмежений космосом, із цільовим значенням в кінці)

Вихід:

('2200|680', 519.4444444444445)
('1000|1000', 500.0)
('150+330', 480)
('220+330', 550)
('1500|680', 467.88990825688074)
('3300|680', 563.8190954773869)

[snip]

('2200+4700', 6900)
('3300+4700', 8000)
('4700+4700', 9400)

Я б сказав, що результати, скажімо, 680|2200і 2200|680окремо, все ще досить зрозумілі. Якщо це неприйнятно, я можу це змінити, але це коштуватиме мені байтів.Не було прийнятним. Коштуй мені байтів. Тепер я сортую кортежі перед тим, як зафіксувати їх у наборі, інакше рішення буде ідентичним.

Рубін 2.1, 156 154 байти

s=->(a,z){c={};a.map{|e|a.map{|f|c[e]=e;c[e+f]="#{e}+#{f}";c[1/(1.0/f+1.0/e)]="#{e}|#{f}"}};c.sort_by{|k,|(k/z.to_f-1).abs}.map{|e|puts"#{e[1]}=#{e[0]}"}}

Безголівки:

s =->(a,z) {
  c={}
  a.map{|e|
    a.map{|f|
      c[e]=e
      c[e+f]="#{e}+#{f}"
      c[1/(1.0/f+1.0/e)]="#{e}|#{f}"
    }
  }
  c.sort_by{|k,|
    (k/z.to_f-1).abs
  }.map{|e|
    puts "#{e[1]}=#{e[0]}"
  }
}

Що це робить:

• Для кожного значення eв a;
  • Ітерація через a, обчислення одиничних, серійних та паралельних значень як ключів до друкованих значень у хеші c;
• Визначте відстань від zкожної клавіші в c; і,
• Для кожного значення e[1]для кожного ключа e[0]в cроздрукуйте e[1]=e[0].

Використання зразка:

s[[100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700], 510]

Вибірка зразка:

2200|680=519.4444444444445
1000|1000=500.0
330+150=480
330+220=550
470=470
1500|680=467.88990825688074
3300|680=563.8190954773869
.
.
.
4700+1500=6200
3300+3300=6600
4700+2200=6900
4700+3300=8000
4700+4700=9400

JavaScript (ECMAScript 6) - 186 символів

f=(R,T)=>(D=x=>Math.abs(x[3]/T-1),r={p:(x,y)=>x*y/(x+y),s:(x,y)=>x+y},[...[[x,0,0,x]for(x of R)],...[[x,y,z,r[z](x,y)]for(x of R)for(y of R)for(z in r)if(x<=y)]].sort((a,b)=>D(a)-D(b)))

Вхід:

• Масив Rрезисторів; і
• T, цільовий опір.

Вихід:

Масив масивів (відсортований за відстані від T), кожен з яких містить:

• менша величина резистора;
• значення вищого резистора (або 0, якщо одиночний резистор);
• p, sАбо 0 , якщо резистори з'єднані паралельно, послідовно або поодинокі; і
• чистий опір.

Пояснення:

f=(R,T)=>(                               // Create a function f with arguments R & T
  D=x=>Math.abs(x[3]/T-1),               // A function D to calculate relative
                                         // distance from the target value
  r={p:(x,y)=>x*y/(x+y),s:(x,y)=>x+y},   // An object containing the formulae
                                         // to calculate resistance in serial and parallel
  solitary = [[x,0,0,x]for(x of R)],     // Create an array of solitary resistors
  pairs =                                // Use Array Comprehension to create the array of
   [[x,y,z,r[z](x,y)]                    // arrays
      for(x of R)                        // for each resistor value
      for(y of R)                        // for each resistor value (again)
      for(z in r)                        // for both serial & parallel
      if(x<=y)],                         // where the first resistor value is smaller than the second
  [
    ...solitary,                         // Use the spread ... operator to combine
    ...pairs                             // the two arrays
  ]
    .sort((a,b)=>D(a)-D(b))              // Sort the arrays by minimum distance
                                         // and return.
)

Юлія - 179 163 байти

f(t,s)=(\ =repmat;m=endof(s);A=A[v=(A=s\m).>=(B=sort(A))];B=B[v];F=[s,C=A+B,A.*B./C];n=sum(v);print([[s P=[" "]\m P;A [+]\n B;A [|]\n B] F][sortperm(abs(F-t)),:]))

Це працює так само, як у попередній версії, але аргумент у друкованому викладі організовано дещо інакше, щоб зменшити кількість квадратних дужок, необхідних. Економить 4 байти. Поглинання створення пробілів у аргументі друку економить додаткові 2 байти. Він також перейшов з використання "знайти" для отримання відповідних індексів до використання логічної форми. Економить 6 байт. Поглинаючи обчислення вектора індексу в коригуванні A, зберегли ще 2 байти. Нарешті, замінивши endof (v) на суму (v), збережено ще 2 байти. Загальна економія: 16 байт.

Стара версія:

f(t,s)=(\ =repmat;m=endof(s);A=s\m;v=find(A.>=(B=sort(A)));A=A[v];B=B[v];F=[s,C=A+B,A.*B./C];n=endof(v);P=[" "]\m;print([[s,A,A] [P,[+]\n,[|]\n] [P,B,B] F][sortperm(abs(F-t)),:]))

У межах функції ось що це робить:

\ =repmat            # Overloads \ operator to save lots of characters
m=endof(s)           # Length of input s ("Stock")
A=s\m                # Equivalent to repmat(s,m) (see first command)
B=sort(A)            # Same as A but sorted - rather than cycling through
                     # the resistors m times, it repeats each one m times
v=find(A.>=B)        # Identify which pairs for A,B have A>=B
A=A[v];B=B[v]        # Remove pairs where A<B (prevents duplicates)
F=[s,C=A+B,A.*B./C]  # Constructs vector containing results for single resistor,
                     # resistors in series, and resistors in parallel
n=endof(v)           # equivalent to n=(m+1)m/2, gets number of relevant pairs
P=[" "]\m            # Construct array of blank entries for use in constructing output
print([[s,A,A] [P,[+]\n,[|]\n] [P,B,B] F][sortperm(abs(F-t)),:]))
# The following are the components of the argument in the print statement:
[s,A,A]              # Set of resistor values for resistor 1
[P,[+]\n,[|]\n]      # Operator column, prints either nothing, +, or |
[P,B,B]              # Set of resistor values for resistor 2 (blank for single resistor)
F                    # Contains resulting equivalent resistance
[sortperm(abs(F-t)),:] # Determines permutation for sorting array by distance from Target t
                     # and applies it to array

Вибірка зразка:

julia> f(170,[100,220,300])
300  |  300  150
100  +  100  200
300  |  220  126.92307692307692
220          220
220  |  220  110
100          100
300  |  100  75
220  |  100  68.75
100  |  100  50
300          300
220  +  100  320
300  +  100  400
220  +  220  440
300  +  220  520
300  +  300  600

Javascript (E6) 156 162 164 186

Останнє редагування Припускаючи всі значення резистора> 0, ви можете використовувати їх для умови циклу

F=(t,s)=>{D=a=>Math.abs(a[1]/t-1);for(i=r=[];a=s[j=i++];r[l]=[a,a])for(;b=s[j--];)l=r.push([a+'+'+b,c=a+b],[a+'|'+b,a*b/c]);return r.sort((a,b)=>D(a)-D(b))}

Використання: F(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700])

Безумовно

F = (t,s) => 
{
  D = a => Math.abs(a[1]/t-1);
  for (i=r=[]; a=s[j=i++]; r[l]=[a,a])
    for(; b=s[j--];)
      l = r.push([a+'+'+b, c=a+b], [a+'|'+b, a*b/c]);
   return r.sort((a,b) => D(a)-D(b))
}

Javascript, 248 байт

function r(T,L){R=[],O="";for(i in L){R.push([a=L[i],a]);for(j=i;j<L.length;)b=L[j++],s=a+b,R.push([a+"+"+b,s],[a+"|"+b,a*b/s])}R.sort(function(a,b){A=Math.abs;return A(a[1]/T-1)-A(b[1]/T-1)});for(i in R)q=R[i],O+=q[0]+"="+q[1]+"\n";console.log(O)}

Використання: r(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]);

Вихід

670|2200=519.4444444444445
1000|1000=500
150+330=480

(...such rows...)

2200+4700=6900
3300+4700=8000
4700+4700=9400

Perl, 213 199 185 байт

213 байт:

$t=pop;sub t{abs 1-(split/=/,pop)[1]/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';@i=@ARGV;say for sort{t($a)<=>t($b)}grep s!(..\b(\d+)\b,?\b(\d+)?\b\))=\K(??{$2<$3})!$1!ee&&/\d$/,<{S,P}({@i},{@i})= S({@i})=>;

199 байт:

$t=pop;sub t{abs 1-(split/=/,pop)[1]/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';@i=@ARGV;say for sort{t($a)<=>t($b)}grep/(..(\d+),?(\d+)?\))/&&$2>=$3&&($_.=eval$1),<{S,P}({@i},{@i})= S({@i})=>;

185 байт:

$t=pop;sub t{abs 1-$_[0]=~s!.*=!!r/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';$i="{@ARGV}";say for sort{t($a)<=>t$b}grep{my($x,$y)=/\d+/g;$_.='='.eval,$x>=$y}<{S,P}($i,$i) S($i)>

Передайте всі наявні резистори як аргументи. Цільовий опір повинен бути останнім:

$ perl -E 'code' R1 R2 R3 ... Rn target

Як це працює (старий код)

• Визначте підпрограми Sта Pобчисліть суму та паралельні значення двох резисторів.

• Встановіть $""," для інтерполяції @ARGVвсередині globоператора

• <{S,P}({@i},{@i})= S({@i})=> генерує декартових усіх можливостей:

  S (100,100), S (100,150), S (100,220), ... P (100,100), P (100,150) ... S (100), S (150) ...

• Зернозбиральний s///eeз grepоцінити еквівалентні опори і відфільтрувати небажані повтори ( в виконанні (??{$2<$3})і/\d$/

• sort за фітнес обчислюється в підпрограмі t

Зміни нового коду

• Уникайте використання s///ee, використовуйте коротший регулярний вираз із умовною перевіркою та evalвсерединіgrep

• Замініть повтори "{@i}" with$ i`

• Уявіть $x, $yзамість того $2,$3

• Замініть split/=/,popна$_[0]=~s!!!r

• Немає необхідності в трейлінгу ;

• eval; еквівалентно eval $_;

• Додайте =разом з eval-ed відповідь замість того, щоб оголошувати її вперед

Вихід:

Pпредставляє резистори паралельно, Sпредставляє резистори послідовно.

P(2200,680)=519.444444444444
P(1000,1000)=500
S(330,150)=480
S(330,220)=550
S(470)=470
P(1500,680)=467.889908256881
P(3300,680)=563.819095477387
S(470,100)=570
S(220,220)=440
S(330,100)=430
P(4700,470)=427.272727272727
P(4700,680)=594.052044609665
P(1500,1000)=600
P(3300,470)=411.405835543767
P(1000,680)=404.761904761905
S(470,150)=620
P(2200,470)=387.265917602996
S(220,150)=370
S(330,330)=660
P(1500,470)=357.868020304569
S(680)=680
P(680,680)=340
P(2200,1000)=687.5
S(330)=330
S(470,220)=690
S(220,100)=320
P(1000,470)=319.727891156463
P(4700,330)=308.349900596421
S(150,150)=300
P(3300,330)=300
P(2200,330)=286.95652173913
P(680,470)=277.913043478261
P(1500,330)=270.491803278689
P(1500,1500)=750
P(3300,1000)=767.441860465116
S(150,100)=250
P(1000,330)=248.12030075188
S(680,100)=780
P(470,470)=235
P(680,330)=222.178217821782
S(470,330)=800
S(220)=220
P(4700,220)=210.162601626016
P(3300,220)=206.25
S(100,100)=200
P(2200,220)=200
P(4700,1000)=824.561403508772
P(470,330)=193.875
P(1500,220)=191.860465116279
S(680,150)=830
P(1000,220)=180.327868852459
P(680,220)=166.222222222222
P(330,330)=165
S(150)=150
P(470,220)=149.855072463768
P(4700,150)=145.360824742268
P(3300,150)=143.478260869565
P(2200,150)=140.425531914894
P(1500,150)=136.363636363636
P(330,220)=132
P(1000,150)=130.434782608696
P(2200,1500)=891.891891891892
P(680,150)=122.89156626506
S(680,220)=900
P(470,150)=113.709677419355
P(220,220)=110
P(330,150)=103.125
S(100)=100
P(4700,100)=97.9166666666667
P(3300,100)=97.0588235294118
P(2200,100)=95.6521739130435
P(1500,100)=93.75
P(1000,100)=90.9090909090909
P(220,150)=89.1891891891892
P(680,100)=87.1794871794872
P(470,100)=82.4561403508772
S(470,470)=940
P(330,100)=76.7441860465116
P(150,150)=75
P(220,100)=68.75
P(150,100)=60
P(100,100)=50
S(1000)=1000
S(680,330)=1010
P(3300,1500)=1031.25
S(1000,100)=1100
P(2200,2200)=1100
P(4700,1500)=1137.09677419355
S(680,470)=1150
S(1000,150)=1150
S(1000,220)=1220
P(3300,2200)=1320
S(1000,330)=1330
S(680,680)=1360
S(1000,470)=1470
P(4700,2200)=1498.55072463768
S(1500)=1500
S(1500,100)=1600
S(1500,150)=1650
P(3300,3300)=1650
S(1000,680)=1680
S(1500,220)=1720
S(1500,330)=1830
P(4700,3300)=1938.75
S(1500,470)=1970
S(1000,1000)=2000
S(1500,680)=2180
S(2200)=2200
S(2200,100)=2300
S(2200,150)=2350
P(4700,4700)=2350
S(2200,220)=2420
S(1500,1000)=2500
S(2200,330)=2530
S(2200,470)=2670
S(2200,680)=2880
S(1500,1500)=3000
S(2200,1000)=3200
S(3300)=3300
S(3300,100)=3400
S(3300,150)=3450
S(3300,220)=3520
S(3300,330)=3630
S(2200,1500)=3700
S(3300,470)=3770
S(3300,680)=3980
S(3300,1000)=4300
S(2200,2200)=4400
S(4700)=4700
S(3300,1500)=4800
S(4700,100)=4800
S(4700,150)=4850
S(4700,220)=4920
S(4700,330)=5030
S(4700,470)=5170
S(4700,680)=5380
S(3300,2200)=5500
S(4700,1000)=5700
S(4700,1500)=6200
S(3300,3300)=6600
S(4700,2200)=6900
S(4700,3300)=8000
S(4700,4700)=9400