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

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

 

=={{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>

top(2);

return 0;

<pre>D050 47000: John Rappl

D050 21900: Nathan Adams

=={{header|C sharp|C#}}==

 

using System.Collections.Generic;

using System.Linq;

}

}

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

Department: D101

 

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

#include <set>

#include <list>

 

return 0;

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

Name ID Salary Department

 

=={{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("Nathan Adams", "E41298", 21900, "D050")</pre>

 

 

 

"$\(this.salary) (name: \(this.name), id: \(this.id), department: \(this.department)"

}

Employee("Tyler Bennett","E10297",32000,"D101"),

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

Employee("Timothy Grove","E16398",29900,"D190")

]

func topNSalaries(n) {

//We sort employees based on salary

for i in 0..max {

yield employees[i]

}

}

print(e)

 

{{out}}

 

=={{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

{

string toPrintable()

.writePaddingRight(ID, 12)

.writePaddingRight(Salary.toPrintable(), 12)

}

{

topNPerDepartment(n)

{

^ new {

Employees

}

};

};

{

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] ).

[io:fwrite( "~p ~p: ~p~n", [Department, Salery, Name]) || #employee{department=Department, salery=Salery, name=Name} <- Highest_payeds],

io:nl().

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

 

CHARACTER*28 HEADING(4) !The first line is a header.

TYPE GRIST !But this is the stuff.

 

END !That was straightforward.

 

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 (

}

}

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

 

=={{header|IS-BASIC}}==

110 LET NR=100:LET X=0

120 STRING NAME$(1 TO NR)*20,ID$(1 TO NR)*6,DEPT$(1 TO NR)*4

580 IF J<=N THEN PRINT " ";NAME$(I);TAB(23);ID$(I),SALARY(I):LET J=J+1

590 NEXT

 

=={{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

 

===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" },

end

print ""

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

John Rappl E21437 47000

George Woltman E00127 53500

David McClellan E04242 41500</pre>

 

=={{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

Employee Id Salary

=={{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

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

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

 

=={{header|Phix}}==

{{Out}}

<pre>

 

=={{header|PHP}}==

Array("Tyler Bennett","E10297",32000,"D101"),

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

echo '</pre>';

}

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

Name ID Salary

David Motsinger E27002 19250

</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

 

=={{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 the dplyr package we can use group_by and top_n to select the top n records in each group.

 

library(dplyr)

dfr %>%

group_by(Department) %>%

top_n(2, Salary)

Provides:

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

 

=={{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)

This program also makes heavy use of method calls that start with dot. In Raku this means a method call on the current topic, <tt>$_</tt>, which is automatically set by any <tt>for</tt> or <tt>map</tt> construct that doesn't declare an explicit formal parameter on its closure.

 

E10297 32000 D101 Tyler Bennett

E21437 47000 D050 John Rappl

say .< Dept Id Salary Name > for @es[^$N]:v;

}

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

D050 E21437 47000 John Rappl

=={{header|REXX}}==

===version 1===

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

if topN=='' | topN=="," then topN= 1 /*Not specified? Then use the default.*/

dept.h= /*make sure we see the employee again. */

end /*topN*/

{{out|output|text=&nbsp; when using the input: &nbsp; &nbsp; <tt> 2 </tt>}}

<pre>

 

===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,",")

<pre style="height:30ex;overflow:scroll">Employee Name ID Salary

 

The implementation counts with ties.

 

struct Employee<S> {

// Allow S to be any suitable string representation

 

Ok(())

 

{{out}}

=={{header|Scala}}==

===Application idiomatic version===

import scala.language.implicitConversions

import scala.language.reflectiveCalls

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

}

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

 

===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

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

=={{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

Version using built-in database-like functionality.

 

 

MainModule: {

 

<pre>

[D101, E00127, George Woltman, 53500]

[D101, E04242, David McClellan, 41500]

[D202, E01234, Rich Holcomb, 49500]

[D202, E39876, Claire Buckman, 27800]

</pre>

 

Version using untyped vectors.

#lang transd

 

MainModule: {

 

N: 2,

curN: 0,

dep: String(),

 

 

 

(for i in res do (textout i "\n"))

}

<pre>

</pre>

 

=={{header|TUSCRIPT}}==

MODE DATA

$$ SET dates=*

PRINT " "

ENDLOOP

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

Department D050

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|Wren}}==

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

 

var Employee = Tuple.create("Employee", ["name", "id", "salary", "dept"])

topRanked.each { |e| Fmt.print("$-15s $s $d", e.name, e.id, e.salary) }

System.print()

 

{{out}}

Rich Holcomb E01234 49500

Claire Buckman E39876 27800

</pre>

 

=={{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>