Text processing/Max licenses in use: Difference between revisions

{{task|Text processing}}

Assume the software's licensing daemon faithfully records a checkout event when a copy of the software starts and a checkin event when the software finishes to its log file.

;Task:

Mirror of log file available as a zip [https://github.com/thundergnat/rc/blob/master/resouces/mlijobs.zip here] (offsite mirror).

<br><br>

=={{header|Ada}}==

<lang Ada>-- licenselist.adb --

end licenselist;</lang>

Output:

at these times

=={{header|ALGOL 68}}==

{{trans|C}} note: This specimen retains the original [http://rosettacode.org/mw/index.php?title=Text_processing%2F3&diff=87014&oldid=87011 C] coding style.

)</lang>

Output:

=={{header|APL}}==

mx ← (⎕IO+⍳⍴lu)/⍨lu= max ← ⌈/ lu

⎕ ← 'Maximum simultaneous license use is ' , ' at the following times:' ,⍨ ⍕max ⋄ ⎕←D[mx;]</lang>

2008/10/03_08:39:34

=={{Header|AutoHotkey}}==

{{trans|Python}}

UrlDownloadToFile, http://rosettacode.org/mlijobs.txt, mlijobs.txt

}

=={{header|AWK}}==

'''Sample output'''

On a 2.53MHz machine, these timings were obtained using GNU Awk 4.0.2:

END</lang>

'''Output:'''

=={{header|Bracmat}}==

<lang bracmat>( 0:?N:?n

& :?Ts

)

| out$(!N !Ts)

Output:

=={{header|C}}==

<lang c>#include <stdio.h>

#include <stdlib.h>

munmap(buf, s.st_size);

return close(fd);

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

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

using System.Collections.Generic;

using System.Linq;

}

}

=={{header|Clojure}}==

<lang clojure>(defn delta [entry]

(case (second (re-find #"\ (.*)\ @" entry))

(map println times))</lang>

=={{header|COBOL}}==

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

{{libheader|CL-PPCRE}}

<lang lisp>(defun max-licenses (&optional (logfile "mlijobs.txt"))

(with-open-file (log logfile :direction :input)

(push time max-log-times)))))))</lang>

2008/10/03_08:39:34

2008/10/03_08:40:40.

=={{header|D}}==

<lang d>void main() {

}</lang>

{{out}}

"2008/10/03_08:39:34"

=={{header|E}}==

{{trans|Python}}

<lang e>var out := 0

var maxOut := 0

}</lang>

=={{header|Eiffel}}==

APPLICATION

data: LIST [STRING]

{{out}}

=={{header|Erlang}}==

-export( [out_dates_from_file/1, task/0] ).

out_dates_n( N, <<"OUT">> ) -> N + 1;

{{out}}

=={{header|Euphoria}}==

printf(1, "%s\n", {maxtime[i]})

end for</lang>

Output:

=={{header|Factor}}==

Placing the file in resource:work/mlijobs.txt:

<lang factor>USING: kernel sequences splitting math accessors io.encodings.ascii

io.files math.parser io ;

=={{header|Forth}}==

create max-dates date-size 100 * allot

variable max-out

max-dates count type cr ;

== {{header|Fortran}} ==

{{Works with|Fortran|90 and later}}

IMPLICIT NONE

WRITE(*,"(A)") maxtime(1:maxcount)

Output

Maximum simultaneous license use is 99 at the following times:

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|Gema}}==

Start with ''gema -f licenses.gema mlijobs.txt''

License OUT \@ * *\n=@incr{count}@testmax{${count},*}

testmax:*,*=@cmpn{${max};$1;@set{max;$1};;}@append{times${count};$2\n}

Output:

=={{header|Go}}==

}</lang>

{{out}}

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|Groovy}}==

println "Maximum Licenses $max"

Output:

2008/10/03_08:39:34

2008/10/03_08:40:40

== {{header|Haskell}} ==

main = do

mo = maximum cio

putStrLn $ "Maximum simultaneous license use is " ++ show mo ++ " at:"

=={{header|HicEst}}==

We open Licenses.txt in [http://www.HicEst.com/MatrixExplorer.htm MatrixExplorer mode] with 3 columns: IN/OUT, date_time, ID_nr.

This allows to adress single file elements by Licenses(row, column).

And a run of the program:

2008/10/03_08:39:34

2008/10/03_08:40:40

== {{header|J}} ==

NB. Output results

(mx { D) ,~ 'Maximum simultaneous license use is ' , ' at the following times:' ,~ ": {. ,mx { lu</lang>

Maximum simultaneous license use is 99 at the following times:

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|Java}}==

}

}</lang>

=={{header|JavaScript}}==

output:

2008/10/03_08:39:34

=={{header|jq}}==

{{works with|jq|1.4}}

`0:,/"Maximum simultaneous license use is ",$x;

`0:" at the following times:\n";`0:r[;14+!19]</lang>

Output:

=={{header|Julia}}==

{{works with|Julia|0.6}}

{{trans|Python}}

<lang julia>function maximumsimultlicenses(io::IO)

out, maxout, maxtimes = 0, -1, String[]

println("Maximum simultaneous license use is $maxout at the following times: \n - ", join(maxtimes, "\n - "))

end</lang>

{{out}}

- 2008/10/03_08:39:34

=={{header|Kotlin}}==

println(dates.map { " $it" }.joinToString("\n"))

}</lang>

The file used for testing:

License OUT @ 2008/10/03_23:57:00 for job 4975

License IN @ 2008/10/04_00:00:06 for job 4975

License OUT @ 2008/10/04_00:07:19 for job 4976

License IN @ 2008/10/04_00:11:32 for job 4976

{{out}}

2008/10/03_23:57:00

2008/10/04_00:07:19

=={{header|Lua}}==

end</lang>

Output:

2008/10/03_08:39:34

=={{header|M4}}==

define(`current',0)

define(`max',0)

divert

max

Output:

@ 2008/10/03_08:39:34 @ 2008/10/03_08:40:40

=={{header|Mathematica}}==

Output:

=={{header|MAXScript}}==

licencesInUse()</lang>

Output

=={{header|Nim}}==

for i in maxTimes: echo " ",i</lang>

Output:

2008/10/03_08:39:34

=={{header|OCaml}}==

=={{header|Oz}}==

{{trans|Python}}

<lang oz>declare

fun {MaxLicenses Filename ?Times}

Output:

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

rec

};</lang>

=={{header|Perl}}==

print " $_\n" foreach @max_times;</lang>

Example output:

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|Perl 6}}==

Example output:

=={{header|Phix}}==

end for</lang>

{{out}}

=={{header|PHP}}==

echo $times[$i] . '<br>';

}</lang>

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

declare line character (80) varying;

declare (nout, max_nout) fixed;

free saveline;

end;

OUTPUT:

=={{header|PicoLisp}}==

{{trans|AWK}}

Put the following into an executable file "licenses":

<lang PicoLisp>#!/usr/bin/picolisp /usr/lib/picolisp/lib.l

(bye)</lang>

Then it can be called as

=={{header|PowerShell}}==

[int]$maxCount = 0

[datetime[]]$times = @()

StartTime = $times[0]

EndTime = $times[1]

{{Out}}

=={{header|PureBasic}}==

PrintN(#CRLF$+"Press ENTER to exit"): Input()

CloseConsole()</lang>

=={{header|Python}}==

print("Maximum simultaneous license use is %i at the following times:" % max_out)

print(' ' + '\n '.join(max_times))</lang>

{{out}}

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|R}}==

dfr <- read.table("mlijobs.txt")

dfr <- dfr[,c(2,4)]

when.most.checked.out <- times[which(n.checked.out==most.checked.out)]

# As a bonus, plot license use

=={{header|Racket}}==

(printf "Maximum licences in simultaneously used is ~a at the following times:~%"

max-used)

Output:

The following takes advantage of a combination of ''for/fold'' and ''(in-lines)'' (and is possible more in the Racket idiom, rather than just using ''(read-line)'' and ''(regexp-match)'':

end /*j*/ /*stick a fork in it, we're all done. */</lang>

'''output''' &nbsp; when using the default input file:

The maximum number of licenses out is 99 at:

2008/10/03_08:39:34 for job 1833

===Version 2 dual-coded for PC and TSO===

It should be noted that almost every REXX interpreter returns a different string for &nbsp; '''parse source''' &nbsp; under Microsoft Windows:

Return</lang>

{{out}} on Windows

WindowsNT COMMAND D:\maxl.rex

The maximum number of licences taken out = 99

Example output:

2008/10/03_08:39:34

2008/10/03_08:40:40

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

<lang lb>open "c:\data\temp\logFile.txt" for input as #f

wend

print maxCount;" ";theDate$</lang>

=={{header|Seed7}}==

end for;

end func;</lang>

Output:

=={{header|Sidef}}==

max_times.each {|t| " #{t}".say };</lang>

{{out}}

2008/10/03_08:39:34

2008/10/03_08:40:40

=={{header|Tcl}}==

{{trans|Python}}

<lang tcl> set out 0

set max_out -1

puts " $t"

}</lang>

Output matches Python

=={{header|TUSCRIPT}}==

joblog="mlijobs.txt",jobnrout=0

log=FILE (joblog)

times=SELECT (time,#maxlicout)

PRINT "The max. number of licences out is ", maxlicout

Output:

=={{header|Ursala}}==

Four functions are defined. Log lexes the log file, which can be accessed as a pre-declared constant without explicit I/O by being given as a compile-time command line parameter. Scan accumulates running totals of licenses in use. Search identifies the maxima, and format transforms the results to human readable form.

#import nat

main = format search scan log</lang>

output:

=={{header|Vedit macro language}}==

Reg_Type(10)

Output:

2008/10/03_08:39:34 for job 1833

=={{header|zkl}}==

" the following times:\n %s").fmt(maxOut,maxTimes.concat("\n")));</lang>

{{out}}

{{omit from|GUISS}}