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$

print(justify(word, max_widths[L.index]), end' ‘ ’)

print()

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

ALICOL CSECT

USING ALICOL,R13 base register

PG DS CL120

REGEQU

{{out}}

<pre>

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

bye ;

{{out}}

<pre>

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

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

LEFT :

</pre>

=={{header|ABAP}}==

start-of-selection.

sy-linno = sy-linno - 1.

endloop.

<pre style="height:15ex;overflow:scroll">Given a text file of many lines, where fields within a line

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

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Align_columns.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{libheader|Simple components for Ada}}

with Ada.Text_IO; use Ada.Text_IO;

with Strings_Edit; use Strings_Edit;

end loop;

Close (File);

Formatted file sample:

<pre style="height:15ex;overflow:scroll">

=={{header|Aime}}==

file f;

text n, t;

}

o_newline();

{{Out}}

<pre>left justified

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

aligner(page, align OF aligners[index])

OD

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

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

Print("Left Pad:\n", display Left, Newl, "Right Pad:\n", display Right, Newl, "Center Pad:\n", display Center,Newl)

End

{{out}}

Sample String was saved into "sample.txt" file.

{{trans|JavaScript}}

property pstrLines : ¬

return lst

end tell

{{Out}}

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

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

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

/* ARM assembly Raspberry PI */

/* program alignColumn.s */

/***************************************************/

.include "../affichage.inc"

<pre>

LEFT :

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

loop line 'word -> prints pad word 12

print ""

{{out}}

=={{header|AutoHotkey}}==

Text =

( LTrim

Return Ret

}

=={{header|AutoIt}}==

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

#include <File.au3>

EndSwitch

EndFunc ;==>_GetAligned

Example output in Alignment: left - center - right - left - center - right - left - center - right - left - center - right

<pre>

=={{header|AWK}}==

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

BEGIN {

}

function max(x,y) { return((x > y) ? x : y) }

<p>Output:</p>

<pre>

=={{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", \

Print_In_Columns(1)

Print_In_Columns(2)

{{out}}

<pre>

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

WHEN "right": = STRING$(field%-LEN(word$), " ") + word$

ENDCASE

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

20 rem print words in columns

30 rem commodore basic 2.0

640 data "column$are$separated$by$at$least$one$space."

650 data "Further,$allow$for$each$word$in$a$column$to$be$either$left$"

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

setlocal enabledelayedexpansion

mode con cols=103

)

endlocal & set %~2=%len%

{{out}}

<pre>Given a text file of many lines where fields within a line

=={{header|Beads}}==

const

log "\n{v} justified\n"

div_line

{{out}}

=={{header|BQN}}==

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

PadRow ← {

w‿t𝕊𝕩: # t → type.

Align ← {{𝕨∾' '∾𝕩}´˘⍉" "‿𝕨⊸PadRow˘⍉>⟨""⟩‿0 PadRow '$' Split¨(@+10) Split 𝕩}

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

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

Further, allow for each word in a column to be either left

justified, right justified, or center justified within its column. "

[https://mlochbaum.github.io/BQN/try.html#code=dGV4dOKGkCJHaXZlbiRhJHRleHQkZmlsZSRvZiRtYW55JGxpbmVzLCR3aGVyZSRmaWVsZHMkd2l0aGluJGEkbGluZSQKYXJlJGRlbGluZWF0ZWQkYnkkYSRzaW5nbGUkJ2RvbGxhcickY2hhcmFjdGVyLCR3cml0ZSRhJHByb2dyYW0KdGhhdCRhbGlnbnMkZWFjaCRjb2x1bW4kb2YkZmllbGRzJGJ5JGVuc3VyaW5nJHRoYXQkd29yZHMkaW4kZWFjaCQKY29sdW1uJGFyZSRzZXBhcmF0ZWQkYnkkYXQkbGVhc3Qkb25lJHNwYWNlLgpGdXJ0aGVyLCRhbGxvdyRmb3IkZWFjaCR3b3JkJGluJGEkY29sdW1uJHRvJGJlJGVpdGhlciRsZWZ0JApqdXN0aWZpZWQsJHJpZ2h0JGp1c3RpZmllZCwkb3IkY2VudGVyJGp1c3RpZmllZCR3aXRoaW4kaXRzJGNvbHVtbi4iCgpTcGxpdCDihpAgKOKKoi3LnCtgw5fCrCniiJg94oqU4oqiClBhZFJvdyDihpAgewogIHfigL908J2VivCdlak6ICMgdCDihpIgdHlwZS4KICAgICAgICAjIDAg4oaSIGxlZnQKICAgICAgICAjIDEg4oaSIHJpZ2h0CiAgICAgICAgIyAyIOKGkiBjZW50ZXIKIHBzdHlsZeKGkHTiipHin6h7MOKAv/Cdlal9LHvwnZWp4oC/MH0se+KfqOKMivCdlanDtzIs4oyI8J2VqcO3MuKfqX3in6kKIPCdlal7KOKKo+KIvvCdlajiiL7iiqIpwrQoUHN0eWxlIPCdlakpL8KoPHd9wqgo4oyIwrQt4oqiKeKJoMKo8J2VqQp9CkFsaWduIOKGkCB7e/CdlajiiL4nICfiiL7wnZWpfcK0y5jijYkiICLigL/wnZWo4oq4UGFkUm93y5jijYk+4p+oIiLin6nigL8wIFBhZFJvdyAnJCcgU3BsaXTCqChAKzEwKSBTcGxpdCDwnZWpfQoKMSBBbGlnbiB0ZXh0CgoK Try It!]

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

class ColumnAlignerProgram

{

}

}

===Newer version===

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

using System.Linq;

}

{{out}}

<pre style="height:30ex;overflow:scroll">

=={{header|Clojure}}==

(ns rosettacode.align-columns

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

(print-table (aligned-table table :center))

=={{header|COBOL}}==

identification division.

program-id. AlignColumns.

end-perform

.

{{out}}

<lang>

Further, allow for each word in a column to be either left

justified, right justified, or center justified within its column.

=={{header|CoffeeScript}}==

pad = (n) ->

s = ''

console.log "\n----- #{alignment}"

align input, alignment

{{out}}

<lang>

Further, allow for each word in a column to be either left

justified, right justified, or center justified within its column.

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

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

(format s "~~~d~a<~~a~~>" (1+ w) fmtmod))

(princ "~}~%~}" s))

=={{header|D}}==

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

writefln("%-(%s %)", line.length.iota

.map!(i => just(line[i], maxWidths[i], ' ')));

{{out}}

<pre>Given a txt file of many lines, where fields within a line

=={{header|Delphi}}==

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

USES

StdCtrls, Classes, SysUtils, StrUtils, Contnrs;

END;

end;

=={{header|E}}==

def left(width, word) {

} + "\n"

}

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

=={{header|Elixir}}==

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)

IO.puts "\n# #{alignment} Column-aligned output:"

Align.columns(text, alignment)

{{out}}

=={{header|Erlang}}==

-module (align_columns).

Zipped = lists:zip (All_words, Words_length),

[ apply(string, Alignment, [Word, Length + 1, $\s])

{{out}}

=={{header|Euphoria}}==

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

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

end for

puts(1,'\n')

{{out}}

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

open System.IO

format table align

printfn "%s" (new String('-', (Array.sum width) + width.Length - 1))

Output, when called with a file containing the sample input

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

=={{header|Factor}}==

splitting strings ;

IN: rosetta.column-aligner

: print-aligned ( text alignment -- )

[ split-and-pad flip ] dip align-columns flip

example-text { +left+ +middle+ +right+ } [ print-aligned ] with each

=={{header|FBSL}}==

Using a multiline string:

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

NEXT

{{out}}

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 )

\ cleanup

nip free throw

=={{header|Fortran}}==

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.

CALL RAKE(IN,M,"$",+1) !Align right.

END !That's all.

Every line of output starts with a space, and if it were to be sent to a lineprinter, this would be used as the carriage control character (meaning, advance one line then print the rest) - the first column does not need to be set off by one space from the previous column, but rather than devise special treatment it is spaced off anyway. The free-format output statements also start with a space. Output:

<pre>

=={{header|FreeBASIC}}==

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

Next i

{{out}}

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

HandleEvents

{{output}}

<pre>

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

Next

{{out}}

=={{header|Go}}==

import (

f.print(middle)

f.print(right)

<pre>

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

=={{header|Groovy}}==

Solution:

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

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

words.each { padAll(justify[align], columnWidths, it).each { print it }; println() }

Test Program:

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

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

alignColumns(align, rawTextInput)

println()

{{out}}

=={{header|Harbour}}==

PROCEDURE Main()

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

RETURN

Output:

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

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

column are separated by at least one space.

Further, allow for each word in a column to be either left

=={{header|Haskell}}==

import Control.Arrow (second)

where

dl = cw - length w

{{out}}

<pre>

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

import Data.Text as T

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

(zip cols ((T.length . maximumBy (comparing T.length)) <$> cols))

] <*>

{{Out}}

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

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

WRITE() out

ENDDO

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

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

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)

write()

}

Sample run:

'''Solution'''

NB.* alignCols v Format delimited text in justified columns

7 17 global oldbox NB. restore settings

result

'''Example''':

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

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

column are separated by at least one space.

Further, allow for each word in a column to be either left

=={{header|Java}}==

{{libheader|Apache Commons Lang}}

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

}

}

=={{header|JavaScript}}==

===Imperative===

var justification="center",

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

for(x=0;x<input.length;x++) input[x]=input[x].join(" ");

input=input.join("\n");

===Functional===

var data = [

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

return zip(formattedCols).map(function (row) { return row.join(' '); }).join('\n');

Or (ES5) using transpose and zipWith:

'use strict';

Further,$allow$for$each$word$in$a$column$to$be$either$left$\n\

justified,$right$justified,$or$center$justified$within$its$column."

{{Out}}

{{ 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 []

(""; . + ($line[$i]|justify($widths[$i])) ))

| join("\n")

'''Example''':

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

{{Out}}

Center:

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

Further, allow for each word in a column to be either left

justified, right justified, or center justified within its column.

=={{header|Jsish}}==

From Javascript ES5 entry.

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

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

puts(alignColumns(trial, just), '\n');

}

{{out}}

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

end

println("-"^sum(max_widths))

{{out}}

<pre>

=={{header|Kotlin}}==

import java.nio.file.Files

import java.nio.file.Paths

else -> System.err.println("Error! Unknown alignment: " + alignment)

}

=={{header|Lambdatalk}}==

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

{columns center txt} and {columns right txt} outputs can be seen in this website: http://lambdaway.free.fr/lambdawalks/?view=align_columns

=={{header|Lasso}}==

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

}

{{out}}

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

CRLF$ =chr$( 13)

end function

=={{header|Lua}}==

{{works with|Lua|5.1}}

local tWord = {} -- word table

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

return output

end--alignColumn

Usage Example:

input =

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

outputRight = alignColumn(input, "right")

alignColumn(input, "center", "output.txt")

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

Module Align_Columns {

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

}

Align_Columns

{{out}}

=={{header|Maple}}==

Assign the sample data.

txt :=

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

"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n"

"justified,$right$justified,$or$center$justified$within$its$column.\n":

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;

Join( J, "\n" )

end proc:

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

Further, allow for each word in a column to be either left

justified, right justified, or center justified within its column.

Alternatively, this could be printed to a file (using fprintf instead of printf).

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

end

end;

Note the presetting of P102 to indicate the alignment required.

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

MCPVAR 102

>

MCSET S1=1

=={{header|ML/I}}==

Note the presetting of P102 to indicate the alignment required.

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

MCPVAR 102

>

MCSET S1=1

=={{header|MUMPS}}==

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

Set ii=0

column are separated by at least one space.

Further, allow for each word in a column to be either left

=={{header|Nim}}==

from sequtils import mapIt

from strfmt import format, write

stdout.write(w.format align & $maxs[j])

stdout.write "\n"

{{out}}

<pre>Left column-aligned output:

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.

aligner(text, 0.0)

aligner(text, 1.0)

{{out}}

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

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

works with oo2c version 2.

MODULE Columns;

IMPORT

END Columns.

<pre>

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

=={{header|OCaml}}==

open Str

let sp2 = String.make pad2 ' ' in

Printf.printf "%s%s%s " sp1 word sp2);

=={{header|Oforth}}==

import: file

0 #[ apply( #[ size max ] ) ] lines apply ->maxsize

#[ apply( #[ justify( maxsize , just) . ] ) printcr ] lines apply

{{out}}

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

say out~string

end

<pre>

align left:

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

i_c AS CHAR,

i_calign AS CHAR

alignColumns( cc, "right" ) SKIP

alignColumns( cc, "center" )

{{out}}

=={{header|Oz}}==

%% Lines: list of strings

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

"justified,$right$justified,$or$center$justified$within$its$column."]

in

=={{header|Pascal}}==

See [[Align_columns#Delphi | Delphi]]

modified to {{works with|Free Pascal}}

{$H+}//Use ansistrings

AlignByColumn(taCenter);

AlignByColumn(taRightJustify);

{{out}}

<pre>

=={{header|Perl}}==

use strict ;

}

print "\n" ;

a shorter solution

sub columns {

Further,$allow$for$each$word$in$a$column$to$be$either$left$

justified,$right$justified,$or$center$justified$within$its$column.

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

<span style="color: #000000;">AlignColumns</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

0 40 repeat var gap

0 alignWords nl

1 alignWords nl

=={{header|PHP}}==

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

'R' => STR_PAD_LEFT,

echo aligner($textinfile, $j);

=={{header|Picat}}==

main =>

Pad2 is Pad-Pad1,

printf("%*s%s%*s",Pad1,"",Word,Pad2,"").

{{out}}

<pre>

=={{header|PicoLisp}}==

(let Lines # and of lines

(make

(prinl)

(for L Lines

{{out}}

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

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

declare text character (300) varying;

declare word character (20) varying;

put file (output) skip;

end;

=={{header|PowerShell}}==

$file =

@'

}

$arr | Format-Table -HideTableHeaders -Wrap *

<b>Output:</b>

<pre>

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

{N2 is N1 + 1},

parse_word(T, N2, NF, TF).

{{out}}

=={{header|PureBasic}}==

{{works with|PureBasic|4.41}}

If OpenConsole()

Data.s "Further,$allow$for$each$word$in$a$column$oo$be$either$left$"

Data.s "justified,$right$justified,$or$center$justified$within$its$column."

=={{header|Python}}==

===Procedural===

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

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

print(' '.join(f"{wrd:{j}{wdth}}" for wdth, wrd in zip(widths, line)))

print("- " * 52)

{{out}}

====Using StringIO====

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

infile = StringIO(textinfile)

print "\n# %s Column-aligned output:" % align

{{out}}

Works with Python 2 and 3.

cat <<'EOF' > align_columns.dat

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

for row in rows:

print(' '.join(fmts).format(*(row + [''] * len(fmts))))

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

print(justify(word, max_widths[j]), end=' ')

print()

===Functional===

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

{{Works with|Python|3.7}}

from delimited text.

'''

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

=={{header|q}}==

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

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

ps:$[aln=`R;-1-cw;1+cw]$''s; / padded strings

ps:$[aln=`C;(neg(cw-sl)div 2)rotate''ps;ps]; / center