ie>#pragma indent

ie>using System.Console
ie>using System.Math

ie>def makeDistrib(trxCount : int, quantums : int)
ie>    mutable r : list[int] = []
ie>    mutable remainingTrx = trxCount
ie>    mutable remainingQuantums = quantums
ie>    foreach (_i in [1..quantums])
ie>        r ::= Round(remainingTrx / (remainingQuantums :> double)) :> int
ie>        remainingTrx -= r.Head
ie>        --remainingQuantums
ie>    r

ie>def r = makeDistrib(2, 6)
ie>WriteLine($"$r")
ie>

import std.math;
import std.stdio;

int[] makeDistrib( int trxCount, int quantums )
  {
    auto r = new int[ quantums ];
    foreach( inout c; r )
      {
        c = cast(int)std.math.round(
            cast(float)trxCount / quantums );
        trxCount -= c;
        --quantums;
      }

    return r;
  }

void main()
  {
    int[] d = makeDistrib( 2, 6 );
    writefln( d );
  }

1. отсутствие полноценной поддержки const по-сравнению с C++ (const методы, const указатели)[/*]
   
2. отсутствие возможности перегружать оператор присваивания или аналогичный механизм, который бы позволил реализовать подсчет ссылок[/*]
   
3. отсутствие возможности возвращать ссылки из функций
   (поэтому my_class["name"] += 1 не получится)[/*]
   
4. отсутствие возможности перегружать оператор присваивания не позволяет нормально реализовать механизм expression templates, что очень плохо для вычислительных программ[/*]

1. медленный консервативный GC (для точного нужно по всей вероятности корректировать дизайн)[/*]
   
2. отсутствие полноценных замыканий, но при этом возвращать делегаты из функций не запрещено, что приводит к UB![/*]
   
3. неполноценная поддержка рефлексии[/*]
   
4. отсутствие генераторов (как сейчас реализуется foreach несколько менее удобно и я подозреваю сложнее оптимизировать)[/*]
   
5. семантика использования миксинов до конца не проработана (я их не очень изучал но судя по форуму там много вопросов)[/*]

WH>def makeDistrib(trxCount : int, quantums : int)
WH>{
WH>| (_, 0) => []
WH>| (remainingTrx, remainingQuantums) =>
WH>    def r = (remainingTrx :> double) / remainingQuantums;
WH>    def r = Round(r, MidpointRounding.AwayFromZero) :> int;
WH>    r :: makeDistrib(remainingTrx - r, remainingQuantums - 1);
WH>}
WH>def r = makeDistrib(2, 6);
WH>WriteLine($"$r");
WH>

object BufferizatorDistrib5
  {
    def makeDist( trxCount: int, quantums: int ) : List[ int ] = {
      def distrib( trxCount: int, quantums: int, result: List[ int ] ) : List[ int ] = {
        if( quantums >= 1 )
          {
            val r = Math.round(trxCount.toFloat / quantums)
            distrib( trxCount - r, quantums - 1, r :: result )
          }
        else
          result
      }

      distrib( trxCount, quantums, Nil ).reverse
    }

    def main( args: Array[ String ] ) =
      {
        System.out.print( makeDist( 2000, 60000 ) )
      }
  }

using System;
using System.Console;
using System.Math;

def makeDistrib(trxCount : int, quantums : int)
{
  def distrib( trxCount: int, quantums: int, result ) {
    | (_, 0, _) => result
    | (remainingTrx, remainingQuantums, result) =>
      def r = (remainingTrx :> double) / remainingQuantums;
      def r = Round(r, MidpointRounding.AwayFromZero) :> int;
      distrib(remainingTrx - r, remainingQuantums - 1, r :: result );
  }
  distrib( trxCount, quantums, [] )
}

def r = makeDistrib(2000, 60000);
WriteLine($"$r");

ie>А кстати! J, дайте J!!

r =. [:<.0.5+({.%}.) .NB round(trxCount/trxCount)
md =. ([:|.6{.|.)@([:#:{:@(+(-@r@(2&{.),_1,(2^([:<:1&{))*r@(2&{.))^:(1&{)))@(,&0)
md 2 6 .NB вернет [0 0 1 0 1 0]