অস্বাভাবিক মান প্রতিরোধক

Question

ভূমিকা

ইলেক্ট্রনিক্স প্রকল্প তৈরি করার সময়, একটি স্কিম্যাটিক কোনও অস্বাভাবিক মানের প্রতিরোধকের জন্য ডাকতে পারে (বলুন, 510 ওহম)। আপনি আপনার যন্ত্রাংশ বিন পরীক্ষা করে দেখুন যে আপনার কাছে কোনও 510-ওহম প্রতিরোধক নেই। তবে এই মানটির উপরে এবং নীচে আপনার অনেকগুলি সাধারণ মান রয়েছে। সমান্তরাল এবং সিরিজে প্রতিরোধকের সংমিশ্রণের মাধ্যমে, আপনি মোটামুটিভাবে 510-ওহম প্রতিরোধককে আনুমানিক করতে সক্ষম হবেন।

কার্য

আপনাকে অবশ্যই একটি ফাংশন বা প্রোগ্রাম লিখতে হবে যা প্রতিরোধকের মানগুলির একটি তালিকা গ্রহণ করে (প্রতিরোধকরা আপনার স্টক করে) এবং একটি লক্ষ্য মান (যার লক্ষ্য আপনি আনুমানিক)। প্রোগ্রামটি অবশ্যই বিবেচনা করবে:

• পৃথক প্রতিরোধক
• সিরিজের দুটি প্রতিরোধক
• সমান্তরালে দুটি প্রতিরোধক

প্রোগ্রামটি স্টক তালিকা থেকে 1 এবং 2 রেজিস্টারের সমস্ত সম্ভাব্য সংমিশ্রণগুলি (একই প্রতিরোধকের মানের দুটি অনুলিপি সহ) গণনা করা উচিত, তাদের সিরিজ এবং সমান্তরাল প্রতিরোধের গণনা করা উচিত, তারপরে তারা লক্ষ্য্যের মানটি কতটা আনুমানিক অনুসারে কনফিগারেশনগুলিকে সাজান।

আউটপুট ফর্ম্যাটটি প্রতি +ডাইনোটিং সিরিজ এবং |ড্যানোটিং সমান্তরাল এবং কিছু স্থান বা নেট প্রতিরোধের আগে একটি = চিহ্ন সহ প্রতি লাইনের একটি কনফিগারেশন হওয়া উচিত ।

সূত্র

• একটি প্রতিরোধকের প্রতিরোধ হয় R1
• সিরিজের দুটি প্রতিরোধকের নেট প্রতিরোধের হয় R1 + R2
• সমান্তরাল দুটি প্রতিরোধকের নেট প্রতিরোধের হয় 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.

এই উদাহরণে, 510 ওহমের সর্বোত্তম অনুমান 640- ও 2200-ওহম প্রতিরোধক সমান্তরালভাবে দিয়ে থাকে।

এখন পর্যন্ত প্রতিটি ভাষার সেরা (1 জুন 2014):

1. জে - 70 চর
2. এপিএল - 102 চর
3. গণিত - 122 চর
4. রুবি - 154 চর
5. জাভাস্ক্রিপ্ট - 156 চর
6. জুলিয়া - 163 চর
7. পার্ল - 185 চর
8. পাইথন - 270 চর

Comments

@ ক্লাডিউ 100 + 150 এবং 150 + 100 এর মধ্যে বৈদ্যুতিকভাবে কোনও পার্থক্য নেই; উভয়ই 250 ওহম প্রতিরোধের ফলন দেয় এবং 100-ওহম প্রতিরোধক এবং 150-ওহম প্রতিরোধক গ্রহণ করে, সুতরাং আমাদের অবশ্যই দ্বিগুণ গণনা করা উচিত নয়। যাইহোক, তাদের 125 + 125 থেকে আলাদা করা উচিত, যদিও এটি 250 ওহমও দেয় তবে এটি বিভিন্ন প্রতিরোধক গ্রহণ করে (যা আমাদের অংশ বিবেচনা করে পছন্দনীয়)।

— ফোসগেন

510 হয় E24 সিরিজের তাই এটা না যে গায়ে হাত আছে অস্বাভাবিক

— gnibbler

ফসগিন, রাউভের কী হবে?

— চাচাবিশেষ

আমি মনে করি না তাদের অস্তিত্ব আছে।

— ফসগেন

আমরা সাধারণত কোড গল্ফ প্রশ্নগুলির জন্য সময়সীমা সেট করি না কারণ এটি কিছু লোককে পোস্ট করা থেকে নিরুৎসাহিত করতে পারে। আপনি সর্বদা গৃহীত উত্তরগুলি পরিবর্তন করতে পারেন।

— এনজল

Answer 1

জে - 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 টি দেখতে হবে না, তবে এটি একটি ফাংশন এবং জে আরইপিএল খুব বড় রিটার্ন মানকে ছাঁটাই করে এবং এই উদাহরণটির সম্পূর্ণ আউটপুটটিতে 287 লাইন থাকে। tmoutput toCRLF , LF ,.~ ": blah rouv blahউইন্ডোজ-এর মতো কিছু দিয়ে আপনি লিনাক্সটি ড্রপ করুন it toCRLFতবে rouvএটি একটি ফাংশন এবং অভ্যন্তরীণভাবে সমস্ত সারি বিদ্যমান, এমন কিছু দিয়ে আপনি এটি সমস্ত কিছুতে বাধ্য করতে পারেন ।

বিঃদ্রঃ:

প্রশ্নটি আমাদের নাকের নীচে পরিবর্তিত হয়েছে বলে মনে হয়, এবং এখন লগের দূরত্বটিকে abs(log(Rapprox/Rtarget))পরিবর্তে হিসাবে সংজ্ঞায়িত করা হয়েছে abs(Rapprox/Rtarget-1)। আমার গলফ মধ্যে এটি ঠিক করার জন্য, আমরা পরিবর্তন করতে পারেন |@<:@%থেকে |@^.@%: <:হ্রাস থাকাকালীন ^.লগারিদম হয়।

Comments

যদিও আপনার কোডটি আপাতদৃষ্টিতে অপ্রতিরোধ্য নয়, আমরা এখনও রহস্যটির প্রশংসা করতে পারি। একদিন পর সেরা স্কোর - এটি কি দাঁড়াবে?

— ফোসজেন

না, আমি এখানে কোনও মেইল ​​পাঠাতে চাই না & & a: @, @: {@ (({।;

— কিলাজুর

Answer 2

গণিত, 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}

সুতরাং আউটপুট প্রথম তিনটি উপাদান পড়ুন

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

আপনি যদি যুক্তিসঙ্গত সংখ্যা দিয়ে ভাল থাকেন তবে আমি দুটি অক্ষর বাদ দেওয়া থেকে বাঁচাতে পারি N@। অর্থাৎ প্রথম উপাদান (উদাহরণস্বরূপ) হিসেবে ফেরত পাঠানো হবে 4675/9পরিবর্তে 519.444।

Comments

চমৎকার কাজ. আপনি আমাকে এটি মারলেন (এবং সংক্ষিপ্ত কোড সহ)।

— ডেভিডসি 26'14

'# আপনার ডান # টি # ডাব্লু @ আরএনএন আপনি @ জি @ ইনস # ই @ # আইং # এইচ @ # অনেকটা সিএন # @ সি # আইসিস্ক @ আর?

— ফসজিন

@ এন @ এল টিপলস? এটি কি প্রোগ্রামারদের কোনও ধরণের রোগ?

— ক্লাবচিও

@ ক্লাবাচিও আশ্চর্যজনক, আমি এটিও দেখিনি। ফসগিন, তিনি অবশ্যই এটি উল্লেখ করতে ভুলে গিয়েছিলেন ... বা সম্ভবত তিনি কেবল গল্ফ খেলতেও পছন্দ করেছেন ...

— মার্টিন ইন্ডার

Answer 3

এপিএল (১০২)

{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সমস্ত সমান্তরাল কনফিগারেশন তৈরি করতে ফাংশনটি ব্যবহার করুন (চরিত্রটি হ'ল '|'এবং ফাংশনটি {÷+/÷⍺⍵}যুক্তির বিপরীতের যোগফলের বিপরীত)।
• K←↑: এটিকে একটি ম্যাট্রিক্সে তৈরি করুন এবং এটি সঞ্চয় করুন K।
• 0 4↓K: Kকেবলমাত্র প্রতিরোধের মান রেখে 4 টি প্রথম কলামগুলি ড্রপ করুন ।
• |¯1+⍺÷⍨: ⍺এবং প্রতিটি কনফিগারেশনের মধ্যে দূরত্ব গণনা করুন ।
• K[⍋... ;]: Kদূরত্ব অনুসারে বাছাই করুন।

Comments

আমি আপনার কথাটি নিয়ে যাব এটি কার্যকর। আমার কীবোর্ডটি এই অক্ষরগুলির চেয়ে অনেকগুলি অনুপস্থিত: ডি

— ফোসজেন

@ ফসজিন: আপনি যদি এটি পরীক্ষা করতে চান তবে আপনি ডায়ালগ ডটকম এ ডায়ালগ এপিএলের একটি ট্রায়াল সংস্করণ ডাউনলোড করতে পারেন। তারপরে পুরো জিনিসটি কেবল আটকান, এটি কাজ করা উচিত। যুক্তিগুলি পক্ষের দিকে যায়, উদাহরণস্বরূপ:510 code_here 100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700

— মেরিনাস

@ ফসজিন আপনি এই অনলাইন অনুবাদককে চেষ্টা করতে পারেন , যদিও এটি সম্পূর্ণ আউটপুট সরবরাহ করে না আপনি যাচাই করতে পারেন যে শুরুতে কয়েকটি লাইন এবং শেষ কয়েকটি লাইন একই রকম।

— ব্যবহারকারী 12205

যাচাই! এপিএল হ'ল কিছু রহস্যজনক জিনিস।

— ফোসগেন

@ace ট্রাইএপিএল খুব সীমাবদ্ধ এবং সাধারণত এটি কার্যকর হয় না। এটি যে এটি নিয়ে কাজ করে তা নিছক একটি কাকতালীয় ঘটনা। এটিকে সমর্থন করে না Eval ( ⍎) I / O ( ⎕), অথবা কোনও সিস্টেম ভেরিয়েবল (এমনকি ⎕UCSএবং ⎕Aনা কাজ) যাতে সবচেয়ে APL প্রোগ্রাম চলবে না। এটি প্রতিবন্ধী ফাংশনগুলির মধ্যে যদি একটি ব্যবহার করা হয় তবে এটি আসলে একটি সিএনটিএক্সএক্স ইরর দেবে । ট্রাইএপিএল যে বহু কার্যকারিতা সমর্থন করে না তার মধ্যে একটির ব্যবহার না করার জন্য এটি ঘটেছিল তা সত্য ঘটনা।

— মেরিনাস

Answer 4

পাইথন 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 আলাদাভাবে এখনও খুব পরিষ্কার। যদি এটি অগ্রহণযোগ্য হয় তবে আমি এটি পরিবর্তন করতে পারি তবে এটি আমার বাইটের জন্য ব্যয় করবে।গ্রহণযোগ্য ছিল না। আমার বাইট খরচ। এখন আমি টিপলগুলিকে সেটে চক করার আগে বাছাই করেছি, অন্যথায় সমাধানটি অভিন্ন।

Comments

অবশ্যই, আউটপুট আমার কাছে যথেষ্ট পরিস্কার দেখাচ্ছে!

— ফোসগেন

তবে, আপনি দ্বিগুণ গণনার জিনিস। 150 + 330 বৈদ্যুতিনভাবে 330 + 150 এর মতো, সুতরাং ফলাফলগুলির মধ্যে কেবলমাত্র একটির উপস্থিত হওয়া উচিত (উদাহরণের জন্য 143 মোট কনফিগারেশন)।

— ফোসগেন

@ ফো ঠিক আছে, স্থির। কয়েকটি অতিরিক্ত বাইট তবে সমাধানটি এখন বৈধ হওয়া উচিত।

— আন্ডারগ্রাউন্ডোমোনাইল

এছাড়াও আমি মনে করি আপনার প্রোগ্রামটি কোনও একক প্রতিরোধকের সন্ধান করবে না, মোটেও (a + = [(a, a) এর জন্য r]])। আপনি ঠিক এক সময় ব্যবহার করার সাথে সাথে আপনি a = ... এড়িয়ে যেতে পারেন। এটি সম্পর্কে import sys;r=sys.args[1:], ব্যবহার করুন r=input().split()এবং বলুন যে আপনাকে স্টিডিনের মান দিতে হবে। শেষ অবধি: আপনি এর 1/sum(1/int(n)for n in b)পরিবর্তে ব্যবহার করুন 1/sum(map(lambda n:1/int(n),b)। সব মিলিয়ে, এটি 274 টি অক্ষর হওয়া উচিত

— ওয়ার্ল্ডসেন্ডার

আমি কেবল আরও 1 চর গল্ফ করেছি: মুদ্রণ ব্যবহার করুন (* সাজানো (...),

— সেপ

Answer 5

রুবি ২.১, 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]}"}}

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

এর মানে কি:

• প্রতিটি মূল্য 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

Answer 6

জাভাস্ক্রিপ্ট (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.
)

Comments

একক প্রতিরোধক অনুপস্থিত (উদাহরণস্বরূপ ইনপুট জন্য আউটপুট লেন 143 এর পরিবর্তে 132)। আমি যদি অ্যারে বোঝার কৌশলটি

— ঘৃণা

আহ, নির্জন প্রতিরোধকারীদের ভুলে গেছেন

— এমটি0

Answer 7

জুলিয়া - 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)),:]))

এটি পুরানো সংস্করণ হিসাবে একই কাজ করে, তবে বর্গাকার বন্ধনীগুলির সংখ্যা কমিয়ে আনার জন্য মুদ্রণ বিবৃতিতে যুক্তিটি কিছুটা ভিন্নভাবে সাজানো হয়েছে। 4 বাইট সঞ্চয় প্রিন্ট আর্গুমেন্টে স্পেস ভেক্টর তৈরির শোষণ অতিরিক্ত অতিরিক্ত 2 বাইট সংরক্ষণ করে। লজিকাল ফর্মটি ব্যবহারের ক্ষেত্রে সম্পর্কিত সূচকগুলি পেতে এটি "সন্ধান করুন" ব্যবহার থেকে স্যুইচ করেছে। 6 বাইট সংরক্ষণ করুন সূচক ভেক্টরের গণনার সাথে সংযোজন করে এ এর ​​সামঞ্জস্যকরণে আরও 2 বাইট সংরক্ষণ করা হয়েছে। অবশেষে, endof (v) এর যোগফল (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

Comments

নিস! অনেক জুলিয়া জমাগুলি দেখতে পাবেন না - এটি কি জনপ্রিয়তা বাড়ছে?

— ফোসজেন

@ ফসজিন - আমি আশা করি এটি; আমি বেশিরভাগই এগুলি জমা দিচ্ছি কারণ তারা ভাষার সাথে আমাকে অতিরিক্ত অভিজ্ঞতা দিচ্ছেন।

— গ্লেন ও

Answer 8

জাভাস্ক্রিপ্ট (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])

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

Comments

অবশ্যই ধাক্কা (স্কোর, কম)!

— ফোসগেন

সর্বশেষে আমি যাচাই করেছি, আমার প্রতিরোধকরা সকলেই ইতিবাচক মূল্যবান। আমি মনে করি এটি নিরাপদ অনুমান।

— ফোসগেন

Answer 9

জাভাস্ক্রিপ্ট, 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

Answer 10

পার্ল, 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দুটি প্রতিরোধকের যোগফল এবং সমান্তরাল মানগুলি গণনা করুন।

• অপারেটরের অভ্যন্তরে $"ইন্টারপোলেট করতে "," তে সেট করুন@ARGVglob

• <{S,P}({@i},{@i})= S({@i})=> সমস্ত সম্ভাবনার একটি কার্টেসিয়ান উত্পন্ন:

  এস (100,100), এস (100,150), এস (100,220), ... পি (100,100), পি (100,150) ... এস (100), এস (150) ...

• একত্রিত s///eeসঙ্গে grepসমতুল্য রোধ নির্ণয় এবং অবাঞ্ছিত পুনরাবৃত্তি ফিল্টার (দ্বারা সঞ্চালিত করতে (??{$2<$3})এবং/\d$/

• sort সাবট্রিনে গুণে ফিটনেস দ্বারা t

নতুন কোডে পরিবর্তন

• s///eeশর্তসাপেক্ষে পরীক্ষা করা এবং evalঅভ্যন্তরের সাথে সংক্ষিপ্ত রেজেক্স ব্যবহার করা থেকে বিরত থাকুনgrep

• "{@i}" withEa 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

Comments

নিখোঁজ দুটি লাইন S(100)=100এবং S(1000)=1000।

— অ্যালগরিদমশার্ক

@ অ্যালগরিদমশর্ক: হ্যাঁ, বুঝেছি। রেজেক্স অসাবধানতাবশত তাদের গ্রাস করছিল

— জায়েদ

স্বল্পতম পার্ল সমাধান নিয়ে কেউ আসতে পারে কিনা তা দেখতে আকর্ষণীয় হবে।

— জায়েদ