Параллельное сопротивление в электрических цепях

20

Вступление:

Два резистора, R1и R2параллельно (обозначены R1 || R2) имеют объединенное сопротивление, Rpзаданное как:

RP2=R1⋅R2R1+R2
или как предложено в комментариях:

RP2=11R1+1R2

Три резисторов, R1, R2и R3параллельно ( R1 || R2 || R3) имеют суммарное сопротивление (R1 || R2) || R3 = Rp || R3:

RP3=R1⋅R2R1+R2⋅R3R1⋅R2R1+R2+R3

или, опять же, как предложено в комментариях:

RP3=11R1+1R2+1R3

Эти формулы, конечно, могут быть распространены на неопределенное количество резисторов.

Вызов:

Возьмите список положительных значений резисторов в качестве входных данных и выведите объединенное сопротивление, если они были размещены параллельно в электрической цепи. Вы не можете использовать максимальное количество резисторов (за исключением того, что ваш компьютер, конечно, может с этим справиться).

Тестовые случаи:

1, 1
0.5

1, 1, 1
0.3333333

4, 6, 3
1.3333333

20, 14, 18, 8, 2, 12
1.1295

10, 10, 20, 30, 40, 50, 60, 70, 80, 90
2.6117

Самый короткий код на каждом языке выигрывает. Пояснения приветствуются.

code-golf math physics electrical-engineering Стьюи Гриффин
источник
6
Есть несколько других проблем, которые относятся к гармоническому среднему ( 1 2 3 ), но я не думаю, что есть дубликат. В соответствии с тем, что предложил flawr, я думаю, что в этом теле вызова должна быть указана эта фраза, чтобы мы могли легче закрыть будущий обман.
FryAmTheEggman

Ответы:

13

05AB1E , 5 3 байта

zOz

Попробуйте онлайн!

объяснение

z                     # compute 1/x for each x in input 
 O                    # sum input 
  z                   # compute 1/sum
Истек срок действия данных
источник
4
За исключением встроенных модулей, это, вероятно, так низко, как мы можем пойти!
9

Haskell , 18 16 байтов

(1/).sum.map(1/)

Попробуйте онлайн!

flawr
источник
3
Это выглядит прекрасно.
Эрик Думинил
Решение по рекурсивным линиям OP было бы 22 символов: foldr1(\r s->r*s/(r+s)).
перестал поворачиваться против часовой стрелки
9

MATLAB , 14 байтов

В MATLAB norm(...,p)вычисляет p-норму вектора. Это обычно определяется для p⩾1 как

‖v‖p=(∑i|vi|p)1p.

Но, к счастью для нас, это также работает для p=−1 . (Обратите внимание, что это не работает в Octave.)

@(x)norm(x,-1)

Не пытайтесь сделать это онлайн!

flawr
источник
4
Это ужасно и красиво одновременно!
перестал поворачиваться против часовой стрелки
1
Спасибо, это лучшие комплименты :)
flawr
7

Желе ,  5  3 байта

İSİ

Попробуйте онлайн!

Как?

Первоначально я забыл эту форму из моих дней инженерной электроники ... как легко мы забываем.

İSİ - Link: list of numbers, R   e.g. [r1, r2, ..., rn]
İ   - inverse (vectorises)            [1/r1, 1/r2, ..., 1/rn]
 S  - sum                             1/r1 + 1/r2 + ... + 1/rn
  İ - inverse                         1/(1/r1 + 1/r2 + ... + 1/rn)
Джонатан Аллан
источник
4
Я предполагаю, İчто произносится так же, как iпроизносится в list. Это способ сказать, что задача была легкой?
Стьюи Гриффин
4

Октава , 15 байт

@(x)1/sum(1./x)

Попробуйте онлайн!

Гармоническое среднее, разделенная n. Очень просто.

Giuseppe
источник
@ ты знаешь, я не думаю, что когда-либо заметил это. Я думаю, что это почти гармоническое среднее ...
Джузеппе
4

APL (Dyalog Unicode) , 4 байта

÷1⊥÷

Попробуйте онлайн!

-1 спасибо Адаму .

Эрик Outgolfer
источник
1
APL - оригинальный язык игры в гольф!
@YiminRong Это не игра в гольф ...: P
Эрик Аутгольфер
Я знаю, но его количество байтов не уступает современным языкам игры в гольф!
-1 байт: ÷1⊥÷ попробуйте онлайн!
Адам
@ Adám О, да, конечно 1∘⊥, то же самое, что и +/для векторов ...
Эрик Игрок в гольф
3

Perl 6 , 14 байт

1/*.sum o 1/**

Попробуйте онлайн!

1 / **является анонимной функцией, которая возвращает список обратных значений своих аргументов. 1 / *.sumэто другая анонимная функция, которая возвращает обратную сумму суммы элементов своего аргумента списка. oОператор сочиняет эти две функции.

Шон
источник
Очень хорошо. Я не вижу, чтобы HyperWhatevers использовались достаточно часто в гольфе, поскольку их нельзя использовать в более сложных выражениях. Если бы они были ближе к нормальным Whatevers, я бы ожидать sumething , как это работает, но увы ...
Джо Кинг
Да, это, наверное, первый раз, когда я даже думал об использовании одного для игры в гольф, и я был разочарован, обнаружив его ограничения.
Шон
3

bash + coreutils, 25 байт

bc -l<<<"1/(0${@/#/+1/})"

TIO

Науэль Фуйе
источник
3

Wolfram Language (Mathematica) , 10 байт

1/Tr[1/#]&

Попробуйте онлайн!

attinat
источник
Разве нет встроенного среднего гармонического значения или оно дольше печатается?
Эрик Думинил
@Eric AFAIK интуитивно назван HarmonicMeanи длиннее.
мое местоимение monicareinstate
3

MathGolf , 3 байта

∩Σ∩

Же , как и другие ответы, используя встроенные команды ∩(1N) и Σ(сумма):

M(x1,...,xn)=11x1+1x2+...+1xn

Try it online.

Kevin Cruijssen
источник
2

PHP, 51 bytes

Reciprocal of sum of reciprocals. Input is $a.

1/array_reduce($a,function($c,$i){return$c+1/$i;});

Try it online!


источник
With PHP7.4, I think you can do this: 1/array_reduce($a,fn($c,$i)=>$c+1/$i); (38 bytes). Read more in wiki.php.net/rfc/arrow_functions
Ismael Miguel
I think you're right! But nowhere to demo?
You have to download it yourself. However, since PHP 7.4.0RC1 was released on the 5th of this month (php.net/archive/2019.php#2019-09-05-1), you probably are safe using it. If you have doubts, you can ask in the meta.
Ismael Miguel
2

x86-64 Machine code - 20 18 bytes

0F 57 C0             xorps       xmm0,xmm0  
loopHead
F3 0F 53 4C 8A FC    rcpss       xmm1,dword ptr [rdx+rcx*4-4]
0F 58 C1             addps       xmm0,xmm1  
E2 F6                loop        loopHead
0F 53 C0             rcpps       xmm0,xmm0  
C3                   ret

Input - Windows calling convention. First parameter is the number of resistors in RCX. A pointer to the resistors is in RDX. *ps instructions are used since they are one byte smaller. Technically, you can only have around 2^61 resistors but you will be out of RAM long before then. The precision isn't great either, since we are using rcpps.

me'
источник
“Only 2⁶¹ resistors” would probably fill the observable universe (many times over)!
Actually, 2^61 is only 2.305843e+18 and the observable universe is 8.8 × 10^26 m in diameter.
me'
Yeah, serious overestimation! Actual magnitude would be around the size and mass of Deimos, smaller moon of Mars.
2

Java 8, 24 bytes

a->1/a.map(d->1/d).sum()

I noticed there wasn't a Java answer yet, so figured I'd add one.

Try it online.

Explanation:

Uses the same Harmonic Mean approach as other answers:

M(x1,...,xn)=11x1+1x2+...+1xn

a->                       // Method with DoubleStream parameter and double return-type
     a.map(d->1/d)        //  Calculate 1/d for each value `d` in the input-stream
                  .sum()  //  Then take the sum of the mapped list
   1/                     //  And return 1/sum as result
Kevin Cruijssen
источник
2

MATL, 5 bytes

,1w/s

Try it online!

I'm not sure if "do twice" (,) counts as a loop, but this is just the harmonic mean, divided by n.

С другой стороны, ,-1^sэто также пять байтов.

Giuseppe
источник
2

Машинный код Intel 8087 FPU, 19 байтов

 D9 E8      FLD1                    ; push 1 for top numerator on stack
 D9 EE      FLDZ                    ; push 0 for running sum 
        R_LOOP: 
 D9 E8      FLD1                    ; push 1 numerator for resistor
 DF 04      FILD WORD PTR[SI]       ; push resistor value onto stack 
 DE F9      FDIV                    ; divide 1 / value 
 DE C1      FADD                    ; add to running sum 
 AD         LODSW                   ; increment SI by 2 bytes 
 E2 F4      LOOP R_LOOP             ; keep looping 
 DE F9      FDIV                    ; divide 1 / result                  
 D9 1D      FSTP WORD PTR[DI]       ; store result as float in [DI]

This uses the stack-based floating point instructions in the original IBM PC's 8087 FPU.

Вход указатель на значения резисторов в [SI], количество резисторов в CX. Вывод с одинарной точностью (DD) значение при [DI].

640 КБ
источник
1

Дротик , 42 байта

f(List<num>a)=>a.reduce((p,e)=>p*e/(p+e));

Попробуйте онлайн!

Необходимость явно указывать numтип является своего рода отстойным, предотвращает вывод типа, потому что это будет означать, что (dynamic, dynamic) => dynamicпо какой-то причине не может быть удвоено

Elcan
источник
1

Python 3, 58 44 байта

f=lambda x,y=0,*i:f(x*y/(x+y),*i)if y else x

Рекурсивная функция. Требует, чтобы аргументы передавались без упаковки, вот так:

i=[10, 10, 20]
f(*i)

или

f(10, 10, 20)

Объяснение:

# lambda function with three arguments. *i will take any unpacked arguments past x and y,
# so a call like f(10, 20) is also valid and i will be an empty tuple
# since y has a default value, f(10) is also valid
f=lambda x,y=0,*i: \

# a if case else b
# determine parallel resistance of x and y and use it as variable x
# since i is passed unpacked, the first item in the remaining list will be y and
# the rest of the items will be stored in i
# in the case where there were no items in the list, y will have the default value of 0
f(x*y/(x+y),*i) \

# if y does not exist or is zero, return x
if y else x
Triggernometry
источник
1

Древесный уголь , 7 байт

Ｉ∕¹Σ∕¹Ａ

Попробуйте онлайн! Ссылка на подробную версию кода. Работает, вычисляя ток, потребляемый каждым резистором при подаче 1 В, принимая общее значение и вычисляя сопротивление, которое потребляет этот ток при приложении 1 В. Объяснение:

      Ａ Input array
    ∕¹  Reciprocal (vectorised)
   Σ    Sum
 ∕¹     Reciprocal
Ｉ       Cast to string for implicit print
Нил
источник
1

J , 6 байт

1%1#.%

Попробуйте онлайн!

Гален Иванов
источник
2
жаль "сумма под взаимностью" такое же количество байтов:+/&.:%
нгн
@ngn Да, но ваше решение выглядит более идиоматичным для Дж.
Гален Иванов
1

[MATLAB], 15 байт

Еще один байт, чем flawr отличный ответ, но мне пришлось использовать другие функции, так что здесь идет:

@(x)1/sum(1./x)

Это довольно явно, он суммирует обратное сопротивление, а затем инвертирует сумму, чтобы вывести эквивалентное параллельное сопротивление.

Hoki
источник
1

Forth (gforth) , 49 байтов

: f 0e 0 do dup i cells + @ s>f 1/f f+ loop 1/f ;

Попробуйте онлайн!

Ввод - это адрес памяти и длина массива (используется как импровизированный массив, так как Forth не имеет встроенной конструкции массива)

Использует метод суммы обратных, так как большинство других ответов

Код Объяснение

: f           \ start a new word definition
  0e          \ stick an accumulator on the floating point stack
  0 do        \ start a loop from 0 to array-length -1
    dup       \ copy the array address
    i cells + \ get the address of the current array value
    @ s>f     \ get the value and convert it to a float
    1/f f+    \ invert and add to accumulator
  loop        \ end the loop definition
  1/f         \ invert the resulting sum
;             \ end the word definition
reffu
источник
1

expl3 (уровень программирования LaTeX3), 65 байт

Следующее определяет функцию, которая печатает результат в терминал (к сожалению, expl3имеет очень подробные имена функций):

\def\1#1{\fp_show:n{1/(\clist_map_function:nN{#1}\2)}}\def\2{+1/}

Полный сценарий, который можно запустить из терминала, включая все тестовые примеры, а также настройки для ввода expl3:

\RequirePackage{expl3}\ExplSyntaxOn
\def\1#1{\fp_show:n{1/(\clist_map_function:nN{#1}\2)}}\def\2{+1/}
\1{1, 1}
\1{1, 1, 1}
\1{4, 6, 3}
\1{20, 14, 18, 8, 2, 12}
\1{10, 10, 20, 30, 40, 50, 60, 70, 80, 90}
\stop

Если запустить со pdflatex <filename>следующим выводом консоли:

This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019) (preloaded format=pdflatex)
 restricted \write18 enabled.
entering extended mode
(./cg_resistance.tex
LaTeX2e <2018-12-01>
(/usr/local/texlive/2019/texmf-dist/tex/latex/unravel/unravel.sty
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3kernel/expl3.sty
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3kernel/expl3-code.tex)
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3backend/l3backend-pdfmode.def))
 (/usr/local/texlive/2019/texmf-dist/tex/latex/l3packages/xparse/xparse.sty)
(/usr/local/texlive/2019/texmf-dist/tex/generic/gtl/gtl.sty))
> 1/(\clist_map_function:nN {1,1}\2)=0.5.
<recently read> }

l.3 \1{1, 1}

?
> 1/(\clist_map_function:nN {1,1,1}\2)=0.3333333333333333.
<recently read> }

l.4 \1{1, 1, 1}

?
> 1/(\clist_map_function:nN {4,6,3}\2)=1.333333333333333.
<recently read> }

l.5 \1{4, 6, 3}

?
> 1/(\clist_map_function:nN {20,14,18,8,2,12}\2)=1.129538323621694.
<recently read> }

l.6 \1{20, 14, 18, 8, 2, 12}

?
> 1/(\clist_map_function:nN
{10,10,20,30,40,50,60,70,80,90}\2)=2.611669603067675.
<recently read> }

l.7 \1{10, 10, 20, 30, 40, 50, 60, 70, 80, 90}

?
 )
No pages of output.
Transcript written on cg_resistance.log.

объяснение

\fp_show:n : оценивает свой аргумент как выражение с плавающей запятой и печатает результат на терминале, каждый расширяемый макрос раскрывается во время этого процесса.

\clist_map_function:nN : принимает два аргумента, список, разделенный запятыми, и функцию / макрос, если вызывается так, как если бы \clist_map_function:nN { l1, l2, l3 } \fooон расширялся до чего-то подобного \foo{l1}\foo{l2}\foo{l3}. В нашем случае вместо \fooмакроса \2используется макрос , который расширяется до +1/так, что выражение расширяется до+1/{l1}+1/{l2}+1/{l3}

Skillmon
источник