Align columns: Difference between revisions

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

justified,$right$justified,$or$center$justified$within$its$column.</pre>

 

Note that:

 

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

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

justified, right justified, or center justified within its column.</pre>

 

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

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

</pre>

 

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

 

)

 

 

{

}

 

 

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

}

}

END {

}

}

 

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

See [[Column Aligner/C]]

 

Uses a delegate, which were added to the language in C# 2, to define left-, right-, or center-justified.

 

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

 

class ColumnAlignerProgram

{

}

}

 

 

 

=={{header|C++}}==

 

=={{header|Clojure}}==

(ns rosettacode.align-columns

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

 

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

 

=={{header|CoffeeScript}}==

pad = (n) ->

s = ''

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

align input, alignment

> coffee align_columns.coffee

 

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|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')

 

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

 

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

 

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

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

=={{header|Forth}}==

{{works with|GNU Forth}}

 

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

\ cleanup

nip free throw

 

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

 

<pre style="height:25ex;overflow:scroll">Left Justified:

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

 

=={{header|Haskell}}==

 

 

 

where

rows = map brkdwn $ lines ls

align cw w =

case j of

<pre>

*Main> mapM_ putStrLn $ format 'c' dat

column are separated by at least one space.

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

 

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

 

=={{header|J}}==

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

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

 

 

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

 

=={{header|jq}}==

{{ Works with|jq|1.4}}

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

<pre>

Left column-aligned output:

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

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

</pre>

 

=={{header|Lasso}}==

 

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

}

 

 

<pre>Left aligned result:

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

 

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