异常值电阻

23

介绍

在构建电子项目时，原理图可能需要一个不正常值的电阻（例如510欧姆）。您检查零件箱，发现没有510欧姆电阻。但是，您确实有许多高于或低于此值的通用值。通过并联和串联组合电阻，您应该能够很好地近似510欧姆电阻。

任务

您必须编写一个函数或程序，该函数或程序接受电阻器值列表（库存的电阻器）和目标值（您要近似的目标值）。该程序必须考虑：

  • 个别电阻
  • 串联两个电阻
  • 两个并联电阻

该程序应从库存清单中计算出1个和2个电阻的所有可能组合（包括相同电阻值的两个副本），计算其串联电阻和并联电阻，然后根据它们对目标值的近似程度对配置进行排序。

输出格式应为每行一种配置，并+表示串联和|并联，并在净电阻前留一些空格或=号。

公式

  • 一个电阻的电阻为 R1
  • 串联的两个电阻的净电阻为 R1 + R2
  • 并联的两个电阻的净电阻为 1 / (1/R1 + 1/R2)
  • 近似电阻值与目标值之间的距离可以计算为伪对数距离，而不是线性距离： dist = abs(Rapprox / Rtarget - 1)。例如，200比350更接近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.

在此示例中，并联的680和2200欧姆电阻器给出了510欧姆的最佳近似值。

到目前为止（2014年6月1日）每种语言的最佳成绩：

  1. J-70个字符
  2. APL-102个字符
  3. Mathematica-122个字符
  4. 红宝石-154个字符
  5. Javascript-156个字符
  6. 朱莉娅-163个字符
  7. Perl-185个字符
  8. Python-270个字符
code-golf  electrical-engineering 
— 光气
source
3
@Claudiu 100 + 150和150 + 100之间在电气上没有区别；两者都会产生250欧姆的电阻，并消耗100欧姆的电阻和150欧姆的电阻，因此我们不能重复计数。但是，应将它们与125 + 125区别开来，因为尽管它也会产生250欧姆，但它会消耗不同的电阻器（考虑到我们的零件数，这可能是更好的选择）。
— 光气
3
510是在E24系列，所以它不是那不寻常的手头上
— gnibbler
3
光气，ROUV呢？
— 2014年
3
我认为它们不存在。
— 光气
1
通常，我们不会为打高尔夫球的代码设置最后期限，因为这可能会阻止某些人发帖。您可以随时更改接受的答案。
— Nzall 2014年

Answers:

6

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 toCRLF上的工具（在Linux 上）将其全部强制为STDOUT，但这rouv是一个函数，并且在内部，所有行都存在。

注意：

这个问题似乎已经改变了，现在，对数距离定义为abs(log(Rapprox/Rtarget))而不是abs(Rapprox/Rtarget-1)。要在高尔夫中更正此问题，我们可以将更|@<:@%改为|@^.@%：<:是减量，而^.对数是。

— 算法
source
尽管您的代码看似难以理解，但我们仍然可以欣赏其中的奥秘。一天后的最佳成绩-坚持吗？
— 光气
1
不，我不想发送邮件至-。＆a：@，@：{@（（{
— 。–
12

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。

— 马丁·恩德
source
辛苦了 您击败了我（并且用较短的代码）。
— DavidC 2014年
15
＃您的窝＃是不是@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@的
— 光气
2
@ N @ l元组？那是某种程序员的病吗？
— clabacchio 2014年
@clabacchio很棒，我什至没有看到。光气，他一定忘了提及它……或者他也喜欢打高尔夫球……
— 马丁·恩德2014年
10

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 '|'和function is {÷+/÷⍺⍵}，自变量逆和之和的逆）。
  • K←↑：将其制成矩阵并将其存储在中K。
  • 0 4↓K：从中删除第4列K，仅保留电阻值。
  • |¯1+⍺÷⍨：计算⍺每个配置之间的距离。
  • K[⍋... ;]：K按距离排序。
— 马里纳斯
source
3
我相信你说的有效。我的键盘缺少许多这样的字符：D
— 光气2014年
@phosgene：如果要对其进行测试，可以从dyalog.com下载Dyalog APL的试用版。然后将整个内容粘贴进去，它应该可以工作。论点在两边，例如：510 code_here 100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700
— marinus
@phosgene您可以尝试使用此在线解释器，尽管它没有提供完整的输出，您可以验证开头几行和最后几行是否相同。
— user12205 2014年
已验证！APL是一些深奥的东西。
— 光气
1
@ace TryAPL非常有限，通常无法正常工作。它恰好在这一方面起作用只是一个巧合。它不支持的eval（⍎），I / O（ ⎕），或（甚至任何系统变量⎕UCS和⎕A不工作），所以大部分APL程序将无法运行。如果使用禁用的功能之一，它实际上会给出语法错误。巧合的是，这一功能碰巧没有使用TryAPL不支持的众多功能之一。
— marinus，2014年
4

Python 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仍然很清楚。如果这是不可接受的，我可以更改它，但要花我一些字节。不能接受。花了我字节。现在，我先将元组排序，然后再将其放入集合中，否则解决方案是相同的。

— 地下单轨铁路
source
当然，输出对我来说很清楚！
— 光气
但是，您正在重复计算。150 + 330在电气上与330 + 150相同，因此结果中仅应显示其中一个（此示例为143个总体配置）。
— 光气
@pho好的，已修复。一些额外的字节，但解决方案现在应该有效。
— 地下
同样，我认为您的程序根本不寻找单个电阻器（a + = [（a，a）中的r中的a]）。您可以只使用一次就跳过a...。关于此import sys;r=sys.args[1:]，使用r=input().split()并说您必须在stdin上给出值。最后：您使用1/sum(1/int(n)for n in b)代替1/sum(map(lambda n:1/int(n),b)。总共应该是274个字符
— WorldSEnder 2014年
我只是打了1个字符：使用print（* sorted（...），sep ='\ n'）
— WorldSEnder 2014年
3

Ruby 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
— 乔希
source
3

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 ；否则为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.
)
— MT0
source
缺少单个电阻器（例如，输出len输入为132而不是143）。如果我能理解的话，我想借用Array Comprehension技巧...
— edc65
啊，忘记了
— 隔离
3

朱莉娅- 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个字节。将空间矢量创建吸收到print参数中可以节省额外的2个字节。它也从使用“查找”获得相关索引转变为使用逻辑形式。节省6个字节。将索引向量的计算吸收到A的调整中可以节省另外2个字节。最后，用sum（v）替换endof（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
— 格伦·奥
source
真好！看不到Julia提交的内容很多-它是否越来越受欢迎？
— 光气
@phosgene-我希望是这样；我主要是提交这些，因为它们给了我额外的语言经验。
— Glen O
2

Javascript（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))
}
— edc65
source
1
必须推（得分，更低）！
— 光气2014年
最后我检查了一下，所有电阻器均为正值。我认为这是一个安全的假设。
— 光气
1

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
— 小吃
source
0

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
— 扎伊德
source
缺少的两行是S(100)=100和S(1000)=1000。
— algorithmhark
@algorithmshark：是的，知道了。正则表达式无意间消耗了它们
— Zaid 2014年
看看是否有人可以提出一个较短的Perl解决方案将会很有趣。
— Zaid 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.