Kernighans large earthquake problem: Difference between revisions

{{task}}

 

 

;Problem:

:# Or: Incorporate the file name into the program, (as it is assumed that the program is single use).

<br><br>

 

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

STRING file name = "data.txt";

open( input file, file name, stand in channel ) /= 0

# close the file #

close( input file )

 

=={{header|AppleScript}}==

 

-- A local "owner" for the long AppleScript lists. Speeds up references to their items and properties.

script o

end kernighansEarthquakes

 

 

===Functional===

while emphasising code reuse, and speed of writing and refactoring:

 

use framework "Foundation"

use scripting additions

set my text item delimiters to dlm

str

{{Out}}

<pre>Magnitudes above 6.0 in ~/Desktop/data.txt:

8/27/1883 Krakatoa 8.8

5/18/1980 MountStHelens 7.6</pre>

 

=={{header|AWK}}==

 

=={{header|C}}==

#include <string.h>

#include <stdlib.h>

if (line) free(line);

return 0;

 

{{output}}

 

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

using System.IO;

using System.Linq;

select parts;

 

 

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

#include <iostream>

#include <fstream>

 

return 0;

 

New version:

#include <iostream>

#include <iomanip>

cout << endl << "Number of quakes greater than 6 is " << count_quake << endl;

return 0;

 

=={{header|Cixl}}==

use: cx;

 

$m1 6 >= $m2 0 > and {[$time @@s $place @@s $mag] say} if

} for

 

{{output}}

First, with a data file. This adds a fair amount of verbosity to COBOL. For something this one-off, a simpler cut using ACCEPT from standard in is shown.

 

 

 

 

 

 

 

 

 

 

 

 

{{output}}

A slighter shorter-version.

 

*> Tectonics: ./kerighan-earth-quakes <quakes.txt

 

 

 

 

show-big-ones.

 

 

 

 

 

That cut would be used as <pre>prompt$ ./kernighans-large-earthquakes <quakes.txt</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

import std.regex : ctRegex, split;

import std.stdio : File, writeln;

}

}

{{out}}

<pre>Those earthquakes with a magnitude > 6.0 are:

 

=={{header|Emacs Lisp}}==

(while (not (eobp))

(let* ((line (buffer-substring (line-beginning-position)

(when (> (string-to-number magn) 6.0)

(message line)))

 

=={{header|Factor}}==

<code>lines</code> is a convenience word that reads lines from standard input. If you don't want to type them all in yourself, it is suggested that you give the program a file to read. For example, on the Windows command line: <code>factor kernighan.factor < earthquakes.txt</code>

IN: rosetta-code.kernighan

 

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Kotlin}}

 

class LargeEarthquake {

}

}

{{out}}

<pre>Those earthquakes with a magnitude > 6.0 are:

 

=={{header|Haskell}}==

 

main :: IO ()

(\x ->

[ x

{{Out}}

<pre>"8/27/1883 Krakatoa 8.8"

 

=={{header|J}}==

NB. this program is designed for systems where the line ending is either LF or CRLF

 

(y <: magnitudes) # lines

)

 

<pre>

=={{header|Java}}==

Input file contains sample data shown in the task

import java.io.BufferedReader;

import java.io.FileReader;

 

}

 

{{out}}

8/27/1883 Krakatoa 8.8

5/18/1980 MountStHelens 7.6

</pre>

 

=={{header|Julia}}==

Using the example data as a small text file.

 

df = CSV.File("kernighansproblem.txt", delim=" ", ignorerepeated=true,

 

println(filter(row -> row[:Magnitude] > 6, df))

2×3 DataFrame

│ Row │ Date │ Location │ Magnitude │

 

=={{header|Klingphix}}==

 

( [get nip]

$f fclose

 

 

=={{header|Kotlin}}==

 

import java.io.File

if (it.split(r)[2].toDouble() > 6.0) println(it)

}

 

{{output}}

=={{header|Lua}}==

For each line, the Lua pattern "%S+$" is used to capture between the final space character and the end of the line.

for line in io.lines(arg[1] or "data.txt") do -- use data.txt if arg[1] is nil

magnitude = line:match("%S+$")

if tonumber(magnitude) > 6 then print(line) end

 

=={{header|Perl}}==

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

if

get nip

endif

endwhile

 

=={{header|PHP}}==

Parse using PHP's fscanf().

 

// make sure filename was specified on command line

 

fclose( $fh );

 

Usage: Specify file name on command line. Ex:

 

=={{header|PicoLisp}}==

(load "@lib/misc.l")

 

(prinl (align -10 Date) " " (align -15 Quake) " " Mag)))))

(bye)

{{Out}}

<pre>

{{works with|SWI Prolog}}

Example command line: <code>swipl kernighans_earthquake.pl earthquake.txt</code>.

 

process_line(Line):-

main(_):-

swritef(Message, 'File argument is missing\n', []),

 

{{out}}

5/18/1980 MountStHelens 7.6

</pre>

 

=={{header|Python}}==

Typed into a bash shell or similar:

with open("data.txt") as f:

for ln in f:

if float(ln.strip().split()[2]) > 6:

 

 

Or, if scale permits a file slurp and a parse retained for further processing, we can combine the parse and filter with a concatMap abstraction:

 

from functools import (reduce)

from itertools import (chain)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>[('8/27/1883', 'Krakatoa', '8.8'), ('5/18/1980', 'MountStHelens', '7.6')]</pre>

This is just a file filter, matching lines are printed out.

 

 

(with-input-from-file "data/large-earthquake.txt"

(for ((s (in-port read-line))

#:when (> (string->number (third (string-split s))) 6))

 

 

Or, defining a list -> list function in terms of '''filter''':

 

; largeQuakes :: Int -> [String] -> [String]

; unlines :: [String] -> String

(define (unlines xs)

 

{{out}}

 

To combine filtering with more pre-processing, we can use '''concatMap''' in place of '''filter''':

 

(require gregor) ; Date parsing

(define (readFile fp)

(file->string

{{Out}}

<pre>(#<date 1883-08-27> "Krakatoa" 8.8)

{{works with|Rakudo|2018.03}}

Pass in a file name, or use default for demonstration purposes.

8/27/1883 Krakatoa 8.8

5/18/1980 MountStHelens 7.6

END

 

 

=={{header|REXX}}==

:::* &nbsp; the number of records that met the qualifying magnitude

:::* &nbsp; the qualifying magnitude

parse arg iFID mMag . /*obtain optional arguments from the CL*/

if iFID=='' | iFID=="," then iFID= 'earthquakes.dat' /*Not specified? Then use default*/

say

if j==0 then say er 'file ' iFID " is empty or not found."

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

<pre>

 

=={{header|Ring}}==

# Project : Kernighans large earthquake problem

 

ok

next

Output:

<pre>

 

=={{header|Rust}}==

use std::io::{BufRead, BufReader};

 

 

Ok(())

 

=={{header|Scala}}==

.map("\\s+".r.split(_))

.filter(_(2).toDouble > 6.0)

.map(_.mkString("\t"))

 

=={{header|Swift}}==

Expects the program to be started with the path to the data file.

 

 

guard let path = Array(CommandLine.arguments.dropFirst()).first else {

 

print(line)

 

=={{header|Tcl}}==

Inspired by awk.

catch {wm withdraw .}

 

if {$f3 > 6} { puts "$line" }

}

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

 

=={{header|Wren}}==

{{libheader|Wren-pattern}}

import "os" for Process

 

var args = Process.arguments

var mag = Num.fromString(data[2])

if (mag > 6) System.print(line)

 

{{out}}

8/27/1883 Krakatoa 8.8

5/18/1980 MountStHelens 7.6

</pre>

 

=={{header|Yabasic}}==

filename$ = peek$("argument")

else

if val(tok$(3)) > 6 print a$

wend

 

=={{header|zkl}}==

is bad practice so I don't do it (written so text is automatically

converted to float).

data.pump(out,fcn(line){ 6.0line.split()[-1] },Void.Filter)

#<<<

"8/27/1883 Krakatoa 8.8\n"

"3/13/2009 CostaRica 5.1\n"

#<<<

or

or

{{out}}

<pre>