Top rank per group: Difference between revisions

</pre>

<br>

 

=={{header|Ada}}==

top.adb:

with Ada.Text_IO;

 

end;

end loop;

<pre style="height:30ex;overflow:scroll">Department D050

John Rappl | E21437 | 47000

 

=={{header|Aime}}==

{

employees[name] = list(name, id, salary, department);

 

0;

<pre>aime rcs/top_rank_per_group c N 5</pre>{{out}}

<pre style="height:30ex;overflow:scroll">Department D050

David Motsinger | E27002 | 19250

Adam Smith | E63535 | 18000</pre>

 

=={{header|AutoHotkey}}==

StringSplit, Department_, Departments, `,, %A_Space%

 

Employee_%m%_Salary := Salary

Employee_%m%_Dept := Department

<pre style="height:30ex;overflow:scroll">Department: D050

---------------------------

Claire Buckman E39876 27800 D202

David Motsinger E27002 19250 D202</pre>

=={{header|AWK}}==

# syntax: GAWK -f TOP_RANK_PER_GROUP.AWK [n]

#

exit(0)

}

<p>Sample command and output:</p>

<pre>

=={{header|Bracmat}}==

Bracmat has no dedicated sorting functions. However, when evaluating algebraic expressions, Bracmat sorts factors in products and terms in sums. Moreover, Bracmat simplifies products by, amongst other transformations, collecting exponents of the same base into a single exponent, which is the sum of the collected exponents: <code>a^b*a^c</code> &rarr; <code>a^(b+c)</code>. This built-in behaviour is made use of in this solution.

(John Rappl,E21437,47000,D050)

(George Woltman,E00127,53500,D101)

)

& toprank$(!employees.3)

<pre style="height:30ex;overflow:scroll">Top 3 salaries per department.

Department D050:

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

typedef struct {

} person;

 

person ppl[] = {

};

 

int pcmp(const void *a, const void *b)

{

}

 

void top(int n)

{

 

 

}

 

int main()

{

<pre>D050 47000: John Rappl

D050 21900: Nathan Adams

D202 49500: Rich Holcomb

D202 27800: Claire Buckman</pre>

 

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

#include <set>

#include <list>

struct Employee

{

 

};

 

struct CompareEarners

{

};

 

void initialize(EMPLOYEELIST& Employees)

{

}

 

void group(EMPLOYEELIST& Employees, DEPARTMENTLIST& Departments)

{

 

}

 

void present(DEPARTMENTLIST& Departments, unsigned int N)

{

}

 

int main(int argc, char* argv[])

{

 

 

 

 

 

<pre style="height:30ex;overflow:scroll">In department D050

Name ID Salary Department

Claire Buckman E39876 27800 D202

David Motsinger E27002 19250 D202</pre>

 

=={{header|Ceylon}}==

shared String name;

shared String id;

for (dept -> staff in employees.group(Employee.dept))

dept -> staff.sort(byDecreasing(Employee.salary)).take(n)

 

=={{header|Clojure}}==

 

 

(defstruct employee :Name :ID :Salary :Department)

(doseq [e (take 3 (reverse (sort-by :Salary emps)))]

(println e)))

<pre style="height:30ex;overflow:scroll">Department: D050

{:Name John Rappl, :ID E21437, :Salary 47000, :Department D050}

 

=={{header|Common Lisp}}==

(let ((not-pred (complement predicate))

(group-data (make-hash-table :test group-test)))

(second entry) (insert datum (second entry))))))

(dolist (datum data group-data)

Example

'(("Tyler Bennett" E10297 32000 D101)

("John Rappl" E21437 47000 D050)

D050 (2 (("Nathan Adams" E41298 21900 D050) ("John Rappl" E21437 47000 D050)))

D202 (3 (("David Motsinger" E27002 19250 D202) ("Claire Buckman" E39876 27800 D202) ("Rich Holcomb" E01234 49500 D202)))

 

=={{header|D}}==

 

struct Employee {

writefln("Department %s\n %(%s\n %)\n", dep, recs.take(n));

}

<pre style="height:30ex;overflow:scroll">Department D202

Employee("Rich Holcomb", "E01234", 49500, "D202")

Employee("John Rappl", "E21437", 47000, "D050")

Employee("Nathan Adams", "E41298", 21900, "D050")</pre>

 

=={{header|E}}==

def addKeys(keys, rows) {

def res := [].diverge()

out.println()

}

 

Note: This uses an append-and-then-sort to maintain the list of top N; a sorted insert or a proper [[wp: selection algorithm|selection algorithm]] would be more efficient. As long as <var>N</var> is small, this does not matter much; the algorithm is O(n) with respect to the data set.{{out}}

=={{header|EchoLisp}}==

We use the '''sql.lib''' to select, sort and group records from the table 'emps'. The output is appended in a new table, 'high'.

(lib 'struct) ;; tables are based upon structures

(lib 'sql) ;; sql-select function

group-by emp.dept

order-by emp.salary desc limit N into high))

{{out}}

(define emps_file

'(("Tyler Bennett" E10297 32000 D101)

[3] D202 Rich Holcomb 49500

[4] D666 Simon Gallubert 42

 

=={{header|Elena}}==

import system'routines;

import extensions;

class Employee

{

= new StringWriter()

.writePaddingRight(Name, 25)

.writePaddingRight(ID, 12)

}

{

topNPerDepartment(n)

{

Department = x.Key;

Employees

}

};

var employees := new Employee[]

{

};

{

console.printLine("Department: ",info.Department);

};

console.readChar()

{{out}}

<pre>

=={{header|Elixir}}==

Quick implementation using piping and anonymous functions.

def per_groupe(data, n) do

String.split(data, ~r/(\n|\r\n|\r)/, trim: true)

Timothy Grove,E16398,29900,D190

"""

 

{{out}}

 

=={{header|Erlang}}==

 

-export( [employees/0, employees_in_department/2, highest_payed/2, task/1] ).

 

employees() ->

 

employees_in_department( Department, Employees ) -> [X || #employee{department=D}=X <- Employees, D =:= Department].

 

highest_payed( N, Employees ) ->

 

task( N ) ->

 

 

 

task_write( Highest_payeds ) ->

<pre><14> top_rank_per_group:task(2).

"D050" 53500: "George Woltman"

 

=={{header|F Sharp|F#}}==

[

"Tyler Bennett", "E10297", 32000, "D101";

let topRank n =

Seq.groupBy (fun (_, _, _, d) -> d) data

 

=={{header|Factor}}==

sorting ;

IN: top-rank

] first-n-each

nl

<pre style="height:30ex;overflow:scroll">

Department D101:

 

=={{header|Forth}}==

\ Written in ANS-Forth; tested under VFX.

\ Requires the novice package: http://www.forth.org/novice.html

 

test-data kill-employee

{{out}}

<pre style="height:30ex;overflow:scroll">

 

=={{header|Fortran}}==

1 GRIST("Tyler Bennett","E10297",32000,"D101"),

2 GRIST("John Rappl","E21437",47000,"D050"),

3 GRIST("George Woltman","E00127",53500,"D101")/

(just showing the first three), however this does not allow the preparation of the header line, because <code>GRIST("Employee Name","Employee ID","Salary","Department")</code> would be invalid since the "salary" entry is a floating-point number in the data aggregate, not text. The header line could be discarded, but this is in violation of the ideas of properly-described data files. So, the plan is to read the data from an input file containing the full example input, with its header line given special treatment. No attempt is made to detect or report improperly-formatted data. The READ statements could refer to an internally-defined block of text, but reading an actual disc file is more normal. Ad-hoc decisions are made for the size of the CHARACTER variables, that are "surely big enough" for the example data, likewise with the size of the array to hold all the records.

 

If the requirement had been to report the highest-ranked salary, the deed could have been done via the F90 function MAXLOC, which locates the array index of the (first-encountered?) maximum value of an array of values; further, it allows an additional MASK parameter which could be used to select only those entries having a particular "department" code. However, aside from the multiple scans that would be required for multiple departmental codes, there is the requirement for the top N salaries, and anyway, there would still be the need to identify the different departmental codes once only. Accordingly, the way ahead is the classic: sort the data and then work through the sorted sequence. Since standard Fortran provides no "sort" function in its standard libraries nor does it offer a pre-processor that might include a sort generator and the like to generate the specific code needed for a particular data aggregate and sort key specification, one must engage in some repetition. For this purpose, the "comb" sort is convenient with its code requiring just one comparison and one "swap" action, so in-line code is not troublesome. On the other hand, when dealing with compound sort keys, a three-way IF statement (or equivalent) is necessary whereby the first field of the sort key is compared with appropriate action for the < and > cases, but for the = case the comparison moves on to the second key. ''Three'' different consequences from the one comparison. Despite the deprecations of the modernisers this is still possible for numerical comparisons, but alas, character comparisons are not allowed in an arithmetic-IF statement - though one could struggle with ICHAR action. Thus, two comparisons are made where only one should suffice.

 

 

WRITE (MSG,1)

1 FORMAT ("Reads a set of employee information from TopRank.csv"/

1"Then for each department code, shows the N highest paid.")

OPEN (IN,NAME = "TopRank.csv",FORM = "FORMATTED")

Chug through the input.

Collate the collection.

Crank up a comb sort, which requires only one comparison statement. Especially good for compound fields.

 

Cast forth results.

WRITE (MSG,32) "Rank",HEADING

 

 

As ever, some tricky sizing of fields in the FORMAT statements, and a collection of ad-hoc constants. Cross-linking the integers via PARAMETER statements and the like would add a whole lot of blather, so if field sizes are changed, a fair amount of fiddling would follow. A more accomplished data processing routine would include this.

2 Claire Buckman E39876 27800.00 D202

3 David Motsinger E27002 19250.00 D202

</pre>

 

=={{header|FunL}}==

 

employees = [

printf( " %-16s %6s %7d\n", e.name, e.id, e.salary )

{{out}}

 

=={{header|Go}}==

 

import (

)

 

// language-native data description

type Employee struct {

}

 

 

var data = EmployeeList{

}

 

type By func(e1, e2 *Employee) bool

type employeeSorter struct {

}

 

// nth salary (callers that don't care about ties could just trim more.)

func (el EmployeeList) TopSalariesByDept(n int) []EmployeeList {

 

 

}

 

func main() {

{{out|Output (with additional data demonstrating ties)}}

<pre style="height:30ex;overflow:scroll">

 

=={{header|Groovy}}==

employees.groupBy { it.Department }.sort().each { department, staff ->

println "Department $department"

[Name: 'Timothy Grove', ID: 'E16398', Salary: 29900, Department: 'D190']

]

<pre style="height:30ex;overflow:scroll">Department D050

Name ID Salary

====Data.List====

{{Works with|GHC|7.10.3}}

 

import Text.Printf (printf)

putStrLn $ replicate 31 '='

mapM_ (traverse ((printf "%-16s %3s %10.2g\n" . name) <*> dep <*> sal)) $

{{out}}

<pre>NAME DEP TIP

Alternatively, if we store the data in key-value maps, rather than in a cons list, we can use Map.lookup and Map.filter, Map.keys and Map.elems, to pull out the data and shape reports fairly flexibly.

 

import Data.Ord (comparing)

 

 

 

highSalaryKeys :: Int -> String -> [(Int, Int)]

highSalaryKeys n dept =

take n $

 

 

xs :: [(Int, String, String, Int)]

xs =

]

 

 

nameKV (k, _, name, _) = (k, name)

deptKV (k, dept, _, _) = (k, dept)

 

table :: String -> [[String]] -> [String]

table delim rows =

{{Out}}

<pre>de Bont C.A. AB 65000

 

=={{header|HicEst}}==

CHARACTER name*20, employee_ID*10, department*10, temp*10

REAL :: idx(1), N_top_salaries=3

ENDDO

 

<pre style="height:30ex;overflow:scroll">John Rappl E21437 47000 D050

Nathan Adams E41298 21900 D050

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure getEmployees ()

every show_employee (!employeesInGroup[1:(1+min(N,*employeesInGroup))])

}

<pre style="height:30ex;overflow:scroll">

$ ./top-rank-by-group 2

Kim Arlich E10001 57000 D190

Timothy Grove E16398 29900 D190</pre>

 

=={{header|J}}==

J has a rich set of primitive functions, which combine the power of an imperative language with the expressiveness of a declarative, SQL-like language:

 

('`',,;:^:_1: N=:{.Employees) =:, (_&{"1)`'' ([^:(_ -: ])L:0)"0 _~ i.# E =: {: Employees

NB. Show top six ranked employees in each dept

<pre style="height:30ex;overflow:scroll">

+-----+-----+-----------------+------+

Named as a function where the (maximum) number of employees in each department is a parameter:

 

<pre style="height:30ex;overflow:scroll">

reportTopSalaries 2

=={{header|Java}}==

{{works with|Java|8}}

import java.util.*;

 

});

}

 

<pre style="height:30ex;overflow:scroll">Department D050

E39876 Claire Buckman 27800 D202

E27002 David Motsinger 19250 D202</pre>

 

=={{header|JavaScript}}==

 

===Iterative Solution===

{name: "Tyler Bennett", id: "E10297", salary: 32000, dept: "D101"},

{name: "John Rappl", id: "E21437", salary: 47000, dept: "D050"},

 

top_rank(3);

{{out}}

<pre style="height:30ex;overflow:scroll">D101

===Map and reduce===

====ES5====

var collect = arrOfObj.reduce(function (rtnObj, obj) {

if (rtnObj[obj.dept] === undefined) {

return list.slice(0,n);

});

====ES6====

By composition of generic functions:

'use strict';

 

topNSalariesPerDept(3, xs)

);

{{Out}}

<pre>[

=={{header|jq}}==

The task description invites use of the "language-native" data structure, which for jq is JSON, and so the following assumes that the file data.json contains an array of objects, each having as keys the strings on the header line. Thus, the first object in the array looks like this:

"Employee Name": "Tyler Bennett",

"Employee ID": "E10297",

"Salary": "32000",

"Department": "D101"

===Program===

group_by(.Department)

| reduce .[] as $dept

| ($dept[0] | .Department) as $dept

| . + [ { "Department": $dept, "top_salaries": $max } ] );

 

===Example===

$ jq 'top_rank_per_department(2) data.json

[

]

}

 

=={{header|Jsish}}==

Based on Javascript, imperative solution

/* Top rank per group, in Jsish */

function top_rank(n) {

 

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

using DataFrames

println("\n$cl:\n$data")

end

 

{{out}}

 

=={{header|Kotlin}}==

 

data class Employee(val name: String, val id: String, val salary: Int, val dept: String)

println()

}

 

{{out}}

Claire Buckman E39876 27800

</pre>

 

=={{header|Lua}}==

 

lst = { { "Tyler Bennett","E10297",32000,"D101" },

}

 

for i = 1, #lst do

if dep[ lst[i][4] ] == nil then

else

end

end

for i, _ in pairs( dep ) do

table.sort( dep[i], function (a,b) return a[3] > b[3] end )

print( "Department:", dep[i][1][4] )

for l = 1, math.min( N, #dep[i] ) do

end

print ""

 

 

 

=={{header|M2000 Interpreter}}==

Module Checkit {

' erase stack of values, so we can add data

}

Checkit

{{out}}

<pre style="height:30ex;overflow:scroll">

</pre >

 

{"John Rappl","E21437",47000,"D050"},{"George Woltman","E00127",53500,"D101"},

{"Adam Smith","E63535",18000,"D202"},{"Claire Buckman","E39876",27800,"D202"},

 

Scan[((Print["Department ",#[[1,4]],"\n","Employee","\t","Id","\t","Salary"]&[#])&[#];

<pre style="height:30ex;overflow:scroll"><pre>Department D101

Department D050

Department D202

Department D190

 

=={{header|Nim}}==

{{trans|C}}

 

 

 

result = cmp(a.department, b.department)

 

var rank = 0

for i, p in people:

if i > 0 and p.department != people[i-1].department:

rank = 0

if rank < n:

inc rank

 

<pre>D050 47000 John Rappl

D050 21900 Nathan Adams

 

=={{header|OCaml}}==

 

let to_string (name,_,s,_) = (Printf.sprintf "%s (%d)" name s)

let () =

toprank data 3;

<pre style="height:30ex;overflow:scroll">Department: D190

Kim Arlich (57000), Timothy Grove (29900)

Then sort each department by salaries and keep only the first n elements.

 

Employee method: initialize := dep := salary := id := name ;

#dep employees sortBy groupWith( #dep )

 

{{out}}

 

=={{header|Oz}}==

%% Create a list of employee records.

Data = {Map

{Record.map {GroupBy Employees department}

fun {$ Employees}

end}

end

end

in

 

=={{header|PARI/GP}}==

{{PARI/GP select}}

["John Rappl","E21437",47000,"D050"],

["George Woltman","E00127",53500,"D101"],

};

 

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

{{libheader|Classes}} {{libheader|Math}}

 

uses

TData = record

name: string;

PTData = ^TData;

 

end;

end.

<pre style="height:30ex;overflow:scroll">% ./TopRankPerGroup

Enter the number of ranks: 3

 

=={{header|Perl}}==

my @a = @{shift()};

my @b = @{shift()};

}

print "\n";

{{out}}

<pre>D050

Claire Buckman | E39876 | 27800

David Motsinger | E27002 | 19250</pre>

 

=={{header|Phix}}==

{{Out}}

<pre>

 

=={{header|PHP}}==

function top_sal($num){

}

<pre style="height:30ex;overflow:scroll">D050

 

D101

 

D190

 

D202

</pre>

 

=={{header|PicoLisp}}==

(de *Employees

("Tyler Bennett" E10297 32000 D101)

(prinl) ) ) )

 

<pre style="height:30ex;overflow:scroll">Department D101:

Name ID Salary

 

=={{header|PL/I}}==

rank: procedure options (main); /* 10 November 2013 */

 

end;

put skip list ('FINISHED');

<pre style="height:30ex;overflow:scroll">How many highest-paid employees do you want?

 

 

=={{header|PL/SQL}}==

cursor CSR_EMP(TOP_N pls_integer) is

select case LINE

DBMS_OUTPUT.PUT_LINE(v_emp."Top rank per group");

end loop;

=={{header|PowerShell}}==

New-Object PSObject `

| Add-Member -PassThru NoteProperty EmployeeName $Name `

} `

| Format-Table -GroupBy Department

<pre style="height:30ex;overflow:scroll">PS> Get-TopRank 2

 

 

=={{header|Prolog}}==

emp('Tyler Bennett','E10297',32000,'D101').

emp('John Rappl','E21437',47000,'D050').

writef(' ID: %w\t%w\tSalary: %w\n', [Id,Name,Sal]),

fail.

<pre style="height:30ex;overflow:scroll">?- topDeps(2).

Department: D101

Department: D050

Department: D202

Department: D190

true.

</pre>

 

=={{header|PureBasic}}==

Name$

ID$

NewList MyEmployees.Employees()

 

 

'''Save this as 'DataFile.txt and let the program open this file'''<pre>

=={{header|Python}}==

Python 2.7/3.x compatible.

from heapq import nlargest

for rec in nlargest(N, recs, key=lambda rec: rec[-2]):

print (format % rec)

<pre style="height:30ex;overflow:scroll">Department D050

Employee Name Employee ID Salary Department

Uses namedtuples for database records, and groupby builtin to group records by Department:

{{Works with|Python|3.7}}

from itertools import groupby

 

lambda record: record.Department

)

<pre style="height:30ex;overflow:scroll">D050

DBRecord(Employee_Name='John Rappl', Employee_ID='E21437', Salary='47000', Department='D050')

=={{header|R}}==

First, read in the data.

"Employee Name,Employee ID,Salary,Department

Tyler Bennett,E10297,32000,D101

Tim Sampair,E03033,27000,D101

Kim Arlich,E10001,57000,D190

To just return the top salary, it's very simple using tapply.

To return N salaries, we replace max with our own function.

{

with(dfr, tapply(Salary, Department,

}

 

$D050

[1] 47000 21900

 

To return the whole record for each of the top salaries, a different tack is required.

{

#Sort data frame by Department, then by Salary

})

}

<pre style="height:30ex;overflow:scroll"> $D050

Employee.Name Employee.ID Salary Department

 

=== With dplyr ===

library(dplyr)

dfr %>%

group_by(Department) %>%

Provides:

<pre style="height:30ex;overflow:scroll">

</pre>

 

=={{header|Racket}}==

 

(struct employee (name id salary dept))

(employee-name e)

(employee-id e))))

<pre style="height:30ex;overflow:scroll">Department D101:

$53500: George Woltman (E00127)

$57000: Kim Arlich (E10001)

$29900: Timothy Grove (E16398)</pre>

 

=={{header|REXX}}==

===version 1===

parse arg topN . /*get optional # for the top N salaries*/

say 'Finding the top ' topN " salaries in each department."; say

say 'There are ' employees "employees, " words(depts) 'departments: ' depts

say

<pre>

Finding the top 2 salaries in each department.

department: D190 $29900 E16398 Timothy Grove

</pre>

<pre>

Finding the top 100 salaries in each department.

 

===version 2===

* 12.02.2014 Walter Pachl

*--------------------------------------------------------------------*/

exit: Say arg(1)

help: Say 'Syntax: rexx topsal [topn]'

'''output'''

<pre>13 employees, 4 departments: D101 D050 D202 D190

 

=={{header|Ring}}==

# Project : Top rank per group

 

ok

next

Output:

<pre>

Without much thought to report formatting:

{{works with|Ruby|2.2+}}

 

data = <<EOS

end

 

 

{{out}}

 

=={{header|Run BASIC}}==

John Rappl,E21437,47000,D050;

George Woltman,E00127,53500,D101

end if

print word$(depSal$(i),1,",");chr$(9);word$(depSal$(i),2,",");chr$(9);word$(depSal$(i),3,",")

 

Department:D050

 

Department:D050;

 

Department:D101

 

Department:D190

 

Department:D202

 

Department:D202;

 

=={{header|Scala}}==

===Application idiomatic version===

import scala.language.implicitConversions

import scala.language.reflectiveCalls

 

val rawData = """Employee Name;Employee ID;Salary;Department

 

class Employee(name: String, id: String,

.map(_.toString).mkString("\t", "\n\t", ""))

}

<pre style="height:30ex;overflow:scroll">Reporting top 3 salaries in each department.

 

 

Department: D190 pop: 2 avg: 43450,00

Department: D050 pop: 2 avg: 34450,00

Department: D101 pop: 5 avg: 33980,00

Department: D202 pop: 4 avg: 28637,50

</pre>

===using SLICK ORM===

{{libheader|H2 Database Engine}} Version 1.3.1

import scala.slick.lifted.ProvenShape

 

plainQuery.foreach(println(_))

} // session

{{out}}

<pre style="height:30ex;overflow:scroll">Tot.15 Employees in 4 deps.Avg salary: 33336.67

E27002 David Motsinger 19250.00 3

</pre>

 

=={{header|Scheme}}==

{{works with|Gauche Scheme}}

 

;; This will let us treat a list as though it is a structure (record).

(for-each

(pa$ print-record col-widths)

<b>Testing:</b>

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

Tyler Bennett,E10297,32000,D101

John Rappl,E21437,47000,D050

}

print "\n"

{{out}}

<pre>

The following [[SMEQL]] example returns the top 6 earners in each department based on this table schema:

 

----------------

empID

dept

empName

Source Code:

top = group(srt, [(dept) dept2, max(order) order])

 

Note: Since SMEQL is a query language, it has no built-in I/O capability to prompt the user for the threshold number ("6" in this example). However, it would be possible to retrieve the threshold from another table, but would make the example a bit confusing. In practice, an application language would most likely pass the value to it as a parameter.

 

=={{header|SQL}}==

(

EMP_ID varchar2(6 char),

insert into EMP (EMP_ID, EMP_NAME, DEPT_ID, SALARY)

values ('E16400','Timothy Grive','D190',29900);

when 10 then

'Tot.' || LPAD(POPULATION, 2) || ' Employees in ' || TIE_COUNT ||

where EMP4.DEPT_ID = EMP3.DEPT_ID

and EMP4.SALARY >= EMP3.SALARY))

<pre style="height:30ex;overflow:scroll">Tot.15 employees in 4 deps.Avg salary: 33336.67

-

 

Since there is no requirement for the layout - using the data from the table above

SELECT emp_name

,dept_id

FROM ranked_emp

WHERE ranking <= 2

 

<pre style="height:30ex;overflow:scroll">

=={{header|Stata}}==

The following shows the top k salaries. If there are less than k employees in a department, this will print all salaries.

local k 2

 

=={{header|Swift}}==

 

var name: String

var id: String

 

print("\(dept)'s highest paid employees are: \n\t\(employeeString)")

 

{{out}}

 

<pre style="height:30ex;overflow:scroll">D050's highest paid employees are:

D101's highest paid employees are:

D202's highest paid employees are:

D190's highest paid employees are:

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

set text {Tyler Bennett,E10297,32000,D101

}

 

<pre style="height:30ex;overflow:scroll">Department D101

George Woltman E00127 53500

Kim Arlich E10001 57000

Timothy Grove E16398 29900</pre>

 

=={{header|TUSCRIPT}}==

MODE DATA

$$ SET dates=*

PRINT " "

ENDLOOP

<pre style='height:30ex;overflow:scroll'>

Department D050

Claire Buckman E39876 27800

David Motsinger E27002 19250

</pre>

 

The data is in a file, exactly as given in the problem. Parameter N is accepted from command line.

 

@{n-param}

@(next "top-rank-per-group.dat")

@ (end)

@ (end)

<pre style="height:30ex;overflow:scroll">Department: D101

George Woltman (E00127) $ 53500

Descend into argument list:

 

 

Collect first argument as <code>n-param</code> variable:

 

 

Drill into data file:

 

 

Match header exactly:

 

 

Now iterate over the data, requiring a variable called <code>record</code> to be bound in each iteration, and suppress all other variables from emerging. In the body of the collect, bind four variables. Then use these four variables to create a four-element list which is bound to the variable <code>record</code>. The <code>int-str</code> function converts the textual variable <code>salary</code> to an integer:

 

@name,@id,@salary,@dept

@(bind record (@(int-str salary) dept name id))

@(end)

 

Next, we bind five variables to the output of some TXR Lisp code, which will return five lists:

 

@(let* ((n (int-str n-param))

(dept-hash [group-by second record :equal-based])

(ranked (collect-each ((rec (hash-values dept-hash)))

[apply mapcar list [[sort rec > first] 0..n]])))

 

This code binds some successive variables. <code>n</code> is an integer conversion of the command line argument.

The reason for these transpositions is to convert the data into individual nested lists, once for each field. This is the format needed by the TXR <code>@(output)</code> clause:

 

@ (repeat)

Department: @dept

@ (end)

@ (end)

 

Here, all these variables are individual lists. The <code>dept</code> variable is a flat list; one nesting of <code>@(repeat)</code> iterates over it. The other variables are nested lists; a nested repeat drills into these.

The output is identical to the previous version.

 

@{n-param}

@(next "top-rank-per-group.dat")

(put-line `Department: @d`)

(each ((r dept-recs))

 

=={{header|Ursala}}==

sort each partition descending by the second to last, take the first

n strings in each partition, and display the list of them in a reasonably understandable form.

#import nat

 

#show+

 

<pre style="height:30ex;overflow:scroll">D190

Kim Arlich,E10001,57000

=={{header|VBA}}==

Creating an Excel pivot table to display the top n salaried employees per department. Data is read from a file.

Workbooks.OpenText filename:=filename, Comma:=True

Dim ws As Worksheet

Public Sub main()

top_rank filename:="D:\data.txt", n:=3

=={{header|zkl}}==

This reads a data file, the contents of which are as given by the task description (minus the header). To protect privacy, identifying information has been stripped from the output (aka laziness enhanced coding).

 

fcn topNsalaries(n){

"%s: %s".fmt(d,ss.concat(",")).println();

}

{{out}}

<pre>