Kernighans large earthquake problem: Difference between revisions

{{task}}

 

 

;Problem:

{{trans|Python}}

 

I Float(ln.split(‘ ’, group_delimiters' 1B)[2]) > 6

 

{{out}}

I'm going to make the assumption that all magnitudes are given as floating points rounded to one decimal place, e.g. "6.0" when the magnitude is exactly 6. That way I don't need to actually use floating point logic. The hardware print routines were omitted to keep things short, since the Sega Genesis doesn't have a built-in kernel and so I'd have to manually write to the video chip. Chances are you're not interested in seeing all that fluff when you'd rather look at the actual algorithm for the task.

 

macro pushRegs 1

MOVEM.L \1,-(SP)

endm

;---------------------------------------------------------------------------

 

;Ram Variables

bra lineseek

.done:

{{out}}

<pre>8/27/1883 Krakatoa 8.8

5/18/1980 MountStHelens 7.6</pre>

 

=={{header|8080 Assembly}}==

automatically.

 

puts: equ 9 ; CP/M syscall to print a string

fopen: equ 15 ; CP/M syscall to open a file

jmp 5

emsg: db 'Error!$'

 

{{out}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

BYTE FUNC FindFirstNonspace(CHAR ARRAY s BYTE start)

PrintRE(value) PutE()

Process(fname,value,1)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Kernighans_large_earthquake_problem.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

end loop;

Close (Inpt_File);

The file data.txt contains a 0 length line as well as a line composed of only blanks.

<pre>

 

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

STRING file name = "data.txt";

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

# close the file #

close( input file )

 

=={{header|Amazing Hopper}}==

/* Kernighans large earthquake problem. */

 

CEND

END

{{out}}

<pre>

<p>On the other hand, HOPPER processes dates in DD/MM/YYYY format, and the file records dates in MM/DD/YYYY format: therefore, it is necessary to exchange "DD" for "MM", because HOPPER does not allow other types of format for "dates".</p>

<p>The final program would be as follows:</p>

/* Kernighans large earthquake problem. */

 

CEND

END

<p>And this is fast!</p>

<p>If you want to print the original dates, just add the line "Swap Day By Month(1,2)" before printing the result. In this case, the results are printed with the dates changed.</p>

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

and the magnitude as an optional left argument (defaulting to 6).

 

⍺←6

nl←⎕UCS 13 10

keep←⍺{0::0 ⋄ ⍺ < ⍎3⊃(~⍵∊4↑⎕TC)⊆⍵}¨lines

↑keep/lines

 

{{out}}

=={{header|Arturo}}==

 

3/13/2009 CostaRica 5.1

8/27/1883 Krakatoa 8.8

 

print first sort.descending.by:'magnitude map split.lines data =>

 

{{out}}

 

=={{header|AWK}}==

 

=={{header|Bash}}==

while read line

do

[[ ${line##* } =~ ^([7-9]|6\.0*[1-9]).*$ ]] && echo "$line"

 

{{out}}

 

=={{header|BASIC256}}==

f = freefile

filename$ = "data.txt"

close f

end

 

 

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

include "file.coh";

 

end if;

 

 

{{out}}

5/18/1980 MountStHelens 7.6

1/25/4567 EdgeCase3 6.1</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}}==

(insert-file-contents "data.txt")

(goto-char (point-min))

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

Dim As Long f

f = Freefile

Close #f

Sleep

 

 

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

=={{header|JavaScript}}==

Input file contains sample data shown in the task. The code below uses Nodejs to read the file.

const fs = require("fs");

const readline = require("readline");

}

});

 

{{out}}

where data.txt is as for [[#Snobol|Snobol]].

 

| "The earthquakes from \(input_filename) with a magnitude greater than 6 are:\n",

( $one, inputs

| $line) catch "WARNING: column 3 is not a recognized number in the line:\n\($line)"

end )

{{out}}

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

Module Find_Magnitude {

data$={8/27/1883 Krakatoa 8.8

 

 

 

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|Nim}}==

Here is one way to do that:

 

 

for line in "data.txt".lines:

if magnitude > 6:

echo line

 

Here is another way with less checks:

 

 

for line in "data.txt".lines:

let magnitude = line.rsplit(' ', 1)[1]

if magnitude.parseFloat() > 6:

 

{{out}}

 

=={{header|Perl}}==

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">filename</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"data.txt"</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

 

=={{header|PureBasic}}==

PrintN("Those earthquakes with a magnitude > 6.0 are:")

While Not Eof(0)

CloseFile(0)

Input()

{{out}}

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

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

This is hard-coded to read the input from "data.txt".

 

num = '.0123456789'

 

 

err output = 'Error!'

 

{{output}}

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

 

 

fn main() {

lines := os.read_lines('data.txt')?

}

}

 

{{out}}

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

=={{header|XPL0}}==

Usage: quake <data.txt

[loop [OpenO(8); \get line from input file

repeat C:= ChIn(1);

];

];

 

{{out}}

 

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