Skip to main content
100%

Split large file by number of lines

✓ Published0🌍 Public
WWilliamQLiu
Last edited Feb 8, 2015
Created on Feb 8, 2015

This example demonstrates how to split a large file into smaller, more manageable pieces by specifying a line count. It shows the command-line utility `split` dividing a source file into multiple output files, each containing exactly one million lines. The code uses the `-l` flag to set the line limit and a prefix (`data.`) to generate sequential filenames like `data.aa`, `data.ab`, and `data.ac`. The rendering approach is purely text-based, illustrating a shell command and its expected output files.

AI-generated description

Similar vizzes

Loading thumbnail…

Linux - Count number of lines in file

This example demonstrates how to count the number of lines in a file using the `wc -l` command, displaying the result directly in the terminal. The code runs `wc -l <myfile>` and prints the output, such as `4577465 myfile.csv`, showing both the line count and the filename. It relies solely on the standard Unix `wc` utility via a shell command, with no external visualization libraries or rendering APIs. The approach is a straightforward command-line operation, not a graphical data visualization, and the output is plain text rather than a chart or interactive graphic.

WWilliamQLiu
60% match
Loading thumbnail…

Gist e3718d6464d2ba18e5a08233edd0aeb1

This Perl script splits a multi-sequence FASTA file into individual FASTA files, one per sequence. It reads the input file line by line, opens a new output file whenever a header line starting with `>` is encountered, and writes the header and subsequent sequence lines to that file. The code uses the `open`, `close`, and `shift` built-in functions to manage up to 248 output files named `CEG0.fasta` through `CEG247.fasta`. The script demonstrates a simple file-parsing and output-splitting workflow for bioinformatics sequence data.

NNpfn
55% match
Loading thumbnail…

Windows equivalent of head, pipe, write to file

This example demonstrates a PowerShell command that reads the first 10,000 lines of a CSV file named `load_me.csv` and writes them to a new file called `test.csv`. It shows how to truncate a large dataset for quick inspection or further processing. The code uses the `Get-Content` cmdlet with the `-TotalCount` parameter to limit the line count, and pipes the output through `Out-File` to save the result. This approach provides a lightweight, command-line method for sampling data before loading it into a visualization tool.

WWilliamQLiu
53% match
Loading thumbnail…

Gist f919aa6a77ff3feb4d8a6d77af5dee85

This example computes the number and length distribution of contiguous sequences from a FASTA file, then writes the results to a tab-delimited text file. It uses Perl’s `Math::Complex` module for mathematical operations, though only basic arithmetic appears. The script reads `gapCloserMinia.break.broken_assembly.fasta`, tracks sequence lengths via regex matching for `[ACTGN]+` lines, and outputs a numbered list of contig sizes, along with the mean and standard deviation. The visualization shows a histogram or table of contig lengths, derived directly from the computed file `tailles_contigues.txt`. There is no graphical rendering; the output is purely textual.

NNpfn
52% match
Loading thumbnail…

Gist 776981b42d618f2717fb986bbf501186

This example counts the number of sequences in a FASTA file, displaying the total as a plain numeric output. It reads the file line by line and increments a counter whenever a line begins with the `>` character, which marks a new sequence header. The tool is a Perl script that relies on the standard Perl file-handling and regular-expression capabilities rather than any external visualization library. The output is a single integer representing the number of contigs, scaffolds, or genes, depending on the input file's content. The approach is purely computational, with no graphical rendering involved.

NNpfn
51% match
Loading thumbnail…

Need to split PDF every n pages, do it with pdftk

This visualization demonstrates a shell script that splits a multi-page PDF into separate files containing a fixed number of pages each, using the `pdftk` command-line tool. It shows the workflow for processing `layout_atlas_multipage.pdf`, splitting it into two-page chunks, and naming each output file with a zero-padded counter (e.g., `_0000`, `_0001`). The script first extracts the total page count via `pdfinfo` and `awk`, then calculates the number of output files using integer division, and finally iterates through page ranges with a `while` loop, calling `pdftk` to extract each chunk. The approach relies entirely on Unix shell utilities and `pdftk`, with no graphical or web-based rendering involved.

TThomasG77
51% match
Loading thumbnail…

Add , to end of each line

This example shows a simple command-line text-processing workflow that appends a comma to the end of every line in a CSV file. The code uses the Unix stream editor `sed` with the substitution expression `s/$/,/g` to insert a comma at each line’s end, then redirects the output to a new file. It demonstrates a lightweight, scriptable approach for formatting tabular data without a visualization library, relying instead on standard shell tools. The data source is the input CSV file, and the rendering approach is plain text output rather than graphical display.

WWilliamQLiu
50% match
Loading thumbnail…

Remove first line of a csv file with 'sed'

This example demonstrates how to remove the first line of a CSV file using the `sed` command-line utility. The code shows two separate commands: `sed -i '1d' file.csv` deletes the first line, while `sed -i '2d' file.csv` removes the second line. Both commands modify the file in place with the `-i` flag, and the `d` command specifies which line number to delete. The data source is a generic CSV file named `file.csv`.

WWilliamQLiu
50% match