পটভূমি

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

উদাহরণস্বরূপ, আমার তুলসী টমেটো সস, এর প্যাকেজিংয়ে কেবলমাত্র কয়েকটি বড় লাল টমেটো এবং সুন্দর তুলসী পাতা দেখায়, নিম্নলিখিত সংকেত রয়েছে:

উপকরণ: টমেটো ৮০%, টুকরো টুকরো পেঁয়াজ, তুলসী ১.৪%, সামুদ্রিক লবণ, কাঁচা রসুন, কাঁচা বেত চিনি, অতিরিক্ত কুমারী জলপাই তেল, কালো মরিচ।

এটি অদ্ভুত লাগছে, তবে ... আমি ঠিক কতটা পেঁয়াজ খাব ?

চ্যালেঞ্জ

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

আপনি হয় একটি ফাংশন, বা একটি সম্পূর্ণ প্রোগ্রাম লিখতে পারেন।
ইনপুট কোনো যুক্তিসংগত ফর্ম (সংখ্যা বা স্ট্রিং তালিকার অ্যারে, উদাহরণস্বরূপ) এ হতে পারে না। ভগ্নাংশের মানগুলি কমপক্ষে একটি দশমিক স্থানে সমর্থিত হওয়া উচিত। একটি অনুপস্থিত ওজন শতাংশ (যে কোন সামঞ্জস্যপূর্ণ এবং দ্ব্যর্থহীন ভাবে প্রতিনিধিত্ব করা যাবে 0, '?'বা nullউদাহরণস্বরূপ,)। আপনি ধরে নিতে পারেন যে ইনপুটটি সর্বদা একটি বৈধ রেসিপিটির সাথে সম্পর্কিত হবে ( [70]এবং [∅, ∅, 50]উদাহরণস্বরূপ অবৈধ)।
আউটপুট কোনো যুক্তিসংগত ফর্ম (ন্যূনতম এবং সর্বাধিক ওজন শতকরা, অথবা doublets একটি একক তালিকা উভয়ের জন্য এক অ্যারে, উদাহরণস্বরূপ) এ হতে পারে না। সর্বনিম্ন এবং সর্বাধিক শতাংশ যে কোনও ক্রমে হতে পারে ( [min, max]এবং [max, min]উভয়ই গ্রহণযোগ্য)। সঠিক ওজন শতাংশের অন্যান্য শতাংশের চেয়ে আলাদাভাবে প্রক্রিয়া করার দরকার নেই এবং সমান ন্যূনতম এবং সর্বাধিক মান দ্বারা প্রতিনিধিত্ব করা যেতে পারে।

কোড-গল্ফের জন্য স্ট্যান্ডার্ড নিয়মগুলি প্রয়োগ করা হয়: আপনি নিজের কোডটি টাইপ করার সময় আমার পাস্তা ডিশ শীতল হচ্ছে, সুতরাং স্বল্পতম জমাটি জেতে।

উদাহরণ

যেহেতু এই সমস্যাটি প্রথম নজরে দেখার চেয়েও কঠিন, তাই কয়েকটি মামলার ধাপে ধাপে সমাধানটি এখানে দেওয়া হল।

`[40, ∅, ∅]`

আসুন যথাক্রমে কল xএবং yদুটি অনুপস্থিত শতাংশ।

কারণ এটি 40% এ প্রথম উপাদান পরে আসে, 40% এর xবেশি হতে পারে না।
[40, [?, 40], [?, ?]]
দুটি অনুপস্থিত শতাংশের যোগফল সর্বদা 60%। অতএব :
- যদি xএটির সর্বাধিক মান গ্রহণ করে , তবে yতার সর্বনিম্ন মান গ্রহণ করে , যা 60% - 40% = 20%।
  [40, [?, 40], [20, ?]]
- যদি xএটির সর্বনিম্ন মান yনেয় তবে তার সর্বোচ্চ মানটি নেয় । তবে এর xচেয়ে কম হতে পারে না y, সুতরাং এক্ষেত্রে x= y= 60% / 2 = 30%।
  [40, [30, 40], [20, 30]]

`[70, ∅, ∅, 5, ∅]`

এর যথাক্রমে কল করা যাক x, yএবং zতিনটি অনুপস্থিত শতকরা।

এর জন্য সর্বনিম্ন এবং সর্বোচ্চ শতাংশ zঅবশ্যই 0% থেকে 5% এর মধ্যে। zএক মুহুর্তের জন্য = 0% ধরে নেওয়া যাক । দুটি অনুপস্থিত শতাংশের যোগফল সর্বদা 25%। অতএব :
[70, [?, ?], [?, ?], 5, [0, 5]]
- যদি yএটির সর্বনিম্ন মান, 5% xনেয় , তবে তার সর্বোচ্চ মানটি গ্রহণ করে , যার ফলে 25% - 5% = 20%।
  [70, [?, 20], [5, ?], 5, [0, 5]]
- যদি yএটির সর্বাধিক মান xনেয় তবে তার সর্বনিম্ন মান নেয় । তবে এর xচেয়ে কম হতে পারে না y, সুতরাং এক্ষেত্রে x= y= 25% / 2 = 12.5%।
  [70, [12.5, 20], [5, 12.5], 5, [0, 5]]
আসুন যাচাই করুন যে আমরা এখন z= 5% ধরে নিলে সবকিছু ঠিক আছে । দুটি অনুপস্থিত শতাংশের যোগফল সর্বদা 20%। অতএব :
- যদি yএটির সর্বনিম্ন মান, 5% xগ্রহণ করে , তবে এর সর্বোচ্চ মানটি গ্রহণ করে , তাই এটি 20% - 5% = 15%। এই ক্ষেত্রে ইতিমধ্যে পূর্বে গণনা করা ব্যাপ্তি অন্তর্ভুক্ত করা হয়েছে।
- যদি yএটির সর্বাধিক মান xনেয় তবে তার সর্বনিম্ন মান নেয় । তবে এর xচেয়ে কম হতে পারে না y, সুতরাং এক্ষেত্রে x= y= 20% / 2 = 10%। এই ক্ষেত্রে ইতিমধ্যে এর জন্য পূর্বে গণনা করা রেঞ্জের অন্তর্ভুক্ত ছিল yতবে তা নয় x।
  [70, [10, 20], [5, 12.5], 5, [0, 5]]

পরীক্ষার মামলা

Input:  [∅]
Output: [100]

Input:  [70, 30]
Output: [70, 30]

Input:  [70, ∅, ∅]
Output: [70, [15, 30], [0, 15]]

Input:  [40, ∅, ∅]
Output: [40, [30, 40], [20, 30]]

Input:  [∅, ∅, 10]
Output: [[45, 80], [10, 45], 10]

Input:  [70, ∅, ∅, ∅]
Output: [70, [10, 30], [0, 15], [0, 10]]

Input:  [70, ∅, ∅, 5, ∅]
Output: [70, [10, 20], [5, 12.5], 5, [0, 5]]

Input:  [30, ∅, ∅, ∅, 10, ∅, ∅, 5, ∅, ∅]
Output: [30, [10, 25], [10, 17.5], [10, 15], 10, [5, 10], [5, 10], 5, [0, 5], [0, 5]]

code-golf math

— কৃষ্ণ গহ্বর
সূত্র

সম্পূর্ণরূপে নিরবিচ্ছিন্ন

— ম্যাজিক অক্টোপাস উরন

আমি ইনপুট-টু-আউটপুটের জন্য [40, ∅, ∅]এবং [70, ∅, ∅, 5, ∅]জিনিসগুলিকে কিছুটা আরও স্পষ্ট করে তোলার জন্য ধাপে ধাপে ধাপে ব্যাখ্যা যুক্ত করব । পরীক্ষার কেসগুলি না দেখে একটি চ্যালেঞ্জ পরিষ্কার হওয়া উচিত, এটি এখনকার ক্ষেত্রে নয়। যদি আমি এটি সঠিকভাবে বুঝতে পারি [40, ∅, ∅]: তবে এই দুটিয়ের মধ্যে ভাগ করে নেওয়া 100% এর জন্য আরও 60 টি প্রয়োজনীয় ∅। প্রথমটি ∅30 বা তার বেশি ∅হতে হবে (অন্যথায় দ্বিতীয়টি তার উপরে থাকবে, যা তারা যখন ক্রমযুক্ত থাকে তখন সম্ভব হবে না)। তদ্ব্যতীত, এটি উপরে হতে পারে না 40, তাই প্রথম ∅হয় [30,40], এবং দ্বিতীয়টি হয়ে যায় [(100-40-40=)20, (100-40-30=)30]।

— কেভিন ক্রুইজসেন

ধারাবাহিকভাবে [min,max]/ [max,min]বা মিশ্র অনুমোদিত?

— l4m2

@ l4m2 মিশ্রণ [min,max]এবং [max,min]এটি সীমান্তরেখা গ্রহণযোগ্য, তবে যেহেতু এটি অস্পষ্ট ফলাফলের দিকে নিয়ে যেতে পারে না, তাই আমি বলব এটি ঠিক আছে।

— ব্ল্যাকহোল

হয়তো আমি কিছু মিস করছি, তবে কেন [70, 12, 11, 5, 2]আপনার দ্বিতীয় উদাহরণটির জন্য কাজ করা হচ্ছে না? এটি যদি কাজ করে তবে এর জন্য সর্বনিম্ন xকম হবে 12.5।

— DLosc

জাভাস্ক্রিপ্ট (ES6), 252 বাইট

0অনুপস্থিত শতাংশের জন্য প্রত্যাশা । সমস্ত এন্ট্রিগুলির জন্য এক জোড়া ন্যূনতম এবং সর্বাধিক মানগুলি দেয়।

a=>(g=a=>(h=(M,I,J=I^1)=>a.some((x,i)=>a.map((y,j)=>s-=j-i?M(j,i)-i?y[I]:M(w=y[I],z=x[J])-z||w==z?w:++k&&z:y[J],s=100,k=1,X=x)&&(I?-s:s)<0)?X[J]=M(X[I],X[J]+s/k):0)(Math.max,0)+h(Math.min,1)?g(a):a)(a.map((n,i)=>[n?p=n:a.find(n=>i--<0&&n)||0,p],p=100))

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

আরম্ভ

আমরা প্রথমে সর্বাধিক সম্ভাব্য ব্যাপ্তির সাথে ইনপুট অ্যারে [ প্রতিটি] মান প্রতিস্থাপন করি ।

a.map((n, i) =>       // for each value n at position i in a[]:
  [                   //   generate a [min, max] array:
    n ?               //     if n is not 0:
      p = n           //       use n as the minimum and save it in p
    :                 //     else:
      a.find(n =>     //       find the first value n
        i-- < 0 &&    //         which is beyond the current value
        n             //         and is not equal to 0
      ) || 0,         //       or use 0 as a default value
    p                 //     use p as the maximum
  ],                  //   end of array declaration
  p = 100             //   start with p = 100
)                     // end of map()

উদাহরণ:

[ 0 ] --> [ [ 0, 100 ] ]
[ 30, 0, 5, 0 ] --> [ [ 30, 30 ], [ 5, 30 ], [ 5, 5 ], [ 0, 5 ] ]

প্রধান ফাংশন

মূল ফাংশন হ () । এটি প্রথম এন্ট্রির সন্ধান করে যা আমরা যখন এটি হ্রাস বা সর্বাধিক করার চেষ্টা করি তখন এটি বেমানান বলে মনে হয়। এটি যদি কোনওটি সন্ধান করে তবে এটি এটিকে এমন একটি মানের সাথে আপডেট করে যা অন্যান্য ব্যাপ্তির পরিমাপে কমপক্ষে সাময়িকভাবে গ্রহণযোগ্য।

এটি এম = ম্যাথ.ম্যাক্স / আই = 0 বা এম = ম্যাথ.মিন / আই = 1 কে ইনপুট হিসাবে গ্রহণ করবে এবং জে I XOR 1 হিসাবে সংজ্ঞায়িত করবে ।

যেহেতু এইচ () ছোট করা এবং সর্বাধিক পাস উভয়কেই সমর্থন করার জন্য লেখা হয়েছিল, তাই কোডটি মন্তব্য করা কিছুটা জটিল y এজন্য আমরা কেবলমাত্র সর্বোচ্চ পাসের দিকে মনোনিবেশ করব, যার জন্য আমাদের এম = ম্যাথ.ম্যাক্স , আই = 0 এবং জে = 1 রয়েছে । এই পরামিতিগুলির সাথে কোডটি নিম্নরূপ পঠিত:

a.some((x, i) =>              // for each range x at position i in a[] (tested range):
  a.map((y, j) =>             //   for each range y at position j in a[] (reference range):
    s -=                      //     update s:
      j - i ?                 //       if i is not equal to j:
        Math.max(j, i) - i ?  //         if j > i:
          y[0]                //           the reference range is beyond the tested range
                              //           so we just use the minimum value of the y range
        :                     //         else:
          Math.max(           //           take the maximum of:
            w = y[0],         //             w = minimum value of the y range
            z = x[1]          //             z = maximum value of the x range
          ) - z ||            //           if it's not equal to z
          w == z ?            //           or they are equal (i.e. if w <= z):
            w                 //             use w
          :                   //           else:
            ++k && z          //             increment the counter k and use z
      :                       //       else:
        y[1],                 //         use the maximum value of the y range
    s = 100,                  //     start with s = 100
    k = 1,                    //     start with k = 1
    X = x                     //     save the range x in X
  ) &&                        //   end of map()
  (0 ? -s : s) < 0            //   abort if s < 0 (i.e. if we've subtracted more than 100)
) ?                           // end of some(); if truthy:
  X[1] = Math.max(            //   update the maximum value of the faulty range to:
    X[0],                     //     either the minimum value
    X[1] + s / k              //     or the maximum value, less the correction
  )                           //   whichever is greater
:                             // else:
  0                           //   do nothing

recursion

পুনরাবৃত্ত ফাংশন জি () এইচ () কল করে রাখে যতক্ষণ না মিনিমাইজিং বা সর্বাধিক পাস দুটিই নতুন সংশোধনের দিকে না যায় এবং শেষ পর্যন্ত চূড়ান্ত ফলাফল দেয় returns

g = a => h(Math.max, 0) + h(Math.min, 1) ? g(a) : a

— Arnauld
সূত্র

সুন্দরভাবে সম্পন্ন :-) !