Align columns: Difference between revisions
m
syntax highlighting fixup automation
Drkameleon (talk | contribs) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 30:
=={{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$
Line 53:
print(justify(word, max_widths[L.index]), end' ‘ ’)
print()
print(‘- ’ * 52)</
=={{header|360 Assembly}}==
<
ALICOL CSECT
USING ALICOL,R13 base register
Line 235:
PG DS CL120
REGEQU
END ALICOL </
{{out}}
<pre>
Line 262:
=={{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
Line 308:
bye ;
</syntaxhighlight>
{{out}}
<pre>
Line 337:
=={{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 */
Line 666:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
<pre>
LEFT :
Line 693:
</pre>
=={{header|ABAP}}==
<
start-of-selection.
Line 769:
sy-linno = sy-linno - 1.
endloop.
endform.</
<pre style="height:15ex;overflow:scroll">Given a text file of many lines, where fields within a line
Line 794:
=={{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"
Line 1,002:
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Align_columns.png Screenshot from Atari 8-bit computer]
Line 1,032:
=={{header|Ada}}==
{{libheader|Simple components for Ada}}
<
with Ada.Text_IO; use Ada.Text_IO;
with Strings_Edit; use Strings_Edit;
Line 1,096:
end loop;
Close (File);
end Column_Aligner;</
Formatted file sample:
<pre style="height:15ex;overflow:scroll">
Line 1,120:
=={{header|Aime}}==
<
file f;
text n, t;
Line 1,164:
}
o_newline();
}</
{{Out}}
<pre>left justified
Line 1,191:
=={{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+
Line 1,256:
aligner(page, align OF aligners[index])
OD
END</
=={{header|Amazing Hopper}}==
<
#define IGet(__N__,__X__) [__N__]SGet(__X__)
Line 1,310:
Print("Left Pad:\n", display Left, Newl, "Right Pad:\n", display Right, Newl, "Center Pad:\n", display Center,Newl)
End
</syntaxhighlight>
{{out}}
Sample String was saved into "sample.txt" file.
Line 1,346:
{{trans|JavaScript}}
<
property pstrLines : ¬
Line 1,597:
return lst
end tell
end zipWith</
{{Out}}
<pre> Given a text file of many lines, where fields within a line
Line 1,621:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<
/* ARM assembly Raspberry PI */
/* program alignColumn.s */
Line 1,947:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
<pre>
LEFT :
Line 1,974:
</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
Line 1,988:
loop line 'word -> prints pad word 12
print ""
]</
{{out}}
Line 2,001:
=={{header|AutoHotkey}}==
<
Text =
( LTrim
Line 2,049:
Return Ret
}
</syntaxhighlight>
=={{header|AutoIt}}==
<
; == If the given text is in an file, it will read with:
#include <File.au3>
Line 2,136:
EndSwitch
EndFunc ;==>_GetAligned
</syntaxhighlight>
Example output in Alignment: left - center - right - left - center - right - left - center - right - left - center - right
<pre>
Line 2,148:
=={{header|AWK}}==
<
# syntax: GAWK -f ALIGN_COLUMNS.AWK ALIGN_COLUMNS.TXT
BEGIN {
Line 2,190:
}
function max(x,y) { return((x > y) ? x : y) }
</syntaxhighlight>
<p>Output:</p>
<pre>
Line 2,227:
=={{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", \
Line 2,262:
Print_In_Columns(1)
Print_In_Columns(2)
</syntaxhighlight>
{{out}}
<pre>
Line 2,292:
==={{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"
Line 2,347:
WHEN "right": = STRING$(field%-LEN(word$), " ") + word$
ENDCASE
= word$</
==={{header|Commodore BASIC}}===
<
20 rem print words in columns
30 rem commodore basic 2.0
Line 2,415:
640 data "column$are$separated$by$at$least$one$space."
650 data "Further,$allow$for$each$word$in$a$column$to$be$either$left$"
660 data "justified,$right$justified,$or$center$justified$within$its$column"</
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
mode con cols=103
Line 2,501:
)
endlocal & set %~2=%len%
exit /b</
{{out}}
<pre>Given a text file of many lines where fields within a line
Line 2,525:
=={{header|Beads}}==
<
const
Line 2,577:
log "\n{v} justified\n"
div_line
show_table(v)</
{{out}}
Line 2,629:
=={{header|BQN}}==
A function which returns a rectangular 2D array which represents the lines.
<
PadRow ← {
w‿t𝕊𝕩: # t → type.
Line 2,640:
Align ← {{𝕨∾' '∾𝕩}´˘⍉" "‿𝕨⊸PadRow˘⍉>⟨""⟩‿0 PadRow '$' Split¨(@+10) Split 𝕩}
1 Align text</
<
╵" Given a text file of many lines, where fields within a line
are delineated by a single 'dollar' character, write a program
Line 2,648:
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!]
Line 2,660:
{{works with|C sharp|C#|2+}}
<
class ColumnAlignerProgram
{
Line 2,733:
}
}
}</
===Newer version===
Line 2,739:
{{works with|C sharp|C#|8+}}
<
using System.Linq;
Line 2,790:
}
}</
{{out}}
<pre style="height:30ex;overflow:scroll">
Line 2,821:
=={{header|Clojure}}==
<
(ns rosettacode.align-columns
(:require [clojure.contrib.string :as str]))
Line 2,863:
(print-table (aligned-table table :center))
</syntaxhighlight>
=={{header|COBOL}}==
<
identification division.
program-id. AlignColumns.
Line 2,950:
end-perform
.
</syntaxhighlight>
{{out}}
<lang>
Line 2,974:
Further, allow for each word in a column to be either left
justified, right justified, or center justified within its column.
</syntaxhighlight>
=={{header|CoffeeScript}}==
<
pad = (n) ->
s = ''
Line 3,026:
console.log "\n----- #{alignment}"
align input, alignment
</syntaxhighlight>
{{out}}
<lang>
Line 3,054:
Further, allow for each word in a column to be either left
justified, right justified, or center justified within its column.
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(position-if (lambda (x) (declare (ignore x)) t) seq))
Line 3,104:
(format s "~~~d~a<~~a~~>" (1+ w) fmtmod))
(princ "~}~%~}" s))
fields))</
=={{header|D}}==
<
import std.stdio, std.string, std.algorithm, std.range, std.typetuple;
Line 3,128:
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
Line 3,151:
=={{header|Delphi}}==
{{libheader|Delphi StdCtrls, Classes, SysUtils, StrUtils, Contnrs}}
<
USES
StdCtrls, Classes, SysUtils, StrUtils, Contnrs;
Line 3,208:
END;
end;
</syntaxhighlight>
=={{header|E}}==
<
def left(width, word) {
Line 3,240:
} + "\n"
}
}</
<
are$delineated$by$a$single$'dollar'$character,$write$a$program
that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$
Line 3,271:
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|Elixir}}==
Line 3,278:
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)
Line 3,312:
IO.puts "\n# #{alignment} Column-aligned output:"
Align.columns(text, alignment)
end)</
{{out}}
Line 3,342:
=={{header|Erlang}}==
<
-module (align_columns).
Line 3,380:
Zipped = lists:zip (All_words, Words_length),
[ apply(string, Alignment, [Word, Length + 1, $\s])
|| {Word, Length} <- Zipped]. </
{{out}}
Line 3,413:
=={{header|Euphoria}}==
<
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$",
"are$delineated$by$a$single$'dollar'$character,$write$a$program",
Line 3,473:
end for
puts(1,'\n')
end for</
{{out}}
Line 3,500:
=={{header|F_Sharp|F#}}==
<
open System.IO
Line 3,532:
format table align
printfn "%s" (new String('-', (Array.sum width) + width.Length - 1))
0</
Output, when called with a file containing the sample input
<pre>Given a text file of many lines, where fields within a line
Line 3,557:
=={{header|Factor}}==
<
splitting strings ;
IN: rosetta.column-aligner
Line 3,596:
: print-aligned ( text alignment -- )
[ split-and-pad flip ] dip align-columns flip
[ [ write " " write ] each nl ] each ;</
example-text { +left+ +middle+ +right+ } [ print-aligned ] with each
Line 3,602:
=={{header|FBSL}}==
Using a multiline string:
<
DIM s = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 3,636:
NEXT
PAUSE</
{{out}}
Given a text file of many lines, where fields within a line
Line 3,649:
=={{header|Forth}}==
{{works with|GNU Forth}}
<
: split ( addr len char -- addr len1 addr len-len1 )
Line 3,718:
\ cleanup
nip free throw
column-widths free throw</
=={{header|Fortran}}==
Line 3,736:
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.
Line 3,831:
CALL RAKE(IN,M,"$",+1) !Align right.
END !That's all.
</syntaxhighlight>
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>
Line 3,865:
=={{header|FreeBASIC}}==
<
Sub Split(s As String, sep As String, result() As String)
Line 3,962:
Next i
Close #1 : Close #2 : Close #3</
{{out}}
Line 4,005:
=={{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"
Line 4,052:
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Line 4,081:
=={{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'
Line 4,124:
Next
End</
{{out}}
Line 4,151:
=={{header|Go}}==
<
import (
Line 4,211:
f.print(middle)
f.print(right)
}</
<pre>
Given a text file of many lines, where fields within a line
Line 4,237:
=={{header|Groovy}}==
Solution:
<
def lines = rawText.tokenize('\n')
def words = lines.collect { it.tokenize(/\$/) }
Line 4,250:
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$
Line 4,264:
alignColumns(align, rawTextInput)
println()
}</
{{out}}
Line 4,293:
=={{header|Harbour}}==
<
PROCEDURE Main()
LOCAL a := { "Given$a$text$file$of$many$lines,$where$fields$within$a$line$",;
Line 4,334:
RETURN
</syntaxhighlight>
Output:
<
Given a text file of many lines, where fields within a line
are delineated by a single 'dollar' character, write a program
Line 4,358:
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|Haskell}}==
<
import Control.Arrow (second)
Line 4,386:
where
dl = cw - length w
(l, r) = (dl `div` 2, dl - l)</
{{out}}
<pre>
Line 4,400:
Or, using '''Text''' and its functions as an alternative to '''[Char]''' strings:
<
import Data.Text as T
(Text, pack, unpack, splitOn, unlines, unwords, length,
Line 4,434:
(zip cols ((T.length . maximumBy (comparing T.length)) <$> cols))
] <*>
[justifyLeft, justifyRight, center]</
{{Out}}
<pre>Given a text file of many lines, where fields within a line
Line 4,459:
=={{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"
Line 4,486:
WRITE() out
ENDDO
END</
<pre>Given a text file of many lines, where fields within a line
are delineated by a single 'dollar' character, write a program
Line 4,509:
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)
Line 4,538:
write()
}
end</
Sample run:
Line 4,557:
'''Solution'''
<
NB.* alignCols v Format delimited text in justified columns
Line 4,574:
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
Line 4,600:
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|Java}}==
Line 4,607:
{{libheader|Apache Commons Lang}}
<
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
Line 4,750:
}
}
}</
=={{header|JavaScript}}==
Line 4,756:
===Imperative===
<
var justification="center",
input=["Given$a$text$file$of$many$lines,$where$fields$within$a$line$",
Line 4,787:
for(x=0;x<input.length;x++) input[x]=input[x].join(" ");
input=input.join("\n");
document.write(input);</
===Functional===
<
var data = [
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$",
Line 4,838:
return zip(formattedCols).map(function (row) { return row.join(' '); }).join('\n');
};</
Line 4,844:
Or (ES5) using transpose and zipWith:
<
'use strict';
Line 4,976:
Further,$allow$for$each$word$in$a$column$to$be$either$left$\n\
justified,$right$justified,$or$center$justified$within$its$column."
);</
{{Out}}
Line 5,004:
{{ 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 5,046:
(""; . + ($line[$i]|justify($widths[$i])) ))
| join("\n")
;</
'''Example''':
<
"Left:", format("left"), "",
"Right:", format("right")</
{{Out}}
<div style="overflow:scroll; height:200px;"><
Center:
Given a text file of many lines, where fields within a line
Line 5,076:
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;
Line 5,121:
puts(alignColumns(trial, just), '\n');
}
}</
{{out}}
Line 5,151:
=={{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\$
Line 5,190:
end
println("-"^sum(max_widths))
end</
{{out}}
<pre>
Line 5,220:
=={{header|Kotlin}}==
<
import java.nio.file.Files
import java.nio.file.Paths
Line 5,282:
else -> System.err.println("Error! Unknown alignment: " + alignment)
}
}</
=={{header|Lambdatalk}}==
Line 5,288:
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.}
Line 5,327:
{columns center txt} and {columns right txt} outputs can be seen in this website: http://lambdaway.free.fr/lambdawalks/?view=align_columns
</syntaxhighlight>
=={{header|Lasso}}==
<
local(text = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 5,396:
}
prepcols(#text)</
{{out}}
Line 5,427:
=={{header|Liberty BASIC}}==
<
CRLF$ =chr$( 13)
Line 5,504:
end function
end</
=={{header|Lua}}==
{{works with|Lua|5.1}}
<
local tWord = {} -- word table
local tColLen = {} -- maximum word length in a column
Line 5,570:
return output
end--alignColumn
</syntaxhighlight>
Usage Example:
<
input =
[[Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 5,587:
outputRight = alignColumn(input, "right")
alignColumn(input, "center", "output.txt")
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<
Module Align_Columns {
a$={Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 5,643:
}
Align_Columns
</syntaxhighlight>
{{out}}
Line 5,669:
=={{header|Maple}}==
Assign the sample data.
<
txt :=
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"
Line 5,677:
"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n"
"justified,$right$justified,$or$center$justified$within$its$column.\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;
Line 5,704:
Join( J, "\n" )
end proc:
</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
Line 5,735:
Further, allow for each word in a column to be either left
justified, right justified, or center justified within its column.
</syntaxhighlight>
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]]
Line 5,745:
=={{header|MATLAB}} / {{header|Octave}}==
center-justified formatting is not implemented here
<
function r = align_columns(f)
fid = fopen('align_column_data.txt', 'r');
Line 5,775:
end
end;
</syntaxhighlight>
Line 5,801:
Note the presetting of P102 to indicate the alignment required.
<
"" Align columns - assumes macros on input stream 1, data on stream 2
MCPVAR 102
Line 5,857:
>
MCSET S1=1
*MCSET S10=102</
=={{header|ML/I}}==
Line 5,863:
Note the presetting of P102 to indicate the alignment required.
<
"" Align columns - assumes macros on input stream 1, data on stream 2
MCPVAR 102
Line 5,919:
>
MCSET S1=1
*MCSET S10=102</
=={{header|MUMPS}}==
<
New col,half,ii,max,spaces,word
Set ii=0
Line 5,974:
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|Nim}}==
<
from sequtils import mapIt
from strfmt import format, write
Line 6,001:
stdout.write(w.format align & $maxs[j])
stdout.write "\n"
stdout.write "\n"</
{{out}}
<pre>Left column-aligned output:
Line 6,031:
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.
Line 6,079:
aligner(text, 0.0)
aligner(text, 1.0)
aligner(text, 0.5)</
{{out}}
<pre>Given a text file of many lines, where fields within a line
Line 6,103:
=={{header|Oberon-2}}==
works with oo2c version 2.
<
MODULE Columns;
IMPORT
Line 6,212:
END Columns.
</syntaxhighlight>
<pre>
Given a text file of many lines, where fields within a line
Line 6,239:
=={{header|OCaml}}==
<
open Str
Line 6,292:
let sp2 = String.make pad2 ' ' in
Printf.printf "%s%s%s " sp1 word sp2);
;;</
=={{header|Oforth}}==
<
import: file
Line 6,316:
0 #[ apply( #[ size max ] ) ] lines apply ->maxsize
#[ apply( #[ justify( maxsize , just) . ] ) printcr ] lines apply
;</
{{out}}
Line 6,332:
=={{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", -
Line 6,407:
say out~string
end
</syntaxhighlight>
<pre>
align left:
Line 6,438:
=={{header|OpenEdge/Progress}}==
<
i_c AS CHAR,
i_calign AS CHAR
Line 6,497:
alignColumns( cc, "right" ) SKIP
alignColumns( cc, "center" )
VIEW-AS ALERT-BOX.</
{{out}}
Line 6,662:
=={{header|Oz}}==
<
%% Lines: list of strings
%% Alignment: function like fun {Left Txt ExtraSpace} ... end
Line 6,736:
"justified,$right$justified,$or$center$justified$within$its$column."]
in
{ForAll {Align Lines Left} System.showInfo}</
=={{header|Pascal}}==
See [[Align_columns#Delphi | Delphi]]
modified to {{works with|Free Pascal}}
<
{$H+}//Use ansistrings
Line 6,814:
AlignByColumn(taCenter);
AlignByColumn(taRightJustify);
end.</
{{out}}
<pre>
Line 6,840:
=={{header|Perl}}==
<
use strict ;
Line 6,895:
}
print "\n" ;
}</
a shorter solution
<
sub columns {
Line 6,920:
Further,$allow$for$each$word$in$a$column$to$be$either$left$
justified,$right$justified,$or$center$justified$within$its$column.
END</
=={{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>
Line 6,991:
<span style="color: #000000;">AlignColumns</span><span style="color: #0000FF;">()</span>
<!--</
{{out}}
<pre>
Line 7,017:
=={{header|Phixmonti}}==
<
0 40 repeat var gap
Line 7,062:
0 alignWords nl
1 alignWords nl
drop</
=={{header|PHP}}==
<
$j2justtype = array('L' => STR_PAD_RIGHT,
'R' => STR_PAD_LEFT,
Line 7,111:
echo aligner($textinfile, $j);
?></
=={{header|Picat}}==
<
main =>
Line 7,160:
Pad2 is Pad-Pad1,
printf("%*s%s%*s",Pad1,"",Word,Pad2,"").
</syntaxhighlight>
{{out}}
<pre>
Line 7,188:
=={{header|PicoLisp}}==
<
(let Lines # and of lines
(make
Line 7,208:
(prinl)
(for L Lines
(prinl (apply center L Sizes)) ) ) ) # and centered</
{{out}}
<pre>Given a text file of many lines, where fields within a line
Line 7,232:
=={{header|PL/I}}==
<
declare text character (300) varying;
declare word character (20) varying;
Line 7,270:
put file (output) skip;
end;
</syntaxhighlight>
=={{header|PowerShell}}==
<
$file =
@'
Line 7,296:
}
$arr | Format-Table -HideTableHeaders -Wrap *
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 7,309:
=={{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
Line 7,388:
{N2 is N1 + 1},
parse_word(T, N2, NF, TF).
</syntaxhighlight>
{{out}}
Line 7,420:
=={{header|PureBasic}}==
{{works with|PureBasic|4.41}}
<
If OpenConsole()
Line 7,494:
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."
EndDataSection</
=={{header|Python}}==
===Procedural===
====Using f-strings====
<
txt = """Given$a$txt$file$of$many$lines,$where$fields$within$a$line$
Line 7,518:
print(' '.join(f"{wrd:{j}{wdth}}" for wdth, wrd in zip(widths, line)))
print("- " * 52)
</syntaxhighlight>
{{out}}
Line 7,550:
====Using StringIO====
<
textinfile = '''Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 7,594:
infile = StringIO(textinfile)
print "\n# %s Column-aligned output:" % align
print aligner(infile, align[0])</
{{out}}
Line 7,625:
Works with Python 2 and 3.
<
cat <<'EOF' > align_columns.dat
Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 7,642:
for row in rows:
print(' '.join(fmts).format(*(row + [''] * len(fmts))))
print('')</
====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$
Line 7,667:
print(justify(word, max_widths[j]), end=' ')
print()
print("- " * 52)</
===Functional===
Line 7,675:
(Selection of string justification methods via '''getattr'''):
{{Works with|Python|3.7}}
<
from delimited text.
'''
Line 7,749:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Given a text file of many lines, where fields within a line
Line 7,773:
=={{header|q}}==
<
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$";
"are$delineated$by$a$single$'dollar'$character,$write$a$program";
Line 7,786:
ps:$[aln=`R;-1-cw;1+cw]$''s; / padded strings
ps:$[aln=`C;(neg(cw-sl)div 2)rotate''ps;ps]; / center
1,[;"\n\n"]"\n"sv raze each ps; } / print</
{{out}}
<pre>q)ta[`L]text
Line 7,814:
=={{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
Line 7,838:
print0(leftjust)
print0(rightjust)
print0(centrejust)</
Right justified output shown.
<div style="width:full;overflow:scroll"><pre>
Line 7,850:
=={{header|Racket}}==
<
#lang racket
Line 7,885:
(display-aligned #:justify 'right text)
(display-aligned #:justify 'center text)
</syntaxhighlight>
=={{header|Raku}}==
Line 7,893:
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
Line 7,915:
default { $word ~ " " x $lr }
}
}</
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);
Line 7,925:
my $format = @widths.map( '%' ~ ++$ ~ '$' ~ $align ~ * ~ 's' ).join(' ') ~ "\n";
printf $format, |$_ for @lines;
}</
=={{header|RapidQ}}==
<syntaxhighlight lang=vb>
Dim MText as QMemorystream
MText.WriteLine "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
Line 7,970:
TextCenter = TextCenter + Newline
next
</syntaxhighlight>
{{out}}
<pre style="height:20ex;overflow:scroll">TextLeft contains:
Line 7,998:
=={{header|REBOL}}==
<
Title: "Align Columns"
URL: http://rosettacode.org/wiki/Align_columns
Line 8,055:
foreach i [left centre right] [
print ["^/Align" i "...^/"] entable data get i]
</syntaxhighlight>
{{out}}
Line 8,087:
=={{header|Red}}==
<
Title: "Align Columns"
Original-Author: oofoe
Line 8,145:
foreach i [left centre right] [
print [newline "Align" i "..." newline] entable data get i]</
=={{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"
Line 8,197:
end
say out
end</
===(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$"
Line 8,229:
say substr(_, 2) /*ignore the leading extra blank. */
end /*r*/
end /*j*/ /*stick a fork in it, we're all done. */</
{{out|output|text= when using the default input:}}
<pre>
Line 8,261:
===(boxed output)===
Note: 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$"
Line 8,297:
end /*r*/ /* [↑] shows words in boxes. */
say translate(bot, '┴', "┬") /*display the bottom line of the box. */
end /*j*/ /*stick a fork in it, we're all done. */</
{{out|output|text= when using the default input:}}
<pre>
Line 8,335:
=={{header|Ruby}}==
{{works with|Ruby|1.9.3+}}
<
=begin
Line 8,378:
puts aligner(infile, align)
end
</syntaxhighlight>
{{out}}
Line 8,408:
=={{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$"_
Line 8,446:
wend
print
end function</
{{out}}
<pre style="height:15ex;overflow:scroll">------------ align:left -- across:6 ------------
Line 8,486:
=={{header|Rust}}==
<
enum AlignmentType {
Line 8,549:
println!("{}", repeat('-').take(110).collect::<String>());
println!("{}", align_columns(text, AlignmentType::Right));
}</
{{out}}
<pre style="height:15ex;overflow:scroll">
Line 8,581:
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)
Line 8,608:
alignFile(filename, alignment) foreach println
}
}</
Another take:
<
val padsize = (i-s.length).max(0)
d match {
Line 8,633:
val padded = words map ( _.zipWithIndex.map{case(s,i)=>pad(s,maxlens(i),"center")+" "} )
padded map (_.reduceLeft(_ + _)) foreach println</
=={{header|Scheme}}==
<
(import (scheme base)
(scheme write)
Line 8,691:
(align-columns *example* 'center)
(align-columns *example* 'right)
</syntaxhighlight>
{{out}}
Line 8,723:
=={{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>...
Line 8,799:
bnextline
}
</syntaxhighlight>
Example:
<pre>
Line 8,819:
=={{header|Seed7}}==
<
const array string: inputLines is [] (
Line 8,870:
writeln;
end for;
end func;</
{{out}}
Line 8,883:
=={{header|Shiny}}==
<
are$delineated$by$a$single$\'dollar\'$character,$write$a$program
that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$
Line 8,921:
align text 'left'
align text 'center'
align text 'right'</
<pre>Given a text file of many lines, where fields within a line
Line 8,945:
=={{header|Sidef}}==
<
method align(j) {
text.map { |row|
Line 8,991:
say f.align(left);
say f.align(middle);
say f.align(right);</
=={{Header|Smalltalk}}==
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
Line 9,065:
Stdout cr; printCR:'Centered with box:'.
printCentered value:text value:true.</
{{out}}
<pre>Left justified:
Line 9,138:
=={{header|Snobol}}==
{{works with|Snobol|4}}
<
* we store the words and field widths in tables
Words = TABLE()
Line 9,230:
END
</syntaxhighlight>
{{Out}}
Line 9,259:
=={{header|Standard ML}}==
<
fun uncurry f (x, y) = f x y
Line 9,287:
(* test stdin with all alignments *)
val () = print (String.concatWith "\n\n"
(map (formatTable (readTable TextIO.stdIn)) [alignL, alignC, alignR]) ^ "\n")</
{{out}}
<pre>Given a text file of many lines, where fields within a line
Line 9,315:
{{trans|Rust}}
<
extension String {
Line 9,400:
print(alignCols(input: input, align: .center))
print()
print(alignCols(input: input, align: .right))</
{{out}}
Line 9,428:
=={{header|Tcl}}==
<
set text {Given$a$text$file$of$many$lines,$where$fields$within$a$line$
Line 9,475:
}
puts ""
}</
{{out}}
<pre>Given a text file of many lines, where fields within a line
Line 9,501:
Transd has built-in support for "left" and "right" formatting, but not "centered", which added quite a bit of code.
<
MainModule : {
Line 9,543:
(lout "") (print true)
)
}</
<pre>
Given a text file of many lines, where fields within a line
Line 9,568:
=={{header|TSE SAL}}==
<
INTEGER PROC FNBlockChangeColumnAlignLeftB( INTEGER columnTotalI, INTEGER spaceTotalI, INTEGER buffer1I )
INTEGER B = FALSE
Line 9,702:
GotoBufferId( bufferI )
END
</syntaxhighlight>
{{out}} <pre>
Given a text file of many lines, where fields within a line
Line 9,713:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
MODE DATA
Line 9,736:
ENDLOOP
SET exampletext=JOIN(new1,"$",new2,new3,new4,new5,new6,new7,new8,new9,new10,new11,new12)
</syntaxhighlight>
{{out}}
<pre>
Line 9,750:
=={{header|TXR}}==
<
@ (coll)@{item /[^$]+/}@(end)
@(end)
Line 9,776:
@{pi @(- [cw i] (trunc (- [cw i] (length pi)) 2))} @(end)
@ (end)
@(end)</
<pre>$ txr align-columns.txr align-columns.dat
Line 9,800:
=={{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
Line 9,838:
exit
EOF_OUTER
</syntaxhighlight>
{{out}}
<syntaxhighlight lang=sh>
$ ./just-nocenter.sh
Given a text file of many lines, where fields within a line
Line 9,855:
Further, allow for each word in a column to be either left
justified, right justified, or center justified within its column.
</syntaxhighlight>
The centered output will be added later, when I've more time. '' I did this in about 10 minutes.''
Line 9,862:
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}}
Line 9,879:
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 =
Line 9,898:
#show+
main = mat0 <.just_left,just_center,just_right> text</
{{out}}
<pre style="height:17ex;overflow:scroll">
Line 9,927:
Both arguments are optional and default to "left" and 1 respectively.
<syntaxhighlight lang=vb>
Public Sub TestSplit(Optional align As String = "left", Optional spacing As Integer = 1)
Dim word() As String
Line 9,993:
Next l
End Sub
</syntaxhighlight>
{{out}}
Line 10,017:
=={{header|VBScript}}==
{{trans|Rexx}}
<
Const nr=16, nc=16
ReDim d(nc),t(nr), wor(nr,nc)
Line 10,079:
xRTrim = cc
End Function 'xRTrim
</syntaxhighlight>
{{out}}
<pre>
Line 10,109:
=={{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
Line 10,148:
}
Line(1, ERRBREAK)
}</
{{out}}
Line 10,176:
=={{header|Visual Basic}}==
<
Dim i&, j&, D&, L&, R&: ReDim W(UBound(Lines)): ReDim C&(0)
Line 10,191:
Debug.Print Space(L); W(j)(i); Space(R); IIf(i < UBound(W(j)), "", vbLf);
Next i, j
End Sub</
Usage:<
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 & _
Line 10,203:
Debug.Print vbLf; "-- Center:": AlignCols Split(Text, vbLf), vbCenter
Debug.Print vbLf; "-- Right:": AlignCols Split(Text, vbLf), vbRightJustify
End Sub</
{{out}}
<pre>-- Left:
Line 10,230:
=={{header|Visual Basic .NET}}==
<
Private Delegate Function Justification(s As String, width As Integer) As String
Line 10,294:
End Sub
End Module</
{{out}}
Line 10,323:
=={{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
Line 10,391:
f.print(Justify.middle)
f.print(Justify.right)
}</
{{out}}
Line 10,419:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
import "/fmt" for Fmt
Line 10,472:
var fileName = "align_cols.txt"
var lines = getLines.call(fileName)
for (i in 0..2) alignCols.call(lines, i)</
{{out}}
Line 10,503:
=={{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$"
Line 10,569:
wend
print
end sub</
{{out}}
<pre>Same as Run BASIC entry.</pre>
=={{header|zkl}}==
<
words:=text.split("$").apply("split").flatten();
max:=words.reduce(fcn(p,n){ n=n.len(); n>p and n or p },0);
Line 10,589:
do{ w.pump(wordsPerCol,d,fmt).append("\n") } while(not w.atEnd);
d.text;
}</
<
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"
"are$delineated$by$a$single$'dollar'$character,$write$a$program\n"
Line 10,600:
format(text,-1).print();
format(text, 0).print();
format(text, 1).print();</
Blow apart the text into a list of words, find max len of any word, calc how many words will fit on a 80 col line, format all words into a bit bucket line at a time. Formatting is "%-ms" or "%ms" for left & right justify (m is field width), calculated for center. fmt is the string format method or center calc function, depending. Where string formatting can be used, it would be better to format all words in a line in one go but the code would be longer.
{{out}}
Line 10,637:
=={{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$"
Line 10,683:
3090 NEXT i
3095 PRINT
3100 RETURN</
{{out}}Left alignement example:
|