编写一个函数，该函数接受一个正整数列表，并返回一个整数列表，该整数列表近似于相同位置中相应整数的总百分比。

返回列表中的所有整数必须正好等于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]

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

Dyalog APL，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)

TI-BASIC，26 23 16字节

适用于TI-83 + / 84 +系列计算器。

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

感谢@Dennis提供了漂亮的算法！在转换为百分比之后，我们取列表的累积总和，然后取下，将0固定在最前面，然后取差。ᴇ2比100。短一字节。

在相同的字节数是：

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

有趣的事实：%是一个两字节的令牌，将数字乘以.01，但是无法将其输入计算器！您需要在外部编辑源代码或使用汇编程序。

旧代码：

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

第一行计算所有下限百分比，然后第二行将1添加到第一个N元素，这里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。

CJam，25 23 22字节

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

感谢@ Sp3000 for 25→24。

在线尝试。

怎么运行的

_                   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.

Mathematica，41个字节

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

J（8.04 beta），59个字节（30个被盗字节）

Dennis 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=. 变量“ p”，从以下项构建：
  • y 是数字列表 1 0 2
  • +/y 在每个值“ /”之间加上“ +”，即列表的总和 3
  • y % (+/y) 是原始y值除以和： 0.333333 0 0.666667
  • 100 * (y%+/y) 是这些值的100倍： 33.33.. 0 0.66...获得百分比。
  • <. (100*y%+/y) 是适用于百分比的下限运算符： 33 0 66
• r=. 变量“ r”，从以下项构建：
  • +/p 是下限百分比的总和： 99
  • 100 - (+/p) 是100-总和，或使百分比总和为100所需的剩余百分比。
• 结果，未存储：
  • r $ 1 是1的列表，只要我们需要增加的项数即可： 1 [1 1 ..]
  • #p 是百分比列表的长度
  • (#p - r) 是不会增加的项目数
  • (#p-r) $ 0 只要该计数是0的列表： 0 0 [0 ..]
  • ((r$1) , (#p-r)$0) 是1s列表，然后是0s列表： 1 0 0
  • \: p 是要获取的索引列表 p要按降序排列。
  • /: (\:p)是要从\:p中升序排列的索引列表
  • ((r$1),(#p-r)$0)/:\:p从1取的元素.. 0 0 ..面膜排行榜和分拣所以有1秒的最大百分比，每一个我们需要增加的编号的位置，和0为其他号码：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不太了解；如果内置了“将清单转换为总数的百分比”的操作，并且还有一种更清洁的方式“递增n个最大值” ，我也不会感到惊讶。（这比我的第一次尝试少11个字节）。

JavaScript（ES6），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，并决定将其称为足够精确。

Haskell，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

果冻，7个字节

-2感谢Dennis，提醒我使用另一个新功能（Ä），并使用:原来的功能。

ŻÄ׳:SI

在线尝试！

果冻，11字节

0;+\÷S×ȷ2ḞI

在线尝试！

与CairdCoinheringaahing和user202729一起在聊天中完成。

怎么运行的

0; + \÷S×ȷ2ḞI-完整程序。

0; -加上0。
  + \-累计和。
    ÷S-除以输入总和。
      ×ȷ2-乘以100。在单声道链接版本中由׳代替。
         -I-分别取下，计算增量（增量，差）。

Haskell，63 56 55字节

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

Perl，42个字节

基于丹尼斯算法

包括+1的 -p

使用STDIN上的数字列表运行，例如

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

percent.pl：

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

八度，40字节

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

Python 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]

150字节的Brain-Flak

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

在线尝试！

从头开始并向后工作，此代码可确保在每个步骤中，到目前为止的输出数之和等于所遇到的总百分比，并四舍五入。

(

  # 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
<>{}{}

JavaScript（ES6）60 63 95

从我对另一个挑战的错误回答中改编和简化
对@ l4m2的 Thk的因为发现这也是错误的

固定保存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>

Rust，85个字节

它使用向量而不是数组，因为据我所知，没有办法接受多个不同长度的数组。

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

JavaScript，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>

jQuery 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

在线尝试！

PHP，82字节

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

从命令行参数获取输入，输出下划线分隔的百分比。

运行-nr或在线尝试。