प्रतिशत को "सरल" अनुपात में बदलें

Question

आप कोई राजनीतिक वेबसाइट चलाने , और निर्धारित किया है कि एक बेहतर सहज ज्ञान युक्त समझ है लोग जब जीत या एक चुनावी खोने का मौका एक के रूप में व्यक्त किया जाता है अनुपात ( "7 में 5") जब यह एक के रूप में व्यक्त किया जाता है की तुलना में प्रतिशत ( "71%" )।

लेकिन आप "82 में 58" जैसे भ्रामक अनुपात प्रदर्शित नहीं करना चाहते हैं, आप उन्हें अधिक आसानी से समझना चाहेंगे, भले ही वे बहुत सटीक न हों।

इसलिए, 0.1% और 99.9% के बीच एक प्रतिशत दिया गया है , निम्नलिखित नियमों का उपयोग करते हुए निकटतम "आसानी से समझने वाला" अनुपात " x in y " लौटाएं :

1. अधिकांश मान (नीचे अपवाद देखें) 10 या उससे कम के निकटतम अनुपात को वापस करना चाहिए । 55% को "9 में 5" लौटना चाहिए, न कि "20 में 11"।
2. अनुपात को उनकी न्यूनतम शर्तों तक कम किया जाना चाहिए । 65% को "2 इन 3" लौटना चाहिए, न कि "4 इन 6"।
3. 10% से कम के मानों को " 1 एन में " फॉर्म का निकटतम अनुपात वापस करना चाहिए, जहां एन (10,12,15,20,30,40,50,60,70,80,90,100) में से एक है । उदाहरण के लिए, 6% को "15 में 1" वापस करना चाहिए।
4. 90% से अधिक के मानों को " n-1 in n " फॉर्म का निकटतम अनुपात वापस करना चाहिए, जहां n (10,12,15,20,30,40,50,60,80,80,90,100) में से एक है । उदाहरण के लिए, 98.7% को "80 में 79" वापस करना चाहिए।
5. 1% से कम मान चाहिए " <100 में 1 "
6. 99% से अधिक मान चाहिए " > 99 100 में "

या, इसे दूसरे तरीके से सोचने के लिए, आपके कार्यक्रम को निम्नलिखित संभावित आउटपुट से निकटतम अनुपात वापस करना चाहिए (मैंने उनकी सुविधा के लिए उनके अनुमानित मूल्यों को शामिल किया है):

<1 in 100
 1 in 100  = 1.00%
 1 in 90   = 1.11%
 1 in 80   = 1.25%
 1 in 70   = 1.43%
 1 in 60   = 1.67%
 1 in 50   = 2.00%
 1 in 40   = 2.50%
 1 in 30   = 3.33%
 1 in 20   = 5.00%
 1 in 15   = 6.67%
 1 in 12   = 8.33%
 1 in 10   = 10.00%
 1 in 9    = 11.11%
 1 in 8    = 12.50%
 1 in 7    = 14.29%
 1 in 6    = 16.67%
 1 in 5    = 20.00%
 2 in 9    = 22.22%
 1 in 4    = 25.00%
 2 in 7    = 28.57%
 3 in 10   = 30.00%
 1 in 3    = 33.33%
 3 in 8    = 37.50%
 2 in 5    = 40.00%
 3 in 7    = 42.86%
 4 in 9    = 44.44%
 1 in 2    = 50.00%
 5 in 9    = 55.56%
 4 in 7    = 57.14%
 3 in 5    = 60.00%
 5 in 8    = 62.50%
 2 in 3    = 66.67%
 7 in 10   = 70.00%
 5 in 7    = 71.43%
 3 in 4    = 75.00%
 7 in 9    = 77.78%
 4 in 5    = 80.00%
 5 in 6    = 83.33%
 6 in 7    = 85.71%
 7 in 8    = 87.50%
 8 in 9    = 88.89%
 9 in 10   = 90.00%
 11 in 12  = 91.67%
 14 in 15  = 93.33%
 19 in 20  = 95.00%
 29 in 30  = 96.67%
 39 in 40  = 97.50%
 49 in 50  = 98.00%
 59 in 60  = 98.33%
 69 in 70  = 98.57%
 79 in 80  = 98.75%
 89 in 90  = 98.89%
 99 in 100 = 99.00%
>99 in 100

अन्य शर्तें:

• न्यूमेरिक इनपुट 0.1 से 99.9 या 0.001 से 0.999 की रेंज में हो सकता है, जो भी अधिक सुविधाजनक हो। आपको कम से कम 3 महत्वपूर्ण अंकों को संभालना होगा।
• आपको एक अनुपात ("3 में 4") का उत्पादन करना चाहिए , न कि बराबर अंश ("3/4") पर।
• यदि इनपुट के समान रूप से दो अनुपात हैं, तो आपका प्रोग्राम एक भी वापस आ सकता है। 7.5% "12 में 1" या "15 में 1" वापस कर सकता है।
• सफ़ेद स्थान और / या नई पंक्तियों का अनुगमन ठीक है

उदाहरण :

Input  :   Output
 0.5   :  <1 in 100
 1.0   :   1 in 100
 1.5   :   1 in 70
 7.5   :   1 in 15  or  1 in 12 (either is acceptable)
 9.2   :   1 in 10
13.1   :   1 in 8
29.2   :   2 in 7
29.3   :   3 in 10
52.7   :   1 in 2
52.8   :   5 in 9
72.0   :   5 in 7
73.9   :   3 in 4
88.8   :   8 in 9
90.8   :   9 in 10
94.2   :  19 in 20
98.7   :  79 in 80
98.9   :  89 in 90
99.0   :  99 in 100
99.1   : >99 in 100

यह एक कोड-गोल्फ चुनौती है, प्रत्येक भाषा में सबसे छोटा कोड जीतता है।

(समान, लेकिन डुप्लिकेट नहीं: दशमलव को एक अंश में बदलें , निकटतम अंश , n-अंकीय अंकों के साथ अनुमानित फ्लोटिंग पॉइंट संख्या )

Comments

If there are two ratios equally close to the input, your program can return either one. 7.5% could return "1 in 12" or "1 in 15"क्या इसका मतलब यह है कि हम भी लौट सकते हैं 7 in 100? Btw, 1 in 14इस मामले में इनपुट के करीब है।

— डिमचिट्ज़

@DimChtz नहीं, वह के रूप में नियम 3 का उल्लंघन करती है (10% के तहत मूल्यों के रूप में "में 1 व्यक्त किया जाना चाहिए n ", के विशिष्ट संभावित मान के लिए एन )।

— ब्रैडेक

ओह, मैंने इस पर ध्यान नहीं दिया। ठीक है।

— डिमच्ट्ज़

मुझे यह पसंद है अगर हम अंश और हर को किसी भी प्रारूप के रूप में आउटपुट कर सकते हैं जैसे कि टपल / सूची या कुछ और, लेकिन पहले से ही प्रतिस्पर्धी उत्तर हैं इसलिए मुझे लगता है कि इस चुनौती के लिए बहुत देर हो चुकी है। हालांकि भविष्य की चुनौतियों के लिए, मैं एक और अधिक लचीले I / O प्रारूप पर विचार करूंगा क्योंकि कुछ भाषाओं को दूसरों की तुलना में अधिक प्रतिस्पर्धा खो देती है जब आपको स्ट्रिंग हैंडलिंग की आवश्यकता होती है।

— हाइपरन्यूट्रीनो

@ ब्रैड - LOL। मैं सिर्फ 538 पर था, और मैं सभी "वाह! मैं इस से बाहर एक गोल्फ चुनौती बनाऊंगा!"

— चास ब्राउन

Answer 1

टी-एसक्यूएल, 385 बाइट्स

SELECT TOP 1IIF(i>.99,'>',IIF(i<.01,'<',''))+n+' in '+d
FROM t,(SELECT ISNULL(PARSENAME(value,2),'1')n,PARSENAME(value,1)d FROM
STRING_SPLIT('100,90,80,70,60,50,40,30,20,15,12,10,9,8,7,6,5,2.9,4,2.7,3.10,3,3.8,2.5,3.7,4.9,2,5.9,4.7,3.5,5.8,2.3,7.10,5.7,3.4,7.9,4.5,5.6,6.7,7.8,8.9,9.10,11.12,14.15,19.20,29.30,39.40,49.50,59.60,69.70,79.80,89.90,99.100',','))m
ORDER BY ABS(i-ABS(n)/d)

इनपुट पूर्व मौजूदा तालिका के माध्यम से है टी संख्यात्मक फ़ील्ड के साथ मैं , हमारे आईओ मानकों के अनुसार ।

वह इनपुट तालिका एक इन-मेमोरी टेबल के साथ एक स्ट्रिंग से पार्स हुई STRING_SPLIT(जो पंक्तियों को अलग करती है) और PARSENAME(जो अंश और हर को अलग करती है ) के साथ जुड़ जाती है .।

तालिका को इनपुट मूल्य i से दूरी के अनुसार क्रमबद्ध किया जाता है , और उचित रूप से स्वरूपित शीर्ष पंक्ति देता है।

Answer 2

चारकोल , 84 बाइट्स

ＮθＦ¹¹«Ｆ⊖ι⊞υ⟦⊕κι⟧≔⎇⊖ι∨×χι¹²¦¹⁵ιＦ²⊞υ⟦∨κ⊖ιι⟧»≔Ｅυ↔⁻θ∕§ι⁰§ι¹η≔⌕η⌊ηη×<‹θ·⁰¹×>›θ·⁹⁹⪫§υη in 

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एक प्रतिशत के बजाय एक दशमलव के रूप में इनपुट लेता है। स्पष्टीकरण:

Ｎθ

अंश इनपुट करें।

Ｆ¹¹«

$n = 0$$n = 10$

Ｆ⊖ι⊞υ⟦⊕κι⟧

लिए अनुपात उत्पन्न करें$\frac 1 n$$\frac {n - 1} n$

≔⎇⊖ι∨×χι¹²¦¹⁵ι

$n^{th}$$12, 15, 20 ... 100$$n$

Ｆ²⊞υ⟦∨κ⊖ιι⟧»

लिए अनुपात उत्पन्न करें$\frac {n - 1} n$$\frac 1 n$

≔Ｅυ↔⁻θ∕§ι⁰§ι¹η

सभी अनुपातों के दशमलव मानों की गणना करें और मूल इनपुट के साथ पूर्ण अंतर लें।

≔⌕η⌊ηη

$\frac 1 2$$\frac 2 4$

×<‹θ·⁰¹

<$0.01$

×>›θ·⁹⁹

>$0.99$

⪫§υη in 

inप्रिंट के साथ उपयुक्त अनुपात के अंश और हर में शामिल हों ।

Answer 3

जावास्क्रिप्ट (ईएस 7), 164 159 144 बाइट्स

$]0,1[$

r=>(g=m=>--n+11?g((q=n>1?n*10:n+10-~'13'[n],d=((p=r<.1?1:r>.9?q-1:n<0&&r*q+.5|0)/q-r)**2)>m?m:(o=p+' in '+q,d)):r<.01?'<'+o:r>.99?'>'+o:o)(n=11)

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

कैसे?

$p/q$

$$d=(p/q-r)^2$$

$m$$d$$m$

$q$

टिप्पणी की गई

r => (g = m =>               // r = input; g() = recursive function, taking m = best score
  --n + 11 ?                 // decrement n; if n is still greater than or equal to -10:
    g(                       //   do a recursive call to g():
      ( q =                  //     compute q = denominator:
        n > 1 ?              //       if n is greater than 1:
          n * 10             //         q = n * 10 (20, 30, ..., 100)
        :                    //       else:
          n + 10 - ~'13'[n], //         q = 12 if n = 0, 15 if n = 1, n + 11 if n < 0
        d = ((               //     compute d = (p / q - r)²:
          p =                //       compute p = numerator:
          r < .1 ?           //         if r is less than 0.01:
            1                //           p = 1
          :                  //         else:
            r > .9 ?         //           if r is greater than 0.90:
              q - 1          //             p = q - 1
            :                //           else:
              n < 0 &&       //             if n is negative (i.e. q is in [1,10]):
              r * q + .5 | 0 //               p = round(r * q)
                             //             otherwise: p = 0 (which will be ignored)
          ) / q - r          //       compute p / q - r
        ) ** 2               //       and square the result (cheaper than absolute value)
      ) > m ?                //     if d is greater than m:
        m                    //       leave m unchanged
      : (                    //     else:
        o = p + ' in ' + q,  //       update the output string o
        d                    //       and update m to d
    ))                       //   end of recursive call
  :                          // else (all possible ratios have been tried out):
    r < .01 ? '<' + o :      //   if r is less than 0.01, prefix with '<'
    r > .99 ? '>' + o :      //   if r is greater than 0.99, prefix with '>'
    o                        //   otherwise, just return o
)(n = 11)                    // initial call to g() with m = n = 11

Answer 4

जेली , 58 बाइट्स

⁵R×⁵;12,15µ’,1,€)Ẏ;⁵Œc¤ð÷/ạ¥ÞḢj“ in ”
”<”>“”>.99$?<.01$?;Ç

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

-16 बाइट्स के लिए धन्यवाद अर्नुलद ( पूरे वाक्यांश को फिर से लिखने के बजाय ( <और >पूरे वाक्यांश को फिर से लिखना)
के लिए धन्यवाद कर सकते हैं-जोनाथन एलन के लिए बग-फिक्स धन्यवाद

Comments

@Arnauld ओह, तुम सही हो, इस बारे में कभी नहीं सोचा: पी धन्यवाद!

— हाइपरएनुट्रीनो

0.3परिणाम में 3 in 10नहीं होना चाहिए2 in 7

— जोनाथन एलन

आपको बस हटा देना चाहिए µµ, नहीं? संपादित करें - और फिर गोल्फ ÐṂṂके लिएÞḢ

— जोनाथन एलन

बदल रहा है 9करने के लिए ⁵बग मेरा मानना है कि समाधान हो जाना चाहिए।

— जोनाथन एलन

@JonathanAllan ओह व्हाट्स, हाँ, मैं एक वैध भाजक के रूप में 10 का उपयोग नहीं कर रहा था। धन्यवाद। और नहीं, डबल म्यू को हटाने से काम नहीं चलता क्योंकि तब "न्यूनतम" डाइएडिक लिंक-मिन फ़ंक्शन के दाईं ओर जुड़ा होता है, जो निश्चित रूप से वह नहीं है जो मैं चाहता हूं, लेकिन केवल एक म्यू डालने से यह ठीक नहीं होता है । हालांकि गोल्फ के लिए धन्यवाद: D

— HyperNeutrino

Answer 5

पायथन 2 , 261 278 261 237 177 बाइट्स

lambda n:' <>'[(n<.01)-(n>.99)]+'%d in %d'%min([(a,b)for b in[[12,15]+r(10,110,10),r(1,11)][.1<n<.9]for a in r([1,b-1][n>.9],[b,2][n<.1])],key=lambda(a,b):abs(1.*a/b-n))
r=range

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

Comments

क्या अजगर अर्धविराम का समर्थन नहीं करता है? आप के '\n 'साथ बदल सकता है ';'... जब तक मैं गलत नहीं हूँ।

— देव

@ ब्रैडक फिक्स्ड :)

— टीएफडीएल

Answer 6

स्वच्छ , 224 198 197 बाइट्स

import StdEnv,Data.List,Text
t=toReal
$p=if(p<1.0)"<"if(p>99.0)">"""+snd(minimum[(abs(p-t n*1E2/t d),n<+" in "<+d)\\i<-[10,12,15:[20,30..100]],(n,d)<-[(1,i),(i-1,i):diag2[1..10][1..10]]|gcd n d<2])

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

व्याख्या की:

t = toReal                              // give `toReal` a shorter name
$ p
 = if(p < 1.0)                          // if the percentage is less than 1%
  "<"                                   // prepend "<"
 if(p > 99.0)                           // if the percentage is > 99%
  ">"                                   // prepend ">"
  ""                                    // otherwise prepend nothing
 + snd (                                // to the second element of
  minimum [                             // the smallest item in a list composed of
   (                                    // pairs of
    abs (                               // the absolute value of
     p -                                // the difference between the percentage
     t n*1E2 / t d                      // and the ratio
    ) 
   ,                                    // associated with
    n <+ " in " <+ d                    // the string representation of the ratio
   )                                    // in the form of a tuple
   \\ i <- [10, 12, 15: [20, 30..100]]  // for every special denominator `i`
   , (n, d) <- [(1, i), (i - 1, i): diag2 [1..10] [1..10]]
                                        // for every ratio `n` : `d`
   | gcd n d < 2                        // where `n` / `d` cannot be further simplified
  ]
 )

Answer 7

जेली ,  53  52 बाइट्स

_.01,.99Ṡµ<0ịØ<ḣE⁵Ż×⁵+12,5Ṡ,’Ɗż€$Ẏ;⁵Œc¤÷/ạ¥Þ³Ḣj“ in 

एक पूर्ण कार्यक्रम जो परिणाम प्रिंट करता है।

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

या परीक्षण-सूट देखें

ध्यान दें कि टेस्ट-सूट को कोड को एक लिंक बनाने के लिए बदल दिया गया है:

1. रजिस्टर का उपयोग कर के साथ मौजूदा "कार्यक्रम इनपुट" का ट्रैक रखने के लिए, ³करने के लिए ®; तथा
2. "के लिए" के साथ वर्ण कोड की सूची को बंद “ in करना“ in ”

कैसे?

कोड के साथ शुरू होता है जो किसी भी आवश्यक प्रिंटिंग <या >साइन को बाध्य करता है और फिर कोड जो सभी न्यूमेरिक-डिनोमिनेटर जोड़े का निर्माण करता है (कुछ अनावश्यक रूप से सरलीकृत फॉर्म संस्करण नहीं, सभी उनके सरलीकृत रूप के बाद) और एक स्थिर का उपयोग करके न्यूनतम अलग-अलग डिवीजन-मूल्यांकन प्रविष्टि प्रिंट करता है। के साथ शामिल हो गए in ।

_.01,.99Ṡµ<0ịØ<ḣE⁵Ż×⁵+12,5Ṡ,’Ɗż€$Ẏ;⁵Œc¤÷/ạ¥Þ³Ḣj“ in  - Main Link: number in [0,1], n
 .01,.99                                             - literal pair = [0.01, 0.99]
_                                                    - subtract -> [n - 0.01, n - 0.99]
        Ṡ                                            - sign (vectorises) (-1 if <0; 1 if >0; else 0) 
         µ                                           - start a new monadic link
                                                     -   call that X
          <0                                         - less than zero? (vectorises)
             Ø<                                      - literal list of characters = "<>"
            ị                                        - index into (vectorises) ("<<" if n < 0.01; ">>" if n >= 0.99; else "><")
                E                                    - all (of X) equal? (1 if ((n < 0.01) OR (n > 0.99)) else 0
               ḣ                                     - head to index ("<" if n < 0.01; ">" if n > 0.99; else "")
                                                     -   (the following nilad forces a print of that)
                 ⁵                                   - literal 10
                  Ż                                  - zero-range -> [0,1,2,3,4,5,6,7,8,9,10]
                   ×⁵                                - multiply by 10 -> [0,10,20,30,40,50,60,70,80,90,100]
                      12,5                           - literal pair = [12,5]
                     +                               - add -> [12,15,20,30,40,50,60,70,80,90,100]
                                $                    - last two links as a monad
                             Ɗ                       -   last three links as a monad
                          Ṡ                          -     sign -> [1,1,1,1,1,1,1,1,1,1,1]
                            ’                        -     decrement -> [11,14,19,29,39,49,59,69,79,89,99]
                           ,                         -     pair -> [[1,1,1,1,1,1,1,1,1,1,1],[11,14,19,29,39,49,59,69,79,89,99]]
                              ż€                     -   zip with for €ach -> [[[1,12],[1,15],[1,20],[1,30],[1,40],[1,50],[1,60],[1,70],[1,80],[1,90],[1,100]],[[11,12],[14,15],[19,20],[29,30],[39,40],[49,50],[59,60],[69,70],[79,80],[89,90],[99,100]]]
                                 Ẏ                   - tighten -> [[1,12],[1,15],[1,20],[1,30],[1,40],[1,50],[1,60],[1,70],[1,80],[1,90],[1,100],[11,12],[14,15],[19,20],[29,30],[39,40],[49,50],[59,60],[69,70],[79,80],[89,90],[99,100]]
                                      ¤              - nilad followed by link(s) as a nilad:
                                   ⁵                 -   literal 10
                                    Œc               -   unordered pairs -> [[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],[1,10],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],[2,10],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],[3,10],[4,5],[4,6],[4,7],[4,8],[4,9],[4,10],[5,6],[5,7],[5,8],[5,9],[5,10],[6,7],[6,8],[6,9],[6,10],[7,8],[7,9],[7,10],[8,9],[8,10],[9,10]]
                                  ;                  - concatenate -> [[1,12],[1,15],[1,20],[1,30],[1,40],[1,50],[1,60],[1,70],[1,80],[1,90],[1,100],[11,12],[14,15],[19,20],[29,30],[39,40],[49,50],[59,60],[69,70],[79,80],[89,90],[99,100],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],[1,10],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],[2,10],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],[3,10],[4,5],[4,6],[4,7],[4,8],[4,9],[4,10],[5,6],[5,7],[5,8],[5,9],[5,10],[6,7],[6,8],[6,9],[6,10],[7,8],[7,9],[7,10],[8,9],[8,10],[9,10]]
                                           Þ         - sort by:
                                          ¥          -   last two links as a dyad:
                                                     -       ...(with right argument of
                                            ³        -           the program input, n)
                                        /            -     reduce by:
                                       ÷             -       division
                                         ạ           -     absolute difference
                                             Ḣ       - head
                                               “ in  - literal list of characters " in "
                                              ;      - concatenate
                                                     - implicit print

Answer 8

पर्ल 6 , 118 बाइट्स

{'<'x(.01>$_)~'>'x($_>.99)~(|(1..9 X ^11),|map({|(1,$_-1 X$_)},12,15,|(^11 X*10))).min({abs $_-[/] @^a}).join(' in ')}

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