Text processing/Max licenses in use: Difference between revisions

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

-- run under GPS 4.3-5 (Sidux/Debian)

-- process rosetta.org text_processing/3 example

-- to record the time of max OUT licenses

 

outcnt, maxoutcnt : integer := 0;

infilename : string := "license.log";

if outcnt > maxoutcnt then

maxoutcnt := outcnt;

licenselog.clear; -- reset list for new time(s)

licenselog.append (logtime); -- put current time into list

trace_times;

close ( infile );

Output:

<pre>

[2010-06-06 01:06:07] process terminated successfully (elapsed time: 00.25s)

</pre>

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

 

MODE TIME = [19]CHAR;

FI;

exit main error: SKIP

Output:

<pre>

=={{header|APL}}==

{{works with|APL2}}{{trans|J}}

I ← TXT[;8+⎕IO]

D ← TXT[;⎕IO+14+⍳19]

lu ← +\ ¯1 * 'OI' ⍳ I

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

2008/10/03_08:39:34

 

{{trans|Python}}

IfNotExist, mlijobs.txt

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

 

MsgBox Maximum use is %max_out% at:`n`n%max_times%

<pre>

Maximum use is 99 at:

=={{header|AWK}}==

to be called with ''awk -f licenses.awk ./mlijobs.txt''

count = count + 1

time = $4

}

$2=="IN" { count = count - 1 }

 

'''Sample output'''

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

 

 

=={{header|BBC BASIC}}==

nlicence% = 0

file% = OPENIN("mlijobs.txt")

PRINT "Maximum licences checked out = " ; max%

PRINT "From " start$ " to " finish$

'''Output:'''

<pre>

=={{header|Bracmat}}==

 

& :?Ts

& @( get$("mlijobs.txt",STR)

| out$(!N !Ts)

);

Output:

<pre>99 2008/10/03_08:39:34 2008/10/03_08:40:40</pre>

=={{header|C}}==

 

#include <stdlib.h>

#include <string.h>

if ( l_out == maxout ) {

if ( maxcount < MAX_MAXOUT ) {

} else {

}

}

if ( in != stdin ) fclose(in);

exit(0);

 

#include <unistd.h>

#include <fcntl.h>

int main()

{

 

 

 

}

 

 

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

using System;

using System.Collections.Generic;

}

}

<pre>

99

2008/10/03_08:40:40

</pre>

 

=={{header|Clojure}}==

 

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

"IN " -1

(keep-indexed #(when (= m %2) %1) in-use))]

(println "Maximum simultaneous license use is" m "at the following times:")

 

<pre>

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. max-licenses-in-use.

 

 

GOBACK

 

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

{{libheader|CL-PPCRE}}

 

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

(do ((current-logs 0) (max-logs 0) (max-log-times '())

max-log-times (list time)))

((= current-logs max-logs)

 

<pre>> (max-licenses)

 

=={{header|D}}==

import std.stdio;

int nOut, maxOut = -1;

writefln("Maximum simultaneous license use is %d at" ~

" the following times:\n%( %s\n%)", maxOut, maxTimes);

{{out}}

<pre>Maximum simultaneous license use is 99 at the following times:

{{trans|Python}}

 

var maxOut := 0

var maxTimes := []

for time in maxTimes {

println(` $time`)

=={{header|Eiffel}}==

class

 

create

 

feature

 

 

 

feature {NONE}

 

 

 

end

{{out}}

<pre>

 

=={{header|Erlang}}==

-module( text_processing_max_licenses ).

 

 

out_dates_from_file( Name ) ->

 

task() ->

out_dates( <<>>, Acc ) -> Acc;

out_dates( Line, {N, Date, Dict} ) ->

 

out_dates_dict( N, New_n, Date, Dict ) when N > New_n -> dict:append( N, Date, Dict );

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

out_dates_n( N, <<"IN">> ) -> N - 1.

{{out}}

<pre>

 

=={{header|Euphoria}}==

sequence out

integer first, delim

for i = 1 to length(maxtime) do

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

 

Output:

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

 

io.files math.parser io ;

IN: maxlicenses

number>string write

" at the following times: " print

 

Maximum simultaneous license use is 99 at the following times:

2008/10/03_08:39:34

2008/10/03_08:40:40

 

=={{header|Forth}}==

20 constant date-size

create max-dates date-size 100 * allot

 

main bye

 

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

 

PROGRAM MAX_LICENSES

IMPLICIT NONE

END PROGRAM MAX_LICENSES

Output

<pre>

2008/10/03_08:40:40

</pre>

=={{header|Gema}}==

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

@set{count;0};@set{max;0}

 

 

report:*,*=Maximum simultaneous license use is * at\n*

Output:

<pre>

 

=={{header|Go}}==

 

import (

)

 

const (

)

 

func main() {

 

 

{{out}}

<pre>

 

=={{header|Groovy}}==

def dates = []

def licenses = [:]

println "Maximum Licenses $max"

dates.each { date -> println " $date" }

Output:

<pre>

</pre>

 

import Data.List

 

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

mapM_ (putStrLn . (dt!!)) . elemIndices mo $ cio

 

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

REAL :: counts(1), Top10(10)

 

ENDDO

 

<pre>99 2008/10/03_08:40:40

99 2008/10/03_08:39:34

 

The following solution works in both languages:

maxCount := count := 0

 

write("There were ",maxCount," licenses out at:")

every write("\t",!maxTime)

 

And a run of the program:

 

 

'I D' =: (8 ; 14+i.19) {"1 &.> <'m' fread 'licenses.txt' NB. read file as matrix, select columns

lu =: +/\ _1 ^ 'OI' i. I NB. Number of licenses in use at any given time

 

NB. Output results

<pre>

Maximum simultaneous license use is 99 at the following times:

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.io.FileNotFoundException;

import java.io.FileReader;

System.out.println("At time(s): "+dates);

}

<pre>Max licenses out: 99

At time(s): [2008/10/03_08:39:34, 2008/10/03_08:40:40]</pre>

=={{header|JavaScript}}==

{{works with|JScript}} for the file i/o

var fh = file_system.openTextFile('mlijobs.txt', 1); // 1 == open for reading

var in_use = 0, max_in_use = -1, max_in_use_at = [];

fh.close();

 

 

output:

2008/10/03_08:39:34

2008/10/03_08:40:40</pre>

=={{header|jq}}==

{{works with|jq|1.4}}

def max_licenses_in_use:

# state: [in_use = 0, max_in_use = -1, max_in_use_at = [] ]

 

# The file is read in as a single string and so must be split at newlines:

{{Out}}

$ time /usr/local/bin/jq -M -R -r -s -f Max_licences_in_use.jq mlijobs.txt

2008/10/03_08:40:40

 

=={{header|Julia}}==

{{trans|Python}}

 

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

for job in readlines(io)

let (maxout, maxtimes) = open(maximumsimultlicenses, "data/mlijobs.txt")

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

 

{{out}}

- 2008/10/03_08:39:34

- 2008/10/03_08:40:40</pre>

 

=={{header|Kotlin}}==

The link for downloading the file, mlijobs.txt, is currently broken so I've created a small file myself to test the program:

 

import java.io.File

println("Maximum simultaneous license use is $maxLicenses at the following time(s):")

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

 

The file used for testing:

 

=={{header|Lua}}==

filename = "mlijobs.txt"

io.input( filename )

for i = 1, #occurr_dates do

print( "", occurr_dates[i] )

Output:

<pre>Maximum licenses in use: 99

Occurrences:

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

Load.Doc load txt in any format of UTF-16LE, UTF16-BE, UTF-8, ANSI, in any line separator CRLF, CR, LF and place text in paragraphs in a document object. A document object return a string containing text (as utf16le using CRLF), but for some specific functions and statements treated as object. So changing paragraphs done with Paragraph$(a$, (m)) where m is by reference with a special syntax for this function (using without m we place order number, but m is a valid paragraph id, which always point to same paragraph until removing it).

 

Module Checkit {

Document a$, max_time$

}

Checkit

Output

<pre>Maximum simultaneous license use is 99 at the following times:

 

=={{header|M4}}==

divert(-1)

define(`current',0)

max

undivert(1)

 

Output:

</pre>

 

If[MemberQ[#, "OUT"], LC++;

If[LCMax < LC, LCMax = LC; LCMaxtimes = {};];

If[LCMax == LC, AppendTo[LCMaxtimes, #[[4]]]],

LC--;] &, Import["mlijobs.txt", "Table"]]

<pre>-> The maximum number of licenses used was 99, at {2008/10/03_08:39:34,2008/10/03_08:40:40}</pre>

 

=={{header|MAXScript}}==

(

local logFile = openFile "mlijobs.txt"

local maxOut = -1

local maxTimes = #()

while not EOF logFile do

(

)

 

Output

<pre>Maximum simultaneous license use is 99 at the following times:

=={{header|Nim}}==

{{trans|Python}}

 

var

if curOut > maxOut:

maxOut = curOut

if curOut == maxOut:

maxTimes.add job.split[3]

 

<pre>Maximum simultaneous license use is 99 at the following times:

2008/10/03_08:39:34

=={{header|OCaml}}==

 

let out = ref 0 in

let max_out = ref(-1) in

at the following times:\n" !max_out;

List.iter print_endline !max_times;

 

=={{header|Oz}}==

{{trans|Python}}

 

fun {MaxLicenses Filename ?Times}

InUse = {NewCell 0}

for Job in {ReadLines Filename} do

case {List.take Job 11} of "License OUT" then

[] "License IN " then

end

end

{System.showInfo

"Maximum simultaneous license use is "#MaxInUse#" at the following times:"}

 

Output:

 

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

<pre>["2008/10/03_08:39:34", "2008/10/03_08:40:40"]

%1 = 99</pre>

 

=={{header|Perl}}==

use strict;

 

 

print "Maximum simultaneous license use is $max_out at the following times:\n";

Example output:

<pre>Maximum simultaneous license use is 99 at the following times:

2008/10/03_08:39:34

2008/10/03_08:40:40

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

2008/10/03_08:40:40

</pre>

 

=={{header|PHP}}==

$maxcount = 0;

$count = 0;

$buffer = fgets($handle);

$op = trim(substr($buffer,8,3));

}

fclose ($handle);

echo $maxcount . '<br>';

for($i=0;$i<count($times);$i++){

<pre>

99

2008/10/03_08:40:40

</pre>

 

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

text3: procedure options (main); /* 19 November 2011 */

declare line character (80) varying;

end;

end text3;

OUTPUT:

<pre>

It occurred at 2008/10/03_08:39:34 for job 1833

</pre>

 

=={{header|PowerShell}}==

[int]$count = 0

[int]$maxCount = 0

EndTime = $times[1]

}

{{Out}}

<pre>

 

=={{header|PureBasic}}==

 

If ReadFile(0, OpenFileRequester("Text processing/3","mlijobs.txt","All files",1))

 

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

<pre>

99 license(s) used at ;

 

=={{header|Python}}==

for job in open('mlijobs.txt'):

out += 1 if "OUT" in job else -1

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

 

{{out}}

 

=={{header|R}}==

# Read in data, discard useless bits

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

# As a bonus, plot license use

plot(times, n.checked.out, type="s")

 

=={{header|Racket}}==

;;; reads a licence file on standard input

;;; returns max licences used and list of times this occurred

max-used)

(for-each displayln max-used-when)

Output:

<pre>Maximum licences in simultaneously used is 99 at the following times:

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)'':

 

;;; reads a licence file on standard input

;;; returns max licences used and list of times this occurred

(define-values (max-used max-used-when) (with-input-from-file "mlijobs.txt" count-licences))

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

(Same output)

 

=={{header|REXX}}==

===version 1===

iFID= 'LICENSE.LOG' /*the fileID of the input file. */

high=0 /*highest number of licenses (so far). */

do j=1 for n /*show what/when max licenses occurred.*/

say left('',20) job.j /*indent the information displayed. */

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

<pre>

<br>I am sure it has worked for Regina.

Maybe this is now correct for all the WIN (and xxDOS) situations (pun intended)

* 19.11.2012 Walter Pachl transcribed from PL/I

* and dual-coded (for PC (Windows) and TSO)

store.z=line

store.0=z

{{out}} on Windows

<pre>

 

=={{header|Ruby}}==

max_out = -1

max_times = []

puts "Maximum simultaneous license use is #{max_out} at the following times:"

 

Example output:

2008/10/03_08:40:40

</pre>

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

while not(eof(#f))

line input #f, a$

if count = maxCount then theDate$ = theDate$ + " | " + word$(a$,4," ") + " Job:";word$(a$,7," ")

wend

 

=={{header|Scala}}==

===Translated imperative version===

Can be seen running in your browser [https://scastie.scala-lang.org/a31Q3P5gQ36VcAre5i4I7g Scastie (remote JVM)].

import java.net.URL

 

println("At time(s): " + dates.mkString(", "))

 

 

===Smart Imperative Scala with dirty side effects===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/2bdByPOUSICgRIMx4KJ29A Scastie (remote JVM)].

 

object License1 extends App {

println("At time(s): " + dates.mkString(", "))

 

===Clean coded [[functional_programming|FP]] with (tail) recursion, no side effects===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/MvwfLtnFTcqBoNHwB4aURg Scastie (remote JVM)].

 

object License2 extends App {

println("At time(s): " + dates.mkString(", "))

 

===Totally [[functional_programming|FP]] with foldLeft===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/h8CgsFx8TJGtRy1B5KVSOg Scastie (remote JVM)].

type resultTuple = (Int /*max*/, Int /*count*/, List[String] /*dates*/ )

 

println("At time(s): " + dates.mkString(", "))

 

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(eventTime);

end for;

 

Output:

=={{header|Sidef}}==

{{trans|Perl}}

var max_out = -1

var max_times = []

 

say "Maximum simultaneous license use is #{max_out} at the following times:"

{{out}}

<pre>

{{trans|Python}}

 

set max_out -1

set max_times {}

foreach t $max_times {

puts " $t"

 

Output matches Python

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

joblog="mlijobs.txt",jobnrout=0

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

PRINT "at these times: ", times

Output:

<pre>

The max. number of licences out is 99

at these times: 2008/10/03_08:39:34 2008/10/03_08:40:40

</pre>

 

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 std

#import nat

#show+

 

output:

<pre>99 licenses in use at

 

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

File_Open("|(PATH_ONLY)\data\mlijobs.txt", BROWSE)

 

 

Buf_Quit(OK)

 

Output:

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

2008/10/03_08:40:40 for job 1837

</pre>

 

{{trans|D}}

The referenced log file is no longer available, so, using the example log:

foreach job in (File("mlijobs.txt")){

_,status,_,date:=job.split();

}

println(("Maximum simultaneous license use is %d at"

{{out}}

<pre>