異常な値の抵抗器

23

前書き

電子回路プロジェクトを構築するとき、回路図では通常とは異なる値（510オームなど）の抵抗器が必要になる場合があります。部品箱を確認すると、510Ωの抵抗器がないことがわかります。ただし、この値の上下には多くの共通値があります。抵抗を並列および直列に組み合わせることにより、510Ωの抵抗をかなりうまく近似できるはずです。

仕事

抵抗値（ストックする抵抗）とターゲット値（概算を目指す）のリストを受け入れる関数またはプログラムを作成する必要があります。プログラムは以下を考慮する必要があります。

  • 個別の抵抗器
  • 直列の2つの抵抗
  • 並列の2つの抵抗

プログラムは、ストックリストから1と2の抵抗器のすべての可能な組み合わせ（同じ抵抗値の2つのコピーを含む）を計算し、それらの直列抵抗と並列抵抗を計算し、ターゲット値にどれだけ近似するかに従って構成をソートする必要があります。

出力形式は、ラインごとに1つの構成で、+直列と|並列を表し、ネット抵抗の前にスペースまたは=記号を付ける必要があります。

フォーミュラ

  • 1つの抵抗の抵抗は R1
  • 直列の2つの抵抗の正味抵抗は R1 + R2
  • 並列の2つの抵抗の正味抵抗は 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.

この例では、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 
— ホスゲン
ソース
3
@Claudiu 100 + 150と150 + 100の間に電気的な違いはありません。どちらも250Ωの抵抗を生成し、100Ω抵抗と150Ω抵抗を消費するため、二重カウントしてはいけません。ただし、これらは125 + 125と区別する必要があります。これも250オームを生成しますが、異なる抵抗を消費するためです（パーツ数を考慮すると、これが望ましい場合があります）。
— ホスゲン
3
510はであるE24シリーズ、それはないですので、ということは珍しいが、手に持っている
— gnibbler
3
ホスゲン、ROUVはどうですか？
— unclemeat
3
それらが存在するとは思わない。
— ホスゲン
1
一部の人々が投稿するのを思いとどまらせる可能性があるため、通常、ゴルフに関する質問の期限を設定しません。受け入れられた回答はいつでも変更できます。
— Nzall

回答:

6

J- 86 71 70文字

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

さまざまな機能の結果を同期するために多くのコードが費やされているため、私は少し詳細に説明するつもりはありませんが、ゴルフの要点は次のとおりです。

  • ;@((<@,.{:)\) 抵抗の可能なペアをすべて並列または直列に接続します。

  • [:,/(<,.+`|,.+/;+&.%/)"1@ 次に、それらを並列および直列に接続し、可能な接続の大きなリストを作成します。

  • (;a:,<)"0, 近似する抵抗を1つだけ使用する可能性が追加されます。

  • (]/:[|@<:@%~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に強制することができます。toCRLF Linuxにrouvが、機能であり、内部的にはすべての行が存在します。

注意：

質問は私たちの鼻のすぐ下で変更されたようで、今では対数距離はのabs(log(Rapprox/Rtarget))代わりに定義されていますabs(Rapprox/Rtarget-1)。私のゴルフでこれを修正するために、|@<:@%to を変更できます|@^.@%：<:is Decrement while ^.is Logarithm。

— アルゴリズムサメ
ソース
あなたのコードは一見すると計り知れないほどですが、私たちはまだその謎に感謝することができます。1日後のベストスコア-それは耐えられますか？
— ホスゲン
1
いいえ、-。＆a：@、@：{@（（{.;
— Kilazur
12

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

したがって、出力の最初の3つの要素は、

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

有理数に問題がなければ、を省略しないように2文字節約できますN@。つまり、最初の要素（たとえば）はの4675/9代わりにとして返されます519.444。

— マーティン・エンダー
ソース
よくやった。あなたはそれに私を打ち負かしました（そしてより短いコードで）。
— DavidC
15
あなたのden＃is＃w @ rn you @ g @ ins＃e @＃ing＃h @＃much syn＃@ c＃ic sug @ rでしたか？
— ホスゲン
2
@ N @ lタプル？それはある種のプログラマーの病気ですか？
— クラバッキオ
@clabacchioすごい、私もそれを見なかった。ホスゲン、...彼はそれを言及するのを忘れていなければなりません...または多分彼はあまりにも、ゴルフをプレーするのが好き
— マーティン・エンダー
10

APL（102）

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

これは、左の引数としてターゲット抵抗を、右の引数として利用可能な抵抗器のリストを取ります。

説明：

  • V←{... }：Vは次の機能です。
    • Z/⍨≤/¨Z←,∘.,⍨⍵：で2つの値のすべてのユニークな組み合わせを見つけ⍵、
      • Z←,∘.,⍨⍵：の各値⍵をの各値と結合し⍵、保存しZ、
      • Z/⍨≤/¨Z：Z最初の値が2番目の値以下である組み合わせから選択します
    • ⍺{... }⍺⍺/¨：そして⍺⍺、右の左の関数（）と左の左の引数（⍺）でバインドされた次の関数を各ペアに適用します。
      • ⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵、左の引数、それに続く左の範囲の引数、右の引数、次に=、その後⍵⍵に両方の引数に適用される右の関数（）が続きます。（これはフォーマット関数ですX [configuration] Y [equals] (X [fn] Y)。）
    • ⊃¨：次に、各要素のボックス化を解除します。
  • {⍵,' =',⍵}¨⍵：の各要素⍵について、個々の抵抗の構成を行います。（⍵、何も、何も、=、⍵）。
  • ('+'+V⍵)：V関数を使用して、すべてのシリアル構成を作成します（文字は'+'および関数は+）。
  • '|'{÷+/÷⍺⍵}V⍵：V関数を使用して、すべての並列構成を作成します（文字is '|'および関数is {÷+/÷⍺⍵}、引数の逆数の合計の逆数）。
  • K←↑：これを行列にして、に保存しKます。
  • 0 4↓K：から最初の4列を削除しK、抵抗値のみを残します。
  • |¯1+⍺÷⍨：⍺各構成間の距離を計算します。
  • K[⍋... ;]：K距離で並べ替えます。
— マリヌス
ソース
3
それが機能するというあなたの言葉を取ります。私のキーボードにはこれらの文字がかなりありません：D
— phosgene
@phosgene：テストする場合は、dyalog.comでDyalog APLの試用版をダウンロードできます。次に、すべてを貼り付けるだけで、動作するはずです。引数はそう例えば、側面に行く：510 code_here 100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700
— マリナス
@phosgene このオンラインインタープリターを試すことができますが、完全な出力は提供されませんが、最初の数行と最後の数行が同じであることを確認できます。
— user12205
確認済み！APLは難解なものです。
— ホスゲン
1
@ace TryAPLは非常に限定されており、通常は機能しません。偶然にもこれに取り組んでいるのは偶然です。eval（⍎）、I / O（⎕）、またはシステム変数（⎕UCSおよび動作しない）をサポートしていない⎕Aため、ほとんどのAPLプログラムは実行されません。無効化された機能のいずれかが使用されている場合、実際にはSYNTAX ERRORが発生します。これが、TryAPLがサポートしていない多くの関数の1つを使用しないという事実は偶然です。
— マリヌス
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別にまだかなり明らかです。これが受け入れられない場合は、変更できますが、バイトがかかります。受け入れられませんでした。バイトかかります。次に、タプルをセットにチャックする前にソートします。それ以外の場合の解決策は同じです。

— 地下モノレール
ソース
確かに、出力は私にはかなり明確に見えます！
— ホスゲン
しかし、あなたは二重にカウントしています。150 + 330は電気的に330 + 150と同一であるため、結果に表示されるのはそのうちの1つだけです（この例では合計143個の構成）。
— ホスゲン
@phoわかりました、修正しました。いくつかの余分なバイトが、ソリューションは今有効であるはずです。
— 地下
また、あなたのプログラムは単一の抵抗をまったく探していないと思います（a + = [（a、a）for a in r]）。一度だけ使用するので、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
私はちょうど1、より多くの文字をgolfed：使用プリント（*ソート（...）、9月= '\ n'は）
— WorldSEnder
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
— ジョシュ
ソース
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。そして
  • 正味抵抗。

説明：

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
ソース
単一の抵抗器がありません（たとえば、入力の出力lenは143ではなく132です）。私はちょうどそれを理解することができれば、私は...、配列内包トリックを借りたいのですが
— edc65
ああ、孤独な抵抗忘れてしまった
— MT0の
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バイト節約できます。最後に、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
— グレン・オー
ソース
いいね！多くのジュリアの投稿を見ないでください-人気が高まっていますか？
— ホスゲン
@phosgene-そうだと思います。これらの言語を使って余分な経験をしてくれるので、私はほとんどこれらを提出しています。
— グレンO
2

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))
}
— edc65
ソース
1
（スコア、下）をプッシュする必要があります！
— ホスゲン
最後に確認したところ、抵抗器はすべて正の値でした。安全な仮定だと思います。
— ホスゲン
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
— スナック
ソース
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、2つの抵抗の合計値と並列値を計算します。

  • $"「、」に設定し@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
— ザイド
ソース
行方不明の2行があるS(100)=100とS(1000)=1000。
— algorithmshark
@algorithmshark：うん、わかった。正規表現は意図せずそれらを消費していました
— Zaid、
誰かが短いPerlソリューションを思い付くことができるかどうかを見るのは興味深いでしょう。
— ザイド
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.