21

एक फ़ंक्शन लिखें जो सकारात्मक पूर्णांक की एक सूची में लेता है और एक ही स्थिति में संबंधित पूर्णांक के लिए कुल के प्रतिशत का अनुमान लगाते हुए पूर्णांकों की सूची लौटाता है।

रिटर्न लिस्ट में सभी पूर्णांकों को 100 तक जोड़ना होगा। आप मान सकते हैं कि पूर्णांक उत्तीर्ण होने का योग 0. से अधिक है। आप किस तरह से गोल या छोटा डिस्मेंटल करना चाहते हैं, जब तक कोई भी परिणामी पूर्णांक प्रतिशत के रूप में वापस आ जाता है। किसी भी दिशा में 1 से अधिक नहीं है।

p([1,0,2])      ->  [33,0,67] or [34,0,66]
p([1000,1000])  ->  [50,50]
p([1,1,2,4])    ->  [12,12,25,51] or [13,12,25,50] or [12,13,25,50] or [12,12,26,50]
p([0,0,0,5,0])  ->  [0,0,0,100,0]

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है!

code-golf array-manipulation

— DaveAlger
स्रोत

क्या हमारा एल्गोरिथ्म नियतात्मक होना चाहिए? क्या इसे हमेशा एक तय समय के भीतर समाप्त करना चाहिए?

— lirtosiast

हमारे पास पहले से ही कुछ समान समस्या थी लेकिन अधिक सामान्य

— edc65

1

मेरा सुझाव है कि आप एक और परीक्षण मामला जोड़ते हैं p([2,2,2,2,2,3]):। इसके कई संभावित कानूनी उत्तर हैं, लेकिन सभी 2को समान मूल्य पर मैप नहीं किया जा सकता है। यह कई अति-सरल एल्गोरिदम को समाप्त करता है जो पिछले सभी परीक्षण मामलों पर काम करते हैं क्योंकि गोलाई बहुत बुरा नहीं है।

— सोफिया लेचनर

4

कर सकते हैं p([1000,1000]) -> [49,51]?

— l4m2

1

@ l4m2 यह गलत लगता है, लेकिन दोनों परिणाम 1 और अधिक नहीं हैं, इसलिए यह कल्पना का अनुसरण करता है

— edc65

20

डायलॉग एपीएल, 21 19 16 बाइट्स

+\⍣¯1∘⌊100×+\÷+/

ऊपर एक ट्रेन के बराबर है

{+\⍣¯1⌊100×+\⍵÷+/⍵}

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

यह काम किस प्रकार करता है

                 ⍝ Sample input: 1 1 2 4
           +\    ⍝ Cumulative sum of input. (1 2 4 8)
              +/ ⍝ Sum of input. (8)
             ÷   ⍝ Divide the first result by the second. (0.125 0.25 0.5 1)
       100×      ⍝ Multiply each quotient by 100. (12.5 25 50 100)
      ⌊          ⍝ Round the products down to the nearest integer... (12 25 50 100)
     ∘           ⍝ and ...
  ⍣¯1            ⍝ apply the inverse of...
+\               ⍝ the cumulative sum. (12 13 25 50)

— डेनिस
स्रोत

9

यदि केवल Fermat आप से गोल्फ सबक ले सकता था।

— TessellatingHeckler

1

@TessellatingHeckler मैं देखता हूं कि आपने वहां क्या किया। हो सकता है कि तब वह अपने प्रमाण के लिए हाशिये पर पर्याप्त जगह रखता हो। :)

— mbomb007 20

14

TI-BASIC, 26 23 16 बाइट्स

TI-83 + / 84 + श्रृंखला कैलकुलेटर के लिए।

ΔList(augment({0},int(cumSum(ᴇ2Ans/sum(Ans

एक सुंदर एल्गोरिथ्म के लिए @ डेनिस का धन्यवाद! हम percents में कनवर्ट करने के बाद सूची का संचयी योग लेते हैं, फिर फर्श, सामने की तरफ 0 से निपटते हैं, और अंतर लेते हैं। ᴇ2एक बाइट से छोटा है 100।

एक ही बाइट काउंट है:

ΔList(augment({0},int(cumSum(Ans/sum(Ans%

मजेदार तथ्य: %एक टू-बाइट टोकन है जो किसी संख्या को .01 से गुणा करता है - लेकिन इसे कैलकुलेटर में टाइप करने का कोई तरीका नहीं है! आपको या तो बाहर स्रोत को संपादित करने या असेंबली प्रोग्राम का उपयोग करने की आवश्यकता है।

पुराना कोड:

int(ᴇ2Ans/sum(Ans
Ans+(ᴇ2-sum(Ans)≥cumSum(1 or Ans

पहली पंक्ति सभी फ्लोर्ड पर्केंट्स की गणना करती है, फिर दूसरी लाइन पहले Nतत्वों में 1 जोड़ती है , जहां Nप्रतिशत शेष है। cumSum("संचयी योग" के लिए खड़ा है।

उदाहरण के साथ {1,1,2,4}:

          sum(Ans                  ; 8
int(ᴇ2Ans/                         ; {12,12,25,50}

                        1 or Ans   ; {1,1,1,1}
                 cumSum(           ; {1,2,3,4}
     ᴇ2-sum(Ans)                   ; 1
                ≥                  ; {1,0,0,0}
Ans+                               ; {13,12,25,50}

हमारे पास नहीं होगा N>dim([list], क्योंकि फर्श में 1 प्रतिशत से अधिक की कमी नहीं हुई है।

— lirtosiast
स्रोत

यकीन नहीं है कि आप यहां बाइट्स कैसे गिन रहे हैं, यह मेरे लिए 23 से अधिक समय तक

— भयानक

@DavidArenburg यह मानव-पठनीय रूप है। सभी टोकन ( int(, sum(, Ans, आदि) केवल एक बाइट पर कब्जा।

— डेनिस

4

+1 यह सबसे प्रभावशाली TI-BASIC गोल्फ में से एक है जिसे मैंने इस साइट पर देखा है।

— PhiNotPi

थॉमस यह जवाब आश्चर्यजनक है!

— डेवलेगर

क्या आप सुनिश्चित हैं कि %प्रतीक में प्रवेश करने का कोई तरीका नहीं है ? मुझे लगता है कि यह प्रतीक सूची में पाया जा सकता है ... इसके अलावा, मुझे अपना TI-84 + रजत बाहर निकालना चाहिए। मैंने थोड़ी देर में इसका इस्तेमाल नहीं किया है। ब्लॉक ड्यूड कमाल का है।

— mbomb007

7

CJam, 25 23 22 बाइट्स

{_:e2\:+f/_:+100-Xb.+}

25 → 24 के लिए @ Sp3000 को धन्यवाद।

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

यह काम किस प्रकार करता है

_                   e# Push a copy of the input.
 :e2                e# Apply e2 to each integer, i.e., multiply by 100.
    \               e# Swap the result with the original.
     :+             e# Add all integers from input.
       f/           e# Divide the product by the sum. (integer division)
        _:+         e# Push the sum of copy.
           100-     e# Subtract 100. Let's call the result d.
               Xb   e# Convert to base 1, i.e., push an array of |d| 1's.
                 .+ e# Vectorized sum; increment the first |d| integers.

— डेनिस
स्रोत

5

गणितज्ञ, 41 बाइट्स

(s=Floor[100#/Tr@#];s[[;;100-Tr@s]]++;s)&

— alephalpha
स्रोत

रुको, यहाँ क्या होता है?

— seequ

@Seeq एल्गोरिथ्म TI-BASIC जवाब में पुराने कोड की तरह है। यह सभी फ्लोर्ड पर्केंट्स की गणना करता है, फिर 1 को पहले Nतत्वों में जोड़ता है , जहां Nप्रतिशत शेष है।

— एलेफाल्फा

5

जे (8.04 बीटा) , 59 बाइट्स (30 चोरी बाइट्स)

डेनिस के APL उत्तर का 30 बाइट शाब्दिक J- पोर्ट :

    f=.3 :'+/\^:_1<.100*(+/\%+/)y'

    f 1 1 2 4
12 13 25 50

59 बाइट्स का जवाब, सबसे अच्छा मैं खुद कर सकता था:

f=.3 :0
p=.<.100*y%+/y
r=.100-+/p
p+((r$1),(#p-r)$0)/:\:p
)

(उच्चतम मानों पर जाने के लिए शेष होने के आधार पर, +1 से अधिक नहीं, शेष> 1 या उच्चतम मूल्य के लिए एक टाई के मामले में कई मूल्यों पर विभाजित होता है)।

जैसे

   f 1 0 2
33 0 67

   f 1000 1000
50 50

   f 1 1 2 4
12 12 25 51

   f 0 0 0 5 0
0 0 0 100 0

   f 16 16 16 16 16 16
17 17 17 17 16 16

   f 0 100 5 0 7 1
0 89 4 0 7 0

व्याख्या

f=.3 : 0 - 'f' एक चर है, जो एक क्रिया प्रकार (3) है, जिसे नीचे परिभाषित किया गया है: (0):
p=. चर 'पी', से निर्मित:
- y संख्याओं की एक सूची है 1 0 2
- +/y है '+' प्रत्येक मान के बीच में '/', सूची का योग 3
- y % (+/y) मूल y मान योग से विभाजित है: 0.333333 0 0.666667
- 100 * (y%+/y)उन मूल्यों को 100x है: 33.33.. 0 0.66...प्रतिशत प्राप्त करने के लिए।
- <. (100*y%+/y) फर्श ऑपरेटर को प्रतिशत पर लागू किया जाता है: 33 0 66
r=. चर 'र', से निर्मित:
- +/p फ्लोर्ड प्रतिशत का योग है: 99
- 100 - (+/p) 100 है - योग, या शेष प्रतिशत अंक 100 को योग बनाने के लिए आवश्यक है।
परिणाम, संग्रहीत नहीं:
- r $ 1 1s की एक सूची है, जब तक कि हमें वेतन वृद्धि के लिए आवश्यक वस्तुओं की संख्या: 1 [1 1 ..]
- #p प्रतिशत सूची की लंबाई है
- (#p - r) उन मदों की गिनती है जिन्हें बढ़ाया नहीं जाएगा
- (#p-r) $ 0 जब तक वह गिनती है, 0s की एक सूची है: 0 0 [0 ..]
- ((r$1) , (#p-r)$0) 0s सूची के बाद 1s सूची है: 1 0 0
- \: pअनुक्रमणिका की एक सूची है जो pइसे अवरोही क्रम में रखने के लिए ले जाती है।
- /: (\:p)अनुक्रमणिका की एक सूची है \:pजो कि आरोही क्रम में रखनी है
- ((r$1),(#p-r)$0)/:\:p1 1 .. 0 0 .. मास्क सूची से तत्वों को ले रहा है और छँटाई कर रहा है, इसलिए सबसे बड़े प्रतिशत के पदों में 1s हैं, प्रत्येक संख्या के लिए हमें वेतन वृद्धि की आवश्यकता है, और अन्य संख्याओं के लिए 0s 0 0 1:।
- p + ((r$1),(#p-r)$0)/:\:p प्रतिशतता + मुखौटा है, परिणाम सूची बनाने के लिए जो 100% के लिए रकम देता है, जो कि फ़ंक्शन रिटर्न मान है।

जैसे

33 0 66 sums to 99
100 - 99 = 1
1x1 , (3-1)x0 = 1, 0 0
sorted mask   = 0 0 1

33 0 66
 0 0  1
-------
33 0 67

तथा

) परिभाषा का अंत।

मैं J के साथ बहुत अनुभवी नहीं हूं; मुझे बहुत आश्चर्य नहीं होगा अगर इसमें "कुल के प्रतिशत में बारी सूची" ऑपरेशन बनाया गया है, और एक क्लीनर तरीका "वेतन वृद्धि एन सबसे बड़ा मूल्य" भी है। (यह मेरे पहले प्रयास से 11 बाइट कम है)।

— TessellatingHeckler
स्रोत

1

बहुत ही शांत। मेरे पास एक अजगर समाधान है लेकिन यह इस से बहुत अधिक लंबा है। अच्छा काम!

— डेवलेगर

1

यदि आपने ध्यान नहीं दिया है, तो नियम बदल गए हैं, इसलिए आपको इसे काफी छोटा करना चाहिए।

— lirtosiast

@DaveAlger धन्यवाद! @ThomasKwa मैंने देखा, मुझे यकीन नहीं है कि यह मुझे काफी मदद करता है - पहला प्रयास मुझे -2 वर्ण मिल सकता है। मुझे list[0:100-n] + list[:-100-n]दृष्टिकोण बदलने की आवश्यकता होगी - और मैंने इसे अप्रोच करने का दूसरा तरीका नहीं सोचा है।

— TessellatingHeckler

4

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

a=>(e=0,a.map(c=>((e+=(f=c/a.reduce((c,d)=>c+d)*100)%1),f+(e>.999?(e--,1):0)|0)))

उस "100 के बराबर" स्थिति (गोल करने और जोड़ने के बजाय) ने लगभग मेरा कोड (44 से 81 तक) दोगुना कर दिया। चाल को दशमलव मानों के लिए एक पॉट जोड़ना था, जो एक बार 1 तक पहुंचने पर 1 को खुद से लेता है और इसे वर्तमान संख्या में जोड़ता है। समस्या तब फ़्लोटिंग पॉइंट्स की थी, जिसका अर्थ कुछ इस प्रकार है [1,1,1] .9999999999999858 शेष है। इसलिए मैंने .999 से अधिक होने के लिए चेक को बदल दिया, और उस सटीक को पर्याप्त रूप से कॉल करने का निर्णय लिया।

— Mwr247
स्रोत

4

हास्केल, 42 27 बाइट्स

p a=[div(100*x)$sum a|x<-a]

Haskell में बहुत अधिक तुच्छ विधि, कुछ स्थानों पर गोल्फ के लिए हटा दिया गया है।

कंसोल (उदाहरण के लिए संगत होने के लिए शामिल किए गए कोष्ठक):

*Main> p([1,0,2])
[33,0,66]
*Main> p([1000,1000])
[50,50]
*Main> p([1,1,2,4])
[12,12,25,50]
*Main> p([0,0,0,5,0])
[0,0,0,100,0]

संपादित करें: मेरे डालने का अभ्यास किया, कुछ स्पष्ट प्रतिस्थापन किए।

मूल:

p xs=[div(x*100)tot|x<-xs]where tot=sum xs

— जेक
स्रोत

1

सूची का योग 100 होना चाहिए। आपके पहले उदाहरण में, यह 99 है

— डेमियन

4

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

-2 डेनिस के लिए धन्यवाद, मुझे एक और नई सुविधा ( Ä) का उपयोग :करने की याद दिलाते हुए और इसके बजाय कि मेरे पास शुरुआत में क्या था।

ŻÄ×³:SI

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

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

0;+\÷S×ȷ2ḞI

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

चैट में caird coinheringaahing और user202729 के साथ किया गया ।

यह काम किस प्रकार करता है

0; + \ _ ÷ एस × ȷ2 +I - पूर्ण कार्यक्रम।

0; - पूर्वसर्ग करना ०।
  + \ _ - संचयी योग।
    ÷ एस - इनपुट के योग से विभाजित।
      × ³2 - टाइम्स 100। monadic लिंक संस्करण में × the द्वारा प्रतिस्थापित।
         ḞI - प्रत्येक तल, वृद्धि (डेल्टास, अंतर) की गणना करें।

— श्री Xcoder
स्रोत

3

हास्केल, 63 56 55 बाइट्स

p l=tail>>=zipWith(-)$[100*x`div`sum l|x<-0:scanl1(+)l]

— डेमियन
स्रोत

3

पर्ल, 42 बाइट्स

डेनिस के एल्गोरिथ्म पर आधारित है

के लिए +1 शामिल है -p

एसटीडीआईएन पर संख्याओं की सूची के साथ भाग लें, जैसे

perl -p percent.pl <<< "1 0 2"

percent.pl:

s%\d+%-$-+($-=$a+=$&*100/eval y/ /+/r)%eg

— टन हास्पेल
स्रोत

2

ऑक्टेव, 40 बाइट्स

@(x)diff(ceil([0,cumsum(100*x/sum(x))]))

— alephalpha
स्रोत

2

पायथन 2, 89 बाइट्स

def f(L):
 p=[int(x/0.01/sum(L))for x in L]
 for i in range(100-sum(p)):p[i]+=1
 return p

print f([16,16,16,16,16,16])
print f([1,0,2])

->

[17, 17, 17, 17, 16, 16]
[34, 0, 66]

— TessellatingHeckler
स्रोत

2

ब्रेन-फ्लैक , 150 बाइट्स

((([]){[{}]({}<>)<>([])}{})[()])<>([]){{}<>([{}()]({}<([()])>)<>(((((({})({})({})){}){}){}{}){}){}(<()>))<>{(({}<({}())>)){({}[()])<>}{}}{}([])}<>{}{}

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

अंत से शुरू होकर और पीछे की ओर काम करते हुए, यह कोड प्रत्येक चरण में यह सुनिश्चित करता है कि अब तक के आउटपुट नंबरों का योग कुल प्रतिशत के बराबर है, जो गोल है।

(

  # Compute and push sum of numbers
  (([]){[{}]({}<>)<>([])}{})

# And push sum-1 above it (simulating a zero result from the mod function)
[()])

<>

# While elements remain
([]){{}

  # Finish computation of modulo from previous step
  <>([{}()]({}

    # Push -1 below sum (initial value of quotient in divmod)
    <([()])>

  # Add to 100*current number, and push zero below it
  )<>(((((({})({})({})){}){}){}{}){}){}(<()>))

  # Compute divmod
  <>{(({}<({}())>)){({}[()])<>}{}}{}

([])}

# Move to result stack and remove values left over from mod
<>{}{}

— Nitrodon
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 60 63 95

अनुकूलित और से सरलीकृत मेरी (गलत) जवाब एक और चुनौती को
पता चलने पर कि यह बहुत गलत था के लिए Thk @ l4m2 को

फिक्स्ड सेविंग 1 बाइट (और 2 बाइट कम, नाम मत गिनना F=)

v=>v.map(x=>(x=r+x*100,r=x%f,x/f|0),f=eval(v.join`+`),r=f/2)

किसी भी EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें

F=
v=>v.map(x=>(x=r+x*100,r=x%f,x/f|0),f=eval(v.join`+`),r=f/2)

console.log('[1,0,2] (exp [33,0,67] [34,0,66])-> '+F([1,0,2]))
console.log('[1000,1000] (exp [50,50])-> '+F([1000,1000]))
console.log('[1,1,2,4] (exp[12,12,25,51] [13,12,25,50] [12,13,25,50] [12,12,26,50])-> '+F([1,1,2,4]))
console.log('[0,0,0,5,0] (exp [0,0,0,100,0])-> '+F([0,0,0,5,0]))
console.log('[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,980] -> '+F([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,980]))
console.log('[2,2,2,2,2,3] -> ' + F([2,2,2,2,2,3]))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

पर विफल[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,980]

— l4m2

@ l4m2 असफल क्यों हुआ? यह राशि 100 है औरany single resulting integer returned as a percentage is off by no more than 1 in either direction.

— edc65

अंतिम एक को 98 से अधिकतम एक पर होना चाहिए, लेकिन यह 100 है

— l4m2

@ l4m2 उह, ठीक है, धन्यवाद। फिर से सोचने के लिए

— edc65

@ l4m2 को अब तय किया जाना चाहिए

— edc65

1

जंग, 85 बाइट्स

यह सरणियों के बजाय वैक्टर का उपयोग करता है क्योंकि जहां तक मुझे पता है कि कई अलग-अलग लंबाई के सरणियों को स्वीकार करने का कोई तरीका नहीं है।

let a=|c:Vec<_>|c.iter().map(|m|m*100/c.iter().fold(0,|a,x|a+x)).collect::<Vec<_>>();

— jus1in
स्रोत

1

जावास्क्रिप्ट, 48 बाइट्स

F=

x=>x.map(t=>s+=t,y=s=0).map(t=>-y+(y=100*t/s|0))

// Test 
console.log=x=>O.innerHTML+=x+'\n';


console.log('[1,0,2] (exp [33,0,67] [34,0,66])-> '+F([1,0,2]))
console.log('[1000,1000] (exp [50,50])-> '+F([1000,1000]))
console.log('[1,1,2,4] (exp[12,12,25,51] [13,12,25,50] [12,13,25,50] [12,12,26,50])-> '+F([1,1,2,4]))
console.log('[0,0,0,5,0] (exp [0,0,0,100,0])-> '+F([0,0,0,5,0]))

<pre id=O></pre>

स्निपेट का विस्तार करें

— l4m2
स्रोत

0

Jq 1.5 , 46 बाइट्स

add as$s|.[1:]|map(100*./$s|floor)|[100-add]+.

विस्तारित

  add as $s               # compute sum of array elements
| .[1:]                   # \ compute percentage for all elements 
| map(100*./$s|floor)     # / after the first element
| [100-add] + .           # compute first element as remaining percentage

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

— jq170727
स्रोत

0

PHP, 82 बाइट्स

for(;++$i<$argc-1;$s+=$x)echo$x=$argv[$i]/array_sum($argv)*100+.5|0,_;echo 100-$s;

कमांड लाइन के तर्कों से इनपुट लेता है, प्रिंट प्रतिशत को अंडरस्कोर द्वारा सीमांकित करता है।

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

— टाइटस
स्रोत

यह आउटपुट 15_15_15_15_15_25तब दिया जाता है जब इनपुट दिया जाता है [2,2,2,2,3], जो सही नहीं है क्योंकि3/13 ~= 23.1%

— सोफिया लेचनर

@SophiaLechner कौन सा उत्तर सही है?

— टाइटस

ज्यादातर करते हैं, वास्तव में। अब तक के सही उत्तर दो एल्गोरिदम में से एक के आसपास बने प्रतीत होते हैं; पहले संचयी योगों के प्रतिशत से गोल होता है और अंतर लेता है; दूसरा प्रतिशत के फर्श की गणना करता है और फिर कुल 100 तक लाने के लिए पर्याप्त विशिष्ट प्रतिशत बढ़ाता है।

— सोफिया लेचनर

@SophiaLechner का मतलब यह नहीं था कि मैं इसे देखूँगा; लेकिन मैं बाद में करूँगा। ध्यान देने के लिए धन्यवाद।

— टाइटस