Introducción

Al construir un proyecto de electrónica, un esquema puede requerir una resistencia de un valor inusual (por ejemplo, 510 ohmios). Verifica su depósito de piezas y descubre que no tiene resistencias de 510 ohmios. Pero tiene muchos valores comunes por encima y por debajo de este valor. Al combinar resistencias en paralelo y en serie, debería poder aproximar la resistencia de 510 ohmios bastante bien.

Tarea

Debe escribir una función o programa que acepte una lista de valores de resistencia (resistencias que tenga) y un valor objetivo (que pretende aproximar). El programa debe considerar:

• Resistencias individuales
• Dos resistencias en serie.
• Dos resistencias en paralelo

El programa debe calcular todas las combinaciones posibles de 1 y 2 resistencias de la lista de existencias (incluidas dos copias del mismo valor de resistencia), calcular su resistencia en serie y en paralelo, luego clasificar las configuraciones de acuerdo a qué tan bien se aproximan al valor objetivo.

El formato de salida debe ser una configuración por línea, con una +serie que |denota y un paralelo que denota, y algo de espacio o un signo = antes de la resistencia neta.

Fórmulas

• La resistencia de una resistencia es R1
• La resistencia neta de dos resistencias en serie es R1 + R2
• La resistencia neta de dos resistencias en paralelo es 1 / (1/R1 + 1/R2)
• La distancia entre un valor de resistencia aproximado y el valor objetivo se puede calcular como la distancia pseudo-logarítmica, no lineal distancia: dist = abs(Rapprox / Rtarget - 1). Por ejemplo, 200 está más cerca de 350 que de 100.
• Una mejor medida de distancia es la verdadera distancia logarítmica dist = abs(log(Rapprox/Rtarget)), pero como no se especificó en la pregunta original, puede utilizar cualquiera de las dos medidas.

Tanteo

La puntuación se mide en caracteres de código, según las reglas de golf habituales. La puntuación más baja gana.

Ejemplo

Tenemos las siguientes resistencias en stock [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]y deseamos apuntar a 510ohmios. El programa debe generar 143 configuraciones, aproximadamente como se muestra (puede cambiar el formato, pero asegúrese de que el significado se determine fácilmente):

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.

En este ejemplo, la mejor aproximación de 510 ohmios viene dada por resistencias de 680 y 2200 ohmios en paralelo.

Lo mejor de cada idioma hasta ahora (1 de junio de 2014):

1. J - 70 char
2. APL - 102 char
3. Mathematica - 122 char
4. Ruby - 154 char
5. Javascript - 156 caracteres
6. Julia - 163 char
7. Perl - 185 char
8. Python - 270 char

J - 86 71 70 char

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

No me voy a molestar en explicar cada pequeño detalle porque gran parte del código se gasta sincronizando los resultados de diferentes funciones, pero aquí está la esencia del golf:

• ;@((<@,.{:)\) hace que todos los pares de resistencias posibles se conecten en paralelo o en serie.

• [:,/(<,.+`|,.+/;+&.%/)"1@ luego los conecta, en paralelo y en serie, haciendo una gran lista de posibles conexiones.

• (;a:,<)"0, agrega la posibilidad de usar solo una resistencia por sí misma para aproximarse.

• (]/:[|@<:@%~2{::"1])ordena la lista de combinaciones de resistencias por la distancia pseudológica ( |@<:@%) entre el objetivo y la resistencia resultante de cada combinación.

Y así es como se usa:

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

No solo tiene que ver los primeros 10 como lo hice anteriormente, sino que esta es una función y J REPL trunca valores de retorno muy grandes, y la salida completa para este ejemplo tiene 287 líneas. Puede forzarlo a STDOUT con algo como tmoutput toCRLF , LF ,.~ ": blah rouv blahen Windows, soltarlo toCRLFen Linux, pero rouves una función e internamente, existen todas las filas.

Nota:

La pregunta parece haber cambiado justo debajo de nuestras narices, y ahora la distancia logarítmica se define como en abs(log(Rapprox/Rtarget))lugar de abs(Rapprox/Rtarget-1). Para corregir esto en mi golf, podemos cambiar |@<:@%a |@^.@%: <:es Decremento mientras ^.es Logaritmo.

Mathematica, 151 122 caracteres

Espera que se almacene la resistencia objetivo ry la lista de resistencias disponibles en l.

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

Menos golf:

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

El formato de salida difiere del sugerido, pero las configuraciones son fácilmente determinables. El resultado es una lista de configuraciones. Cada configuración tiene una de las siguientes formas:

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

Entonces, los primeros tres elementos de la salida leen

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

Si estás de acuerdo con los números racionales, podría evitar que se omitan dos caracteres N@. Es decir, el primer elemento (por ejemplo) se devolvería como en 4675/9lugar de 519.444.

APL (102)

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

Esto toma la resistencia objetivo como argumento izquierdo y una lista de resistencias disponibles como argumento correcto.

Explicación:

• V←{... }: Ves una función que:
  • Z/⍨≤/¨Z←,∘.,⍨⍵: encuentra cada combinación única de dos valores en ⍵,
    • Z←,∘.,⍨⍵: une cada valor ⍵con cada valor en ⍵, almacenar en Z,
    • Z/⍨≤/¨Z: seleccione de Zaquellas combinaciones donde el primer valor es menor o igual que el segundo valor
  • ⍺{... }⍺⍺/¨: y luego aplica la siguiente función, vinculada con la función izquierda ( ⍺⍺) a la derecha y el argumento izquierdo ( ⍺) a la izquierda, a cada par:
    • ⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵, el argumento izquierdo, seguido del argumento de límite izquierdo, seguido del argumento derecho, seguido de =, seguido de la función derecha ( ⍵⍵) aplicada a ambos argumentos. (Esta es la función de formateo,. X [configuration] Y [equals] (X [fn] Y))
  • ⊃¨: y luego desempaquetar cada elemento.
• {⍵,' =',⍵}¨⍵: para cada elemento en ⍵, realice las configuraciones para las resistencias individuales. ( ⍵, nada, nada =, ⍵).
• ('+'+V⍵): use la Vfunción para hacer todas las configuraciones en serie (el carácter es '+'y la función es +).
• '|'{÷+/÷⍺⍵}V⍵: use la Vfunción para hacer todas las configuraciones paralelas (el carácter es '|'y la función es {÷+/÷⍺⍵}, inversa de la suma de la inversa de los argumentos).
• K←↑: convierta esto en una matriz y guárdelo K.
• 0 4↓K: suelta las 4 primeras columnas K, dejando solo los valores de resistencia.
• |¯1+⍺÷⍨: calcula la distancia entre ⍺y cada configuración.
• K[⍋... ;]: ordenar Kpor las distancias.

Python 3 - 250 247 270 bytes

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)

Corre así:

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

(es decir, una lista de resistencias delimitada por espacios, con el valor objetivo al final)

Salida:

('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)

Yo diría que la salida, digamos, 680|2200y por 2200|680separado todavía es bastante clara. Si esto es inaceptable, puedo cambiarlo, pero me costará bytes.No fue aceptable. Me costó bytes. Ahora clasifico las tuplas antes de arrojarlas al conjunto, de lo contrario la solución es idéntica.

Ruby 2.1, 156 154 bytes

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

Sin golf:

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

Que hace:

• Para cada valor een a;
  • Iterar a, calcular valores únicos, en serie y paralelos como claves para valores impresos en hash c;
• Determine la distancia desde zcada tecla c; y,
• Para cada valor e[1]de cada tecla e[0]en c, imprimir e[1]=e[0].

Uso de la muestra:

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

Salida de muestra:

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 caracteres

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

Entrada:

• Una variedad Rde resistencias de resistencia; y
• T, la resistencia objetivo.

Salida:

Una matriz de matrices (ordenadas por distancia desde T) cada una de las cuales contiene:

• el valor de la resistencia más pequeña;
• el valor de la resistencia más alta (o 0 si es una resistencia solitaria);
• p, so 0 si las resistencias están en paralelo, en serie o en solitario; y
• La resistencia neta.

Explicación:

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

Julia - 179 163 bytes

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)),:]))

Esto funciona igual que la versión anterior, pero el argumento en la declaración de impresión se ha organizado de manera ligeramente diferente para reducir el número de corchetes necesarios. Ahorra 4 bytes. Absorber la creación del vector de espacios en el argumento de impresión ahorra 2 bytes adicionales. También ha cambiado de usar "buscar" para obtener los índices relevantes a usar la forma lógica. Ahorra 6 bytes. Absorber el cálculo del vector índice en el ajuste de A ahorró otros 2 bytes. Finalmente, reemplazar endof (v) con sum (v) ahorró 2 bytes más. Ahorro total: 16 bytes.

Versión antigua:

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)),:]))

Dentro de la función, esto es lo que está haciendo:

\ =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

Salida de muestra:

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

Última edición Suponiendo todos los valores de resistencia> 0, puede usarlos para la condición de bucle

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

Uso: F(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700])

Sin golf

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 bytes

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

Uso: r(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]);

Salida

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 bytes

213 bytes:

$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 bytes:

$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 bytes:

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

Pase todas las resistencias disponibles como argumentos. La resistencia objetivo debe ser la última:

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

Cómo funciona (código antiguo)

• Definir subrutinas Sy Pcalcular la suma y los valores paralelos de dos resistencias.

• Establezca $"en "," para interpolar @ARGVdentro del globoperador

• <{S,P}({@i},{@i})= S({@i})=> genera un cartesiano de todas las posibilidades:

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

• Combine s///eecon greppara evaluar las resistencias equivalentes y filtre las repeticiones no deseadas (realizadas por (??{$2<$3})y/\d$/

• sort por aptitud calculada en subrutina t

Cambios en el nuevo código

• Evite el uso de s///ee, use expresiones regulares más cortas con verificación condicional y evaldentrogrep

• Reemplazar repeticiones de "{@i}" with$ i`

• Introducir $x, en $ylugar de $2,$3

• Reemplazar split/=/,popcon$_[0]=~s!!!r

• No hay necesidad de seguir ;

• eval; es equivalente a eval $_;

• Agregue =junto con la evalrespuesta -ed en lugar de declararlo por adelantado

Salida:

Prepresenta resistencias en paralelo, Srepresenta resistencias en serie.

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