Bin given limits: Difference between revisions

 

Show output here, on this page.

 

=={{header|Ada}}==

This example works with Ada 2012. The definition of the subtype Limits_Array employs a dynamic predicate to ensure that the limits array is sorted. The solution defines the binning types and operations within an Ada package, providing modularity and simplifying the code in the main procedure.

 

'''package specification:'''

type Nums_Array is array (Natural range <>) of Integer;

function Is_Sorted (Item : Nums_Array) return Boolean;

procedure Print (Limits : Limits_Array; Bin_Result : Nums_Array);

end binning;

'''package body:'''

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

 

end binning;

'''main procedure:'''

with binning; use binning;

 

Print (Limits => Limits_2, Bin_Result => Bin_2);

end Main;

{output}

<pre>

>= 720 : 59

</pre>

 

=={{header|AutoHotkey}}==

bin := [], counter := 0

for i, val in data {

}

return output .= (prevlimit ? prevlimit : "-∞") ", ∞ : " ((x:=bin["∞"].Count())?x:0) "`n"

data := [95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,16

, 8, 9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55]

,466, 23,707,467, 33,670,921,180,991,396,160,436,717,918, 8,374,101,684,727,749]

MsgBox, 262144, , % Bin_given_limits(limits, data)

{{out}}

<pre>

720, ∞ : 59

</pre>

=={{header|C}}==

#include <stdlib.h>

 

 

return EXIT_SUCCESS;

 

{{out}}

>= 720 : 59

</pre>

 

=={{header|C++}}==

#include <cassert>

#include <iomanip>

std::cout << "\nExample 2:\n";

print_bins(limits2, bins(limits2, data2));

 

{{out}}

>= 720 : 59

</pre>

 

 

 

 

{{out}}

 

 

=={{header|Factor}}==

Factor provides the <code>bisect-right</code> word in the <code>sorting.extras</code> vocabulary. See the implementation [https://docs.factorcode.org/content/word-bisect-right%2Csorting.extras.html here].

math.statistics sequences sequences.extras sorting.extras ;

 

160 436 717 918 8 374 101 684 727 749

}

{{out}}

<pre>

</pre>

 

=={{header|Go}}==

 

import (

printBins(limitsList[i], bins)

}

 

{{out}}

>= 720 = 59

</pre>

 

=={{header|J}}==

'''Solution:'''

 

require 'format/printf'

 

'''Required Examples:'''

data1=: , 0&".;._2 noun define

95 21 94 12 99 4 70 75 83 93 52 80 57 5 53 86 65 17 92 83 71 61 54 58 47

466 23 707 467 33 670 921 180 991 396 160 436 717 918 8 374 101 684 727 749

)

┌──────────────────────────┬───────────┬─────┬─────────────────┬──────────────────────────┬──────────────┬──────────────────────────────────────┐

│21 12 4 5 17 16 8 9 7 19 6│32 30 29 36│37 40│52 47 46 45 49 43│57 53 65 61 54 58 64 60 55│70 75 80 71 79│95 94 99 83 93 86 92 83 84 87 96 98 97│

└──────────────────────────┴───────────┴─────┴─────────────────┴──────────────────────────┴──────────────┴──────────────────────────────────────┘

11 4 2 6 9 5 13

 

=={{header|Java}}==

import java.util.Collections;

import java.util.List;

printBins(limits, bins(limits, data));

}

{{out}}

<pre>

>= 720 : 59

</pre>

 

=={{header|Julia}}==

{{trans|Python}}

function bisect_right(array, x, low = 1, high = length(array) + 1)

while low < high

 

testbins()

<pre>

RC FIRST EXAMPLE:

>= 720 := 59

</pre>

 

=={{header|Nim}}==

{{trans|Python}}

 

func binIt(limits, data: openArray[int]): seq[Natural] =

160, 436, 717, 918, 8, 374, 101, 684, 727, 749]

let bins2 = binIt(Limits2, Data2)

 

{{out}}

>= 634 .. < 720 := 16

>= 720 := 59</pre>

=={{header|Objective-C}}==

 

NSArray<NSNumber *> *bins(NSArray<NSNumber *> *limits, NSArray<NSNumber *> *data) {

}

return 0;

{{out}}

<pre>

>= 720 : 59

</pre>

=={{header|Perl}}==

Borrowed <tt>bisect_right</tt> from Julia entry.

use warnings; no warnings 'uninitialized';

use feature 'say';

my @limits = (0, @{$tests[$_]{limits}}, Inf);

say bin_format \@limits, bin_it(\@limits,\@{$tests[$_]{data}});

{{out}}

<pre>[ 0, 23) => 11

 

But if we were to take to heart the warning that the input data was scary-big, then perhaps using a more efficient routine to classify the data into bins would be prudent (boilerplate/input/output same as above).

 

for (@tests) {

printf "[%3d, %3d) => %3d\n", $lim[$_], ($lim[$_+1] == Inf ? 'Inf' : $lim[$_+1]), $$data_bins[$_] for 0..@lim-2;

print "\n";

=={{header|Phix}}==

{{out}}

<pre>

>= 720 := 59

</pre>

=={{header|Python}}==

This example uses binary search through the limits to assign each number to its bin, via standard module bisect.bisect_right.<br>

The Counter module is ''not'' used as the number of bins is known allowing faster array access for incrementing bin counts versus dict lookup.

 

 

def bin_it(limits: list, data: list) -> list:

466, 23,707,467, 33,670,921,180,991,396,160,436,717,918, 8,374,101,684,727,749]

bins = bin_it(limits, data)

 

{{out}}

>= 634 .. < 720 := 16

>= 720 := 59</pre>

=={{header|R}}==

This is R's bread and butter. Even with only the base library, the only thing stopping us from giving a one-line solution is the task's requirement of using two functions.

 

Code such as 0:length(limits) is generally considered bad practice, but it didn't cause any problems here. To my amazement, this code works even if limits is of size 0 or 1. Even the <= printing doesn't break!

16,8,9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55)

605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,892,443,198,988,791,

 

 

#Contains some unicode magic so that we can get the infinity symbol and <= to print nicely.

#Half of the battle here is making sure that we're not being thrown by R being 1-indexed.

#The other half is avoiding the mathematical sin of saying that anything can be >=infinity.

{

}

 

#Showing off a one-line solution. Admittedly, calling the massive anonymous function "one-line" is generous.

{

"elements.\n")))

}

 

{{out}}

[1] 11 4 2 6 9 5 13

 

Bin 0 covers the range: -∞ < x < 23 and contains 11 elements.

Bin 1 covers the range: 23 ≤ x < 37 and contains 4 elements.

Bin 6 covers the range: 83 ≤ x < ∞ and contains 13 elements.

 

[1] 3 0 44 10 16 2 28 16 6 16 59

 

Bin 0 covers the range: -∞ < x < 14 and contains 3 elements.

Bin 1 covers the range: 14 ≤ x < 18 and contains 0 elements.

Bin 10 covers the range: 720 ≤ x < ∞ and contains 59 elements.

 

Bin 0 covers the range: -∞ < x < 14 and contains 10 elements.

Bin 1 covers the range: 14 ≤ x < 18 and contains 2 elements.

Bin 9 covers the range: 634 ≤ x < 720 and contains 16 elements.

Bin 10 covers the range: 720 ≤ x < ∞ and contains 59 elements.</pre>

=={{header|Raku}}==

sub bin_it ( @limits, @data ) {

my @ranges = ( -Inf, |@limits, Inf ).rotor( 2 => -1 ).map: { .[0] ..^ .[1] };

say '';

}

{{out}}

<pre>

720..^Inf => 59

</pre>

=={{header|REXX}}==

16 8 9 32 84 7 87 46 19 30 37 96 6 98 40 79 97 45 64 60 29 49 36 43 55

call show 'the 1st set of bin counts for the specified data:'

466 23 707 467 33 670 921 180 991 396 160 436 717 918 8 374 101 684 727 749

call show 'the 2nd set of bin counts for the specified data:'

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

 

 

</pre>

 

=={{header|Ruby}}==

tests = Test.new( [23, 37, 43, 53, 67, 83],

[95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,

puts

end

{{out}}

37...43 2

43...53 6

A very simple and naive algorithm that uses nested dynamic arrays.

 

let mut bins: Vec<Vec<usize>> = Vec::with_capacity(limits.len() + 1);

for _ in 0..=limits.len() {bins.push(Vec::new());}

print_bins(&limits2, &bins2);

}

 

{{out}}

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var getBins = Fn.new { |limits, data|

var bins = getBins.call(limitsList[i], dataList[i])

printBins.call(limitsList[i], bins)

 

{{out}}