Resistores de valor incomum


23

Introdução

Ao construir um projeto de eletrônica, um esquema pode exigir um resistor de valor incomum (por exemplo, 510 ohms). Você verifica o compartimento de peças e descobre que não possui resistores de 510 ohm. Mas você tem muitos valores comuns acima e abaixo desse valor. Ao combinar resistores em paralelo e em série, você poderá aproximar o resistor de 510 ohm razoavelmente bem.

Tarefa

Você deve escrever uma função ou programa que aceite uma lista de valores de resistores (resistores que você armazena) e um valor alvo (que você pretende aproximar). O programa deve considerar:

  • Resistores individuais
  • Dois resistores em série
  • Dois resistores em paralelo

O programa deve calcular todas as combinações possíveis de 1 e 2 resistores da lista de estoques (incluindo duas cópias do mesmo valor de resistor), calcular suas séries e resistências paralelas e, em seguida, classificar as configurações de acordo com a proximidade com o valor alvo.

O formato de saída deve ser uma configuração por linha, com uma +série e |paralelo, e algum espaço ou um sinal = antes da resistência líquida.

Fórmulas

  • A resistência de um resistor é R1
  • A resistência líquida de dois resistores em série é R1 + R2
  • A resistência líquida de dois resistores em paralelo é 1 / (1/R1 + 1/R2)
  • A distância entre um valor da resistência e o valor aproximado alvo pode ser calculada como a distância pseudo-logarítmica, não linear distância: dist = abs(Rapprox / Rtarget - 1). Por exemplo, 200 está mais perto de 350 do que em 100.
  • Uma medida de distância melhor é a distância logarítmica verdadeira dist = abs(log(Rapprox/Rtarget)), mas como isso não foi especificado na pergunta original, você pode usar qualquer uma das medidas.

Pontuação

A pontuação é medida em caracteres de código, de acordo com as regras usuais de golfe. Menor pontuação ganha.

Exemplo

Temos os seguintes resistores em estoque [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]e queremos atingir 510ohms. O programa deve produzir 143 configurações, aproximadamente como mostrado (você pode alterar o formato, mas verifique se o significado é facilmente determinado):

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.

Neste exemplo, a melhor aproximação de 510 ohms é dada pelos resistores de 680 e 2200 ohms em paralelo.

Melhor de cada idioma até agora (1 de junho de 2014):

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

3
@ Claudiu Não há diferença eletricamente entre 100 + 150 e 150 + 100; ambos produzem 250 ohms de resistência e consomem um resistor de 100 ohms e um de 150 ohms, portanto, não devemos contar duas vezes. No entanto, eles devem ser diferenciados de 125 + 125, porque, embora isso também produz 250 ohms, consome resistores diferentes (o que pode ser preferível, considerando a nossa parte).
phosgene

3
510 está na série E24 , então não é que incomum para ter na mão
gnibbler

3
Fosgene, e os ROUV's?
unclemeat

3
Eu não acho que eles existem.
phosgene

1
Normalmente, não definimos prazos para perguntas sobre códigos de golfe, pois isso pode desencorajar algumas pessoas de postar. Você sempre pode alterar as respostas aceitas.
Nzall

Respostas:


6

J - 86 71 70 char

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

Não vou me incomodar em explicar todos os detalhes, porque muito do código é gasto sincronizando os resultados de diferentes funções, mas aqui está a essência do golfe:

  • ;@((<@,.{:)\) faz com que todo par de resistores possível seja conectado em paralelo ou em série.

  • [:,/(<,.+`|,.+/;+&.%/)"1@ depois os conecta, em paralelo e em série, fazendo uma grande lista de conexões possíveis.

  • (;a:,<)"0, acrescenta a possibilidade de usar apenas um resistor para se aproximar.

  • (]/:[|@<:@%~2{::"1])classifica a lista de combinações de resistores pela distância pseudológica ( |@<:@%) entre o alvo e a resistência resultante de cada combinação.

E é assim que 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    |
+---------+-+-------+

Você não precisa visualizar apenas os 10 primeiros, como eu fiz acima, mas essa é uma função e o J REPL trunca valores de retorno muito grandes, e a saída completa para este exemplo tem 287 linhas. Você pode forçar tudo a STDOUT com algo como tmoutput toCRLF , LF ,.~ ": blah rouv blahno Windows - solte o toCRLFLinux - mas rouvé uma função e, internamente, todas as linhas existem.

Nota:

A questão parece ter sido alterada bem abaixo do nosso nariz, e agora a distância do log é definida como em abs(log(Rapprox/Rtarget))vez de abs(Rapprox/Rtarget-1). Para corrigir isso no meu golfe, podemos alterar |@<:@%para |@^.@%: <:is Decrement e ^.Logarithm.


Embora seu código seja aparentemente insondável, ainda podemos apreciar o mistério. Melhor pontuação após um dia - será válido?
phosgene 26/05

1
Não, não quero enviar um email para -. & A: @, @: {@ (({;
Kilazur

12

Mathematica, 151 122 caracteres

Espera que a resistência alvo seja armazenada re a lista de resistências disponíveis em l.

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

Menos golfe:

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

O formato de saída difere do sugerido, mas as configurações são facilmente determináveis. A saída é uma lista de configurações. Cada configuração é de uma das seguintes formas:

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

Então, os três primeiros elementos da saída leram

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

Se você estiver bem com números racionais, eu poderia salvar dois caracteres da omissão N@. Ou seja, o primeiro elemento (por exemplo) seria retornado como em 4675/9vez de 519.444.


Bom trabalho. Você me venceu (e com código mais curto).
DavidC

15
Você não disse que seu covil é # w @ rn você @ g @ ins # e @ # ing # h @
phosgene

2
@ N @ l Tuplas? Isso é algum tipo de doença dos programadores?
Clabacchio

@clabacchio incrível, eu nem vi isso. fosgênio, ele deve ter esquecido de mencionar isso ... ou talvez ele simplesmente gosta de jogar golfe, também ...
Martin Ender

10

APL (102)

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

Isso leva a resistência ao alvo como argumento à esquerda e uma lista de resistores disponíveis como o argumento à direita.

Explicação:

  • V←{... }: Vé uma função que:
    • Z/⍨≤/¨Z←,∘.,⍨⍵: localiza todas as combinações únicas de dois valores em ,
      • Z←,∘.,⍨⍵: junte cada valor a cada valor , armazene Z,
      • Z/⍨≤/¨Z: selecione Zas combinações em que o primeiro valor é menor ou igual ao segundo valor
    • ⍺{... }⍺⍺/¨: e aplica a seguinte função, vinculada à função esquerda ( ⍺⍺) à direita e o argumento esquerdo ( ) à esquerda, a cada par:
      • ⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵, o argumento esquerdo, seguido pelo argumento ligado à esquerda, seguido pelo argumento à direita, seguido por =, seguido pela função à direita ( ⍵⍵) aplicada aos dois argumentos. (Esta é a função de formatação X [configuration] Y [equals] (X [fn] Y).)
    • ⊃¨: e depois desmarque cada elemento.
  • {⍵,' =',⍵}¨⍵: para cada elemento , faça as configurações para os resistores individuais. ( , nada, nada =, ).
  • ('+'+V⍵): use a Vfunção para fazer todas as configurações seriais (caractere é '+'e função é +).
  • '|'{÷+/÷⍺⍵}V⍵: use a Vfunção para fazer todas as configurações paralelas (caractere é '|'e função é {÷+/÷⍺⍵}, inverso da soma do inverso dos argumentos).
  • K←↑: faça isso em uma matriz e armazene-o K.
  • 0 4↓K: solte as 4 primeiras colunas K, deixando apenas os valores de resistência.
  • |¯1+⍺÷⍨: calcula a distância entre e cada configuração.
  • K[⍋... ;]: classifique Kpelas distâncias.

3
Vou aceitar sua palavra de que funciona. Meu teclado está faltando um pouco muito desses personagens: D
fosgênio

@phosgene: Se você quiser testá-lo, pode fazer o download de uma versão de avaliação do Dyalog APL em dyalog.com. Em seguida, basta colar a coisa toda, deve funcionar. Os argumentos vão para os lados, por exemplo:510 code_here 100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700
marinus

@phosgene Você pode experimentar este intérprete online, embora ele não forneça a saída completa, você pode verificar se as poucas linhas iniciais e as últimas são iguais.
User12205

Verificado! APL é uma coisa esotérica.
Fosgene 26/05

1
O @ace TryAPL é muito limitado e geralmente não funciona. O fato de trabalhar nesse caso é apenas uma coincidência. Ele não suporta eval ( ), E / S ( ) ou qualquer variável do sistema (uniforme ⎕UCSe ⎕Anão funciona), portanto, a maioria dos programas APL não será executada. Na verdade, ele emitirá um erro de sintaxe se uma das funções desabilitadas for usada. O fato de este não usar uma das muitas funções que o TryAPL não suporta é uma coincidência.
Marinus 27/05

4

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)

Execute assim:

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

(ou seja, uma lista de resistores delimitada por espaço, com o valor alvo no final)

Saída:

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

Eu diria que a saída, digamos, 680|2200e 2200|680separadamente ainda é bastante clara. Se isso for inaceitável, eu posso alterá-lo, mas isso me custará bytes.Não era aceitável. Custou-me bytes. Agora, ordeno as tuplas antes de jogá-las no conjunto, caso contrário, a solução é idêntica.


Claro, a saída parece muito clara para mim!
phosgene 26/05

No entanto, você está contando coisas duas vezes. 150 + 330 é eletricamente idêntico a 330 + 150, portanto, apenas um deles deve aparecer no resultado (143 configurações totais para o exemplo).
phosgene

@ pho Ok, corrigido. Alguns bytes extras, mas a solução deve ser válida agora.
Undergroundmonorail

Também acho que o seu programa não procura um único resistor (a + = [(a, a) para a em r]). Você pode pular a = ... enquanto usa exatamente uma vez. Sobre isso import sys;r=sys.args[1:], use r=input().split()e diga que você deve fornecer os valores em stdin. Por fim: você usa em 1/sum(1/int(n)for n in b)vez de 1/sum(map(lambda n:1/int(n),b). Ao todo, devem ser 274 caracteres.
WorldSEnder

Eu apenas golfed 1 mais de char: Use impressão (* ordenados (...), Set = '\ n')
WorldSEnder

3

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

Ungolfed:

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

O que faz:

  • Para cada valor eem a;
    • Iterar a, computando valores únicos, em série e paralelos como chaves para valores impressos em hash c;
  • Determine a distância de zcada chave c; e,
  • Para cada valor e[1]para cada chave e[0]em c, imprimir e[1]=e[0].

Uso da amostra:

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

Saída de amostra:

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

  • Uma matriz Rde resistências; e
  • T, a resistência ao alvo.

Saída:

Uma matriz de matrizes (classificadas pela distância de T), cada uma contendo:

  • o menor valor do resistor;
  • o valor mais alto do resistor (ou 0 se um resistor solitário);
  • p, sou 0 se os resistores estiverem em paralelo, serial ou solitário; e
  • a resistência líquida.

Explicação:

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

Resistor único ausente (a saída len, por exemplo, a entrada é 132 em vez de 143). Eu gostaria de pedir o truque matriz Compreensão, se eu apenas pudesse entendê-lo ...
edc65

Ah, esqueci os resistores solitários
MT0

3

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

Isso funciona da mesma forma que na versão antiga, mas o argumento na instrução print foi organizado de maneira ligeiramente diferente para reduzir o número de colchetes necessário. Salva 4 bytes. A absorção da criação do vetor de espaços no argumento print economiza 2 bytes extras. Ele também passou de usar "localizar" para obter os índices relevantes para usar o formulário lógico. Salva 6 bytes. A absorção do cálculo do vetor de índice no ajuste de A salvou outros 2 bytes. Finalmente, a substituição de endof (v) pela soma (v) economizou mais 2 bytes. Economia total: 16 bytes.

Versão antiga:

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 da função, aqui está o que está fazendo:

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

Saída de amostra:

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

Agradável! Não vê muitos envios de Julia - está crescendo em popularidade?
phosgene

@phosgene - espero que seja; Estou enviando principalmente porque eles estão me dando uma experiência extra com o idioma.
Glen O

2

Javascript (E6) 156 162 164 186

Última edição Assumindo todos os valores de resistores> 0, você pode usá-los para a condição de loop

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

Ungolfed

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

1
Deve empurrar (marcar, abaixar)!
phosgene 26/05

A última vez que verifiquei, todos os meus resistores foram avaliados positivamente. Eu acho que é uma suposição segura.
phosgene

1

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

Saída

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

Passe todos os resistores disponíveis como argumentos. A resistência alvo deve ser a última:

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

Como funciona (código antigo)

  • Defina sub S- rotinas e Pcalcule a soma e os valores paralelos de dois resistores.

  • Defina $"como "," para interpolar @ARGVdentro do globoperador

  • <{S,P}({@i},{@i})= S({@i})=> gera um cartesiano de todas as possibilidades:

    S (100.100), S (100.150), S (100.220), ... P (100.100), P (100.150) ... S (100), S (150) ...

  • Combine s///eecom greppara avaliar as resistências equivalentes e filtrar repetições indesejadas (executadas por (??{$2<$3})e/\d$/

  • sort por aptidão computada na sub-rotina t

Mudanças no novo código

  • Evite usar s///ee, use regex mais curto com verificação condicional e evalinternagrep

  • Substitua repetições de "{@i}" with$ i`

  • Introduzir $x, em $yvez de $2,$3

  • Substitua split/=/,poppor$_[0]=~s!!!r

  • Não há necessidade de arrastar ;

  • eval; é equivalente a eval $_;

  • Adicione =junto com a evalresposta -ed em vez de declará-la antecipadamente

Saída:

Prepresenta resistores em paralelo, Srepresenta resistores em série.

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

As duas linhas ausentes são S(100)=100e S(1000)=1000.
algorithmshark

@algorithmshark: Sim, entendi. O regex estava consumindo-os inadvertidamente
Zaid 28/05

Será interessante ver se alguém pode encontrar uma solução Perl mais curta.
Zaid
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.