परिचय

एक सर्वेक्षण में विकल्पों के प्रतिशत के एक सेट को देखते हुए, उन आंकड़ों को उत्पन्न करने के लिए मतदाताओं की न्यूनतम संख्या की गणना करनी चाहिए।

उदाहरण: आपका पसंदीदा पालतू जानवर क्या है?

कुत्ता: 44.4%
बिल्ली: 44.4%
माउस: 11.1%

आउटपुट: 9(मतदाताओं का न्यूनतम संभव #)

चश्मा

यहां आपके कार्यक्रम / समारोह की आवश्यकताएं हैं:

आपको इनपुट (स्टड पर, फ़ंक्शन तर्क, आदि के रूप में) प्रतिशत मानों की एक सरणी दी जाती है।
प्रत्येक प्रतिशत मान एक दशमलव स्थान (जैसे, 44.4 44.4 11.1) के लिए गोल संख्या है ।
मतदान में मतदाताओं की न्यूनतम संभावित संख्या की गणना करें जिनके परिणाम एक दशमलव स्थान (स्टडआउट, या फ़ंक्शन रिटर्न मान) पर गोल होने पर उन सटीक प्रतिशत प्राप्त होंगे।
बोनस : -15 वर्ण यदि आप "गैर-तुच्छ" तरीके से हल कर सकते हैं (अर्थात, जब तक कि आप काम न कर लें, तब तक मतदाताओं के हर संभव # माध्यम से पुनरावृत्ति करना शामिल नहीं है)

उदाहरण

>./pollreverse 44.4 44.4 11.1
9
>./pollreverse 26.7 53.3 20.0
15
>./pollreverse 48.4 13.7 21.6 6.5 9.8
153
>./pollreverse 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 99.6
2000
>./pollreverse 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 98.7
667
>./pollreverse 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 98.7
2000
>./pollreverse 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 97.8
401

स्कोरिंग

यह कोड-गोल्फ है, इसलिए कम से कम संभव अक्षर जीतता है। किसी भी बोनस को कुल वर्ण गणना से घटाया जाता है।

code-golf math reverse-engineering

— mellamokb
स्रोत

2

मुझे लगता है कि यह परीक्षण के लिए कुछ और अजीब मामलों के साथ कर सकता है। 26.7 53.3 20.0(१४ ४ ३ १५ का), 48.4 13.7 21.6 6.5 9.8(33४ २१ ३३ १० १५ १५ में से १५५) आदि

— गैरेथ

@ गारेथ: अच्छा सोचा। अपने परीक्षण मामलों के साथ अपडेट किया गया।

— मेलमोकब

क्या सभी वोटों का योग 100% नहीं होना चाहिए? यह अंतिम चार

— टेस्टकेस

@ गजेट: नहीं, यह हमेशा 100% के बराबर नहीं होता है। हर बार नीचे एक राउंडिंग होती है, आप 0.5%कुल से हार जाते हैं , और हर बार एक राउंडिंग अप होता है, आप 0.5%कुल को जोड़ते हैं । पिछले चार परीक्षण मामलों को जानबूझकर इस घटना का फायदा उठाने के लिए तैयार किया गया था। पहले परीक्षण के मामले में 2000, पहले 9 प्रविष्टियों में से प्रत्येक 1वोट का प्रतिनिधित्व करता है (और सभी गोल हैं 0.5%), जबकि अंतिम एक 1991वोट का प्रतिनिधित्व करता है (और नीचे गोल है ~ 0.5%)। यदि आप मैन्युअल रूप से उन प्रतिशतों की गणना करते हैं और 1 दशमलव स्थान पर जाते हैं, तो आप देखेंगे कि वे सभी सही हैं।

— मेलमोकब

मैं वीबीए में गैर-तुच्छ उत्तर के साथ संघर्ष कर रहा हूं (अब तक की कोशिश कर रहा हूं, कोई भी नहीं है), लेकिन मैं इस पर काम कर रहा हूं!

— गफ्फी

2

एपीएल (डायलॉग क्लासिक) , 48 43 बाइट्स

Adám द्वारा -5 बाइट्स

+/0(⊢+{(⌈/⍷⊢)⍺-⍵÷+/⍵})⍣{z≡⍎3⍕⍺÷+/⍺}⍨z←.01×⎕

स्टड से इनपुट लेने वाला पूरा कार्यक्रम।

इसे ऑनलाइन आज़माएं! लिंक dfn संस्करण के लिए है।

Ungolfed

normalize ← ⊢ ÷ +/
find_max ← {⍵⍷⍨⌈/⍵}
round ← {⍎3⍕⍵}
increase ← {find_max ⍺ - normalize ⍵}
vote_totals ← {z←⍺ ⋄ ⍺ (⊢+increase)⍣{z ≡ round normalize ⍺} ⍵}
h ← {+/ (.01×⍵) vote_totals 0}

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

normalizeविभाजित ( ÷) अपने अधिकार का तर्क (के सभी तत्वों को ⊢अपने योग द्वारा) ( +/)।
round(y)स्वरूपण ( ⍕) और फिर ⍎y के प्रत्येक तत्व का मूल्यांकन करके 3 दशमलव स्थानों तक राउंड वाई।
find_max(y) 1 के साथ एक सरणी देता है जहां अधिकतम (y) पाया जाता है और 0 कहीं और।
increase(x,y) x (लक्ष्य प्रतिशत) और y (वर्तमान वोट योगों की सरणी) लेता है और गणना करता है कि प्रतिशत को x के करीब लाने के लिए y में 1 को कहां जोड़ा जाए।
vote_totals(x,y) x (गोल प्रतिशत) और y (शुरुआती वोट योग) लेता है और बार-बार f को निष्पादित करता है, जब तक प्रतिशत x पर गोल नहीं हो जाता तब तक वोट जोड़ते हैं।
- वाक्यविन्यास का f ⍣ gअर्थ है सत्य fहोने तक बार-बार निष्पादित करना g(y,f(y))। इस मामले में हम अनदेखी करते हैं f(y)।
h(x) y को 0 पर सेट करता है (वैश्वीकरण के कारण 0s के एक सरणी के बराबर), जी निष्पादित करता है, और अंतिम वोट योगों को बताता है।

— lirtosiast
स्रोत

7

अजगर, 154

def p(x):
 n=[1]*len(x);d=2;r=lambda z:round(1000.*z/d)/10
 while 1:
    if(map(r,n),sum(n))==(x,d):return d
    d+=1
    for i in range(len(x)):n[i]+=r(n[i])<x[i]

यह अब अंतिम उदाहरण के लिए काम करता है।

उदाहरण चलता है:

>>> p([44.4, 44.4, 11.1])
9
>>> p([26.7, 53.3, 20.0])
15
>>> p([48.4, 13.7, 21.6, 6.5, 9.8])
153
>>> p([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 99.6])
2000
>>> p([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 98.7])
667
>>> p([0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 98.7])
2000
>>> p([0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 97.8])
401

— gRC
स्रोत

मुझे लगता है कि आपके अंतिम उदाहरण में कुछ गलत हो सकता है; शायद आप 99.1अंतिम मूल्य के रूप में थे

— क्रिस्टियन लुपस्कु

2

मुझे लगता है कि यह सही है लेकिन यह काफी भ्रामक है। 1/2000 = 0.05%( 0.1%गोल) और 1991/2000 = 99.55%( 99.6%गोल)। इसलिए अगर किसी मतदान में दस विकल्प हैं और उनमें से नौ को एक बार वोट दिया जाता है जबकि अंतिम को 1991 वोट मिलते हैं, तो यह उन प्रतिशत को देगा।

— grc

आप सही हे। महान समाधान, बीटीडब्ल्यू।

— क्रिस्टियन लुपस्कु

मुझे लगता है कि आप इस टिप का पालन करके 3 और वर्णों को बचा सकते हैं: codegolf.stackexchange.com/a/58/3527

— क्रिश्चियन

धन्यवाद, w0lf मैंने टैब को शामिल करने के लिए इसे अभी अपडेट किया है। टैब्स चार स्थानों के रूप में दिखाते हैं अगर किसी की सोच हो।

— grc

4

जे, 57 वर्ण

t=:".>'1'8!:0|:100*%/~i.1001
{.I.*/"1(t{~i.#t)e."1~1!:1[1

तुच्छ विधि का इस्तेमाल किया। यह कीबोर्ड से इनपुट लेता है। tएक लुकअप तालिका बनाता है और दूसरी पंक्ति तालिका के भीतर इनपुट की तलाश करती है। अगर किसी की दिलचस्पी है तो मैं कोड का एक विस्तृत विवरण प्रदान कर सकता हूं।

मैंने अंश बनाने के लिए प्रतिशत का उपयोग करने पर ध्यान दिया था, फिर संख्या का पता लगाने के लिए अंश का निम्नतम रूप प्राप्त करें, लेकिन मैं इसे परिणाम के दौर के साथ काम करने का तरीका नहीं बता सका।

— गैरेथ
स्रोत

हम्म, यह नए परीक्षण मामले के लिए विफल रहता है। मुझे एक तय करना होगा।

— गारेथ

4

अजगर, 154

def r(l):
 v=0
 while 1:
  v+=1;o=[round(y*v/100)for y in l];s=sum(o)
  if s: 
    if all(a==b for a,b in zip(l,[round(y*1000/s)/10for y in o])):return s

— रंगीन जाकेट
स्रोत

+1 अच्छा लग रहा है! ideone.com/k2Mgb । मैंने इसे तोड़ने के लिए एक रोग संबंधी मामला खोजने की कोशिश की और मैं ऐसा नहीं कर सका।

— मेलमोकब

मैं समय-सीमा से अधिक होने के कारण आइडोन पर उत्पन्न नहीं कर सकता, लेकिन आपको क्या परिणाम मिलेगा [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,99.6]?

— मेलमोकब

हम्म ... आधे घंटे और कार्यक्रम अभी भी चल रहा है। मुझे लगता है कि यह कहना सुरक्षित है कि ब्रेकर है। हालाँकि, मैं नहीं देखता कि यह कैसे एक वैध उत्तर हो सकता है क्योंकि यह 100.5% और 100% योग नहीं है

— ब्लेज़र

2

1/2000 = 0.05%( 0.1%गोल) और 1991/2000 = 99.55%( 99.6%गोल)। तो यह वास्तव में कुल 100% है, लेकिन गोलाई वास्तव में भ्रमित करता है।

— grc

3

VBA - 541

इससे कुछ चमकने वाली त्रुटियां हुई हैं, लेकिन यह गैर-तुच्छ / लूपिंग-जब तक-मैं-मुझे-सही संख्या का समाधान खोजने का मेरा प्रयास था। मैंने इसे पूरी तरह से नहीं बनाया है, हालांकि मुझे नहीं लगता कि उस संबंध में बहुत कुछ है। हालांकि, मैंने इस पर बहुत अधिक समय बिताया है, और यह अब मेरे सिर में दर्द करता है। उल्लेख नहीं करने के लिए, नियम शायद बहुत टूट गए हैं और केवल इन उदाहरणों के लिए अधिक या कम लागू होते हैं।

यह मेरे द्वारा चलाए गए बहुत सारे सरल परीक्षणों के लिए बहुत अच्छा है, (यानी यहां तक कि योग, 2 या 3 इनपुट) लेकिन यह चुनौती द्वारा प्रस्तुत किए गए कुछ परीक्षणों के लिए विफल रहता है। हालांकि, मैंने पाया कि यदि आप इनपुट की दशमलव परिशुद्धता (चुनौती के दायरे से बाहर) बढ़ाते हैं, तो सटीकता में सुधार होता है।

बहुत से कामों में प्रदान किए गए नंबरों के सेट के लिए जीसीडी ढूंढना शामिल है, और मुझे Function g()यह मिला है कि इसके माध्यम से , हालांकि यह निश्चित रूप से अधूरा है और मेरे आउटपुट में कम से कम कुछ त्रुटियों का स्रोत है।

इनपुट एक स्पेस-सीमांकित मान है।

Const q=10^10
Sub a(s)
e=Split(s)
m=1
f=UBound(e)
For i=0 To f
t=1/(e(i)/100)
m=m*t
n=IIf(n>t Or i=0,t,n)
x=IIf(x<t Or i=0,t,x)
Next
h=g(n,x)
i=(n*x)/(h)
If Int(i)=Round(Int(i*q)/q) Then
r=i
ElseIf (n+x)=(n*x) Then
r=(1/(n*x))/h/m
ElseIf x=Int(x) Then
r=x*(f+1)
Else
z=((n+x)+(n*x)+m)*h
y=m/(((m*h)/(f+1))+n)
r=IIf(y>z,z,y)
End If
Debug.Print Round(r)
End Sub
Function g(a,b)
x=Round(Int(a*q)/q,3)
y=Round(Int(b*q)/q,3)
If a Then
If b Then
If x>y Then
g=g(a-b,b)
ElseIf y>x Then
g=g(a,b-a)
Else
g=a
End If
End If
Else
g=b
End If
End Function

टेस्टकेस (इनपुट ==> अपेक्षित / लौटाया गया):

Passed:  

"95 5" ==> 20/20
"90 10" ==> 10/10
"46.7 53.3" ==> 15/15
"4.7 30.9 40.4 23.8" ==> 42/42
"44.4 44.4 11.1" ==> 9/9
"26.7 53.3 20.0" ==> 15/15
"48.4 13.7 21.6 6.5 9.8" ==> 153/153
"0.05 0.05 0.05 0.05 0.05 0.05 0.05 0.05 0.05 99.55" ==> 2000/2000
"0.15 0.15 0.15 0.15 0.15 0.15 0.15 0.15 0.15 98.65" ==> 2000/2000
"0.149925 0.149925 0.149925 0.149925 0.149925 0.149925 0.149925 0.149925 0.149925 98.65067" ==> 667/667


Failed:  

"0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 99.6" ==> 2000/1000
"0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 98.7" ==> 2000/5000
"0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 98.7" ==> 667/1000
"0.14 0.14 0.14 0.14 0.14 0.14 0.14 0.14 0.14 98.65" ==> 667/10000
"0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 97.8" ==> 401/500
"0.24 0.24 0.24 0.24 0.24 0.24 0.24 0.24 0.24 97.75" ==> 401/235
"0.249377 0.249377 0.249377 0.249377 0.249377 0.249377 0.249377 0.249377 0.249377 97.75561" ==> 401/14010

— Gaffi
स्रोत

आप परिवर्तित करके 6 बाइट्स ढीला कर सकते हैं Debug.Print करने के लिएDebug.?

— टेलर स्कॉट

2

C # (.NET Core) , 286 बाइट्स

double M(string[]a){var p=a.Select(double.Parse).ToList();var n=p.Select(x=>1d).ToList();var c=2;for(;;){Func<double,double>f=x=>Math.Round(x*1000/c,(MidpointRounding)1)/10;if(n.Select(f).Zip(p,(x,y)=>x==y).All(z=>z)&&c==n.Sum())return c;c++;n=n.Zip(p,(x,y)=>x+(f(x)<y?1:0)).ToList();}}

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

पीटर टेलर और अज्ञानता के अवतार के लिए बहुत सारे बाइट्स का धन्यवाद

— क्रिस्टियन लुपस्कू
स्रोत

मैं इसे ideone.com पर परीक्षण करने के लिए कैसे संशोधित कर सकता हूं?

— गारेथ

मुझे लगता है कि आप }अंत में याद कर रहे हैं ।

— grc

@ गैरेथ मैंने इसे ideone.com पर निष्पादित करने की कोशिश की, लेकिन मुझे लगता है कि यह 4.0 से पहले .NET फ्रेमवर्क संस्करण का उपयोग कर रहा है, क्योंकि यह लिनक Zipविधि को मान्यता नहीं देता है ।

— क्रिस्टियन लुपस्क्यू

@grc यह इंगित करने के लिए धन्यवाद। अपडेट किया गया।

— क्रिस्टियन लुपस्कू

1

@ गफ्फी: नहीं, C # में सख्त टाइपिंग है (जावा की तरह) इसलिए इसे बूलियन होना चाहिए। चूँकि 1>0यह कम है true, इसलिए इसे पसंद किया जाता है।

— मेलमोकब

0

पायथन 3 , 140 139 137 बाइट्स

f=lambda l,m=1,i=0,c=0,x=0:round(x*100,1)-l[i]and(x<1and f(l,m,i,c,x+1/m)or f(l,m+1))or l[i+1:]and f(l,m,i+1,c+x)or c+x-1and f(l,m+1)or m

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

पहले दो परीक्षण मामलों के लिए सही उत्तर देता है, और दूसरों के लिए पायथन की पुनरावृत्ति सीमा में चलता है। यह बहुत आश्चर्य की बात नहीं है, हर के बाद से जाँच एक नए पुनरावर्तन स्तर पर की जाती है। यह छोटा है, हालांकि ...

(प्रयुक्त चर का स्पष्टीकरण TIO लिंक में पाया जा सकता है)

f=lambda l,m=1,i=0,c=0,x=1:round(x*100,1)-l[i]and(x and f(l,m,i,c,x-1/m)or f(l,m+1))or l[i+1:]and f(l,m,i+1,c+x)or c+x-1and f(l,m+1)or m

136 बाइट्स के लिए काम करना चाहिए , लेकिन फ्लोट सटीक के कारण नहीं होता है।

— अरबो
स्रोत

रिवर्स इंजीनियर मतदान सांख्यिकी

परिचय

चश्मा

उदाहरण

स्कोरिंग

एपीएल (डायलॉग क्लासिक) , 48 43 बाइट्स

Ungolfed

अजगर, 154

जे, 57 वर्ण

अजगर, 154

VBA - 541

C # (.NET Core) , 286 बाइट्स

पायथन 3 , 140 139 137 बाइट्स