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">

=={{header|Ada}}==

with Ada.Command_Line;

with Ada.Containers.Indefinite_Holders;

end loop;

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

using System.Collections.Generic;

}

}

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

=={{header|Go}}==

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

import (

}

}

{{out}}

<pre>

</pre>

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

import (

}

}

{{out}}

<pre>

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

Optimized for clarity and simplicity, not performance.

assumes two files containing sorted integers separated by newlines

let

stream1 = newFileStream("file1")

echo line

for line in stream2.lines:

===Merge N streams===

Of course, as Phix and Nim are very different languages, the code is quite different, but as Phix, we use a priority queue (which is provided by the standard module <code>heapqueue</code>. We work with files built from the “Data” constant, but we destroy them after usage. We have also put the whole merging code in an procedure.

type

# Clean-up: delete the files.

for name in Filenames:

{{out}}

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

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">pqueue</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">delete_file</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filenames</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>

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

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

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

=={{header|REXX}}==

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

=={{header|UNIX Shell}}==

{{libheader|Wren-seq}}

No Heap class, so we use a List. Comparisons are text based even for numbers.

import "/ioutil" for FileUtil

import "/str" for Str

// check it worked

System.print(File.read("merged2.txt"))

{{out}}

=={{header|zkl}}==

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>