Stream merge: Difference between revisions

=={{header|360 Assembly}}==

No usage of tricks such as forbiden records in the streams.

STRMERGE CSECT

USING STRMERGE,R13 base register

PG DS CL64

YREGS

{{in}}

<pre style="height:20ex">

Line 055

</pre>

 

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

NB, all the files (including the output files) must exist before running this. The output files are overwritten with the merged records.

PROC mergenf = ( []REF FILE inf, REF FILE out )VOID:

BEGIN

# test the file merge #

merge2( "in1.txt", "in2.txt", "out2.txt" );

{{out}}

<pre>

 

=={{header|ATS}}==

(* ****** ****** *)

//

//

} (* end of [main0] *)

 

=={{header|AWK}}==

# syntax: GAWK -f STREAM_MERGE.AWK filename(s) >output

# handles 1 .. N files

errors++

}

 

=={{header|C}}==

* Rosetta Code - stream merge in C.

*

return EXIT_SUCCESS;

}

 

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

using System.Collections.Generic;

using System.Linq;

 

}

}

 

}

}

}

 

 

Console.WriteLine();

Console.WriteLine();

}

}

{{out}}

<pre>1 2 4 5 7 8 10 11

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

{{trans|C#}}

#include <iostream>

#include <vector>

mergeN(display, { v3, v2, v1 });

std::cout << '\n';

{{out}}

<pre>0 1 3 4 6 7

 

=={{header|D}}==

import std.stdio;

 

}

} while (!done);

 

{{out}}

 

=={{header|Elixir}}==

def merge2(file1, file2), do: mergeN([file1, file2])

StreamMerge.merge2("temp1.dat", "temp2.dat")

IO.puts "\nN-stream merge:"

 

{{out}}

 

=={{header|Fortran}}==

INTEGER N !The number of input files.

INTEGER INF(*) !Their unit numbers.

CALL FILEMERGE(MANY,FI,F) !E pluribus unum.

 

Obviously, there would be variations according to the nature of the data streams being merged, and whatever sort key was involved. For this example, input from disc files will do and the sort key is the entire record's text. This means there is no need to worry over the case where, having written a record from stream S and obtained the next record from stream S, it proves to have equal precedence with the waiting record for some other stream. Which now should take precedence? With entirely-equal records it obviously doesn't matter but if the sort key is only partial then different record content could be deemed equal and then a choice has an effect.

 

 

The source for subroutine GRAB is within subroutine FILEMERGE for the convenience in sharing and messing with variables important to both, but not to outsiders. This facility is standard in Algol-following languages but often omitted and was not added to Fortran until F90. In its absence, either more parameters are required for the separate routines, or there will be messing with COMMON storage areas.

 

=={{header|Go}}==

'''Using standard library binary heap for mergeN:'''

 

import (

}

}

{{out}}

<pre>

</pre>

'''MergeN using package from [[Fibonacci heap]] task:'''

 

import (

}

}

{{out}}

<pre>

</pre>

 

 

There is no built-in iterator or stream type for file operations in Haskell. But several such libraries exist.

=== conduit ===

 

 

import Control.Monad.Trans.Resource (runResourceT)

runResourceT $ mergeSources inputs $$ sinkStdoutLn

where

 

See implementation in https://github.com/cblp/conduit-merge/blob/master/src/Data/Conduit/Merge.hs

=== pipes ===

 

 

import Pipes (runEffect, (>->))

sourceFileNames <- getArgs

let sources = map readFile sourceFileNames

 

See implementation in https://github.com/bgamari/pipes-interleave/blob/master/Pipes/Interleave.hs

 

=={{header|Java}}==

import java.util.List;

import java.util.Objects;

System.out.flush();

}

{{out}}

<pre>1245781011

{{trans|C}}

The IOStream type in Julia encompasses any data stream, including file I/O and TCP/IP. The IOBuffer used here maps a stream to a buffer in memory, and so allows an easy simulation of two streams without opening files.

function merge(stream1, stream2, T=Char)

if !eof(stream1) && !eof(stream2)

println("\nDone.")

 

abcdefghijklmnopqrstuvwyxz

Done.

=={{header|Kotlin}}==

Uses the same data as the REXX entry. As Kotlin lacks a Heap class, when merging N files, we use a nullable MutableList instead. All comparisons are text based even when the files contain nothing but numbers.

 

import java.io.File

println(File("merged2.txt").readText())

println(File("mergedN.txt").readText())

 

{{out}}

8

</pre>

 

=={{header|Perl}}==

We make use of an iterator interface which String::Tokenizer provides. Credit: we obtained all the sample text from http://www.lipsum.com/.

use warnings;

use English;

# At this point every iterator has been exhausted.

return;

{{out}}

<pre>Merge of 2 streams:

=={{header|Phix}}==

Using a priority queue

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let Heap

(make

(if (in (cdar Heap) (read))

(set (car Heap) @)

<pre>$ cat a

3 14 15

2 3 5 7</pre>

Test:

(streamMerge

(open "a")

(open "b")

(open "c")

'streamMerge' works with non-numeric data as well, and also - instead of calling

'open' on a file or named pipe - with the results of 'connect' or 'listen' (i.e.

sockets).

 

 

Built-in function <code>open</code> opens a file for reading and returns a line-by-line iterator (stream) over the file.

There exists a standard library function <code>heapq.merge</code> that takes any number of sorted stream iterators and merges them into one sorted iterator, using a [[heap]].

 

import sys

 

sources = sys.argv[1:]

for item in heapq.merge(open(source) for source in sources):

 

=={{header|Racket}}==

 

#lang racket/base

(require racket/stream)

'(1 2 3 4 5 6 7 8 9 10))

(check-equal? (for/list ((i (merge-sequences/< '(2 4 6 7 8 9 10) '(1 3 5)))) i)

 

{{out}}

monkey</pre>

 

===version 1===

* Merge 1.txt ... n.txt into all.txt

* 1.txt 2.txt 3.txt 4.txt

Return

 

{{out}}

<pre>1

 

No &nbsp; ''heap'' &nbsp; is needed to keep track of which record was written, nor needs replenishing from its input file.

@.=copies('ff'x, 1e4); call lineout 'ALL.TXT',,1 /*no value should be larger than this. */

do n=1 until @.n==@.; call rdr n; end /*read any number of appropriate files.*/

end /*forever*/ /*keep reading/merging until exhausted.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; is the same as the 1^st REXX version when using identical input files, &nbsp; except the output file is named &nbsp; '''ALL.TXT'''}} <br><br>

 

{{works with|Rakudo|2018.02}}

 

my @s = @streams.map({ hash( STREAM => $_, HEAD => .get ) })\

.grep({ .<HEAD>.defined });

}

 

 

=={{header|Ruby}}==

fio = files.map{|fname| open(fname)}

merge(fio.map{|io| [io, io.gets]})

puts "#{fname}: #{data}"

end

 

{{out}}

 

=={{header|Scala}}==

 

def merge2[A : Ordering](i1: Iterator[A], i2: Iterator[A]): Iterator[A] = {

nextHead ++ merge2Buffered(i1, i2)

}

 

Example usage, demonstrating lazyness:

 

val x = i * 3

println(s"generating $x")

val x = merged.next

println(s"output: $x")

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

var s = streams.map { |stream|

Pair(stream, stream.readline)

}

 

 

=={{header|Tcl}}==

A careful reader will notice that '''$peeks''' is treated alternately as a dictionary ('''dict set''', '''dict get''') and as a list ('''lsort''', '''lassign'''), exploiting the fact that dictionaries are simply lists of even length. For large dictionaries this would not be recommended, as it causes [https://wiki.tcl.tk/3033 "shimmering"], but in this example the impact is too small to matter.

 

proc merge {args} {

set peeks {}

 

merge {*}[lmap f $::argv {open $f r}]

 

 

sort --merge source1 source2 sourceN > sink

 

This solution uses iterators, doesn't care where the streams orginate and only keeps the head of the stream on hand.

streams:=vm.arglist.pump(List(),fcn(s){ // prime and prune

if( (w:=s.walker())._next() ) return(w);

v

}.fp(streams));

Using infinite streams:

{{out}}

<pre>

</pre>

Using files:

{{out}}

<pre>

</pre>

Using the above example to squirt the merged stream to a file:

{{out}}

<pre>