स्थापित करना:

एक सामाजिक नेटवर्क दो तरह से वोटों की संख्या की रिपोर्ट करता है: शुद्ध अपवोट्स (कुल अपवोट्स - कुल डाउनवोट्स), और वोटों का % जो अपवोट थे , निकटतम पूर्णांक (.5 राउंड अप) तक गोल। शुद्ध अपवोट्स की संख्या एक पूर्णांक है (जरूरी नहीं कि सकारात्मक), और दूसरा 0 और +100 समावेशी के बीच पूर्णांक होने की गारंटी है। अपवोट्स और डाउनवोट्स की संख्या दोनों शून्य या सकारात्मक 32-बिट पूर्णांक हैं (आप हस्ताक्षरित या निर्दिष्ट निर्दिष्ट कर सकते हैं)। मान लें कि यदि शून्य कुल वोट हैं, तो प्रतिशत को शून्य के रूप में बताया गया है।

चुनौती:

इन दो पूर्णांकों (शुद्ध उत्तोलन और% उत्तोलन) को देखते हुए, आप सबसे छोटा कार्यक्रम क्या लिख सकते हैं, जो प्राप्त की गई सभी बाधाओं से संतुष्ट कुल पद की संख्या की न्यूनतम संख्या निर्धारित करता है?

इनपुट बाधाओं की गारंटी है। यदि इनपुट ऊपर की बाधाओं को संतुष्ट नहीं करता है, तो प्रोग्राम व्यवहार आपके ऊपर है। बोनस कुडोस अगर यह एक अनंत लूप दर्ज नहीं करता है या अन्यथा दुर्घटनाग्रस्त हो जाता है। यदि आप अधिक मार्गदर्शन चाहते हैं तो एक ऋणात्मक संख्या वापस करने पर विचार करें।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध समाधान (बाइट्स में मापा गया) जीतता है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें। जावास्क्रिप्ट की तरह क्लाइंट-साइड वेब लैंग्वेज के लिए बोनस कुडोस।
यदि आपके पास कई भाषाओं में दिलचस्प समाधान हैं, तो उन्हें अलग से पोस्ट करें ।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, या पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट कमियां निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, कृपया एक स्पष्टीकरण जोड़ें कि कोड कैसे काम करता है।
ध्यान रखें कि यदि आप पूर्णांक विभाजन ऑपरेशन कर रहे हैं जो राउंड के बजाय ट्रंकट्स (जैसे 20/3 = 6) है , तो यह पूरी तरह से सही नहीं हो सकता है।
उपरोक्त बाधाओं में किनारे के मामलों का पता लगाने वाले अतिरिक्त परीक्षण मामले स्वागत योग्य हैं।
जबकि अपेक्षित वापसी प्रकार संख्यात्मक है, 0 के स्थान पर बूलियन "गलत" का उपयोग किया जा सकता है ।

उदाहरण के परीक्षण के मामले:

पहला कॉलम चर्चा को सुविधाजनक बनाने के लिए शामिल एक संदर्भ संख्या है।

ref net  %up    answer
1   0    0   => 0    
2   -5   0   => 0    
3   -4   17  => 1    
4   -3   29  => 2    
5   -2   38  => 3    
6   -1   44  => 4    
7   0    50  => 1    
8   5    100 => 5    
9   4    83  => 5    
10  3    71  => 5    
11  2    63  => 5    
12  1    56  => 5    
13  1234 100 => 1234
14  800  90  => 894  (tip: don't refer to this as the "last test case;" others may be added.)

code-golf math arithmetic

— WBT
स्रोत

वह शून्य कुल वोट विशेष मामला बहुत बारीक है। यदि अपवोट्स और डाउनवोट्स की समान संख्या है, तो प्रतिशत 50% है, सिवाय इसके कि यह 0% है जब कोई वोट नहीं है, अपवोट-डाउनवोट समरूपता को तोड़ते हुए।

— xnor

2

@xnor 0/0 आम तौर पर अपरिभाषित है, इसलिए एक धारणा बनाई जानी चाहिए। इस विकल्प के साथ, आपको एक स्वचालित "उत्तर = दूसरा इनपुट" मिलता है यदि दूसरा इनपुट 0 है, और एक स्वचालित "उत्तर = पहला इनपुट" यदि दूसरा इनपुट 100 है।

— WBT

1

सुझाए गए परीक्षण का मामला @nwellnhof से उधार लिया: 1000, 100। क्या आप पुष्टि कर सकते हैं कि अपेक्षित उत्तर है 1000?

— अरनौलद

1

नीच, क्योंकि नफरत करने वाले नफरत करेंगे :)

— होशो 250

@Arnauld और nwellnhof: जैसा कि आपके समक्ष टिप्पणी में उल्लेख किया गया है, यदि दूसरा इनपुट = 100, उत्तर = दूसरा इनपुट। यदि 100 वास्तव में थोड़ा कम प्रतिशत था, तो नेट वोट = प्रथम इनपुट प्राप्त करने के लिए upvotes के पहले इनपुट # से अधिक की आवश्यकता होगी, और यह चुनौती कुल upvotes की सबसे कम संख्या की तलाश करती है।

— WBT

10

जावास्क्रिप्ट (ईएस 6), 47 बाइट्स

करी सिंटैक्स में इनपुट लेता है (n)(p), जहां n नेट अपवोट्स की संख्या है और p अपवोट्स का प्रतिशत है। के falseलिए वापसी कर सकते हैं0 ।

n=>p=>(g=u=>u/(u-n/2)*50+.5^p?g(u+1):u)(n>0&&n)

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

n => p => (          // given n and p
  g = u =>           // g = recursive function taking u = number of upvotes
    u / (u - n / 2)  //   compute u / (total_votes / 2)
    * 50 + .5        //   turn it into a percentage, add 1/2
    ^ p ?            //   XOR it with p, which gives 0 if the integer parts are matching
                     //   if the result is not equal to 0:
      g(u + 1)       //     try again with u + 1
    :                //   else:
      u              //     stop recursion and return u
)(n > 0 && n)        // initial call to g() with u = max(0, n)

किनारे के मामले

चलो F _n (u) = u / (u - n / 2) * 50 + 0.5

यदि u = 0 और n = 0 , तो F _n (u) = NaN और F _n (u) XOR p = p । इसलिए, हम यू = 0 लौटाते हैं अगर n = p = 0 (पहले परीक्षण मामले का पहला पुनरावृत्ति) या पी के साथ जारी है ! = 0 (7 वें परीक्षण मामले का पहला पुनरावृत्ति)।
यदि u> 0 और u = n / 2 , तो F _n (u) = + अनंत और - फिर से - F _n (u) XOR p = p । जब तक पी = 0 नहीं , हम बस अगले पुनरावृत्ति के साथ चलते हैं। (यह 9 वें और 11 वें परीक्षण मामलों में होता है।)

— Arnauld
स्रोत

अच्छा! आपको भाषा की पसंद के लिए बोनस कुदोस मिलता है, और लाइव डेमो के लिए एक स्पष्टीकरण + लिंक शामिल करने के लिए!

— WBT

6

स्टैक्स , 17 बाइट्स

ëI╩½• ╠☺Vì∞«S↑♠αS

इसे चलाएं और डीबग करें

यह पाशविक बल है। यह उम्मीदवार उत्थान के लिए 0 से शुरू होता है, और वेतन वृद्धि तक यह सूत्र को संतुष्ट करता है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

0       push zero
{       start filter block...
        candidate upvotes is on the stack
  cHx-  calculate candidate downvotes for denominator (upvotes * 2 - net)
  c1?   if denominator is zero, replace it with 1
  :_    floating point division
  AJ*   multiply by 100
  j     round to integer
  ;=    is equal to second input?
        increment until a match is found
}gs

इसको चलाओ

— पुनरावर्ती
स्रोत

2

क्लीन , 114 107 104 बाइट्स

import StdEnv
? =toReal o toInt
$a d#e= ?d
= ?a+until(\c#b= ~c*e/(e-100.0)
= ?(?100*b/(?b+c))==e)inc 0.0

इसे ऑनलाइन आज़माएं!

फ़ंक्शन को परिभाषित करता है $ :: Int Int -> Real, जहां तर्कों को पूर्णांक पर हस्ताक्षर किया जाता है और वापसी मूल्य एक 32-बिट हस्ताक्षरित पूर्णांक द्वारा वास्तव में प्रतिनिधित्व योग्य एक डबल-सटीक फ्लोट है।

यह एक संतोषजनक खोजने के cलिए समीकरण के हर मूल्य की जांच करता है और , चूंकि सबसे छोटे परिणाम सबसे छोटे होते हैं , सभी समाधानों के सेट का पहला तत्व लेते हैं।b=-cd/(d+1)ba+c=bb/(b+c)=dcb

— Οurous
स्रोत

2

05AB1E , 13 बाइट्स [हल्के रूप से टूटे हुए]

*²·т-/ò²т;Qi1

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

इसे हल करने के लिए, मैंने इनपुट ए, बी और अपेक्षित परिणाम एक्स माना। सेटअप में जानकारी को देखते हुए, जिसने मुझे समीकरण दिया:

 2x         100x
———— - a = ——————
 a           b

एक्स के लिए रियररेंजिंग देता है

        ab
x = ——————————
     2b - 100

एकमात्र परीक्षण का मामला जिसके लिए यह काम नहीं करता है वह है 0, 50 - मैं इसके लिए जांच करने के लिए केवल हार्डकोड करता हूं।

*²·т-/ò²т;Qi1     Implicit Inputs: a, b              STACK (bottom to top)
*                 Multiply the inputs together       [ab]
 ²·               Take the second input * 2          [ab, 2b]
   т-             Subtract 100                       [ab, 2b - 100]
     /ò           Divide and round                   [round(ab/(2b-100))]
       ²т;Qi1     If 2nd input = 50, push 1 to stack
                  { Implicitly output top item of stack [either 1, or round(...)] }

— जेनो रैकिन अशर
स्रोत

यह कुछ इनपुट के लिए सही ढंग से काम नहीं करता है। 800 नेट वोटों के साथ 90% 894 वोटों के साथ किया जा सकता है।

— पुनरावर्ती

@recursive मुझे पता है कि यह क्या है। यह 90% बिल्कुल सही मानता है, न कि 89.5%।

— जेनो रैकिन अशर

खैर, इस मामले में 90.5% के करीब लेकिन हाँ।

— पुनरावर्ती

1

अब मुझे एहसास हुआ कि मैंने जितना सोचा था उससे कहीं ज्यादा मुश्किल है। मैं इसके बारे में सोचूंगा, लेकिन अब मैं इसे टूटे हुए के रूप में चिह्नित करूंगा।

— जेनो रैकिन एशर

@GenoRacklinAsher अब मुझे एहसास हुआ कि मैंने जितना सोचा था उससे कहीं ज्यादा मुश्किल है। मैं इसके बारे में सोचूंगा ... उन टिप्पणियों के प्रकार हैं जिन्हें मैं पढ़ना पसंद करता हूं, उन्हें एक अच्छी पहेली की पहचान के रूप में देखना :-)।

— WBT

0

1.10, 154 बाइट जाओ

func h(n,u float64)float64{if u==50{return 1};r:=Round(n*u/(2*u-100));s:=Round(n*(u+.5)/(2*u-99));v:=s/(2*s-n);if v>1||Round(v*100)!=u{return r};return s}

जाओ खेल के मैदान पर यह कोशिश करो! (टीआईओ गो 1.9 चलाती है, जिसमें गणित नहीं है।

अनप्लग्ड संस्करण

func haters(n, u float64) float64 {
    if u == 50 {
        return 1
    }
    r := Round(n * u / (2*u - 100))
    //Test the case where we were given a percentage that was rounded down (e.g. 90.4% given as 90%)
    //We test this by adding 0.5% to u. The denominator is just a simplified form of 2*(u+0.5) - 100
    s := Round(n * (u + .5) / (2*u - 99))
    //Check if s is a valid result
    v := s / (2*s - n)
    if v > 1 || Round(v*100) != u {
        return r
    }
    //s is strictly less than r, so we don't need to check the minimum.
    return s
}

स्पष्टीकरण जोड़ने के हितों में, आर के लिए उपरोक्त सूत्र को एक साथ हल करके n=v-dऔर u = 100 * v/(v + d)वी के लिए प्राप्त किया जा सकता है , जहां v और d क्रमशः उत्थान और चढ़ाव की संख्या है। व्युत्पन्न सूत्र v = 50 के लिए अपरिभाषित है, इसलिए हमें उस मामले को संभालना होगा (जो हम पहले बयान के साथ करते हैं)।

— ollien
स्रोत

नफरत करने वालों पर नकेल कसना

स्थापित करना:

चुनौती:

सामान्य नियम:

उदाहरण के परीक्षण के मामले:

जावास्क्रिप्ट (ईएस 6), 47 बाइट्स

टिप्पणी की गई

किनारे के मामले

स्टैक्स , 17 बाइट्स

क्लीन , 114 107 104 बाइट्स

05AB1E , 13 बाइट्स [हल्के रूप से टूटे हुए]

1.10, 154 बाइट जाओ