Align columns: Difference between revisions

=={{header|11l}}==

{{trans|D}}

are$delineated$by$a$single$'dollar'$character,$write$a$program

that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$

 

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

ALICOL CSECT

USING ALICOL,R13 base register

 

=={{header|8th}}==

quote | Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program alignColumn64.s */

</pre>

=={{header|ABAP}}==

start-of-selection.

 

=={{header|Action!}}==

Atari 8-bit computer is able to show only 40 characters per line. The user has to press left/right arrow keys to scroll the content of whole text.

DEFINE COLUMNS_COUNT="20"

DEFINE WORDS_COUNT="100"

=={{header|Ada}}==

{{libheader|Simple components for Ada}}

with Ada.Text_IO; use Ada.Text_IO;

with Strings_Edit; use Strings_Edit;

 

=={{header|Aime}}==

file f;

text n, t;

 

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

STRING text in list := "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"+nl+

"are$delineated$by$a$single$'dollar'$character,$write$a$program"+nl+

 

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

#define IGet(__N__,__X__) [__N__]SGet(__X__)

 

 

{{trans|JavaScript}}

 

property pstrLines : ¬

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program alignColumn.s */

</pre>

=={{header|Arturo}}==

Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

=={{header|AutoHotkey}}==

 

Text =

( LTrim

 

=={{header|AutoIt}}==

; == If the given text is in an file, it will read with:

#include <File.au3>

 

=={{header|AWK}}==

# syntax: GAWK -f ALIGN_COLUMNS.AWK ALIGN_COLUMNS.TXT

BEGIN {

 

=={{header|BaCon}}==

DECLARE in$[] = { "Given$a$text$file$of$many$lines,$where$fields$within$a$line$", \

"are$delineated$by$a$single$'dollar'$character,$write$a$program", \

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

DATA "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"

DATA "are$delineated$by$a$single$'dollar'$character,$write$a$program"

 

==={{header|Commodore BASIC}}===

20 rem print words in columns

30 rem commodore basic 2.0

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

mode con cols=103

 

=={{header|Beads}}==

const

=={{header|BQN}}==

A function which returns a rectangular 2D array which represents the lines.

PadRow ← {

w‿t𝕊𝕩: # t → type.

 

1 Align text</syntaxhighlight>

╵" Given a text file of many lines, where fields within a line

are delineated by a single 'dollar' character, write a program

{{works with|C sharp|C#|2+}}

 

class ColumnAlignerProgram

{

 

{{works with|C sharp|C#|8+}}

using System.Linq;

 

 

=={{header|Clojure}}==

(ns rosettacode.align-columns

(:require [clojure.contrib.string :as str]))

 

=={{header|COBOL}}==

identification division.

program-id. AlignColumns.

</syntaxhighlight>

{{out}}

------------------------------------------------------------------------------------------------------------------------

Given a text file of many lines, where fields within a line

 

=={{header|CoffeeScript}}==

pad = (n) ->

s = ''

</syntaxhighlight>

{{out}}

> coffee align_columns.coffee

 

 

=={{header|Common Lisp}}==

(position-if (lambda (x) (declare (ignore x)) t) seq))

 

 

=={{header|D}}==

import std.stdio, std.string, std.algorithm, std.range, std.typetuple;

 

=={{header|Delphi}}==

{{libheader|Delphi StdCtrls, Classes, SysUtils, StrUtils, Contnrs}}

USES

StdCtrls, Classes, SysUtils, StrUtils, Contnrs;

=={{header|E}}==

 

 

def left(width, word) {

}</syntaxhighlight>

 

are$delineated$by$a$single$'dollar'$character,$write$a$program

that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$

The String module of Elixir doesn't have the function of the center position adjusting.

It calls and processes the function of 'Erlang'.

def columns(text, alignment) do

fieldsbyrow = String.split(text, "\n", trim: true)

 

=={{header|Erlang}}==

-module (align_columns).

 

=={{header|Euphoria}}==

"Given$a$text$file$of$many$lines,$where$fields$within$a$line$",

"are$delineated$by$a$single$'dollar'$character,$write$a$program",

 

=={{header|F_Sharp|F#}}==

open System.IO

 

 

=={{header|Factor}}==

splitting strings ;

IN: rosetta.column-aligner

=={{header|FBSL}}==

Using a multiline string:

 

DIM s = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$

=={{header|Forth}}==

{{works with|GNU Forth}}

 

: split ( addr len char -- addr len1 addr len-len1 )

 

Given a FORMAT text that produces output in aligned columns makes it easy enough to meet the other requirements. To cause texts to be aligned left, append sufficient spaces to each output text, and for centred text, half that number. This relies on the special intrinsic function REPEAT(text,n) returning a varying number of characters - CHARACTER functions have to return a ''fixed'' number of characters, until the standardisation of varying-length strings in F2003 ''et seq''. Earlier Fortrans lack the REPEAT function, but its effect can be gained via something like CHARACTER*66 SPACE, where SPACE is set to spaces, and SPACE(1:N) is used where REPEAT(" ",N) is desired. And if messing with variable FORMAT is unwanted, the REPEAT scheme can be used for the right-justified output also.

SUBROUTINE RAKE(IN,M,X,WAY) !Casts forth text in fixed-width columns.

Collates column widths so that each column is wide enough for its widest member.

 

=={{header|FreeBASIC}}==

 

Sub Split(s As String, sep As String, result() As String)

=={{header|FutureBasic}}==

Note: FB's NSLog, used for demonstrations, does not have a center alignment provision. However FB allows advanced alignment and text formatting in normal application development. Simple right and left alignment are shown here.

include "NSLog.incl"

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=023b4c5144d45e047abe02ebf5c4525a Click this link to run this code]'''

Dim siCount, siCounter, siLength As Short 'Counters

Dim siLongest As Short = -1 'To store the longest 'Word'

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

Solution:

def lines = rawText.tokenize('\n')

def words = lines.collect { it.tokenize(/\$/) }

 

Test Program:

are$delineated$by$a$single$'dollar'$character,$write$a$program

that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$

=={{header|Harbour}}==

 

PROCEDURE Main()

LOCAL a := { "Given$a$text$file$of$many$lines,$where$fields$within$a$line$",;

</syntaxhighlight>

Output:

Given a text file of many lines, where fields within a line

are delineated by a single 'dollar' character, write a program

 

=={{header|Haskell}}==

import Control.Arrow (second)

 

Or, using '''Text''' and its functions as an alternative to '''[Char]''' strings:

 

import Data.Text as T

(Text, pack, unpack, splitOn, unlines, unwords, length,

=={{header|HicEst}}==

A file opened with a Format option describing the column format(s) can be addressed like a standard in-memory array. In addition the DLG function ([http://www.HicEst.com/MatrixExplorer.htm MatrixExplorer]) allows this text/numeric file to be edited or visualized in many ways, but string columns are always left adjusted while numeric columns are right adjusted. Export is possible.

CHARACTER Fnam = "\HicEst\Rosetta\Align columns.txt"

 

An argument of <tt>left</tt>, <tt>center</tt>, or <tt>right</tt> controls the

column alignment. The default is left-alignment.

 

procedure main(args)

 

'''Solution'''

NB.* alignCols v Format delimited text in justified columns

 

'''Example''':

Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

{{libheader|Apache Commons Lang}}

 

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

===Imperative===

 

var justification="center",

input=["Given$a$text$file$of$many$lines,$where$fields$within$a$line$",

===Functional===

 

var data = [

"Given$a$text$file$of$many$lines,$where$fields$within$a$line$",

Or (ES5) using transpose and zipWith:

 

'use strict';

{{ Works with|jq|1.4}}

The key to the following implementation is the filter named "transpose", which is defined to work on a possibly jagged matrix. It is provided as a built-in in jq 1.5 and later.

def transpose:

if . == [] then []

;</syntaxhighlight>

'''Example''':

"Left:", format("left"), "",

"Right:", format("right")</syntaxhighlight>

{{Out}}

Center:

Given a text file of many lines, where fields within a line

=={{header|Jsish}}==

From Javascript ES5 entry.

function alignColumns(phrases:array, just:string) {

var x, y, max, diff, left, right, cols=0;

=={{header|Julia}}==

{{trans|Python}}

are\$delineated\$by\$a\$single\$'dollar'\$character,\$write\$a\$program

that\$aligns\$each\$column\$of\$fields\$by\$ensuring\$that\$words\$in\$each\$

 

=={{header|Kotlin}}==

import java.nio.file.Files

import java.nio.file.Paths

The input data is a sequence of characters where words are supposed to be separated by $ and lines be ended by \$. A HTML table is used to format the output left, centered or right justified.

 

{def txt

Given$a$text$file$of$many$lines,$where$fields$within$a$line\$are$delineated$by$a$single$'dollar'$character,$write$a$program\$that$aligns$each$column$of$fields$by$ensuring$that$words$in$each\$column$are$separated$by$at$least$one$space.\$Further,$allow$for$each$word$in$a$column$to$be$either$left\$justified,$right$justified,$or$center$justified$within$its$column.}

 

=={{header|Lasso}}==

 

local(text = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$

 

=={{header|Liberty BASIC}}==

 

CRLF$ =chr$( 13)

{{works with|Lua|5.1}}

 

local tWord = {} -- word table

local tColLen = {} -- maximum word length in a column

Usage Example:

 

input =

[[Given$a$text$file$of$many$lines,$where$fields$within$a$line$

 

=={{header|M2000 Interpreter}}==

Module Align_Columns {

a$={Given$a$text$file$of$many$lines,$where$fields$within$a$line$

=={{header|Maple}}==

Assign the sample data.

txt :=

"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"

</syntaxhighlight>

The following procedure solves the problem. It takes the string to be operated on as input, and an optional alignment parameter, which defaults to centred alignment. The aligned text is returned, as a string, which can then be printed.

AlignColumns := proc( txt, align :: { "left", "right", "centre" } := "centre" )

uses StringTools;

</syntaxhighlight>

For the sample text, we get the following results.

> printf( "%s\n", AlignColumns( txt ) ):

Given a text file of many lines, where fields within a line

 

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

Output with example text :

[[File:centeredtext.png]]

=={{header|MATLAB}} / {{header|Octave}}==

center-justified formatting is not implemented here

function r = align_columns(f)

fid = fopen('align_column_data.txt', 'r');

Note the presetting of P102 to indicate the alignment required.

 

"" Align columns - assumes macros on input stream 1, data on stream 2

MCPVAR 102

Note the presetting of P102 to indicate the alignment required.

 

"" Align columns - assumes macros on input stream 1, data on stream 2

MCPVAR 102

 

=={{header|MUMPS}}==

New col,half,ii,max,spaces,word

Set ii=0

 

=={{header|Nim}}==

from sequtils import mapIt

from strfmt import format, write

Source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/align_columns.nit the official Nit’s repository]

 

#

# Uses `Text::justify` from the standard library.

=={{header|Oberon-2}}==

works with oo2c version 2.

MODULE Columns;

IMPORT

 

=={{header|OCaml}}==

open Str

 

=={{header|Oforth}}==

 

import: file

 

 

=={{header|ooRexx}}==

text = .array~of("Given$a$text$file$of$many$lines,$where$fields$within$a$line$", -

"are$delineated$by$a$single$'dollar'$character,$write$a$program", -

 

=={{header|OpenEdge/Progress}}==

i_c AS CHAR,

i_calign AS CHAR

 

=={{header|Oz}}==

%% Lines: list of strings

%% Alignment: function like fun {Left Txt ExtraSpace} ... end

See [[Align_columns#Delphi | Delphi]]

modified to {{works with|Free Pascal}}

 

{$H+}//Use ansistrings

 

=={{header|Perl}}==

use strict ;

 

}</syntaxhighlight>

a shorter solution

 

sub columns {

 

=={{header|Phix}}==

<span style="color: #008080;">constant</span> <span style="color: #000000;">data</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span>

<span style="color: #008000;">"Given$a$text$file$of$many$lines,$where$fields$within$a$line$"</span><span style="color: #0000FF;">,</span>

 

=={{header|Phixmonti}}==

 

0 40 repeat var gap

 

=={{header|PHP}}==

$j2justtype = array('L' => STR_PAD_RIGHT,

'R' => STR_PAD_LEFT,

 

=={{header|Picat}}==

 

main =>

 

=={{header|PicoLisp}}==

(let Lines # and of lines

(make

 

=={{header|PL/I}}==

declare text character (300) varying;

declare word character (20) varying;

 

=={{header|PowerShell}}==

$file =

@'

=={{header|Prolog}}==

Works with SWI-Prolog.

L ="Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

=={{header|PureBasic}}==

{{works with|PureBasic|4.41}}

 

If OpenConsole()

===Procedural===

====Using f-strings====

 

txt = """Given$a$txt$file$of$many$lines,$where$fields$within$a$line$

 

====Using StringIO====

textinfile = '''Given$a$text$file$of$many$lines,$where$fields$within$a$line$

Works with Python 2 and 3.

 

cat <<'EOF' > align_columns.dat

Given$a$text$file$of$many$lines,$where$fields$within$a$line$

====Alternative====

{{trans|D}}

are$delineated$by$a$single$'dollar'$character,$write$a$program

that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$

(Selection of string justification methods via '''getattr'''):

{{Works with|Python|3.7}}

from delimited text.

'''

 

=={{header|q}}==

"Given$a$text$file$of$many$lines,$where$fields$within$a$line$";

"are$delineated$by$a$single$'dollar'$character,$write$a$program";

 

=={{header|R}}==

lines <- readLines(tc <- textConnection("Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

 

=={{header|Racket}}==

#lang racket

 

Call with parameter left (default), center or right.

 

q|Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$'dollar'$character,$write$a$program

Or a more functional version, called like <code>./align.p6 left input.txt</code>, which however only supports left and right alignment (not center):

 

my @lines := $file.IO.lines.map(*.split('$').cache).cache;

my @widths = roundrobin(|@lines).map(*».chars.max);

 

=={{header|RapidQ}}==

Dim MText as QMemorystream

MText.WriteLine "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"

 

=={{header|REBOL}}==

Title: "Align Columns"

URL: http://rosettacode.org/wiki/Align_columns

 

=={{header|Red}}==

Title: "Align Columns"

Original-Author: oofoe

=={{header|REXX}}==

===(no output)===

z.1 = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"

z.2 = "are$delineated$by$a$single$'dollar'$character,$write$a$program"

 

===(with output)===

size= 0; t.=; cols= 0; wid.= 0; @.= /*zero or nullify some variables. */

t.1 = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"

===(boxed output)===

Note: &nbsp; this version boxes each column of output to better show the columns.

size= 0; t.=; cols= 0; wid.= 0; @.= /*zero or nullify some variables. */

t.1 = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"

=={{header|Ruby}}==

{{works with|Ruby|1.9.3+}}

 

=begin

 

=={{header|Run BASIC}}==

+ "are$delineated$by$a$single$'dollar'$character,$write$a$program" _

+ "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"_

 

=={{header|Rust}}==

 

enum AlignmentType {

For Scala 2.7, change from fromPath to fromFile, and remove the extra parameter to Source's getLines.

 

val eol = System.getProperty("line.separator")

def getLines(filename: String) = scala.io.Source.fromPath(filename).getLines(eol)

Another take:

 

val padsize = (i-s.length).max(0)

d match {

=={{header|Scheme}}==

 

(import (scheme base)

(scheme write)

=={{header|sed}}==

The code allows to left (by default) or right justify colums. Centering is not supported. Requires about 2x<size of input> bytes of memory (each line duplicated).

#!/bin/sed -nrf

# Format: <master-pattern>\n<line1>\n<line1-as-pattern>\n<line2>\n<line2-as-pattern>...

 

=={{header|Seed7}}==

 

const array string: inputLines is [] (

 

=={{header|Shiny}}==

are$delineated$by$a$single$\'dollar\'$character,$write$a$program

that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$

 

=={{header|Sidef}}==

method align(j) {

text.map { |row|

the following works with Smalltalk/X, but should also in other dialects (may have to add "centerPadded" to the String class).

{{works with |Smalltalk/X }}

'Given$a$text$file$of$many$lines,$where$fields$within$a$line$

are$delineated$by$a$single$''dollar''$character,$write$a$program

=={{header|Snobol}}==

{{works with|Snobol|4}}

* we store the words and field widths in tables

Words = TABLE()

 

=={{header|Standard ML}}==

fun uncurry f (x, y) = f x y

 

{{trans|Rust}}

 

 

extension String {

 

=={{header|Tcl}}==

 

set text {Given$a$text$file$of$many$lines,$where$fields$within$a$line$

Transd has built-in support for "left" and "right" formatting, but not "centered", which added quite a bit of code.

 

 

MainModule : {

 

=={{header|TSE SAL}}==

INTEGER PROC FNBlockChangeColumnAlignLeftB( INTEGER columnTotalI, INTEGER spaceTotalI, INTEGER buffer1I )

INTEGER B = FALSE

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

MODE DATA

=={{header|TXR}}==

 

@ (coll)@{item /[^$]+/}@(end)

@(end)

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

This is a draft implementation of the "align columns" problem using Unix shell commands. The key tool for left and right justified text is the "rs" command. Centered text is a little more complex, since this is not a feature currently in "rs" (''The centered solution will be added later.'')

cat <<EOF_OUTER > just-nocenter.sh

#!/bin/sh

</syntaxhighlight>

{{out}}

$ ./just-nocenter.sh

Given a text file of many lines, where fields within a line

Note that the left-justified case can be handled trivially by the <tt>column</tt> command, which ships with modern Linux and macOS systems:

 

 

{{Out}}

For right justification, each word's string of trailing blanks is moved to the beginning,

and for center justification, the trailing blanks are divided equally between the beginning and end of each word.

 

text =

Both arguments are optional and default to "left" and 1 respectively.

 

Public Sub TestSplit(Optional align As String = "left", Optional spacing As Integer = 1)

Dim word() As String

=={{header|VBScript}}==

{{trans|Rexx}}

Const nr=16, nc=16

ReDim d(nc),t(nr), wor(nr,nc)

=={{header|Vedit macro language}}==

This implementation converts the file currently being edited. The file can then be saved with different filename if required.

#11 = 1 // Align: 1 = left, 2 = center, 3 = right

 

 

=={{header|Visual Basic}}==

Dim i&, j&, D&, L&, R&: ReDim W(UBound(Lines)): ReDim C&(0)

Next i, j

End Sub</syntaxhighlight>

Const Text$ = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$" & vbLf & _

"are$delineated$by$a$single$'dollar'$character,$write$a$program" & vbLf & _

 

=={{header|Visual Basic .NET}}==

Private Delegate Function Justification(s As String, width As Integer) As String

 

=={{header|Vlang}}==

Currently (5/2022) vlang uses string interpolation so `$` have to be escaped. Variables in formatting aren't currently allowed, and if they were only right/left are currently valid options

const text = "Given\$a\$text\$file\$of\$many\$lines,\$where\$fields\$within\$a\$line\$

are\$delineated\$by\$a\$single\$'dollar'\$character,\$write\$a\$program

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

=={{header|Yabasic}}==

{{trans|Run BASIC}}

theString$ = theString$ + "are$delineated$by$a$single$'dollar'$character,$write$a$program"

theString$ = theString$ + "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"

 

=={{header|zkl}}==

words:=text.split("$").apply("split").flatten();

max:=words.reduce(fcn(p,n){ n=n.len(); n>p and n or p },0);

d.text;

}</syntaxhighlight>

"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"

"are$delineated$by$a$single$'dollar'$character,$write$a$program\n"

=={{header|ZX Spectrum Basic}}==

The max width (without 'hack') of ZX Spectrum screen is 32 characters. The text sample is adapted for this feature.

10 DATA 6

20 DATA "The$problem$of$Speccy$"