소개

전자 프로젝트를 구축 할 때 회로도가 비정상 값 (예 : 510 옴)의 저항을 요구할 수 있습니다. 부품 함을 확인한 후 510ohm 저항이없는 것을 발견했습니다. 그러나이 값 위와 아래에 많은 공통 값이 있습니다. 저항을 병렬 및 직렬로 결합하면 510 옴 저항을 상당히 잘 근사 할 수 있어야합니다.

태스크

저항 값 (저장 한 저항)과 목표 값 (근사하려는 목표)의 목록을 허용하는 함수 나 프로그램을 작성해야합니다. 프로그램은 다음을 고려해야합니다.

• 개별 저항
• 직렬로 연결된 2 개의 저항
• 병렬로 두 개의 저항

이 프로그램은 재고 목록에서 1 및 2 저항의 가능한 모든 조합 (같은 저항 값의 사본 2 개 포함)을 계산하고 직렬 및 병렬 저항을 계산 한 다음 목표 값에 얼마나 근접하는지에 따라 구성을 정렬해야합니다.

출력 형식은 +직렬 및 |병렬을 나타내는 선당 하나의 구성이어야하며 , 순 저항 앞에 약간의 공백 또는 = 부호가 있어야합니다.

방식

• 하나의 저항의 저항은 R1
• 직렬로 연결된 두 저항의 순 저항은 R1 + R2
• 병렬로 두 저항의 순 저항은 1 / (1/R1 + 1/R2)
• 근사 저항 값과 목표 값 사이의 거리는 선형 거리가 아닌 의사-로그 거리로 계산할 수 있습니다 dist = abs(Rapprox / Rtarget - 1). 예를 들어 200은 100보다 350에 가깝습니다.
• 더 나은 거리 측정은 실제 대수 거리 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 옴 저항에 의해 병렬로 제공됩니다.

지금까지 각 언어 중 최고 (2014 년 6 월 1 일) :

1. J-70 자
2. APL-102 자
3. Mathematica-122 자
4. 루비-154 자
5. 자바 스크립트-156 자
6. 줄리아-163 자
7. 펄-185 자
8. 파이썬-270 자

J- 86 71 70 자

((]/:[|@<:@%~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 줄이 있습니다. tmoutput toCRLF , LF ,.~ ": blah rouv blahWindows 와 같은 것으로 STDOUT에 강제로 넣을 수 있습니다 ( toCRLFLinux 에서는 삭제). 그러나 rouv내부적으로는 모든 행이 존재합니다.

노트 :

문제는 코 바로 아래에서 변경된 것으로 보이며 이제 로그 거리가 abs(log(Rapprox/Rtarget))대신로 정의됩니다 abs(Rapprox/Rtarget-1). 내 골프에서이 문제를 해결하려면, 우리는 변경할 수 있습니다 |@<:@%에가 |@^.@%: <:동안 감소시킵니다이다 ^.대수입니다.

Mathematica, 151122 자

에 저장된 목표 저항 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함수를 사용하여 모든 병렬 구성을 구성하십시오 ( 인수와 인수의 합의 역수 인 문자 is '|'및 함수 is {÷+/÷⍺⍵}입니다).
• 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)),:]))

이것은 이전 버전과 동일하게 작동하지만 print 문의 인수는 필요한 대괄호 수를 줄이기 위해 약간 다르게 구성되었습니다. 4 바이트를 저장합니다. 공백 벡터 생성을 인쇄 인수에 흡수하면 추가 2 바이트가 절약됩니다. 또한 "find"사용에서 관련 지수를 논리 형식 사용으로 전환했습니다. 6 바이트를 저장합니다. A의 조정으로 인덱스 벡터의 계산을 흡수하면 다른 2 바이트가 절약되었습니다. 마지막으로 endof (v)를 sum (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

자바 스크립트 (E6) 156162164186

마지막 편집 모든 저항 값> 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))
}

자바 스크립트, 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

펄 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 $_;

• 미리 선언하는 대신 -ed 답변 =과 함께 추가하십시오.eval

산출:

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