Kernighans large earthquake problem: Difference between revisions
m
syntax highlighting fixup automation
Puppydrum64 (talk | contribs) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 21:
{{trans|Python}}
<
I Float(ln.split(‘ ’, group_delimiters' 1B)[2]) > 6
print(ln)</
{{out}}
Line 34:
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)
Line 149:
bra lineseek
.done:
RTS</
{{out}}
<pre>8/27/1883 Krakatoa 8.8
Line 164:
automatically.
<
puts: equ 9 ; CP/M syscall to print a string
fopen: equ 15 ; CP/M syscall to open a file
Line 230:
jmp 5
emsg: db 'Error!$'
line: equ $ ; Line buffer after program </
{{out}}
Line 252:
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<
BYTE FUNC FindFirstNonspace(CHAR ARRAY s BYTE start)
Line 314:
PrintRE(value) PutE()
Process(fname,value,1)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Kernighans_large_earthquake_problem.png Screenshot from Atari 8-bit computer]
Line 339:
=={{header|Ada}}==
<
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
Line 371:
end loop;
Close (Inpt_File);
end Main;</
The file data.txt contains a 0 length line as well as a line composed of only blanks.
<pre>
Line 391:
=={{header|ALGOL 68}}==
<
STRING file name = "data.txt";
open( input file, file name, stand in channel ) /= 0
Line 461:
# close the file #
close( input file )
FI</
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
/* Kernighans large earthquake problem. */
Line 491:
CEND
END
</syntaxhighlight>
{{out}}
<pre>
Line 534:
<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>
<syntaxhighlight lang="amazing hopper">
/* Kernighans large earthquake problem. */
Line 568:
CEND
END
</syntaxhighlight>
<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>
Line 581:
=={{header|AppleScript}}==
<
-- A local "owner" for the long AppleScript lists. Speeds up references to their items and properties.
script o
Line 616:
end kernighansEarthquakes
kernighansEarthquakes(6)</
===Functional===
Line 623:
while emphasising code reuse, and speed of writing and refactoring:
<
use framework "Foundation"
use scripting additions
Line 762:
set my text item delimiters to dlm
str
end unlines</
{{Out}}
<pre>Magnitudes above 6.0 in ~/Desktop/data.txt:
Line 775:
and the magnitude as an optional left argument (defaulting to 6).
<
⍺←6
nl←⎕UCS 13 10
Line 782:
keep←⍺{0::0 ⋄ ⍺ < ⍎3⊃(~⍵∊4↑⎕TC)⊆⍵}¨lines
↑keep/lines
}</
{{out}}
Line 799:
=={{header|Arturo}}==
<
3/13/2009 CostaRica 5.1
8/27/1883 Krakatoa 8.8
Line 808:
print first sort.descending.by:'magnitude map split.lines data =>
[to :earthquake split.words &]</
{{out}}
Line 815:
=={{header|AWK}}==
<
=={{header|Bash}}==
<
while read line
do
[[ ${line##* } =~ ^([7-9]|6\.0*[1-9]).*$ ]] && echo "$line"
done < data.txt</
{{out}}
Line 840:
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">
f = freefile
filename$ = "data.txt"
Line 852:
close f
end
</syntaxhighlight>
=={{header|C}}==
<
#include <string.h>
#include <stdlib.h>
Line 883:
if (line) free(line);
return 0;
}</
{{output}}
Line 895:
=={{header|C sharp}}==
<
using System.IO;
using System.Linq;
Line 913:
select parts;
}</
=={{header|C++}}==
<
#include <iostream>
#include <fstream>
Line 959:
return 0;
}</
New version:
<
#include <iostream>
#include <iomanip>
Line 984:
cout << endl << "Number of quakes greater than 6 is " << count_quake << endl;
return 0;
}</
=={{header|Cixl}}==
<
use: cx;
Line 995:
$m1 6 >= $m2 0 > and {[$time @@s $place @@s $mag] say} if
} for
</syntaxhighlight>
{{output}}
Line 1,007:
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.
<
*>
*> Kernighan large earthquake problem
Line 1,093:
.
end program quakes.</
{{output}}
Line 1,108:
A slighter shorter-version.
<
*> Tectonics: ./kerighan-earth-quakes <quakes.txt
identification division.
Line 1,140:
goback.
end program quakes.</
That cut would be used as <pre>prompt$ ./kernighans-large-earthquakes <quakes.txt</pre>
=={{header|Cowgol}}==
<
include "file.coh";
Line 1,226:
end if;
ForEachLine(&quakes, PrintIfGt6); </
{{out}}
Line 1,243:
=={{header|D}}==
{{trans|Kotlin}}
<
import std.regex : ctRegex, split;
import std.stdio : File, writeln;
Line 1,257:
}
}
}</
{{out}}
<pre>Those earthquakes with a magnitude > 6.0 are:
Line 1,264:
=={{header|Emacs Lisp}}==
<
(insert-file-contents "data.txt")
(goto-char (point-min))
Line 1,273:
(when (> (string-to-number magn) 6.0)
(message line)))
(forward-line 1)))</
=={{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
lines [ "\s" split last string>number 6 > ] filter .</
=={{header|FreeBASIC}}==
<
Dim As Long f
f = Freefile
Line 1,301:
Close #f
Sleep
</syntaxhighlight>
=={{header|Go}}==
<
import (
Line 1,336:
}
}
}</
{{out}}
Line 1,348:
=={{header|Groovy}}==
{{trans|Kotlin}}
<
class LargeEarthquake {
Line 1,361:
}
}
}</
{{out}}
<pre>Those earthquakes with a magnitude > 6.0 are:
Line 1,369:
=={{header|Haskell}}==
<
main :: IO ()
Line 1,378:
(\x ->
[ x
| 6 < (read (last (C.unpack <$> C.words x)) :: Float) ])</
{{Out}}
<pre>"8/27/1883 Krakatoa 8.8"
Line 1,384:
=={{header|J}}==
<syntaxhighlight lang="j">
NB. this program is designed for systems where the line ending is either LF or CRLF
Line 1,399:
(y <: magnitudes) # lines
)
</syntaxhighlight>
<pre>
Line 1,409:
=={{header|Java}}==
Input file contains sample data shown in the task
<syntaxhighlight lang="java">
import java.io.BufferedReader;
import java.io.FileReader;
Line 1,430:
}
</syntaxhighlight>
{{out}}
Line 1,440:
=={{header|JavaScript}}==
Input file contains sample data shown in the task. The code below uses Nodejs to read the file.
<syntaxhighlight lang="javascript">
const fs = require("fs");
const readline = require("readline");
Line 1,463:
}
});
</syntaxhighlight>
{{out}}
Line 1,487:
where data.txt is as for [[#Snobol|Snobol]].
<
| "The earthquakes from \(input_filename) with a magnitude greater than 6 are:\n",
( $one, inputs
Line 1,498:
| $line) catch "WARNING: column 3 is not a recognized number in the line:\n\($line)"
end )
</syntaxhighlight>
{{out}}
<pre>
Line 1,510:
=={{header|Julia}}==
Using the example data as a small text file.
<
df = CSV.File("kernighansproblem.txt", delim=" ", ignorerepeated=true,
Line 1,517:
println(filter(row -> row[:Magnitude] > 6, df))
</
2×3 DataFrame
│ Row │ Date │ Location │ Magnitude │
Line 1,527:
=={{header|Klingphix}}==
<
( [get nip]
Line 1,544:
$f fclose
"End " input</
=={{header|Kotlin}}==
<
import java.io.File
Line 1,557:
if (it.split(r)[2].toDouble() > 6.0) println(it)
}
}</
{{output}}
Line 1,570:
=={{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
end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Find_Magnitude {
data$={8/27/1883 Krakatoa 8.8
Line 1,599:
</syntaxhighlight>
Line 1,610:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
=={{header|Nim}}==
Here is one way to do that:
<
for line in "data.txt".lines:
Line 1,623:
if magnitude > 6:
echo line
# else wrong line: ignore.</
Here is another way with less checks:
<
for line in "data.txt".lines:
let magnitude = line.rsplit(' ', 1)[1]
if magnitude.parseFloat() > 6:
echo line</
{{out}}
Line 1,639:
=={{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>
Line 1,656:
<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>
Line 1,664:
=={{header|Phixmonti}}==
<
if
get nip
Line 1,685:
endif
endwhile
fclose</
=={{header|PHP}}==
Parse using PHP's fscanf().
<
// make sure filename was specified on command line
Line 1,706:
fclose( $fh );
</syntaxhighlight>
Usage: Specify file name on command line. Ex:
Line 1,718:
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">
(load "@lib/misc.l")
Line 1,727:
(prinl (align -10 Date) " " (align -15 Quake) " " Mag)))))
(bye)
</syntaxhighlight>
{{Out}}
<pre>
Line 1,737:
{{works with|SWI Prolog}}
Example command line: <code>swipl kernighans_earthquake.pl earthquake.txt</code>.
<
process_line(Line):-
Line 1,765:
main(_):-
swritef(Message, 'File argument is missing\n', []),
write(user_error, Message).</
{{out}}
Line 1,774:
=={{header|PureBasic}}==
<
PrintN("Those earthquakes with a magnitude > 6.0 are:")
While Not Eof(0)
Line 1,784:
CloseFile(0)
Input()
EndIf</
{{out}}
<pre>Those earthquakes with a magnitude > 6.0 are:
Line 1,792:
=={{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:
print(ln.strip())'</
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)
Line 1,838:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>[('8/27/1883', 'Krakatoa', '8.8'), ('5/18/1980', 'MountStHelens', '7.6')]</pre>
Line 1,848:
This is just a file filter, matching lines are printed out.
<
(with-input-from-file "data/large-earthquake.txt"
Line 1,854:
(for ((s (in-port read-line))
#:when (> (string->number (third (string-split s))) 6))
(displayln s))))</
Or, defining a list -> list function in terms of '''filter''':
<
; largeQuakes :: Int -> [String] -> [String]
Line 1,889:
; unlines :: [String] -> String
(define (unlines xs)
(string-join xs "\n"))</
{{out}}
Line 1,896:
To combine filtering with more pre-processing, we can use '''concatMap''' in place of '''filter''':
<
(require gregor) ; Date parsing
Line 1,935:
(define (readFile fp)
(file->string
(expand-user-path fp)))</
{{Out}}
<pre>(#<date 1883-08-27> "Krakatoa" 8.8)
Line 1,944:
{{works with|Rakudo|2018.03}}
Pass in a file name, or use default for demonstration purposes.
<syntaxhighlight lang="raku"
8/27/1883 Krakatoa 8.8
5/18/1980 MountStHelens 7.6
Line 1,950:
END
map { .say if .words[2] > 6 }, .lines;</
=={{header|REXX}}==
Line 1,959:
:::* the number of records that met the qualifying magnitude
:::* 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*/
Line 1,977:
say
if j==0 then say er 'file ' iFID " is empty or not found."
else say # ' earthquakes listed whose magnitude is ≥ ' mMag</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,993:
=={{header|Ring}}==
<
# Project : Kernighans large earthquake problem
Line 2,019:
ok
next
</syntaxhighlight>
Output:
<pre>
Line 2,054:
=={{header|Rust}}==
<
use std::io::{BufRead, BufReader};
Line 2,072:
Ok(())
}</
=={{header|Scala}}==
<
.map("\\s+".r.split(_))
.filter(_(2).toDouble > 6.0)
.map(_.mkString("\t"))
.foreach(println)</
=={{header|Snobol}}==
Line 2,085:
This is hard-coded to read the input from "data.txt".
<
num = '.0123456789'
Line 2,093:
err output = 'Error!'
end</
{{output}}
Line 2,113:
Expects the program to be started with the path to the data file.
<
guard let path = Array(CommandLine.arguments.dropFirst()).first else {
Line 2,131:
print(line)
}</
=={{header|Tcl}}==
Inspired by awk.
<
catch {wm withdraw .}
Line 2,151:
if {$f3 > 6} { puts "$line" }
}
close $fh </
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Module Module1
Line 2,172:
End Sub
End Module</
=={{header|Vlang}}==
<
fn main() {
lines := os.read_lines('data.txt')?
Line 2,186:
}
}
}</
{{out}}
Line 2,198:
=={{header|Wren}}==
{{libheader|Wren-pattern}}
<
import "os" for Process
import "/pattern" for Pattern
Line 2,213:
var mag = Num.fromString(data[2])
if (mag > 6) System.print(line)
}</
{{out}}
Line 2,225:
=={{header|XPL0}}==
Usage: quake <data.txt
<
[loop [OpenO(8); \get line from input file
repeat C:= ChIn(1);
Line 2,242:
];
];
]</
{{out}}
Line 2,260:
=={{header|Yabasic}}==
<
filename$ = peek$("argument")
else
Line 2,274:
if val(tok$(3)) > 6 print a$
wend
close a</
=={{header|zkl}}==
Line 2,280:
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"
Line 2,289:
"3/13/2009 CostaRica 5.1\n"
#<<<
));</
or
<
or
<
{{out}}
<pre>
|