Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
3
Task/Align-columns/00-META.yaml
Normal file
3
Task/Align-columns/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Align_columns
|
||||
note: Text processing
|
||||
28
Task/Align-columns/00-TASK.txt
Normal file
28
Task/Align-columns/00-TASK.txt
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
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.
|
||||
|
||||
<br clear=all>Use the following text to test your programs:
|
||||
<pre>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.</pre>
|
||||
|
||||
|
||||
Note that:
|
||||
# The example input texts lines may, or may not, have trailing dollar characters.
|
||||
# All columns should share the same alignment.
|
||||
# Consecutive space characters produced adjacent to the end of lines are insignificant for the purposes of the task.
|
||||
# Output text will be viewed in a mono-spaced font on a plain text editor or basic terminal.
|
||||
# The minimum space between columns should be computed from the text and not hard-coded.
|
||||
# It is ''not'' a requirement to add separating characters between or around columns.
|
||||
|
||||
|
||||
{{Template:Strings}}
|
||||
<br><br>
|
||||
|
||||
24
Task/Align-columns/11l/align-columns.11l
Normal file
24
Task/Align-columns/11l/align-columns.11l
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
V txt = ‘Given$a$txt$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.’
|
||||
|
||||
V parts = txt.split("\n").map(line -> line.rtrim(‘$’).split(‘$’))
|
||||
V max_widths = [0] * parts[0].len
|
||||
L(line) parts
|
||||
L(word) line
|
||||
max_widths[L.index] = max(max_widths[L.index], word.len)
|
||||
|
||||
((String, Int) -> String) ljust = (s, w) -> s‘’(‘ ’ * (w - s.len))
|
||||
((String, Int) -> String) centr = (s, w) -> (‘ ’ * (w - s.len - (w I/ 2 - s.len I/ 2)))‘’s‘’(‘ ’ * (w I/ 2 - s.len I/ 2))
|
||||
((String, Int) -> String) rjust = (s, w) -> (‘ ’ * (w - s.len))‘’s
|
||||
|
||||
L(justify) [ljust, centr, rjust]
|
||||
print([‘Left’, ‘Center’, ‘Right’][L.index]‘ column-aligned output:’)
|
||||
L(line) parts
|
||||
L(word) line
|
||||
print(justify(word, max_widths[L.index]), end' ‘ ’)
|
||||
print()
|
||||
print(‘- ’ * 52)
|
||||
180
Task/Align-columns/360-Assembly/align-columns.360
Normal file
180
Task/Align-columns/360-Assembly/align-columns.360
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
* Align columns 12/04/2019
|
||||
ALICOL CSECT
|
||||
USING ALICOL,R13 base register
|
||||
B 72(R15) skip savearea
|
||||
DC 17F'0' savearea
|
||||
SAVE (14,12) save previous context
|
||||
ST R13,4(R15) link backward
|
||||
ST R15,8(R13) link forward
|
||||
LR R13,R15 set addressability
|
||||
LA R8,1 i=1
|
||||
DO WHILE=(C,R8,LE,=A(NI)) do r=1 to hbound(t)
|
||||
LA R7,1 j=1
|
||||
LA R6,L'T i=length(t)
|
||||
DO WHILE=(C,R6,GE,=A(1)) do i=length(t) to 1 by -1
|
||||
LR R1,R8 r
|
||||
MH R1,=AL2(L'T) ~
|
||||
LA R4,T-L'T(R1) t(r)
|
||||
BCTR R4,0 -1
|
||||
AR R4,R6 +i
|
||||
MVC CI,0(R4) ci=substr(t(r),i,1)
|
||||
CLI CI,C' ' if ci=' '
|
||||
BE ITERI1 then iterate i
|
||||
CLI CI,C'$' if ci='$'
|
||||
BE ITERI1 then iterate i
|
||||
LR R7,R6 j=i
|
||||
B LEAVEI1 leave i
|
||||
ITERI1 BCTR R6,0 i--
|
||||
ENDDO , enddo i
|
||||
LEAVEI1 LR R1,R8 r
|
||||
MH R1,=AL2(L'T) ~
|
||||
LA R4,T-L'T(R1) @t(r)
|
||||
LA R2,WT @wt
|
||||
LR R5,R7 j
|
||||
ICM R5,B'1000',=C' ' padding
|
||||
LA R3,L'T length(wt)
|
||||
MVCL R2,R4 wt=substr(t(r),1,j)
|
||||
LA R0,1 1
|
||||
ST R0,I0 i0=1
|
||||
SR R9,R9 c=0
|
||||
LA R6,1 i=1
|
||||
DO WHILE=(CR,R6,LE,R7) do i=1 to j
|
||||
LA R4,WT-1 @wt
|
||||
AR R4,R6 i
|
||||
MVC CI(1),0(R4) ci=substr(wt,i,1)
|
||||
IF CLI,CI,EQ,C'$' THEN if ci='$' then
|
||||
BAL R14,SEQ call seq
|
||||
LR R2,R6 i
|
||||
LA R2,1(R2) +1
|
||||
ST R2,I0 i0=i+1
|
||||
ENDIF , endif
|
||||
LA R6,1(R6) i++
|
||||
ENDDO , enddo i
|
||||
BAL R14,SEQ call seq
|
||||
IF C,R9,GT,COLS THEN if c>cols then
|
||||
ST R9,COLS cols=c
|
||||
ENDIF , endif
|
||||
LA R8,1(R8) r++
|
||||
ENDDO , enddo r
|
||||
LR R2,R8 r
|
||||
BCTR R2,0 -1
|
||||
ST R2,ROWS rows=r-1
|
||||
LA R7,1 j=1
|
||||
DO WHILE=(C,R7,LE,=A(3)) do j=1 to 3
|
||||
XPRNT =C'--',2 print
|
||||
LA R8,1 r=1
|
||||
DO WHILE=(C,R8,LE,ROWS) do r=1 to rows
|
||||
MVC PG,=CL120' ' pg=' '
|
||||
LA R0,1 1
|
||||
ST R0,IB ib=1
|
||||
LA R9,1 c=1
|
||||
DO WHILE=(C,R9,LE,COLS) do c=1 to cols
|
||||
LR R1,R8 r
|
||||
BCTR R1,0 -1
|
||||
MH R1,=AL2(NJ) ~
|
||||
AR R1,R9 c
|
||||
MH R1,=AL2(L'WOR) ~
|
||||
LA R4,WOR-L'WOR(R1) @wor(r,c)
|
||||
MVC W,0(R4) w=wor(r,c)
|
||||
LA R6,L'W i=length(w)
|
||||
DO WHILE=(C,R6,GE,=A(1)) do i=length(w) to 1 by -1
|
||||
LA R4,W-1 @w
|
||||
AR R4,R6 i
|
||||
MVC CI,0(R4) ci=substr(w,i,1)
|
||||
CLI CI,C' ' if ci^=' '
|
||||
BNE LEAVEI2 then goto leavei2;
|
||||
BCTR R6,0 i--
|
||||
ENDDO , enddo i
|
||||
LEAVEI2 EQU * ~
|
||||
IF LTR,R6,Z,R6 THEN if i=0 then
|
||||
LA R10,1 l=1
|
||||
ELSE , else
|
||||
LR R10,R6 l=i
|
||||
ENDIF , endif
|
||||
IF C,R7,EQ,=F'1' THEN if j=1 then
|
||||
L R11,IB ibx=ib
|
||||
ENDIF , endif
|
||||
IF C,R7,EQ,=F'2' THEN if j=2 then
|
||||
LR R1,R9 c
|
||||
SLA R1,2 ~
|
||||
L R11,WID-L'WID(R1) wid(c)
|
||||
A R11,IB +ib
|
||||
SR R11,R10 ibx=ib+wid(c)-l
|
||||
ENDIF , endif
|
||||
IF C,R7,EQ,=F'3' THEN if j=3 then
|
||||
LR R1,R9 c
|
||||
SLA R1,2 ~
|
||||
L R11,WID-L'WID(R1) wid(c)
|
||||
SR R11,R10 -l
|
||||
SRA R11,1 /2
|
||||
A R11,IB ibx=ib+(wid(c)-l)/2
|
||||
ENDIF , endif
|
||||
LA R2,PG-1 @pg
|
||||
AR R2,R11 +ibx
|
||||
LR R3,R10 l
|
||||
LA R4,W @w
|
||||
LR R5,R10 l
|
||||
MVCL R2,R4 substr(pg,ibx,l)=substr(w,1,l)
|
||||
LR R1,R9 c
|
||||
SLA R1,2 ~
|
||||
L R2,WID-L'WID(R1) wid(c)
|
||||
A R2,IB +ib
|
||||
LA R2,1(R2) +1
|
||||
ST R2,IB ib=ib+wid(c)+1
|
||||
LA R9,1(R9) c++
|
||||
ENDDO , enddo c
|
||||
XPRNT PG,L'PG print
|
||||
LA R8,1(R8) r++
|
||||
ENDDO , enddo r
|
||||
LA R7,1(R7) j++
|
||||
ENDDO , enddo j
|
||||
L R13,4(0,R13) restore previous savearea pointer
|
||||
RETURN (14,12),RC=0 restore registers from calling sav
|
||||
SEQ EQU * --begin seq
|
||||
LA R9,1(R9) c=c+1
|
||||
LR R10,R6 i
|
||||
S R10,I0 l=i-i0
|
||||
LA R4,WT-1 @wt
|
||||
A R4,I0 +i0
|
||||
LR R5,R10 l
|
||||
ICM R5,B'1000',=C' ' padding
|
||||
LR R1,R8 r
|
||||
BCTR R1,0 -1
|
||||
MH R1,=AL2(NJ) ~
|
||||
AR R1,R9 +c
|
||||
MH R1,=AL2(L'WOR) ~
|
||||
LA R2,WOR-L'WOR(R1) @wor(r,c)
|
||||
LA R3,L'WOR length(wor)
|
||||
MVCL R2,R4 wor(r,c)=substr(wt,i0,l)
|
||||
LR R1,R9 c
|
||||
SLA R1,2 ~
|
||||
L R2,WID-L'WID(R1) wid(c)
|
||||
IF CR,R2,LT,R10 THEN if l>wid(c) then
|
||||
LR R1,R9 c
|
||||
SLA R1,2 ~
|
||||
ST R10,WID-L'WID(R1) wid(c)=l
|
||||
ENDIF , endif
|
||||
BR R14 --end seq
|
||||
NI EQU 6 ni
|
||||
NJ EQU 12 nj
|
||||
T DC CL68'Given$a$text$file$of$many$lines,$where$fields$within$a$line$'
|
||||
DC CL68'are$delineated$by$a$single$''dollar''$character,$write$a$progX
|
||||
ramm'
|
||||
DC CL68'that$aligns$each$column$of$fields$by$ensuring$that$words$in$eX
|
||||
ach$'
|
||||
DC CL68'column$are$separated$by$at$least$one$space.'
|
||||
DC CL68'Further,$allow$for$each$word$in$a$column$to$be$either$left$'
|
||||
DC CL68'justified,$right$justified,$or$center$justified$within$its$coX
|
||||
lumn.'
|
||||
WOR DC (NI*NJ)CL10' ' wor(ni,nj) char(10)
|
||||
WID DC 16F'0' wid(16)
|
||||
COLS DC F'0'
|
||||
ROWS DC F'0'
|
||||
WT DS CL(L'T)
|
||||
W DS CL(L'WOR)
|
||||
CI DS CL1
|
||||
I0 DS F
|
||||
IB DS F
|
||||
PG DS CL120
|
||||
REGEQU
|
||||
END ALICOL
|
||||
44
Task/Align-columns/8th/align-columns.8th
Normal file
44
Task/Align-columns/8th/align-columns.8th
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
quote | 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.|
|
||||
var, raw-text
|
||||
|
||||
[] var, data
|
||||
var width
|
||||
|
||||
: read-and-parse \ --
|
||||
raw-text @
|
||||
( "$" s:/ data @ swap a:push drop )
|
||||
s:eachline ;
|
||||
|
||||
: find-widest \ -- n
|
||||
data @ ( ( swap s:len nip n:max ) swap a:reduce ) 0 a:reduce ;
|
||||
|
||||
: print-data \ fmt --
|
||||
width @ swap s:strfmt >r
|
||||
data @
|
||||
(
|
||||
nip
|
||||
(
|
||||
nip
|
||||
r@ s:strfmt .
|
||||
) a:each drop
|
||||
|
||||
cr
|
||||
) a:each drop rdrop ;
|
||||
|
||||
|
||||
: app:main
|
||||
read-and-parse
|
||||
|
||||
\ find widest column, and add one for the space:
|
||||
find-widest n:1+ width !
|
||||
|
||||
\ print the data
|
||||
cr "right:" . cr "%%>%ds" print-data
|
||||
cr "left:" . cr "%%<%ds" print-data
|
||||
cr "center:" . cr "%%|%ds" print-data
|
||||
bye ;
|
||||
328
Task/Align-columns/AArch64-Assembly/align-columns.aarch64
Normal file
328
Task/Align-columns/AArch64-Assembly/align-columns.aarch64
Normal file
|
|
@ -0,0 +1,328 @@
|
|||
/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */
|
||||
/* program alignColumn64.s */
|
||||
|
||||
/*******************************************/
|
||||
/* Constantes file */
|
||||
/*******************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly*/
|
||||
.include "../includeConstantesARM64.inc"
|
||||
|
||||
.equ BUFFERSIZE, 16 * 10
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessLeft: .asciz "LEFT :\n"
|
||||
szMessRight: .asciz "\nRIGHT :\n"
|
||||
szMessCenter: .asciz "\nCENTER :\n"
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
szLine1: .asciz "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
szLine2: .asciz "are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
szLine3: .asciz "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
szLine4: .asciz "column$are$separated$by$at$least$one$space."
|
||||
szLine5: .asciz "Further,$allow$for$each$word$in$a$column$to$be$either$left$"
|
||||
szLine6: .asciz "justified,$right$justified,$or$center$justified$within$its$column."
|
||||
|
||||
.align 8
|
||||
qtbPtLine: .quad szLine1,szLine2,szLine3,szLine4,szLine5,szLine6
|
||||
.equ NBLINES, (. - qtbPtLine) / 8
|
||||
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: // entry of program
|
||||
ldr x0,qAdrqtbPtLine
|
||||
bl computeMaxiLengthWords
|
||||
mov x19,x0 // column counter
|
||||
ldr x0,qAdrszMessLeft
|
||||
bl affichageMess
|
||||
ldr x0,qAdrqtbPtLine
|
||||
mov x1,x19 // column size
|
||||
bl alignLeft
|
||||
ldr x0,qAdrszMessRight
|
||||
bl affichageMess
|
||||
ldr x0,qAdrqtbPtLine
|
||||
mov x1,x19 // column size
|
||||
bl alignRight
|
||||
ldr x0,qAdrszMessCenter
|
||||
bl affichageMess
|
||||
ldr x0,qAdrqtbPtLine
|
||||
mov x1,x19 // column size
|
||||
bl alignCenter
|
||||
100: // standard end of the program
|
||||
mov x0, #0 // return code
|
||||
mov x8, #EXIT // request to exit program
|
||||
svc #0 // perform the system call
|
||||
qAdrszCarriageReturn: .quad szCarriageReturn
|
||||
qAdrszMessLeft: .quad szMessLeft
|
||||
qAdrszMessRight: .quad szMessRight
|
||||
qAdrszMessCenter: .quad szMessCenter
|
||||
qAdrqtbPtLine: .quad qtbPtLine
|
||||
/******************************************************************/
|
||||
/* compute maxi words */
|
||||
/******************************************************************/
|
||||
/* x0 contains adresse pointer array */
|
||||
computeMaxiLengthWords:
|
||||
stp fp,lr,[sp,-16]! // save registres
|
||||
mov x2,#0 // indice pointer array
|
||||
mov x3,#0 // maxi length words
|
||||
1:
|
||||
ldr x1,[x0,x2,lsl #3] // load pointer
|
||||
mov x4,#0 // length words counter
|
||||
mov x5,#0 // indice line character
|
||||
2:
|
||||
ldrb w6,[x1,x5] // load a line character
|
||||
cmp x6,#0 // line end ?
|
||||
beq 4f
|
||||
cmp x6,#'$' // separator ?
|
||||
bne 3f
|
||||
cmp x4,x3
|
||||
csel x3,x4,x3,gt // if greather replace maxi
|
||||
mov x4,#-1 // raz length counter
|
||||
3:
|
||||
add x4,x4,#1
|
||||
add x5,x5,#1 // increment character indice
|
||||
b 2b // and loop
|
||||
4: // end line
|
||||
cmp x4,x3 // compare word counter and maxi
|
||||
csel x3,x4,x3,gt // if greather replace maxi
|
||||
add x2,x2,#1 // increment indice line pointer
|
||||
cmp x2,#NBLINES // maxi ?
|
||||
blt 1b // no -> loop
|
||||
|
||||
mov x0,x3 // return maxi length counter
|
||||
100:
|
||||
ldp fp,lr,[sp],16 // restaur des 2 registres
|
||||
ret
|
||||
|
||||
/******************************************************************/
|
||||
/* align left */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of pointer array*/
|
||||
/* x1 contains column size */
|
||||
alignLeft:
|
||||
stp fp,lr,[sp,-16]! // save registres
|
||||
sub sp,sp,#BUFFERSIZE // reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov x5,x0 // array address
|
||||
mov x2,#0 // indice array
|
||||
1:
|
||||
ldr x3,[x5,x2,lsl #3] // load line pointer
|
||||
mov x4,#0 // line character indice
|
||||
mov x7,#0 // output buffer character indice
|
||||
mov x6,#0 // word lenght
|
||||
2:
|
||||
ldrb w0,[x3,x4] // load a character line
|
||||
strb w0,[fp,x7] // store in buffer
|
||||
cmp w0,#0 // line end ?
|
||||
beq 6f
|
||||
cmp w0,#'$' // separator ?
|
||||
bne 5f
|
||||
mov x0,#' '
|
||||
strb w0,[fp,x7] // replace $ by space
|
||||
3:
|
||||
cmp x6,x1 // length word >= length column
|
||||
bge 4f
|
||||
add x7,x7,#1
|
||||
mov x0,#' '
|
||||
strb w0,[fp,x7] // add space to buffer
|
||||
add x6,x6,#1
|
||||
b 3b // and loop
|
||||
4:
|
||||
mov x6,#-1 // raz word length
|
||||
5:
|
||||
add x4,x4,#1 // increment line indice
|
||||
add x7,x7,#1 // increment buffer indice
|
||||
add x6,x6,#1 // increment word length
|
||||
b 2b
|
||||
|
||||
6:
|
||||
mov x0,#'\n'
|
||||
strb w0,[fp,x7] // return line
|
||||
add x7,x7,#1
|
||||
mov x0,#0
|
||||
strb w0,[fp,x7] // final zéro
|
||||
mov x0,fp
|
||||
bl affichageMess // display output buffer
|
||||
add x2,x2,#1
|
||||
cmp x2,#NBLINES
|
||||
blt 1b
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
ldp fp,lr,[sp],16 // restaur des 2 registres
|
||||
ret
|
||||
/******************************************************************/
|
||||
/* align right */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of pointer array*/
|
||||
/* x1 contains column size */
|
||||
alignRight:
|
||||
stp fp,lr,[sp,-16]! // save registres
|
||||
sub sp,sp,#BUFFERSIZE // reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov x5,x0 // array address
|
||||
mov x2,#0 // indice array
|
||||
1:
|
||||
ldr x3,[x5,x2,lsl #3] // load line pointer
|
||||
mov x4,#0 // line character indice
|
||||
mov x7,#0 // output buffer character indice
|
||||
mov x6,#0 // word lenght
|
||||
mov x8,x3 // word begin address
|
||||
2: // compute word length
|
||||
ldrb w0,[x3,x4] // load a character line
|
||||
cmp w0,#0 // line end ?
|
||||
beq 3f
|
||||
cmp w0,#'$' // separator ?
|
||||
beq 3f
|
||||
add x4,x4,#1 // increment line indice
|
||||
add x6,x6,#1 // increment word length
|
||||
b 2b
|
||||
|
||||
3:
|
||||
cmp x6,#0
|
||||
beq 4f
|
||||
sub x6,x1,x6 // compute left spaces to add
|
||||
4: // loop add spaces to buffer
|
||||
cmp x6,#0
|
||||
blt 5f
|
||||
mov x0,#' '
|
||||
strb w0,[fp,x7] // add space to buffer
|
||||
add x7,x7,#1
|
||||
sub x6,x6,#1
|
||||
b 4b // and loop
|
||||
5:
|
||||
mov x9,#0
|
||||
6: // copy loop word to buffer
|
||||
ldrb w0,[x8,x9]
|
||||
cmp x0,#'$'
|
||||
beq 7f
|
||||
cmp x0,#0 // line end
|
||||
beq 8f
|
||||
strb w0,[fp,x7]
|
||||
add x7,x7,#1
|
||||
add x9,x9,#1
|
||||
b 6b
|
||||
7:
|
||||
add x8,x8,x9
|
||||
add x8,x8,#1 // new word begin
|
||||
mov x6,#0 // raz word length
|
||||
add x4,x4,#1 // increment line indice
|
||||
b 2b
|
||||
|
||||
8:
|
||||
mov x0,#'\n'
|
||||
strb w0,[fp,x7] // return line
|
||||
add x7,x7,#1
|
||||
mov x0,#0
|
||||
strb w0,[fp,x7] // final zéro
|
||||
mov x0,fp
|
||||
bl affichageMess // display output buffer
|
||||
add x2,x2,#1
|
||||
cmp x2,#NBLINES
|
||||
blt 1b
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
ldp fp,lr,[sp],16 // restaur des 2 registres
|
||||
ret
|
||||
/******************************************************************/
|
||||
/* align center */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of pointer array*/
|
||||
/* x1 contains column size */
|
||||
alignCenter:
|
||||
stp fp,lr,[sp,-16]! // save registres
|
||||
sub sp,sp,#BUFFERSIZE // reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov x5,x0 // array address
|
||||
mov x2,#0 // indice array
|
||||
1:
|
||||
ldr x3,[x5,x2,lsl #3] // load line pointer
|
||||
mov x4,#0 // line character indice
|
||||
mov x7,#0 // output buffer character indice
|
||||
mov x6,#0 // word length
|
||||
mov x8,x3 // word begin address
|
||||
2: // compute word length
|
||||
ldrb w0,[x3,x4] // load a character line
|
||||
cmp w0,#0 // line end ?
|
||||
beq 3f
|
||||
cmp w0,#'$' // separator ?
|
||||
beq 3f
|
||||
add x4,x4,#1 // increment line indice
|
||||
add x6,x6,#1 // increment word length
|
||||
b 2b
|
||||
3:
|
||||
cmp x6,#0
|
||||
beq 5f
|
||||
sub x6,x1,x6 // total spaces number to add
|
||||
mov x12,x6
|
||||
lsr x6,x6,#1 // divise by 2 = left spaces number
|
||||
4:
|
||||
cmp x6,#0
|
||||
blt 5f
|
||||
mov x0,#' '
|
||||
strb w0,[fp,x7] // add space to buffer
|
||||
add x7,x7,#1 // increment output indice
|
||||
sub x6,x6,#1 // decrement number space
|
||||
b 4b // and loop
|
||||
5:
|
||||
mov x9,#0
|
||||
6: // copy loop word to buffer
|
||||
ldrb w0,[x8,x9]
|
||||
cmp x0,#'$' // séparator ?
|
||||
beq 7f
|
||||
cmp x0,#0 // line end ?
|
||||
beq 10f
|
||||
strb w0,[fp,x7]
|
||||
add x7,x7,#1
|
||||
add x9,x9,#1
|
||||
b 6b
|
||||
7:
|
||||
lsr x6,x12,#1 // divise total spaces by 2
|
||||
sub x6,x12,x6 // and compute number spaces to right side
|
||||
8: // loop to add right spaces
|
||||
cmp x6,#0
|
||||
ble 9f
|
||||
mov x0,#' '
|
||||
strb w0,[fp,x7] // add space to buffer
|
||||
add x7,x7,#1
|
||||
sub x6,x6,#1
|
||||
b 8b // and loop
|
||||
|
||||
9:
|
||||
add x8,x8,x9
|
||||
add x8,x8,#1 // new address word begin
|
||||
mov x6,#0 // raz word length
|
||||
add x4,x4,#1 // increment line indice
|
||||
b 2b // and loop new word
|
||||
|
||||
10:
|
||||
mov x0,#'\n'
|
||||
strb w0,[fp,x7] // return line
|
||||
add x7,x7,#1
|
||||
mov x0,#0
|
||||
strb w0,[fp,x7] // final zéro
|
||||
mov x0,fp
|
||||
bl affichageMess // display output buffer
|
||||
add x2,x2,#1 // increment line indice
|
||||
cmp x2,#NBLINES // maxi ?
|
||||
blt 1b // loop
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
ldp fp,lr,[sp],16 // restaur des 2 registres
|
||||
ret
|
||||
/********************************************************/
|
||||
/* File Include fonctions */
|
||||
/********************************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly */
|
||||
.include "../includeARM64.inc"
|
||||
77
Task/Align-columns/ABAP/align-columns.abap
Normal file
77
Task/Align-columns/ABAP/align-columns.abap
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
report z_align no standard page header.
|
||||
start-of-selection.
|
||||
|
||||
data: lt_strings type standard table of string,
|
||||
lv_strings type string.
|
||||
append: 'Given$a$text$file$of$many$lines,$where$fields$within$a$line$' to lt_strings,
|
||||
'are$delineated$by$a$single$''dollar''$character,$write$a$program' to lt_strings,
|
||||
'that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$' to lt_strings,
|
||||
'column$are$separated$by$at$least$one$space.' to lt_strings,
|
||||
'Further,$allow$for$each$word$in$a$column$to$be$either$left$' to lt_strings,
|
||||
'justified,$right$justified,$or$center$justified$within$its$column.' to lt_strings.
|
||||
types ty_strings type standard table of string.
|
||||
|
||||
perform align_col using 'LEFT' lt_strings.
|
||||
skip.
|
||||
perform align_col using 'RIGHT' lt_strings.
|
||||
skip.
|
||||
perform align_col using 'CENTER' lt_strings.
|
||||
|
||||
|
||||
form align_col using iv_just type string iv_strings type ty_strings.
|
||||
constants: c_del value '$'.
|
||||
data: lv_string type string,
|
||||
lt_strings type table of string,
|
||||
lt_tables like table of lt_strings,
|
||||
lv_first type string,
|
||||
lv_second type string,
|
||||
lv_longest type i value 0,
|
||||
lv_off type i value 0,
|
||||
lv_len type i.
|
||||
" Loop through the supplied text. It is expected at the input is a table of strings, with each
|
||||
" entry in the table representing a new line of the input.
|
||||
loop at iv_strings into lv_string.
|
||||
" Split the current line at the delimiter.
|
||||
split lv_string at c_del into lv_first lv_second.
|
||||
" Loop through the line splitting at every delimiter.
|
||||
do.
|
||||
append lv_first to lt_strings.
|
||||
lv_len = strlen( lv_first ).
|
||||
" Check if the length of the new string is greater than the currently stored length.
|
||||
if lv_len > lv_longest.
|
||||
lv_longest = lv_len.
|
||||
endif.
|
||||
if lv_second na c_del.
|
||||
" Check if the string is longer than the recorded maximum.
|
||||
lv_len = strlen( lv_second ).
|
||||
if lv_len > lv_longest.
|
||||
lv_longest = lv_len.
|
||||
endif.
|
||||
append lv_second to lt_strings.
|
||||
exit.
|
||||
endif.
|
||||
split lv_second at c_del into lv_first lv_second.
|
||||
enddo.
|
||||
|
||||
append lt_strings to lt_tables.
|
||||
clear lt_strings.
|
||||
endloop.
|
||||
|
||||
" Loop through each line of input.
|
||||
loop at lt_tables into lt_strings.
|
||||
" Loop through each word in the line (Separated by specified delimiter).
|
||||
loop at lt_strings into lv_string.
|
||||
lv_off = ( sy-tabix - 1 ) * ( lv_longest + 2 ).
|
||||
case iv_just.
|
||||
when 'LEFT'.
|
||||
write : at (lv_longest) lv_string left-justified.
|
||||
when 'RIGHT'.
|
||||
write at (lv_longest) lv_string right-justified.
|
||||
when 'CENTER'.
|
||||
write at (lv_longest) lv_string centered.
|
||||
endcase.
|
||||
endloop.
|
||||
skip.
|
||||
sy-linno = sy-linno - 1.
|
||||
endloop.
|
||||
endform.
|
||||
66
Task/Align-columns/ALGOL-68/align-columns.alg
Normal file
66
Task/Align-columns/ALGOL-68/align-columns.alg
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
STRING nl = REPR 10;
|
||||
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+
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"+nl+
|
||||
"column$are$separated$by$at$least$one$space."+nl+
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$"+nl+
|
||||
"justified,$right$justified,$or$center$justified$within$its$column.";
|
||||
|
||||
MODE PAGE = FLEX[0,0]STRING;
|
||||
PAGE page;
|
||||
|
||||
PROC flex page = (PAGE in page, INT row, col)PAGE:(
|
||||
HEAP FLEX[row, col]STRING out page;
|
||||
out page[:1 UPB in page, :2 UPB in page] := in page;
|
||||
FOR r TO row DO
|
||||
FOR c FROM 2 UPB in page + 1 TO col DO out page[r,c]:="" OD
|
||||
OD;
|
||||
FOR r FROM 1 UPB in page + 1 TO row DO
|
||||
FOR c FROM 1 TO col DO out page[r,c]:="" OD
|
||||
OD;
|
||||
out page
|
||||
);
|
||||
|
||||
FILE text in file;
|
||||
associate(text in file, text in list);
|
||||
make term(text in file, "$");
|
||||
|
||||
on physical file end(text in file, (REF FILE skip)BOOL: stop iteration);
|
||||
on logical file end(text in file, (REF FILE skip)BOOL: stop iteration);
|
||||
FOR row DO
|
||||
on line end(text in file, (REF FILE skip)BOOL: stop iteration);
|
||||
FOR col DO
|
||||
STRING tok;
|
||||
getf(text in file, ($gx$,tok));
|
||||
IF row > 1 UPB page THEN page := flex page(page, row, 2 UPB page) FI;
|
||||
IF col > 2 UPB page THEN page := flex page(page, 1 UPB page, col) FI;
|
||||
page[row,col]:=tok
|
||||
OD;
|
||||
stop iteration:
|
||||
SKIP
|
||||
OD;
|
||||
stop iteration:
|
||||
SKIP;
|
||||
|
||||
BEGIN
|
||||
PROC aligner = (PAGE in page, PROC (STRING,INT)STRING aligner)VOID:(
|
||||
PAGE page := in page;
|
||||
[2 UPB page]INT max width;
|
||||
FOR col TO 2 UPB page DO
|
||||
INT max len:=0; FOR row TO UPB page DO IF UPB page[row,col]>max len THEN max len:=UPB page[row,col] FI OD;
|
||||
FOR row TO UPB page DO page[row,col] := aligner(page[row,col], maxlen) OD
|
||||
OD;
|
||||
printf(($n(UPB page)(n(2 UPB page -1)(gx)gl)$,page))
|
||||
);
|
||||
|
||||
PROC left = (STRING in, INT len)STRING: in + " "*(len - UPB in),
|
||||
right = (STRING in, INT len)STRING: " "*(len - UPB in) + in,
|
||||
centre = (STRING in, INT len)STRING: ( INT pad=len-UPB in; pad%2*" "+ in + (pad-pad%2)*" " );
|
||||
|
||||
[]STRUCT(STRING name, PROC(STRING,INT)STRING align) aligners = (("Left",left), ("Left",right), ("Centre",centre));
|
||||
|
||||
FOR index TO UPB aligners DO
|
||||
print((new line, "# ",name OF aligners[index]," Column-aligned output:",new line));
|
||||
aligner(page, align OF aligners[index])
|
||||
OD
|
||||
END
|
||||
325
Task/Align-columns/ARM-Assembly/align-columns.arm
Normal file
325
Task/Align-columns/ARM-Assembly/align-columns.arm
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
/* ARM assembly Raspberry PI */
|
||||
/* program alignColumn.s */
|
||||
|
||||
/* REMARK 1 : this program use routines in a include file
|
||||
see task Include a file language arm assembly
|
||||
for the routine affichageMess conversion10
|
||||
see at end of this program the instruction include */
|
||||
/* for constantes see task include a file in arm assembly */
|
||||
/************************************/
|
||||
/* Constantes */
|
||||
/************************************/
|
||||
.include "../constantes.inc"
|
||||
.equ BUFFERSIZE, 20 * 10
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessLeft: .asciz "LEFT :\n"
|
||||
szMessRight: .asciz "\nRIGHT :\n"
|
||||
szMessCenter: .asciz "\nCENTER :\n"
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
szLine1: .asciz "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
szLine2: .asciz "are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
szLine3: .asciz "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
szLine4: .asciz "column$are$separated$by$at$least$one$space."
|
||||
szLine5: .asciz "Further,$allow$for$each$word$in$a$column$to$be$either$left$"
|
||||
szLine6: .asciz "justified,$right$justified,$or$center$justified$within$its$column."
|
||||
|
||||
itbPtLine: .int szLine1,szLine2,szLine3,szLine4,szLine5,szLine6
|
||||
.equ NBLINES, (. - itbPtLine) / 4
|
||||
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: @ entry of program
|
||||
ldr r0,iAdritbPtLine
|
||||
bl computeMaxiLengthWords
|
||||
mov r10,r0 @ column counter
|
||||
ldr r0,iAdrszMessLeft
|
||||
bl affichageMess
|
||||
ldr r0,iAdritbPtLine
|
||||
mov r1,r10 @ column size
|
||||
bl alignLeft
|
||||
ldr r0,iAdrszMessRight
|
||||
bl affichageMess
|
||||
ldr r0,iAdritbPtLine
|
||||
mov r1,r10 @ column size
|
||||
bl alignRight
|
||||
ldr r0,iAdrszMessCenter
|
||||
bl affichageMess
|
||||
ldr r0,iAdritbPtLine
|
||||
mov r1,r10 @ column size
|
||||
bl alignCenter
|
||||
100: @ standard end of the program
|
||||
mov r0, #0 @ return code
|
||||
mov r7, #EXIT @ request to exit program
|
||||
svc #0 @ perform the system call
|
||||
iAdrszCarriageReturn: .int szCarriageReturn
|
||||
iAdrszMessLeft: .int szMessLeft
|
||||
iAdrszMessRight: .int szMessRight
|
||||
iAdrszMessCenter: .int szMessCenter
|
||||
iAdritbPtLine: .int itbPtLine
|
||||
/******************************************************************/
|
||||
/* compute maxi words */
|
||||
/******************************************************************/
|
||||
/* r0 contains adresse pointer array */
|
||||
computeMaxiLengthWords:
|
||||
push {r1-r6,lr} @ save registers
|
||||
mov r2,#0 @ indice pointer array
|
||||
mov r3,#0 @ maxi length words
|
||||
1:
|
||||
ldr r1,[r0,r2,lsl #2] @ load pointer
|
||||
mov r4,#0 @ length words counter
|
||||
mov r5,#0 @ indice line character
|
||||
2:
|
||||
ldrb r6,[r1,r5] @ load a line character
|
||||
cmp r6,#0 @ line end ?
|
||||
beq 4f
|
||||
cmp r6,#'$' @ separator ?
|
||||
bne 3f
|
||||
cmp r4,r3
|
||||
movgt r3,r4 @ ig greather replace maxi
|
||||
mov r4,#-1 @ raz length counter
|
||||
3:
|
||||
add r4,r4,#1
|
||||
add r5,r5,#1 @ increment character indice
|
||||
b 2b @ and loop
|
||||
4: @ end line
|
||||
cmp r4,r3 @ compare word counter and maxi
|
||||
movgt r3,r4 @ if greather replace maxi
|
||||
add r2,r2,#1 @ increment indice line pointer
|
||||
cmp r2,#NBLINES @ maxi ?
|
||||
blt 1b @ no -> loop
|
||||
|
||||
mov r0,r3 @ return maxi length counter
|
||||
100:
|
||||
pop {r1-r6,pc}
|
||||
|
||||
/******************************************************************/
|
||||
/* align left */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of pointer array*/
|
||||
/* r1 contains column size */
|
||||
alignLeft:
|
||||
push {r4-r7,fp,lr} @ save registers
|
||||
sub sp,sp,#BUFFERSIZE @ reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov r5,r0 @ array address
|
||||
mov r2,#0 @ indice array
|
||||
1:
|
||||
ldr r3,[r5,r2,lsl #2] @ load line pointer
|
||||
mov r4,#0 @ line character indice
|
||||
mov r7,#0 @ output buffer character indice
|
||||
mov r6,#0 @ word lenght
|
||||
2:
|
||||
ldrb r0,[r3,r4] @ load a character line
|
||||
strb r0,[fp,r7] @ store in buffer
|
||||
cmp r0,#0 @ line end ?
|
||||
beq 6f
|
||||
cmp r0,#'$' @ separator ?
|
||||
bne 5f
|
||||
mov r0,#' '
|
||||
strb r0,[fp,r7] @ replace $ by space
|
||||
3:
|
||||
cmp r6,r1 @ length word >= length column
|
||||
bge 4f
|
||||
add r7,r7,#1
|
||||
mov r0,#' '
|
||||
strb r0,[fp,r7] @ add space to buffer
|
||||
add r6,r6,#1
|
||||
b 3b @ and loop
|
||||
4:
|
||||
mov r6,#-1 @ raz word length
|
||||
5:
|
||||
add r4,r4,#1 @ increment line indice
|
||||
add r7,r7,#1 @ increment buffer indice
|
||||
add r6,r6,#1 @ increment word length
|
||||
b 2b
|
||||
|
||||
6:
|
||||
mov r0,#'\n'
|
||||
strb r0,[fp,r7] @ return line
|
||||
add r7,r7,#1
|
||||
mov r0,#0
|
||||
strb r0,[fp,r7] @ final zéro
|
||||
mov r0,fp
|
||||
bl affichageMess @ display output buffer
|
||||
add r2,r2,#1
|
||||
cmp r2,#NBLINES
|
||||
blt 1b
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
pop {r4-r7,fp,pc}
|
||||
/******************************************************************/
|
||||
/* align right */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of pointer array*/
|
||||
/* r1 contains column size */
|
||||
alignRight:
|
||||
push {r4-r9,fp,lr} @ save registers
|
||||
sub sp,sp,#BUFFERSIZE @ reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov r5,r0 @ array address
|
||||
mov r2,#0 @ indice array
|
||||
1:
|
||||
ldr r3,[r5,r2,lsl #2] @ load line pointer
|
||||
mov r4,#0 @ line character indice
|
||||
mov r7,#0 @ output buffer character indice
|
||||
mov r6,#0 @ word lenght
|
||||
mov r8,r3 @ word begin address
|
||||
2: @ compute word length
|
||||
ldrb r0,[r3,r4] @ load a character line
|
||||
cmp r0,#0 @ line end ?
|
||||
beq 3f
|
||||
cmp r0,#'$' @ separator ?
|
||||
beq 3f
|
||||
add r4,r4,#1 @ increment line indice
|
||||
add r6,r6,#1 @ increment word length
|
||||
b 2b
|
||||
|
||||
3:
|
||||
cmp r6,#0
|
||||
beq 4f
|
||||
sub r6,r1,r6 @ compute left spaces to add
|
||||
4: @ loop add spaces to buffer
|
||||
cmp r6,#0
|
||||
blt 5f
|
||||
mov r0,#' '
|
||||
strb r0,[fp,r7] @ add space to buffer
|
||||
add r7,r7,#1
|
||||
sub r6,r6,#1
|
||||
b 4b @ and loop
|
||||
5:
|
||||
mov r9,#0
|
||||
6: @ copy loop word to buffer
|
||||
ldrb r0,[r8,r9]
|
||||
cmp r0,#'$'
|
||||
beq 7f
|
||||
cmp r0,#0 @ line end
|
||||
beq 8f
|
||||
strb r0,[fp,r7]
|
||||
add r7,r7,#1
|
||||
add r9,r9,#1
|
||||
b 6b
|
||||
7:
|
||||
add r8,r8,r9
|
||||
add r8,r8,#1 @ new word begin
|
||||
mov r6,#0 @ raz word length
|
||||
add r4,r4,#1 @ increment line indice
|
||||
b 2b
|
||||
|
||||
8:
|
||||
mov r0,#'\n'
|
||||
strb r0,[fp,r7] @ return line
|
||||
add r7,r7,#1
|
||||
mov r0,#0
|
||||
strb r0,[fp,r7] @ final zéro
|
||||
mov r0,fp
|
||||
bl affichageMess @ display output buffer
|
||||
add r2,r2,#1
|
||||
cmp r2,#NBLINES
|
||||
blt 1b
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
pop {r4-r9,fp,pc}
|
||||
/******************************************************************/
|
||||
/* align center */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of pointer array*/
|
||||
/* r1 contains column size */
|
||||
alignCenter:
|
||||
push {r4-r12,lr} @ save registers
|
||||
sub sp,sp,#BUFFERSIZE @ reserve place for output buffer
|
||||
mov fp,sp
|
||||
mov r5,r0 @ array address
|
||||
mov r2,#0 @ indice array
|
||||
1:
|
||||
ldr r3,[r5,r2,lsl #2] @ load line pointer
|
||||
mov r4,#0 @ line character indice
|
||||
mov r7,#0 @ output buffer character indice
|
||||
mov r6,#0 @ word length
|
||||
mov r8,r3 @ word begin address
|
||||
2: @ compute word length
|
||||
ldrb r0,[r3,r4] @ load a character line
|
||||
cmp r0,#0 @ line end ?
|
||||
beq 3f
|
||||
cmp r0,#'$' @ separator ?
|
||||
beq 3f
|
||||
add r4,r4,#1 @ increment line indice
|
||||
add r6,r6,#1 @ increment word length
|
||||
b 2b
|
||||
3:
|
||||
cmp r6,#0
|
||||
beq 5f
|
||||
sub r6,r1,r6 @ total spaces number to add
|
||||
mov r12,r6
|
||||
lsr r6,r6,#1 @ divise by 2 = left spaces number
|
||||
4:
|
||||
cmp r6,#0
|
||||
blt 5f
|
||||
mov r0,#' '
|
||||
strb r0,[fp,r7] @ add space to buffer
|
||||
add r7,r7,#1 @ increment output indice
|
||||
sub r6,r6,#1 @ decrement number space
|
||||
b 4b @ and loop
|
||||
5:
|
||||
mov r9,#0
|
||||
6: @ copy loop word to buffer
|
||||
ldrb r0,[r8,r9]
|
||||
cmp r0,#'$' @ séparator ?
|
||||
beq 7f
|
||||
cmp r0,#0 @ line end ?
|
||||
beq 10f
|
||||
strb r0,[fp,r7]
|
||||
add r7,r7,#1
|
||||
add r9,r9,#1
|
||||
b 6b
|
||||
7:
|
||||
lsr r6,r12,#1 @ divise total spaces by 2
|
||||
sub r6,r12,r6 @ and compute number spaces to right side
|
||||
8: @ loop to add right spaces
|
||||
cmp r6,#0
|
||||
ble 9f
|
||||
mov r0,#' '
|
||||
strb r0,[fp,r7] @ add space to buffer
|
||||
add r7,r7,#1
|
||||
sub r6,r6,#1
|
||||
b 8b @ and loop
|
||||
|
||||
9:
|
||||
add r8,r8,r9
|
||||
add r8,r8,#1 @ new address word begin
|
||||
mov r6,#0 @ raz word length
|
||||
add r4,r4,#1 @ increment line indice
|
||||
b 2b @ and loop new word
|
||||
|
||||
10:
|
||||
mov r0,#'\n'
|
||||
strb r0,[fp,r7] @ return line
|
||||
add r7,r7,#1
|
||||
mov r0,#0
|
||||
strb r0,[fp,r7] @ final zéro
|
||||
mov r0,fp
|
||||
bl affichageMess @ display output buffer
|
||||
add r2,r2,#1 @ increment line indice
|
||||
cmp r2,#NBLINES @ maxi ?
|
||||
blt 1b @ loop
|
||||
|
||||
100:
|
||||
add sp,sp,#BUFFERSIZE
|
||||
pop {r4-r12,pc}
|
||||
/***************************************************/
|
||||
/* ROUTINES INCLUDE */
|
||||
/***************************************************/
|
||||
.include "../affichage.inc"
|
||||
41
Task/Align-columns/AWK/align-columns.awk
Normal file
41
Task/Align-columns/AWK/align-columns.awk
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
# syntax: GAWK -f ALIGN_COLUMNS.AWK ALIGN_COLUMNS.TXT
|
||||
BEGIN {
|
||||
colsep = " " # separator between columns
|
||||
report("raw data")
|
||||
}
|
||||
{ printf("%s\n",$0)
|
||||
arr[NR] = $0
|
||||
n = split($0,tmp_arr,"$")
|
||||
for (j=1; j<=n; j++) {
|
||||
width = max(width,length(tmp_arr[j]))
|
||||
}
|
||||
}
|
||||
END {
|
||||
report("left justified")
|
||||
report("right justified")
|
||||
report("center justified")
|
||||
exit(0)
|
||||
}
|
||||
function report(text, diff,i,j,l,n,r,tmp_arr) {
|
||||
printf("\nreport: %s\n",text)
|
||||
for (i=1; i<=NR; i++) {
|
||||
n = split(arr[i],tmp_arr,"$")
|
||||
if (tmp_arr[n] == "") { n-- }
|
||||
for (j=1; j<=n; j++) {
|
||||
if (text ~ /^[Ll]/) { # left
|
||||
printf("%-*s%s",width,tmp_arr[j],colsep)
|
||||
}
|
||||
else if (text ~ /^[Rr]/) { # right
|
||||
printf("%*s%s",width,tmp_arr[j],colsep)
|
||||
}
|
||||
else if (text ~ /^[Cc]/) { # center
|
||||
diff = width - length(tmp_arr[j])
|
||||
l = r = int(diff / 2)
|
||||
if (diff != l + r) { r++ }
|
||||
printf("%*s%s%*s%s",l,"",tmp_arr[j],r,"",colsep)
|
||||
}
|
||||
}
|
||||
printf("\n")
|
||||
}
|
||||
}
|
||||
function max(x,y) { return((x > y) ? x : y) }
|
||||
209
Task/Align-columns/Action-/align-columns.action
Normal file
209
Task/Align-columns/Action-/align-columns.action
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
DEFINE LINES_COUNT="10"
|
||||
DEFINE COLUMNS_COUNT="20"
|
||||
DEFINE WORDS_COUNT="100"
|
||||
DEFINE BUFFER_SIZE="2000"
|
||||
DEFINE LINE_WIDTH="40"
|
||||
DEFINE PTR="CARD"
|
||||
|
||||
PTR ARRAY lines(LINES_COUNT)
|
||||
BYTE ARRAY wordStart(WORDS_COUNT)
|
||||
BYTE ARRAY wordLen(WORDS_COUNT)
|
||||
BYTE ARRAY firstWordInLine(LINES_COUNT)
|
||||
BYTE ARRAY wordsInLine(LINES_COUNT)
|
||||
BYTE ARRAY colWidths(COLUMNS_COUNT)
|
||||
BYTE ARRAY buffer(BUFFER_SIZE)
|
||||
BYTE lineCount,colCount,wordCount
|
||||
|
||||
CHAR sep=['$]
|
||||
|
||||
PROC AddLine(CHAR ARRAY line)
|
||||
lines(lineCount)=line
|
||||
lineCount==+1
|
||||
RETURN
|
||||
|
||||
PROC InitData()
|
||||
lineCount=0
|
||||
AddLine("Given$a$text$file$of$many$lines,$where$fields$within$a$line$")
|
||||
AddLine("are$delineated$by$a$single$'dollar'$character,$write$a$program")
|
||||
AddLine("that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$")
|
||||
AddLine("column$are$separated$by$at$least$one$space.")
|
||||
AddLine("Further,$allow$for$each$word$in$a$column$to$be$either$left$")
|
||||
AddLine("justified,$right$justified,$or$center$justified$within$its$column.")
|
||||
RETURN
|
||||
|
||||
PROC ProcessData()
|
||||
BYTE i,pos,len,start,w,col
|
||||
CHAR ARRAY line
|
||||
|
||||
colCount=0 wordCount=0
|
||||
FOR i=0 TO lineCount-1
|
||||
DO
|
||||
line=lines(i)
|
||||
len=line(0)
|
||||
firstWordInLine(i)=wordCount
|
||||
wordsInLine(i)=0
|
||||
pos=1 col=0
|
||||
WHILE pos<=len
|
||||
DO
|
||||
start=pos
|
||||
WHILE pos<=len AND line(pos)#sep
|
||||
DO pos==+1 OD
|
||||
w=pos-start
|
||||
wordStart(wordCount)=start
|
||||
wordLen(wordCount)=w
|
||||
wordCount==+1
|
||||
wordsInLine(i)==+1
|
||||
IF col=colCount THEN
|
||||
colWidths(col)=w
|
||||
colCount==+1
|
||||
ELSEIF w>colWidths(col) THEN
|
||||
colWidths(col)=w
|
||||
FI
|
||||
col==+1
|
||||
pos==+1
|
||||
OD
|
||||
OD
|
||||
RETURN
|
||||
|
||||
BYTE FUNC GetBufLineLength()
|
||||
BYTE i,res
|
||||
|
||||
res=0
|
||||
FOR i=0 TO colCount-1
|
||||
DO
|
||||
res==+colWidths(i)+1
|
||||
OD
|
||||
res==+1
|
||||
RETURN (res)
|
||||
|
||||
BYTE FUNC AtasciiToInternal(CHAR c)
|
||||
BYTE c2
|
||||
|
||||
c2=c&$7F
|
||||
IF c2<32 THEN
|
||||
RETURN (c+64)
|
||||
ELSEIF c2<96 THEN
|
||||
RETURN (c-32)
|
||||
FI
|
||||
RETURN (c)
|
||||
|
||||
PROC GenerateLine(BYTE index BYTE align BYTE POINTER p)
|
||||
BYTE wordIndex,last,left,right,start,len,colW
|
||||
INT i,j
|
||||
CHAR ARRAY line
|
||||
|
||||
line=lines(index)
|
||||
wordIndex=firstWordInLine(index)
|
||||
last=wordIndex+wordsInLine(index)-1
|
||||
FOR i=0 TO colCount-1
|
||||
DO
|
||||
colW=colWidths(i)
|
||||
|
||||
p^=124 p==+1
|
||||
IF wordIndex<=last THEN
|
||||
start=wordStart(wordIndex)
|
||||
len=wordLen(wordIndex)
|
||||
|
||||
IF align=0 THEN
|
||||
left=0
|
||||
right=colW-len
|
||||
ELSEIF align=1 THEN
|
||||
left=(colW-len)/2
|
||||
right=colW-left-len
|
||||
ELSE
|
||||
left=colW-len
|
||||
right=0
|
||||
FI
|
||||
|
||||
p==+left
|
||||
for j=start TO start+len-1
|
||||
DO
|
||||
p^=AtasciiToInternal(line(j))
|
||||
p==+1
|
||||
OD
|
||||
p==+right
|
||||
ELSE
|
||||
p==+colW
|
||||
FI
|
||||
|
||||
wordIndex==+1
|
||||
OD
|
||||
p^=124
|
||||
RETURN
|
||||
|
||||
PROC FillBuffer(BYTE lineWidth)
|
||||
BYTE i,align
|
||||
BYTE POINTER p
|
||||
|
||||
p=buffer
|
||||
Zero(p,BUFFER_SIZE)
|
||||
FOR align=0 TO 2
|
||||
DO
|
||||
FOR i=0 TO lineCount-1
|
||||
DO
|
||||
GenerateLine(i,align,p)
|
||||
p==+lineWidth
|
||||
OD
|
||||
OD
|
||||
RETURN
|
||||
|
||||
BYTE FUNC GetMaxOffset()
|
||||
BYTE res
|
||||
|
||||
res=GetBufLineLength()-LINE_WIDTH
|
||||
RETURN (res)
|
||||
|
||||
PROC Update(BYTE offset,lineWidth)
|
||||
BYTE POINTER srcPtr,dstPtr
|
||||
BYTE i
|
||||
|
||||
srcPtr=buffer+offset
|
||||
dstPtr=PeekC(88)+3*LINE_WIDTH
|
||||
FOR i=0 TO 3*lineCount-1
|
||||
DO
|
||||
MoveBlock(dstPtr,srcPtr,LINE_WIDTH)
|
||||
srcPtr==+lineWidth
|
||||
dstPtr==+LINE_WIDTH
|
||||
IF i=lineCount-1 OR i=2*lineCount-1 THEN
|
||||
dstPtr==+LINE_WIDTH
|
||||
FI
|
||||
OD
|
||||
RETURN
|
||||
|
||||
PROC Main()
|
||||
BYTE
|
||||
lineWidth,offset,maxOffset,k,
|
||||
CH=$02FC, ;Internal hardware value for last key pressed
|
||||
CRSINH=$02F0 ;Controls visibility of cursor
|
||||
|
||||
CRSINH=1 ;hide cursor
|
||||
|
||||
InitData()
|
||||
ProcessData()
|
||||
lineWidth=GetBufLineLength()
|
||||
FillBuffer(lineWidth)
|
||||
|
||||
Position(2,1)
|
||||
Print("Press left/right arrow key to scroll")
|
||||
|
||||
maxOffset=lineWidth-LINE_WIDTH
|
||||
offset=0
|
||||
Update(offset,lineWidth)
|
||||
DO
|
||||
k=CH
|
||||
IF k#$FF THEN
|
||||
CH=$FF
|
||||
FI
|
||||
|
||||
IF k=134 AND offset>0 THEN
|
||||
offset==-1
|
||||
Update(offset,lineWidth)
|
||||
ELSEIF k=135 AND offset<maxOffset THEN
|
||||
offset==+1
|
||||
Update(offset,lineWidth)
|
||||
ELSEIF k=28 THEN
|
||||
EXIT
|
||||
FI
|
||||
OD
|
||||
|
||||
RETURN
|
||||
65
Task/Align-columns/Ada/align-columns.ada
Normal file
65
Task/Align-columns/Ada/align-columns.ada
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
|
||||
with Ada.Text_IO; use Ada.Text_IO;
|
||||
with Strings_Edit; use Strings_Edit;
|
||||
|
||||
procedure Column_Aligner is
|
||||
Text : constant String :=
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$" & NUL &
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program" & NUL &
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$" & NUL &
|
||||
"column$are$separated$by$at$least$one$space." & NUL &
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$" & NUL &
|
||||
"justified,$right$justified,$or$center$justified$within$its$column." & NUL;
|
||||
File : File_Type;
|
||||
Width : array (1..1_000) of Natural := (others => 0);
|
||||
Line : String (1..200);
|
||||
Column : Positive := 1;
|
||||
Start : Positive := 1;
|
||||
Pointer : Positive;
|
||||
begin
|
||||
Create (File, Out_File, "columned.txt");
|
||||
-- Determining the widths of columns
|
||||
for I in Text'Range loop
|
||||
case Text (I) is
|
||||
when '$' | NUL =>
|
||||
Width (Column) := Natural'Max (Width (Column), I - Start + 1);
|
||||
Start := I + 1;
|
||||
if Text (I) = NUL then
|
||||
Column := 1;
|
||||
else
|
||||
Column := Column + 1;
|
||||
end if;
|
||||
when others =>
|
||||
null;
|
||||
end case;
|
||||
end loop;
|
||||
-- Formatting
|
||||
for Align in Alignment loop
|
||||
Column := 1;
|
||||
Start := 1;
|
||||
Pointer := 1;
|
||||
for I in Text'Range loop
|
||||
case Text (I) is
|
||||
when '$' | NUL =>
|
||||
Put -- Formatted output of a word
|
||||
( Destination => Line,
|
||||
Pointer => Pointer,
|
||||
Value => Text (Start..I - 1),
|
||||
Field => Width (Column),
|
||||
Justify => Align
|
||||
);
|
||||
Start := I + 1;
|
||||
if Text (I) = NUL then
|
||||
Put_Line (File, Line (1..Pointer - 1));
|
||||
Pointer := 1;
|
||||
Column := 1;
|
||||
else
|
||||
Column := Column + 1;
|
||||
end if;
|
||||
when others =>
|
||||
null;
|
||||
end case;
|
||||
end loop;
|
||||
end loop;
|
||||
Close (File);
|
||||
end Column_Aligner;
|
||||
45
Task/Align-columns/Aime/align-columns.aime
Normal file
45
Task/Align-columns/Aime/align-columns.aime
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
data b;
|
||||
file f;
|
||||
text n, t;
|
||||
list c, r, s;
|
||||
integer a, i, k, m, w;
|
||||
|
||||
b = "Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program\n"
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\n"
|
||||
"column$are$separated$by$at$least$one$space.\n"
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n"
|
||||
"justified,$right$justified,$or$center$justified$within$its$column.";
|
||||
|
||||
f.b_affix(b);
|
||||
|
||||
m = 0;
|
||||
|
||||
while (f.news(r, 0, 0, "$") ^ -1) {
|
||||
c.append(r);
|
||||
m = max(m, ~r);
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while (i < m) {
|
||||
w = 0;
|
||||
for (, r in c) {
|
||||
if (i < ~r) {
|
||||
w = max(w, length(r[i]));
|
||||
}
|
||||
}
|
||||
s.append(w + 1);
|
||||
i += 1;
|
||||
}
|
||||
|
||||
for (k, t in list("left", "center", "right")) {
|
||||
o_(t, " justified\n");
|
||||
for (, r in c) {
|
||||
for (i, n in r) {
|
||||
m = s[i] - ~n;
|
||||
o_form("/w~3/~/w~1/", a = (2 - k) * m >> 1, "", m - a, "", n);
|
||||
}
|
||||
o_newline();
|
||||
}
|
||||
o_newline();
|
||||
}
|
||||
50
Task/Align-columns/Amazing-Hopper/align-columns.hopper
Normal file
50
Task/Align-columns/Amazing-Hopper/align-columns.hopper
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
#define IGet(__N__,__X__) [__N__]SGet(__X__)
|
||||
|
||||
#include <hbasic.h>
|
||||
#define MAX_LINE 1000
|
||||
|
||||
Begin
|
||||
Option Stack 15
|
||||
|
||||
Declare as Numeric ( fd, i, index, max token )
|
||||
as Numeric ( num tokens, size Column, tCells )
|
||||
as Alpha ( line )
|
||||
as Numeric ( display Left, display Right, display Center )
|
||||
|
||||
GetParam(script, file to edit, separator)
|
||||
|
||||
// get statistics of file: #lines, #total chars, line more long, and num tokens from first line.
|
||||
Token Sep( separator )
|
||||
Stat( file to edit, dats )
|
||||
|
||||
// declare arrays to work:
|
||||
Dim ( IGet(1,dats), Add(IGet(4,dats),10) ) for Fill Array("",cells)
|
||||
Clear(dats)
|
||||
MStore ( cells, display Left, display Right, display Center )
|
||||
|
||||
// read each line as array, get # of elements, and put into array cells:
|
||||
Open(OPEN_READ, file to edit ) (fd)
|
||||
When( File Error ){ Stop }
|
||||
|
||||
index=1
|
||||
While Not Eof(fd)
|
||||
ReadRow(MAX_LINE)(fd) and Copy to (line); get Length, and Move to (num tokens)
|
||||
Set Interval [index, 1:num tokens]; Take( line ) and SPut(cells)
|
||||
When ( var( max token) Is Lt (num tokens) ) { max token = num tokens }
|
||||
++index
|
||||
Wend
|
||||
Close(fd)
|
||||
|
||||
// formatting...
|
||||
For Up( i:=1, max token, 1 )
|
||||
Set Interval [1:end,i], and Let ( size Column := MaxValue( Len(Get(cells)) ) Plus(1) )
|
||||
Let ( tCells := Get(cells) )
|
||||
LPad$( " ", size Column, tCells ), and Put(display Left)
|
||||
RPad$( " ", size Column, tCells ), and Put(display Right)
|
||||
CPad$( " ", size Column, tCells ), and Put(display Center)
|
||||
Next
|
||||
|
||||
// display:
|
||||
Token Sep ("")
|
||||
Print("Left Pad:\n", display Left, Newl, "Right Pad:\n", display Right, Newl, "Center Pad:\n", display Center,Newl)
|
||||
End
|
||||
252
Task/Align-columns/AppleScript/align-columns.applescript
Normal file
252
Task/Align-columns/AppleScript/align-columns.applescript
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
-- COLUMN ALIGNMENTS ---------------------------------------------------------
|
||||
|
||||
property pstrLines : ¬
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n" & ¬
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program\n" & ¬
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\n" & ¬
|
||||
"column$are$separated$by$at$least$one$space.\n" & ¬
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n" & ¬
|
||||
"justified,$right$justified,$or$center$justified$within$its$column."
|
||||
|
||||
property eLeft : -1
|
||||
property eCenter : 0
|
||||
property eRight : 1
|
||||
|
||||
-- columnsAligned :: EnumValue -> [[String]] -> String
|
||||
on columnsAligned(eAlign, lstCols)
|
||||
-- padwords :: Int -> [String] -> [[String]]
|
||||
script padwords
|
||||
on |λ|(n, lstWords)
|
||||
|
||||
-- pad :: String -> String
|
||||
script pad
|
||||
on |λ|(str)
|
||||
set lngPad to n - (length of str)
|
||||
if eAlign = my eCenter then
|
||||
set lngHalf to lngPad div 2
|
||||
{replicate(lngHalf, space), str, ¬
|
||||
replicate(lngPad - lngHalf, space)}
|
||||
else
|
||||
if eAlign = my eLeft then
|
||||
{"", str, replicate(lngPad, space)}
|
||||
else
|
||||
{replicate(lngPad, space), str, ""}
|
||||
end if
|
||||
end if
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
map(pad, lstWords)
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
unlines(map(my unwords, ¬
|
||||
transpose(zipWith(padwords, ¬
|
||||
map(my widest, lstCols), lstCols))))
|
||||
end columnsAligned
|
||||
|
||||
-- lineColumns :: String -> String -> String
|
||||
on lineColumns(strColDelim, strText)
|
||||
-- _words :: Text -> [Text]
|
||||
script _words
|
||||
on |λ|(str)
|
||||
splitOn(strColDelim, str)
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
set lstRows to map(_words, splitOn(linefeed, pstrLines))
|
||||
set nCols to widest(lstRows)
|
||||
|
||||
-- fullRow :: [[a]] -> [[a]]
|
||||
script fullRow
|
||||
on |λ|(lst)
|
||||
lst & replicate(nCols - (length of lst), {""})
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
transpose(map(fullRow, lstRows))
|
||||
end lineColumns
|
||||
|
||||
-- widest [a] -> Int
|
||||
on widest(xs)
|
||||
|length|(maximumBy(comparing(my |length|), xs))
|
||||
end widest
|
||||
|
||||
-- TEST ----------------------------------------------------------------------
|
||||
on run
|
||||
set lstCols to lineColumns("$", pstrLines)
|
||||
|
||||
script testAlignment
|
||||
on |λ|(eAlign)
|
||||
columnsAligned(eAlign, lstCols)
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
intercalate(return & return, ¬
|
||||
map(testAlignment, {eLeft, eRight, eCenter}))
|
||||
end run
|
||||
|
||||
-- GENERIC FUNCTIONS ---------------------------------------------------------
|
||||
|
||||
-- comparing :: (a -> b) -> (a -> a -> Ordering)
|
||||
on comparing(f)
|
||||
set mf to mReturn(f)
|
||||
script
|
||||
on |λ|(a, b)
|
||||
set x to mf's |λ|(a)
|
||||
set y to mf's |λ|(b)
|
||||
if x < y then
|
||||
-1
|
||||
else
|
||||
if x > y then
|
||||
1
|
||||
else
|
||||
0
|
||||
end if
|
||||
end if
|
||||
end |λ|
|
||||
end script
|
||||
end comparing
|
||||
|
||||
-- foldl :: (a -> b -> a) -> a -> [b] -> a
|
||||
on foldl(f, startValue, xs)
|
||||
tell mReturn(f)
|
||||
set v to startValue
|
||||
set lng to length of xs
|
||||
repeat with i from 1 to lng
|
||||
set v to |λ|(v, item i of xs, i, xs)
|
||||
end repeat
|
||||
return v
|
||||
end tell
|
||||
end foldl
|
||||
|
||||
-- Text -> [Text] -> Text
|
||||
on intercalate(strText, lstText)
|
||||
set {dlm, my text item delimiters} to {my text item delimiters, strText}
|
||||
set strJoined to lstText as text
|
||||
set my text item delimiters to dlm
|
||||
return strJoined
|
||||
end intercalate
|
||||
|
||||
-- length :: [a] -> Int
|
||||
on |length|(xs)
|
||||
length of xs
|
||||
end |length|
|
||||
|
||||
-- Lift 2nd class handler function into 1st class script wrapper
|
||||
-- mReturn :: Handler -> Script
|
||||
on mReturn(f)
|
||||
if class of f is script then
|
||||
f
|
||||
else
|
||||
script
|
||||
property |λ| : f
|
||||
end script
|
||||
end if
|
||||
end mReturn
|
||||
|
||||
-- map :: (a -> b) -> [a] -> [b]
|
||||
on map(f, xs)
|
||||
tell mReturn(f)
|
||||
set lng to length of xs
|
||||
set lst to {}
|
||||
repeat with i from 1 to lng
|
||||
set end of lst to |λ|(item i of xs, i, xs)
|
||||
end repeat
|
||||
return lst
|
||||
end tell
|
||||
end map
|
||||
|
||||
-- maximumBy :: (a -> a -> Ordering) -> [a] -> a
|
||||
on maximumBy(f, xs)
|
||||
set cmp to mReturn(f)
|
||||
script max
|
||||
on |λ|(a, b)
|
||||
if a is missing value or cmp's |λ|(a, b) < 0 then
|
||||
b
|
||||
else
|
||||
a
|
||||
end if
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
foldl(max, missing value, xs)
|
||||
end maximumBy
|
||||
|
||||
-- min :: Ord a => a -> a -> a
|
||||
on min(x, y)
|
||||
if y < x then
|
||||
y
|
||||
else
|
||||
x
|
||||
end if
|
||||
end min
|
||||
|
||||
-- Egyptian multiplication - progressively doubling a list, appending
|
||||
-- stages of doubling to an accumulator where needed for binary
|
||||
-- assembly of a target length
|
||||
|
||||
-- replicate :: Int -> a -> [a]
|
||||
on replicate(n, a)
|
||||
if class of a is string then
|
||||
set out to ""
|
||||
else
|
||||
set out to {}
|
||||
end if
|
||||
if n < 1 then return out
|
||||
set dbl to a
|
||||
|
||||
repeat while (n > 1)
|
||||
if (n mod 2) > 0 then set out to out & dbl
|
||||
set n to (n div 2)
|
||||
set dbl to (dbl & dbl)
|
||||
end repeat
|
||||
return out & dbl
|
||||
end replicate
|
||||
|
||||
-- Text -> Text -> [Text]
|
||||
on splitOn(strDelim, strMain)
|
||||
set {dlm, my text item delimiters} to {my text item delimiters, strDelim}
|
||||
set lstParts to text items of strMain
|
||||
set my text item delimiters to dlm
|
||||
return lstParts
|
||||
end splitOn
|
||||
|
||||
-- transpose :: [[a]] -> [[a]]
|
||||
on transpose(xss)
|
||||
script column
|
||||
on |λ|(_, iCol)
|
||||
script row
|
||||
on |λ|(xs)
|
||||
item iCol of xs
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
map(row, xss)
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
map(column, item 1 of xss)
|
||||
end transpose
|
||||
|
||||
-- [Text] -> Text
|
||||
on unlines(lstLines)
|
||||
intercalate(linefeed, lstLines)
|
||||
end unlines
|
||||
|
||||
-- [Text] -> Text
|
||||
on unwords(lstWords)
|
||||
intercalate(" ", lstWords)
|
||||
end unwords
|
||||
|
||||
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
|
||||
on zipWith(f, xs, ys)
|
||||
set lng to min(length of xs, length of ys)
|
||||
set lst to {}
|
||||
tell mReturn(f)
|
||||
repeat with i from 1 to lng
|
||||
set end of lst to |λ|(item i of xs, item i of ys)
|
||||
end repeat
|
||||
return lst
|
||||
end tell
|
||||
end zipWith
|
||||
15
Task/Align-columns/Arturo/align-columns.arturo
Normal file
15
Task/Align-columns/Arturo/align-columns.arturo
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
text: {
|
||||
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.
|
||||
}
|
||||
|
||||
output: map split.lines text => [split.by:"$" &]
|
||||
|
||||
loop output 'line [
|
||||
loop line 'word -> prints pad word 12
|
||||
print ""
|
||||
]
|
||||
48
Task/Align-columns/AutoHotkey/align-columns.ahk
Normal file
48
Task/Align-columns/AutoHotkey/align-columns.ahk
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
Alignment := "L" ; Options: L, R, C
|
||||
Text =
|
||||
( LTrim
|
||||
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.
|
||||
)
|
||||
|
||||
Loop, Parse, Text ; calculate column's width
|
||||
If A_LoopField in $,`n
|
||||
If (N > W)
|
||||
W := N, N := 0
|
||||
Else
|
||||
N := 0
|
||||
Else
|
||||
++N
|
||||
Width := ++W
|
||||
|
||||
Loop, Parse, Text, `n ; process each line
|
||||
{
|
||||
Words := StrSplit(A_LoopField, "$")
|
||||
For i, Word in Words ; process each word
|
||||
Line .= Align(Word, Alignment, Width)
|
||||
Result .= RTrim(Line) . "`n"
|
||||
Line := ""
|
||||
}
|
||||
|
||||
Clipboard := Result ; present results
|
||||
MsgBox, The results are in the Clipboard
|
||||
|
||||
Align(Pal, How, Width) { ; function for alignment
|
||||
Length := StrLen(Pal)
|
||||
If (How = "L")
|
||||
Return Pal . Spc(Width - Length)
|
||||
Else If (How = "R")
|
||||
Return Spc(Width - Length) . Pal
|
||||
Else If (How = "C")
|
||||
Return Spc((Width - Length)//2) . Pal . Spc(Width - Length - (Width - Length)//2)
|
||||
}
|
||||
|
||||
Spc(Number) { ; function to concatenate space characters
|
||||
Loop, %Number%
|
||||
Ret .= A_Space
|
||||
Return Ret
|
||||
}
|
||||
83
Task/Align-columns/AutoIt/align-columns.autoit
Normal file
83
Task/Align-columns/AutoIt/align-columns.autoit
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
; == If the given text is in an file, it will read with:
|
||||
#include <File.au3>
|
||||
Global $aRead
|
||||
_FileReadToArray($sPath, $aRead) ; == $aRead[0] includes count of lines, every line stored in one item (without linebreak)
|
||||
|
||||
; == For example we get the same result with StringSplit()
|
||||
Global $sText = _
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$" & @CRLF & _
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program" & @CRLF & _
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$" & @CRLF & _
|
||||
"column$are$separated$by$at$least$one$space." & @CRLF & _
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$" & @CRLF & _
|
||||
"justified,$right$justified,$or$center$justified$within$its$column." & @CRLF
|
||||
|
||||
$aRead = StringSplit($sText, @CRLF, 1)
|
||||
|
||||
; == strip leading and trailing "$" and trailing spaces, count remaining "$" to get max column number
|
||||
Global $iMaxColumn = 0, $iLines = 0
|
||||
For $i = 1 To $aRead[0]
|
||||
If $aRead[$i] = '' Then ContinueLoop ; skip empty lines
|
||||
$iLines += 1
|
||||
$aRead[$i] = StringRegExpReplace(StringRegExpReplace(StringRegExpReplace($aRead[$i], '^\$', ''), '\$$', ''), '\s*$', '')
|
||||
StringReplace($aRead[$i], '$', '$')
|
||||
If @extended +1 > $iMaxColumn Then $iMaxColumn = @extended +1
|
||||
Next
|
||||
|
||||
; == build array to store all fields and length of every item
|
||||
Global $aFields[$iLines][$iMaxColumn +1][2]
|
||||
; == and store the max. length of item in columns
|
||||
Global $aColLen[$iMaxColumn]
|
||||
|
||||
; == fill the array
|
||||
Global $aSplitLine
|
||||
$iLines = 0
|
||||
For $i = 1 To $aRead[0]
|
||||
If $aRead[$i] = '' Then ContinueLoop ; skip empty lines
|
||||
$iMaxColLen = 0
|
||||
$aSplitLine = StringSplit($aRead[$i], '$')
|
||||
For $j = 1 To $aSplitLine[0]
|
||||
$aFields[$iLines][$j-1][0] = $aSplitLine[$j]
|
||||
$aFields[$iLines][$j-1][1] = StringLen($aSplitLine[$j])
|
||||
If $aFields[$iLines][$j-1][1] > $aColLen[$j-1] Then $aColLen[$j-1] = $aFields[$iLines][$j-1][1]
|
||||
Next
|
||||
$iLines += 1
|
||||
Next
|
||||
|
||||
; == let the user select the alignment for every column
|
||||
$sAlign = InputBox('Column alignment', 'There are ' & $iMaxColumn & ' columns.' & @LF & '0 = left 1 = center 2 = right' & @LF & _
|
||||
'Input alignment for all columns without delimiters.' & @LF & 'Let it empty, to align all left.')
|
||||
If $sAlign = '' Then
|
||||
For $i = 1 To $iMaxColumn
|
||||
$sAlign &= '0'
|
||||
Next
|
||||
EndIf
|
||||
Global $aAlignment = StringSplit($sAlign, '', 2)
|
||||
|
||||
; == output all to console
|
||||
Global $sLineOut
|
||||
For $i = 0 To UBound($aFields) -1
|
||||
$sLineOut = ''
|
||||
For $j = 0 To $iMaxColumn -1
|
||||
If $aFields[$i][$j][0] = '' Then ContinueLoop
|
||||
$sLineOut &= _GetAligned($aFields[$i][$j][0], $aFields[$i][$j][1], $aAlignment[$j], $aColLen[$j])
|
||||
Next
|
||||
ConsoleWrite(StringTrimRight($sLineOut, 1) & @LF)
|
||||
Next
|
||||
|
||||
Func _GetAligned($_sString, $_iLen, $_iAlign, $_iMaxLen)
|
||||
Local $sSpace = ''
|
||||
For $i = 1 To $_iMaxLen
|
||||
$sSpace &= ' '
|
||||
Next
|
||||
Switch $_iAlign
|
||||
Case 0
|
||||
Return $_sString & StringLeft($sSpace, $_iMaxLen - $_iLen +1)
|
||||
Case 1
|
||||
Local $iLenLeft = Int(($_iMaxLen - $_iLen)/2)
|
||||
Local $iLenRight = $_iMaxLen - $iLenLeft - $_iLen
|
||||
Return StringLeft($sSpace, $iLenLeft) & $_sString & StringLeft($sSpace, $iLenRight) & ' '
|
||||
Case 2
|
||||
Return StringLeft($sSpace, $_iMaxLen - $_iLen) & $_sString & ' '
|
||||
EndSwitch
|
||||
EndFunc ;==>_GetAligned
|
||||
56
Task/Align-columns/BBC-BASIC/align-columns.basic
Normal file
56
Task/Align-columns/BBC-BASIC/align-columns.basic
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
DATA 6
|
||||
DATA "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
DATA "are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
DATA "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
DATA "column$are$separated$by$at$least$one$space."
|
||||
DATA "Further,$allow$for$each$word$in$a$column$to$be$either$left$"
|
||||
DATA "justified,$right$justified,$or$center$justified$within$its$column."
|
||||
|
||||
REM First find the maximum length of a 'word':
|
||||
max% = 0
|
||||
READ nlines%
|
||||
FOR Line% = 1 TO nlines%
|
||||
READ text$
|
||||
REPEAT
|
||||
word$ = FNword(text$, "$")
|
||||
IF LEN(word$) > max% THEN max% = LEN(word$)
|
||||
UNTIL word$ = ""
|
||||
NEXT Line%
|
||||
@% = max% : REM set column width
|
||||
|
||||
REM Now display the aligned text:
|
||||
RESTORE
|
||||
READ nlines%
|
||||
FOR Line% = 1 TO nlines%
|
||||
READ text$
|
||||
REPEAT
|
||||
word$ = FNword(text$, "$")
|
||||
PRINT FNjustify(word$, max%, "left"),;
|
||||
UNTIL word$ = ""
|
||||
PRINT
|
||||
NEXT Line%
|
||||
|
||||
END
|
||||
|
||||
DEF FNword(text$, delim$)
|
||||
PRIVATE delim%
|
||||
LOCAL previous%
|
||||
IF delim% = 0 THEN
|
||||
previous% = 1
|
||||
ELSE
|
||||
previous% = delim% + LEN(delim$)
|
||||
ENDIF
|
||||
delim% = INSTR(text$+delim$, delim$, previous%)
|
||||
IF delim% = 0 THEN
|
||||
= ""
|
||||
ELSE
|
||||
= MID$(text$, previous%, delim%-previous%) + " "
|
||||
ENDIF
|
||||
|
||||
DEF FNjustify(word$, field%, mode$)
|
||||
IF word$ = "" THEN = ""
|
||||
CASE mode$ OF
|
||||
WHEN "center": = STRING$((field%-LEN(word$)) DIV 2, " ") + word$
|
||||
WHEN "right": = STRING$(field%-LEN(word$), " ") + word$
|
||||
ENDCASE
|
||||
= word$
|
||||
12
Task/Align-columns/BQN/align-columns-1.bqn
Normal file
12
Task/Align-columns/BQN/align-columns-1.bqn
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
Split ← (⊢-˜+`׬)∘=⊔⊢
|
||||
PadRow ← {
|
||||
w‿t𝕊𝕩: # t → type.
|
||||
# 0 → left
|
||||
# 1 → right
|
||||
# 2 → center
|
||||
pstyle←t⊑⟨{0‿𝕩},{𝕩‿0},{⟨⌊𝕩÷2,⌈𝕩÷2⟩}⟩
|
||||
𝕩{(⊣∾𝕨∾⊢)´(Pstyle 𝕩)/¨<w}¨(⌈´-⊢)≠¨𝕩
|
||||
}
|
||||
Align ← {{𝕨∾' '∾𝕩}´˘⍉" "‿𝕨⊸PadRow˘⍉>⟨""⟩‿0 PadRow '$' Split¨(@+10) Split 𝕩}
|
||||
|
||||
1 Align text
|
||||
8
Task/Align-columns/BQN/align-columns-2.bqn
Normal file
8
Task/Align-columns/BQN/align-columns-2.bqn
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
┌─
|
||||
╵" 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. "
|
||||
┘
|
||||
34
Task/Align-columns/BaCon/align-columns.bacon
Normal file
34
Task/Align-columns/BaCon/align-columns.bacon
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
DECLARE in$[] = { "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." }
|
||||
|
||||
OPTION DELIM "$"
|
||||
|
||||
CONST items = 6
|
||||
|
||||
SUB Print_In_Columns(style)
|
||||
|
||||
' Find widest column
|
||||
FOR y = 0 TO items-1
|
||||
FOR x = 1 TO AMOUNT(in$[y])
|
||||
IF LEN(TOKEN$(in$[y], x)) > max THEN max = LEN(TOKEN$(in$[y], x))
|
||||
NEXT
|
||||
NEXT
|
||||
|
||||
' Print aligned
|
||||
FOR y = 0 TO items-1
|
||||
FOR x = 1 TO AMOUNT(in$[y])
|
||||
PRINT ALIGN$(TOKEN$(in$[y], x), max+1, style);
|
||||
NEXT
|
||||
PRINT
|
||||
NEXT
|
||||
PRINT
|
||||
|
||||
END SUB
|
||||
|
||||
Print_In_Columns(0)
|
||||
Print_In_Columns(1)
|
||||
Print_In_Columns(2)
|
||||
84
Task/Align-columns/Batch-File/align-columns.bat
Normal file
84
Task/Align-columns/Batch-File/align-columns.bat
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
@echo off
|
||||
setlocal enabledelayedexpansion
|
||||
mode con cols=103
|
||||
|
||||
echo Given$a$text$file$of$many$lines,$where$fields$within$a$line$ >file.txt
|
||||
echo are$delineated$by$a$single$'dollar'$character,$write$a$program! >>file.txt
|
||||
echo that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$>>file.txt
|
||||
echo column$are$separated$by$at$least$one$space.>>file.txt
|
||||
echo Further,$allow$for$each$word$in$a$column$to$be$either$left$>>file.txt
|
||||
echo justified,$right$justified,$or$center$justified$within$its$column.>>file.txt
|
||||
|
||||
for /f "tokens=1-13 delims=$" %%a in ('type file.txt') do (
|
||||
call:maxlen %%a %%b %%c %%d %%e %%f %%g %%h %%i %%j %%k %%l %%m )
|
||||
echo.
|
||||
for /f "tokens=1-13 delims=$" %%a in ('type file.txt') do (
|
||||
call:align 1 %%a %%b %%c %%d %%e %%f %%g %%h %%i %%j %%k %%l %%m )
|
||||
echo.
|
||||
for /f "tokens=1-13 delims=$" %%a in ('type file.txt') do (
|
||||
call:align 2 %%a %%b %%c %%d %%e %%f %%g %%h %%i %%j %%k %%l %%m )
|
||||
echo.
|
||||
for /f "tokens=1-13 delims=$" %%a in ('type file.txt') do (
|
||||
call:align 3 %%a %%b %%c %%d %%e %%f %%g %%h %%i %%j %%k %%l %%m )
|
||||
|
||||
exit /B
|
||||
|
||||
:maxlen &::sets variables len1 to len13
|
||||
set "cnt=1"
|
||||
:loop1
|
||||
if "%1"=="" exit /b
|
||||
call:strlen %1 length
|
||||
if !len%cnt%! lss !length! set len%cnt%=!length!
|
||||
set /a cnt+=1
|
||||
shift
|
||||
goto loop1
|
||||
|
||||
:align
|
||||
setlocal
|
||||
set cnt=1
|
||||
set print=
|
||||
:loop2
|
||||
if "%2"=="" echo(%print%&endlocal & exit /b
|
||||
set /a width=len%cnt%,cnt+=1
|
||||
set arr=%2
|
||||
if %1 equ 1 call:left %width% arr
|
||||
if %1 equ 2 call:right %width% arr
|
||||
if %1 equ 3 call:center %width% arr
|
||||
set "print=%print%%arr% "
|
||||
shift /2
|
||||
goto loop2
|
||||
|
||||
:left %num% &string
|
||||
setlocal
|
||||
set "arr=!%2! "
|
||||
set arr=!arr:~0,%1!
|
||||
endlocal & set %2=%arr%
|
||||
exit /b
|
||||
|
||||
:right %num% &string
|
||||
setlocal
|
||||
set "arr= !%2!"
|
||||
set arr=!arr:~-%1!
|
||||
endlocal & set %2=%arr%
|
||||
exit /b
|
||||
|
||||
:center %num% &string
|
||||
setlocal
|
||||
set /a width=%1-1
|
||||
set arr=!%2!
|
||||
:loop3
|
||||
if "!arr:~%width%,1!"=="" set "arr=%arr% "
|
||||
if "!arr:~%width%,1!"=="" set "arr= %arr%"
|
||||
if "!arr:~%width%,1!"=="" goto loop3
|
||||
endlocal & set %2=%arr%
|
||||
exit /b
|
||||
|
||||
:strlen StrVar &RtnVar
|
||||
setlocal EnableDelayedExpansion
|
||||
set "s=#%~1"
|
||||
set "len=0"
|
||||
for %%N in (4096 2048 1024 512 256 128 64 32 16 8 4 2 1) do (
|
||||
if "!s:~%%N,1!" neq "" set /a "len+=%%N" & set "s=!s:~%%N!"
|
||||
)
|
||||
endlocal & set %~2=%len%
|
||||
exit /b
|
||||
53
Task/Align-columns/Beads/align-columns.beads
Normal file
53
Task/Align-columns/Beads/align-columns.beads
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
beads 1 program 'Align columns'
|
||||
|
||||
const
|
||||
text = '''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.'''
|
||||
|
||||
var
|
||||
words : array^2 of str
|
||||
widths : array of num
|
||||
|
||||
calc div_line
|
||||
var s = '+'
|
||||
loop across:widths val:w
|
||||
s = s & str_repeat('-',w) & '+'
|
||||
log s
|
||||
|
||||
calc show_table(
|
||||
justify
|
||||
)
|
||||
loop across:words index:i
|
||||
var s = '|'
|
||||
loop across:widths index:j val:w
|
||||
var
|
||||
word = words[i,j]
|
||||
if word == U
|
||||
word = ''
|
||||
case justify
|
||||
| RIGHT
|
||||
s = s & pad_left(word,w)
|
||||
| LEFT
|
||||
s = s & pad_right(word,w)
|
||||
| CENTER
|
||||
w = w - str_len(word)
|
||||
s = s & str_repeat(' ',idiv(w,2)) & word & str_repeat(' ',idiv(w,2)+mod(w,2))
|
||||
s = s & '|'
|
||||
log s
|
||||
div_line
|
||||
|
||||
calc main_init
|
||||
var w
|
||||
split_lines_words (text, words, delim:'$')
|
||||
loop across:words index:i
|
||||
loop across:words[i] index:j
|
||||
w = str_len(words[i,j])
|
||||
widths[j] = max(w,widths[j])
|
||||
loop across:[LEFT CENTER RIGHT] val:v
|
||||
log "\n{v} justified\n"
|
||||
div_line
|
||||
show_table(v)
|
||||
74
Task/Align-columns/C-sharp/align-columns-1.cs
Normal file
74
Task/Align-columns/C-sharp/align-columns-1.cs
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
using System;
|
||||
class ColumnAlignerProgram
|
||||
{
|
||||
delegate string Justification(string s, int width);
|
||||
|
||||
static string[] AlignColumns(string[] lines, Justification justification)
|
||||
{
|
||||
const char Separator = '$';
|
||||
// build input table and calculate columns count
|
||||
string[][] table = new string[lines.Length][];
|
||||
int columns = 0;
|
||||
for (int i = 0; i < lines.Length; i++)
|
||||
{
|
||||
string[] row = lines[i].TrimEnd(Separator).Split(Separator);
|
||||
if (columns < row.Length) columns = row.Length;
|
||||
table[i] = row;
|
||||
}
|
||||
// create formatted table
|
||||
string[][] formattedTable = new string[table.Length][];
|
||||
for (int i = 0; i < formattedTable.Length; i++)
|
||||
{
|
||||
formattedTable[i] = new string[columns];
|
||||
}
|
||||
for (int j = 0; j < columns; j++)
|
||||
{
|
||||
// get max column width
|
||||
int columnWidth = 0;
|
||||
for (int i = 0; i < table.Length; i++)
|
||||
{
|
||||
if (j < table[i].Length && columnWidth < table[i][j].Length)
|
||||
columnWidth = table[i][j].Length;
|
||||
}
|
||||
// justify column cells
|
||||
for (int i = 0; i < formattedTable.Length; i++)
|
||||
{
|
||||
if (j < table[i].Length)
|
||||
formattedTable[i][j] = justification(table[i][j], columnWidth);
|
||||
else
|
||||
formattedTable[i][j] = new String(' ', columnWidth);
|
||||
}
|
||||
}
|
||||
// create result
|
||||
string[] result = new string[formattedTable.Length];
|
||||
for (int i = 0; i < result.Length; i++)
|
||||
{
|
||||
result[i] = String.Join(" ", formattedTable[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static string JustifyLeft(string s, int width) { return s.PadRight(width); }
|
||||
static string JustifyRight(string s, int width) { return s.PadLeft(width); }
|
||||
static string JustifyCenter(string s, int width)
|
||||
{
|
||||
return s.PadLeft((width + s.Length) / 2).PadRight(width);
|
||||
}
|
||||
|
||||
static void Main()
|
||||
{
|
||||
string[] input = {
|
||||
"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.",
|
||||
};
|
||||
|
||||
foreach (string line in AlignColumns(input, JustifyCenter))
|
||||
{
|
||||
Console.WriteLine(line);
|
||||
}
|
||||
}
|
||||
}
|
||||
52
Task/Align-columns/C-sharp/align-columns-2.cs
Normal file
52
Task/Align-columns/C-sharp/align-columns-2.cs
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
using System;
|
||||
using System.Linq;
|
||||
|
||||
enum Justification { Left, Center, Right }
|
||||
|
||||
public class Program
|
||||
{
|
||||
static void Main()
|
||||
{
|
||||
string text =
|
||||
@"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.";
|
||||
|
||||
AlignColumns(text, Justification.Left);
|
||||
Console.WriteLine();
|
||||
AlignColumns(text, Justification.Center);
|
||||
Console.WriteLine();
|
||||
AlignColumns(text, Justification.Right);
|
||||
}
|
||||
|
||||
public static void AlignColumns(string text, Justification justification) =>
|
||||
AlignColumns(text.Split(Environment.NewLine), justification);
|
||||
|
||||
public static void AlignColumns(string[] lines, Justification justification) =>
|
||||
AlignColumns(lines.Select(line => line.Split('$')).ToArray(), justification);
|
||||
|
||||
public static void AlignColumns(string[][] table, Justification justification)
|
||||
{
|
||||
Console.WriteLine(justification + ":");
|
||||
int columns = table.Max(line => line.Length);
|
||||
var columnWidths =
|
||||
Enumerable.Range(0, columns)
|
||||
.Select(i => table.Max(line => i < line.Length ? line[i].Length : 0)
|
||||
).ToArray();
|
||||
|
||||
foreach (var line in table) {
|
||||
Console.WriteLine(string.Join(" ",
|
||||
Enumerable.Range(0, line.Length)
|
||||
.Select(i => justification switch {
|
||||
Justification.Left => line[i].PadRight(columnWidths[i]),
|
||||
Justification.Right => line[i].PadLeft(columnWidths[i]),
|
||||
_ => line[i].PadLeft(columnWidths[i] / 2).PadRight(columnWidths[i])
|
||||
})
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
83
Task/Align-columns/COBOL/align-columns-1.cobol
Normal file
83
Task/Align-columns/COBOL/align-columns-1.cobol
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
identification division.
|
||||
program-id. AlignColumns.
|
||||
|
||||
data division.
|
||||
working-storage section.
|
||||
*>-> Constants
|
||||
78 MAX-LINES value 6.
|
||||
78 MAX-LINE-SIZE value 66.
|
||||
78 MAX-COLUMNS value 12.
|
||||
78 MAX-COLUMN-SIZE value 16.
|
||||
*>-> Indexes
|
||||
01 w-idx pic is 9(2).
|
||||
01 w-idy pic is 9(2).
|
||||
01 w-pos pic is 9(3).
|
||||
*>-> Data structures
|
||||
01 w-lines.
|
||||
05 w-line pic is x(MAX-LINE-SIZE) occurs MAX-LINES.
|
||||
01 w-column-sizes.
|
||||
05 w-column-size pic is 99 occurs MAX-COLUMNS value zeros.
|
||||
01 w-matrix.
|
||||
05 filler occurs MAX-LINES.
|
||||
10 filler occurs MAX-COLUMNS.
|
||||
15 w-content pic is x(MAX-COLUMN-SIZE).
|
||||
*>-> Output
|
||||
01 w-line-out pic is x(120).
|
||||
*>-> Data alignment
|
||||
01 w-alignment pic is x(1).
|
||||
88 alignment-left value is "L".
|
||||
88 alignment-center value is "C".
|
||||
88 alignment-right value is "R".
|
||||
|
||||
procedure division.
|
||||
main.
|
||||
move "Given$a$text$file$of$many$lines,$where$fields$within$a$line$" to w-line(1)
|
||||
move "are$delineated$by$a$single$'dollar'$character,$write$a$program" to w-line(2)
|
||||
move "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$" to w-line(3)
|
||||
move "column$are$separated$by$at$least$one$space." to w-line(4)
|
||||
move "Further,$allow$for$each$word$in$a$column$to$be$either$left$" to w-line(5)
|
||||
move "justified,$right$justified,$or$center$justified$within$its$column." to w-line(6)
|
||||
perform calculate-size-columns
|
||||
set alignment-left to true
|
||||
perform show-content
|
||||
set alignment-center to true
|
||||
perform show-content
|
||||
set alignment-right to true
|
||||
perform show-content
|
||||
goback
|
||||
.
|
||||
calculate-size-columns.
|
||||
perform
|
||||
varying w-idx from 1 by 1
|
||||
until w-idx > MAX-LINES
|
||||
unstring w-line(w-idx) delimited by "$" into w-content(w-idx, 1), w-content(w-idx, 2),
|
||||
w-content(w-idx, 3), w-content(w-idx, 4), w-content(w-idx, 5), w-content(w-idx, 6),
|
||||
w-content(w-idx, 7), w-content(w-idx, 8), w-content(w-idx, 9), w-content(w-idx, 10),
|
||||
w-content(w-idx, 11), w-content(w-idx, 12),
|
||||
perform
|
||||
varying w-idy from 1 by 1
|
||||
until w-idy > MAX-COLUMNS
|
||||
if function stored-char-length(w-content(w-idx, w-idy)) > w-column-size(w-idy)
|
||||
move function stored-char-length(w-content(w-idx, w-idy)) to w-column-size(w-idy)
|
||||
end-if
|
||||
end-perform
|
||||
end-perform
|
||||
.
|
||||
show-content.
|
||||
move all "-" to w-line-out
|
||||
display w-line-out
|
||||
perform
|
||||
varying w-idx from 1 by 1
|
||||
until w-idx > MAX-LINES
|
||||
move spaces to w-line-out
|
||||
move 1 to w-pos
|
||||
perform
|
||||
varying w-idy from 1 by 1
|
||||
until w-idy > MAX-COLUMNS
|
||||
call "C$JUSTIFY" using w-content(w-idx, w-idy)(1:w-column-size(w-idy)), w-alignment
|
||||
move w-content(w-idx, w-idy) to w-line-out(w-pos:w-column-size(w-idy))
|
||||
compute w-pos = w-pos + w-column-size(w-idy) + 1
|
||||
end-perform
|
||||
display w-line-out
|
||||
end-perform
|
||||
.
|
||||
21
Task/Align-columns/COBOL/align-columns-2.cobol
Normal file
21
Task/Align-columns/COBOL/align-columns-2.cobol
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
------------------------------------------------------------------------------------------------------------------------
|
||||
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.
|
||||
------------------------------------------------------------------------------------------------------------------------
|
||||
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.
|
||||
------------------------------------------------------------------------------------------------------------------------
|
||||
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.
|
||||
41
Task/Align-columns/Clojure/align-columns.clj
Normal file
41
Task/Align-columns/Clojure/align-columns.clj
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
(ns rosettacode.align-columns
|
||||
(:require [clojure.contrib.string :as str]))
|
||||
|
||||
(def data "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.")
|
||||
|
||||
(def table (map #(str/split #"\$" %) (str/split-lines data)))
|
||||
|
||||
(defn col-width [n table] (reduce max (map #(try (count (nth % n))
|
||||
(catch Exception _ 0))
|
||||
table)))
|
||||
(defn spaces [n] (str/repeat n " "))
|
||||
(defn add-padding
|
||||
"if the string is too big turncate it, else return a string with padding"
|
||||
[string width justification]
|
||||
(if (>= (count string) width) (str/take width string)
|
||||
(let [pad-len (int (- width (count string))) ;we don't want rationals
|
||||
half-pad-len (int (/ pad-len 2))]
|
||||
(case justification
|
||||
:right (str (spaces pad-len) string)
|
||||
:left (str string (spaces pad-len))
|
||||
:center (str (spaces half-pad-len) string (spaces (- pad-len half-pad-len)))))))
|
||||
|
||||
(defn aligned-table
|
||||
"get the width of each column, then generate a new table with propper padding for eath item"
|
||||
([table justification]
|
||||
(let [col-widths (map #(+ 2 (col-width % table)) (range (count(first table))))]
|
||||
(map
|
||||
(fn [row] (map #(add-padding %1 %2 justification) row col-widths))
|
||||
table))))
|
||||
|
||||
(defn print-table
|
||||
[table]
|
||||
(do (println)
|
||||
(print (str/join "" (flatten (interleave table (repeat "\n")))))))
|
||||
|
||||
(print-table (aligned-table table :center))
|
||||
48
Task/Align-columns/CoffeeScript/align-columns-1.coffee
Normal file
48
Task/Align-columns/CoffeeScript/align-columns-1.coffee
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
pad = (n) ->
|
||||
s = ''
|
||||
while n > 0
|
||||
s += ' '
|
||||
n -= 1
|
||||
s
|
||||
|
||||
align = (input, alignment = 'center') ->
|
||||
tokenized_lines = (line.split '$' for line in input)
|
||||
col_widths = {}
|
||||
for line in tokenized_lines
|
||||
for token, i in line
|
||||
if !col_widths[i]? or token.length > col_widths[i]
|
||||
col_widths[i] = token.length
|
||||
padders =
|
||||
center: (s, width) ->
|
||||
excess = width - s.length
|
||||
left = Math.floor excess / 2
|
||||
right = excess - left
|
||||
pad(left) + s + pad(right)
|
||||
|
||||
right: (s, width) ->
|
||||
excess = width - s.length
|
||||
pad(excess) + s
|
||||
|
||||
left: (s, width) ->
|
||||
excess = width - s.length
|
||||
s + pad(excess)
|
||||
|
||||
padder = padders[alignment]
|
||||
|
||||
for line in tokenized_lines
|
||||
padded_tokens = (padder(token, col_widths[i]) for token, i in line)
|
||||
console.log padded_tokens.join ' '
|
||||
|
||||
|
||||
input = [
|
||||
"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."
|
||||
]
|
||||
|
||||
for alignment in ['center', 'right', 'left']
|
||||
console.log "\n----- #{alignment}"
|
||||
align input, alignment
|
||||
25
Task/Align-columns/CoffeeScript/align-columns-2.coffee
Normal file
25
Task/Align-columns/CoffeeScript/align-columns-2.coffee
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
> coffee align_columns.coffee
|
||||
|
||||
----- center
|
||||
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.
|
||||
|
||||
----- right
|
||||
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.
|
||||
|
||||
----- left
|
||||
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.
|
||||
66
Task/Align-columns/Commodore-BASIC/align-columns.basic
Normal file
66
Task/Align-columns/Commodore-BASIC/align-columns.basic
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
10 rem ********************************
|
||||
20 rem print words in columns
|
||||
30 rem commodore basic 2.0
|
||||
40 rem ********************************
|
||||
50 print chr$(14) : rem change to upper/lower case set
|
||||
60 gosub 140 : rem find length of longest word
|
||||
70 algn$ = "left"
|
||||
80 gosub 260 : rem print aligned text
|
||||
90 algn$ = "center"
|
||||
100 gosub 260
|
||||
110 algn$ = "right"
|
||||
120 gosub 260
|
||||
130 end
|
||||
140 rem *** find length of longest word
|
||||
150 mx=0
|
||||
160 for i=1 to 6
|
||||
170 read a$
|
||||
180 n=1
|
||||
190 for j=1 to len(a$)
|
||||
200 if mid$(a$,j,1)<>"$" then n=n+1: goto 230
|
||||
210 if mx<n then mx=n
|
||||
220 n=1
|
||||
230 next
|
||||
240 next
|
||||
250 return
|
||||
260 rem print aligned text
|
||||
270 restore : rem reset data read pointer
|
||||
280 s$ = " "
|
||||
290 print : print algn$;"-aligned"
|
||||
300 c=1 : rem column counter
|
||||
310 for i=1 to 6
|
||||
320 read a$
|
||||
330 n=1
|
||||
340 for j=1 to len(a$)
|
||||
350 if mid$(a$,j,1)<>"$" then n=n+1 : goto 380
|
||||
360 gosub 440 : rem print word
|
||||
370 n=1
|
||||
380 next
|
||||
390 if n>1 then gosub 440
|
||||
400 next
|
||||
410 print
|
||||
420 return
|
||||
430 rem ********* print word **********
|
||||
440 b$ = mid$(a$,j-n+1,n-1)
|
||||
450 b = len(b$)
|
||||
460 if algn$ = "center" then 520
|
||||
470 if algn$ = "right" then 570
|
||||
480 if c+b<40 and c+mx>40 then print b$: c=1: return
|
||||
490 if c+mx>40 then print : c=1
|
||||
500 print b$;left$(s$,mx-b);: c=c+mx
|
||||
510 return
|
||||
520 if c+mx>40 then print : c=1
|
||||
530 bb=(mx-b)/2 : ba=bb
|
||||
540 if bb>1 and int(bb)=bb then ba=bb-1
|
||||
550 print left$(s$,ba);b$;left$(s$,bb);: c=c+mx
|
||||
560 return
|
||||
570 if c+mx>40 then print : c=1
|
||||
580 print left$(s$,mx-b);b$;: c=c+mx
|
||||
590 return
|
||||
600 rem *********** the words *********
|
||||
610 data "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
620 data "are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
630 data "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
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"
|
||||
48
Task/Align-columns/Common-Lisp/align-columns.lisp
Normal file
48
Task/Align-columns/Common-Lisp/align-columns.lisp
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
(defun nonempty (seq)
|
||||
(position-if (lambda (x) (declare (ignore x)) t) seq))
|
||||
|
||||
(defun split (delim seq)
|
||||
"Splits seq on delim into a list of subsequences. Trailing empty
|
||||
subsequences are removed."
|
||||
(labels
|
||||
((f (seq &aux (pos (position delim seq)))
|
||||
(if pos
|
||||
(cons
|
||||
(subseq seq 0 pos)
|
||||
(f (subseq seq (1+ pos))))
|
||||
(list seq))))
|
||||
(let* ((list (f seq))
|
||||
(end (position-if #'nonempty list :from-end t)))
|
||||
(subseq list 0 (1+ end)))))
|
||||
|
||||
(defun lengthen (list minlen filler-elem &aux (len (length list)))
|
||||
"Destructively pads list with filler-elem up to minlen."
|
||||
(if (< len minlen)
|
||||
(nconc list (make-list (- minlen len) :initial-element filler-elem))
|
||||
list))
|
||||
|
||||
(defun align-columns (text
|
||||
&key (align :left)
|
||||
&aux
|
||||
(fmtmod (case align
|
||||
(:left "@")
|
||||
(:right ":")
|
||||
(:center "@:")
|
||||
(t (error "Invalid alignment."))))
|
||||
(fields (mapcar (lambda (line) (split #\$ line))
|
||||
(split #\Newline text)))
|
||||
(mostcols (loop for l in fields
|
||||
maximize (length l)))
|
||||
widest)
|
||||
(setf fields (mapcar (lambda (l) (lengthen l mostcols ""))
|
||||
fields))
|
||||
(setf widest (loop for col below (length (first fields))
|
||||
collect (loop for row in fields
|
||||
maximize (length (elt row col)))))
|
||||
(format nil
|
||||
(with-output-to-string (s)
|
||||
(princ "~{~{" s)
|
||||
(dolist (w widest)
|
||||
(format s "~~~d~a<~~a~~>" (1+ w) fmtmod))
|
||||
(princ "~}~%~}" s))
|
||||
fields))
|
||||
22
Task/Align-columns/D/align-columns.d
Normal file
22
Task/Align-columns/D/align-columns.d
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
void main() {
|
||||
import std.stdio, std.string, std.algorithm, std.range, std.typetuple;
|
||||
|
||||
immutable data =
|
||||
"Given$a$txt$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."
|
||||
.split.map!(r => r.chomp("$").split("$")).array;
|
||||
|
||||
size_t[size_t] maxWidths;
|
||||
foreach (const line; data)
|
||||
foreach (immutable i, const word; line)
|
||||
maxWidths[i] = max(maxWidths.get(i, 0), word.length);
|
||||
|
||||
foreach (immutable just; TypeTuple!(leftJustify, center, rightJustify))
|
||||
foreach (immutable line; data)
|
||||
writefln("%-(%s %)", line.length.iota
|
||||
.map!(i => just(line[i], maxWidths[i], ' ')));
|
||||
}
|
||||
56
Task/Align-columns/Delphi/align-columns.delphi
Normal file
56
Task/Align-columns/Delphi/align-columns.delphi
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
USES
|
||||
StdCtrls, Classes, SysUtils, StrUtils, Contnrs;
|
||||
|
||||
procedure AlignByColumn(Output: TMemo; Align: TAlignment);
|
||||
const
|
||||
TextToAlign =
|
||||
'Given$a$text$file$of$many$lines,$where$fields$within$a$line$'#$D#$A +
|
||||
'are$delineated$by$a$single$''dollar''$character,$write$a$program'#$D#$A +
|
||||
'that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$'#$D#$A +
|
||||
'column$are$separated$by$at$least$one$space.'#$D#$A +
|
||||
'Further,$allow$for$each$word$in$a$column$to$be$either$left$'#$D#$A +
|
||||
'justified,$right$justified,$or$center$justified$within$its$column.';
|
||||
var
|
||||
TextLine, TempTString: TStringlist;
|
||||
TextLines: TObjectList;
|
||||
MaxLength, i, j: Byte;
|
||||
OutPutString, EmptyString, Item: String;
|
||||
begin
|
||||
TRY
|
||||
MaxLength := 0;
|
||||
TextLines := TObjectList.Create(True);
|
||||
TextLine := TStringList.Create;
|
||||
TextLine.text := TextToAlign;
|
||||
for i:= 0 to TextLine.Count - 1 do
|
||||
begin
|
||||
TempTString := TStringlist.create;
|
||||
TempTString.text :=AnsiReplaceStr(TextLine[i], '$', #$D#$A);
|
||||
TextLines.Add(TempTString);
|
||||
end;
|
||||
for i := 0 to TextLines.Count - 1 do
|
||||
for j := 0 to TStringList(TextLines.Items[i]).Count - 1 do
|
||||
If Length(TStringList(TextLines.Items[i])[j]) > MaxLength then
|
||||
MaxLength := Length(TStringList(TextLines.Items[i])[j]);
|
||||
If MaxLength > 0 then
|
||||
MaxLength := MaxLength + 2; // Add to empty spaces to it
|
||||
for i := 0 to TextLines.Count - 1 do
|
||||
begin
|
||||
OutPutString := '';
|
||||
for j := 0 to TStringList(TextLines.Items[i]).Count - 1 do
|
||||
begin
|
||||
EmptyString := StringOfChar(' ', MaxLength);
|
||||
Item := TStringList(TextLines.Items[i])[j];
|
||||
case Align of
|
||||
taLeftJustify: Move(Item[1], EmptyString[2], Length(Item));
|
||||
taRightJustify: Move(Item[1], EmptyString[MaxLength - Length(Item) + 1], Length(Item));
|
||||
taCenter: Move(Item[1], EmptyString[(MaxLength - Length(Item) + 1) div 2 + 1], Length(Item));
|
||||
end;
|
||||
OutPutString := OutPutString + EmptyString;
|
||||
end;
|
||||
Output.Lines.Add(OutPutString);
|
||||
end;
|
||||
FINALLY
|
||||
FreeAndNil(TextLine);
|
||||
FreeAndNil(TextLines);
|
||||
END;
|
||||
end;
|
||||
29
Task/Align-columns/E/align-columns-1.e
Normal file
29
Task/Align-columns/E/align-columns-1.e
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
pragma.enable("accumulator")
|
||||
|
||||
def left(width, word) {
|
||||
return word + " " * (width - word.size())
|
||||
}
|
||||
|
||||
def center(width, word) {
|
||||
def leftCount := (width - word.size()) // 2
|
||||
return " " * leftCount + word + " " * (width - word.size() - leftCount)
|
||||
}
|
||||
|
||||
def right(width, word) {
|
||||
return " " * (width - word.size()) + word
|
||||
}
|
||||
|
||||
def alignColumns(align, text) {
|
||||
def split := accum [] for line in text.split("\n") { _.with(line.split("$")) }
|
||||
var widths := []
|
||||
for line in split {
|
||||
for i => word in line {
|
||||
widths with= (i, widths.fetch(i, fn{0}).max(word.size()))
|
||||
}
|
||||
}
|
||||
return accum "" for line in split {
|
||||
_ + accum "" for i => word in line {
|
||||
_ + align(widths[i] + 1, word)
|
||||
} + "\n"
|
||||
}
|
||||
}
|
||||
30
Task/Align-columns/E/align-columns-2.e
Normal file
30
Task/Align-columns/E/align-columns-2.e
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
? def text := "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."; null
|
||||
|
||||
? println(alignColumns(left, text))
|
||||
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.
|
||||
|
||||
? println(alignColumns(center, text))
|
||||
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.
|
||||
|
||||
? println(alignColumns(right, text))
|
||||
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.
|
||||
35
Task/Align-columns/Elixir/align-columns.elixir
Normal file
35
Task/Align-columns/Elixir/align-columns.elixir
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
defmodule Align do
|
||||
def columns(text, alignment) do
|
||||
fieldsbyrow = String.split(text, "\n", trim: true)
|
||||
|> Enum.map(fn row -> String.split(row, "$", trim: true) end)
|
||||
maxfields = Enum.map(fieldsbyrow, fn field -> length(field) end) |> Enum.max
|
||||
colwidths = Enum.map(fieldsbyrow, fn field -> field ++ List.duplicate("", maxfields - length(field)) end)
|
||||
|> List.zip
|
||||
|> Enum.map(fn column ->
|
||||
Tuple.to_list(column) |> Enum.map(fn col-> String.length(col) end) |> Enum.max
|
||||
end)
|
||||
Enum.each(fieldsbyrow, fn row ->
|
||||
Enum.zip(row, colwidths)
|
||||
|> Enum.map(fn {field, width} -> adjust(field, width, alignment) end)
|
||||
|> Enum.join(" ") |> IO.puts
|
||||
end)
|
||||
end
|
||||
|
||||
defp adjust(field, width, :Left), do: String.pad_trailing(field, width)
|
||||
defp adjust(field, width, :Right), do: String.pad_leading(field, width)
|
||||
defp adjust(field, width, _), do: :string.centre(String.to_charlist(field), width)
|
||||
end
|
||||
|
||||
text = """
|
||||
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.
|
||||
"""
|
||||
|
||||
Enum.each([:Left, :Right, :Center], fn alignment ->
|
||||
IO.puts "\n# #{alignment} Column-aligned output:"
|
||||
Align.columns(text, alignment)
|
||||
end)
|
||||
38
Task/Align-columns/Erlang/align-columns.erl
Normal file
38
Task/Align-columns/Erlang/align-columns.erl
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
-module (align_columns).
|
||||
|
||||
-export([align_left/0, align_right/0, align_center/0]).
|
||||
-define (Lines,
|
||||
["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."].
|
||||
|
||||
align_left()-> align_columns(left).
|
||||
align_right()-> align_columns(right).
|
||||
align_center()-> align_columns(centre).
|
||||
align_columns(Alignment) ->
|
||||
Words = [ string:tokens(Line, "\$") || Line <- ?Lines ],
|
||||
Words_length = lists:foldl( fun max_length/2, [], Words),
|
||||
Result = [prepare_line(Words_line, Words_length, Alignment)
|
||||
|| Words_line <- Words],
|
||||
|
||||
[ io:fwrite("~s~n", [lists:flatten(Line)]) || Line <- Result],
|
||||
ok.
|
||||
|
||||
max_length(Words_of_a_line, Acc_maxlength) ->
|
||||
Line_lengths = [length(W) || W <- Words_of_a_line ],
|
||||
Max_nb_of_length = lists:max([length(Acc_maxlength), length(Line_lengths)]),
|
||||
Line_lengths_prepared = adjust_list (Line_lengths, Max_nb_of_length, 0),
|
||||
Acc_maxlength_prepared = adjust_list(Acc_maxlength, Max_nb_of_length, 0),
|
||||
Two_lengths =lists:zip(Line_lengths_prepared, Acc_maxlength_prepared),
|
||||
[ lists:max([A, B]) || {A, B} <- Two_lengths].
|
||||
adjust_list(L, Desired_length, Elem) ->
|
||||
L++lists:duplicate(Desired_length - length(L), Elem).
|
||||
|
||||
prepare_line(Words_line, Words_length, Alignment) ->
|
||||
All_words = adjust_list(Words_line, length(Words_length), ""),
|
||||
Zipped = lists:zip (All_words, Words_length),
|
||||
[ apply(string, Alignment, [Word, Length + 1, $\s])
|
||||
|| {Word, Length} <- Zipped].
|
||||
61
Task/Align-columns/Euphoria/align-columns.euphoria
Normal file
61
Task/Align-columns/Euphoria/align-columns.euphoria
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
constant data = {
|
||||
"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."
|
||||
}
|
||||
|
||||
function split(sequence s, integer c)
|
||||
sequence out
|
||||
integer first, delim
|
||||
out = {}
|
||||
first = 1
|
||||
while first<=length(s) do
|
||||
delim = find_from(c,s,first)
|
||||
if delim = 0 then
|
||||
delim = length(s)+1
|
||||
end if
|
||||
out = append(out,s[first..delim-1])
|
||||
first = delim + 1
|
||||
end while
|
||||
return out
|
||||
end function
|
||||
|
||||
function align(sequence s, integer width, integer alignment)
|
||||
integer n
|
||||
n = width - length(s)
|
||||
if n <= 0 then
|
||||
return s
|
||||
elsif alignment < 0 then
|
||||
return s & repeat(' ', n)
|
||||
elsif alignment > 0 then
|
||||
return repeat(' ', n) & s
|
||||
else
|
||||
return repeat(' ', floor(n/2)) & s & repeat(' ', floor(n/2+0.5))
|
||||
end if
|
||||
end function
|
||||
|
||||
integer maxlen
|
||||
sequence lines
|
||||
maxlen = 0
|
||||
lines = repeat(0,length(data))
|
||||
for i = 1 to length(data) do
|
||||
lines[i] = split(data[i],'$')
|
||||
for j = 1 to length(lines[i]) do
|
||||
if length(lines[i][j]) > maxlen then
|
||||
maxlen = length(lines[i][j])
|
||||
end if
|
||||
end for
|
||||
end for
|
||||
|
||||
for a = -1 to 1 do
|
||||
for i = 1 to length(lines) do
|
||||
for j = 1 to length(lines[i]) do
|
||||
puts(1, align(lines[i][j],maxlen,a) & ' ')
|
||||
end for
|
||||
puts(1,'\n')
|
||||
end for
|
||||
puts(1,'\n')
|
||||
end for
|
||||
33
Task/Align-columns/F-Sharp/align-columns.fs
Normal file
33
Task/Align-columns/F-Sharp/align-columns.fs
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
open System
|
||||
open System.IO
|
||||
|
||||
let tableFromPath path =
|
||||
let lines =
|
||||
[ for line in File.ReadAllLines(path) -> (line.TrimEnd('$').Split('$')) ]
|
||||
let width = List.fold (fun max (line : string[]) -> if max < line.Length then line.Length else max) 0 lines
|
||||
List.map (fun (a : string[]) -> (List.init width (fun i -> if i < a.Length then a.[i] else ""))) lines
|
||||
|
||||
let rec trans m =
|
||||
match m with
|
||||
| []::_ -> []
|
||||
| _ -> (List.map List.head m) :: trans (List.map List.tail m)
|
||||
|
||||
let colWidth table =
|
||||
List.map (fun col -> List.max (List.map String.length col)) (trans table)
|
||||
|
||||
let left = (fun (s : string) n -> s.PadRight(n))
|
||||
let right = (fun (s : string) n -> s.PadLeft(n))
|
||||
let center = (fun (s : string) n -> s.PadLeft((n + s.Length) / 2).PadRight(n))
|
||||
|
||||
[<EntryPoint>]
|
||||
let main argv =
|
||||
let table = tableFromPath argv.[0]
|
||||
let width = Array.ofList (colWidth table)
|
||||
let format table align =
|
||||
List.map (fun (row : string list) -> List.mapi (fun i s -> sprintf "%s" (align s width.[i])) row) table
|
||||
|> List.iter (fun row -> printfn "%s" (String.Join(" ", Array.ofList row)))
|
||||
|
||||
for align in [ left; right; center ] do
|
||||
format table align
|
||||
printfn "%s" (new String('-', (Array.sum width) + width.Length - 1))
|
||||
0
|
||||
35
Task/Align-columns/FBSL/align-columns.fbsl
Normal file
35
Task/Align-columns/FBSL/align-columns.fbsl
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#APPTYPE CONSOLE
|
||||
|
||||
DIM s = "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."
|
||||
|
||||
DIM lines[] = SPLIT(s, CRLF), tokens[], l, t, length, margin, justify = "center"
|
||||
|
||||
FOREACH l IN lines
|
||||
tokens = SPLIT(l, "$")
|
||||
FOREACH t IN tokens
|
||||
IF STRLEN(t) > length THEN length = INCR(STRLEN)
|
||||
NEXT
|
||||
NEXT
|
||||
|
||||
FOREACH l IN lines
|
||||
tokens = SPLIT(l, "$")
|
||||
FOREACH t IN tokens
|
||||
SELECT CASE justify
|
||||
CASE "left"
|
||||
PRINT t, SPACE(length - STRLEN(t));
|
||||
CASE "center"
|
||||
margin = (length - STRLEN(t)) \ 2
|
||||
PRINT SPACE(margin), t, SPACE(length - STRLEN - margin);
|
||||
CASE "right"
|
||||
PRINT SPACE(length - STRLEN(t)), t;
|
||||
END SELECT
|
||||
NEXT
|
||||
PRINT
|
||||
NEXT
|
||||
|
||||
PAUSE
|
||||
40
Task/Align-columns/Factor/align-columns.factor
Normal file
40
Task/Align-columns/Factor/align-columns.factor
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
USING: fry io kernel math math.functions math.order sequences
|
||||
splitting strings ;
|
||||
IN: rosetta.column-aligner
|
||||
|
||||
CONSTANT: example-text "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."
|
||||
|
||||
: split-and-pad ( text -- lines )
|
||||
"\n" split [ "$" split harvest ] map
|
||||
dup [ length ] [ max ] map-reduce
|
||||
'[ _ "" pad-tail ] map ;
|
||||
|
||||
: column-widths ( columns -- widths )
|
||||
[ [ length ] [ max ] map-reduce ] map ;
|
||||
|
||||
SINGLETONS: +left+ +middle+ +right+ ;
|
||||
|
||||
GENERIC: align-string ( str n alignment -- str' )
|
||||
|
||||
M: +left+ align-string drop CHAR: space pad-tail ;
|
||||
M: +right+ align-string drop CHAR: space pad-head ;
|
||||
|
||||
M: +middle+ align-string
|
||||
drop
|
||||
over length - 2 /
|
||||
[ floor CHAR: space <string> ]
|
||||
[ ceiling CHAR: space <string> ] bi surround ;
|
||||
|
||||
: align-columns ( columns alignment -- columns' )
|
||||
[ dup column-widths ] dip '[
|
||||
[ _ align-string ] curry map
|
||||
] 2map ;
|
||||
|
||||
: print-aligned ( text alignment -- )
|
||||
[ split-and-pad flip ] dip align-columns flip
|
||||
[ [ write " " write ] each nl ] each ;
|
||||
70
Task/Align-columns/Forth/align-columns.fth
Normal file
70
Task/Align-columns/Forth/align-columns.fth
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
\ align columns
|
||||
|
||||
: split ( addr len char -- addr len1 addr len-len1 )
|
||||
>r 2dup r> scan 2swap 2 pick - ;
|
||||
|
||||
variable column
|
||||
|
||||
: for-each-line ( file len xt -- )
|
||||
>r begin #lf split r@ execute 1 /string dup 0<= until 2drop rdrop ;
|
||||
|
||||
: for-each-field ( line len xt -- )
|
||||
0 column !
|
||||
>r begin '$ split r@ execute 1 column +! 1 /string dup 0<= until 2drop rdrop ;
|
||||
|
||||
0 value num-columns
|
||||
|
||||
: count-columns ( line len -- )
|
||||
['] 2drop for-each-field
|
||||
num-columns column @ max to num-columns ;
|
||||
: find-num-columns ( file len -- )
|
||||
0 to num-columns
|
||||
['] count-columns for-each-line ;
|
||||
|
||||
0 value column-widths
|
||||
|
||||
: column-width ( field len -- )
|
||||
column-widths column @ + c@
|
||||
max
|
||||
column-widths column @ + c!
|
||||
drop ;
|
||||
: measure-widths ( line len -- )
|
||||
['] column-width for-each-field ;
|
||||
: find-column-widths ( file len -- )
|
||||
num-columns allocate throw to column-widths
|
||||
column-widths num-columns erase
|
||||
['] measure-widths for-each-line ;
|
||||
|
||||
\ type aligned, same naming convention as standard numeric U.R, .R
|
||||
: type.l ( addr len width -- )
|
||||
over - >r type r> spaces ;
|
||||
: type.c ( addr len width -- )
|
||||
over - dup 2/ spaces >r type r> 1+ 2/ spaces ;
|
||||
: type.r ( addr len width -- )
|
||||
over - spaces type ;
|
||||
|
||||
defer type.aligned
|
||||
|
||||
: print-field ( field len -- )
|
||||
column-widths column @ + c@ type.aligned space ;
|
||||
: print-line ( line len -- ) cr ['] print-field for-each-field ;
|
||||
: print-fields ( file len -- ) ['] print-line for-each-line ;
|
||||
|
||||
|
||||
\ read file
|
||||
s" columns.txt" slurp-file ( file len )
|
||||
|
||||
\ scan once to determine num-columns
|
||||
2dup find-num-columns
|
||||
|
||||
\ scan again to determine column-widths
|
||||
2dup find-column-widths
|
||||
|
||||
\ print columns, once for each alignment type
|
||||
' type.l is type.aligned 2dup print-fields cr
|
||||
' type.c is type.aligned 2dup print-fields cr
|
||||
' type.r is type.aligned 2dup print-fields cr
|
||||
|
||||
\ cleanup
|
||||
nip free throw
|
||||
column-widths free throw
|
||||
94
Task/Align-columns/Fortran/align-columns.f
Normal file
94
Task/Align-columns/Fortran/align-columns.f
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
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.
|
||||
INTEGER IN !Fingers the input file.
|
||||
INTEGER M !Maximum record length thereof.
|
||||
CHARACTER*1 X !The delimiter, possibly a comma.
|
||||
INTEGER WAY !Alignment style.
|
||||
INTEGER W(M + 1) !If every character were X in the maximum-length record,
|
||||
INTEGER C(0:M + 1) !Then M + 1 would be the maximum number of fields possible.
|
||||
CHARACTER*(M) ACARD !A scratchpad big enough for the biggest.
|
||||
CHARACTER*(28 + 4*M) FORMAT !Guess. Allow for "Ann," per field.
|
||||
INTEGER I !A stepper.
|
||||
INTEGER L,LF !Text fingers.
|
||||
INTEGER NF,MF !Field counts.
|
||||
CHARACTER*6 WAYNESS(-1:+1) !Some annotation may be helpful.
|
||||
PARAMETER (WAYNESS = (/"Left","Centre","Right"/)) !Using normal language.
|
||||
INTEGER LINPR !The mouthpiece.
|
||||
COMMON LINPR !Used all over.
|
||||
W = 0 !Maximum field widths so far seen.
|
||||
MF = 0 !Maximum number of fields to a record.
|
||||
C(0) = 0 !Syncopation for the first field's predecessor.
|
||||
WRITE (LINPR,*) !Some separation.
|
||||
WRITE (LINPR,*) "Align ",WAYNESS(MIN(MAX(WAY,-1),+1)) !Explain, cautiously.
|
||||
|
||||
Chase through the file assessing the lengths of each field.
|
||||
10 READ (IN,11,END = 20) L,ACARD(1:L) !Grab a record.
|
||||
11 FORMAT (Q,A) !Working only up to its end.
|
||||
CALL LIZZIEBORDEN !Find the chop points.
|
||||
W(1:NF) = MAX(W(1:NF),C(1:NF) - C(0:NF - 1) - 1) !Thereby the lengths between.
|
||||
MF = MAX(MF,NF) !Also want to know the most number of chops.
|
||||
GO TO 10 !Get the next record.
|
||||
|
||||
Concoct a FORMAT based on the maximum size of each field. Plus one.
|
||||
20 REWIND(IN) !Back to the beginning.
|
||||
WRITE (FORMAT,21) W(1:MF) + 1 !Add one to meet the specified at least one space between columns.
|
||||
21 FORMAT ("(",<MF>("A",I0,",")) !Generates a sequence of An, items.
|
||||
LF = INDEX(FORMAT,", ") !The last one has a trailing comma.
|
||||
IF (LF.LE.0) STOP "Format trouble!" !Or, maybe not!
|
||||
FORMAT(LF:LF) = ")" !Convert it to the closing bracket.
|
||||
WRITE (LINPR,*) "Format",FORMAT(1:LF) !Present it.
|
||||
|
||||
Chug afresh, this time knowing the maximum length of each field.
|
||||
30 READ (IN,11,END = 40) L,ACARD(1:L) !Place just the record's content.
|
||||
CALL LIZZIEBORDEN !Find the chop points.
|
||||
SELECT CASE(WAY) !What is to be done?
|
||||
CASE(-1) !Shove leftwards by appending spaces.
|
||||
WRITE (LINPR,FORMAT) (ACARD(C(I - 1) + 1:C(I) - 1)// !The chopped text.
|
||||
1 REPEAT(" ",W(I) - C(I) + C(I - 1) + 1),I = 1,NF) !Some spaces.
|
||||
CASE( 0) !Centre by appending half as many spaces.
|
||||
WRITE (LINPR,FORMAT) (ACARD(C(I - 1) + 1:C(I) - 1)// !The chopped text.
|
||||
1 REPEAT(" ",(W(I) - C(I) + C(I - 1) + 1)/2),I = 1,NF) !Some spaces.
|
||||
CASE(+1) !Align rightwards is the default style.
|
||||
WRITE (LINPR,FORMAT) (ACARD(C(I - 1) + 1:C(I) - 1),I = 1,NF) !So, just the texts.
|
||||
CASE DEFAULT !This shouldn't happen.
|
||||
WRITE (LINPR,*) "Huh? WAY=",WAY !But if it does,
|
||||
STOP "Unanticipated value for WAY!" !Explain.
|
||||
END SELECT !So much for that record.
|
||||
GO TO 30 !Go for another.
|
||||
Closedown
|
||||
40 REWIND(IN) !Be polite.
|
||||
CONTAINS !This also marks the end of source for RAKE...
|
||||
SUBROUTINE LIZZIEBORDEN !Take an axe to ACARD, chopping at X.
|
||||
NF = 0 !No strokes so far.
|
||||
DO I = 1,L !So, step away.
|
||||
IF (ICHAR(ACARD(I:I)).EQ.ICHAR(X)) THEN !Here?
|
||||
NF = NF + 1 !Yes!
|
||||
C(NF) = I !The place!
|
||||
END IF !So much for that.
|
||||
END DO !On to the next.
|
||||
NF = NF + 1 !And the end of ACARD is also a chop point.
|
||||
C(NF) = L + 1 !As if here.
|
||||
END SUBROUTINE LIZZIEBORDEN !She was aquitted.
|
||||
END SUBROUTINE RAKE !So much raking over.
|
||||
|
||||
INTEGER L,M,N !To be determined the hard way.
|
||||
INTEGER LINPR,IN !I/O unit numbers.
|
||||
COMMON LINPR !Some of general note.
|
||||
LINPR = 6 !Standard output via this unit number.
|
||||
IN = 10 !Some unit number for the input file.
|
||||
OPEN (IN,FILE="Rake.txt",STATUS="OLD",ACTION="READ") !For formatted input.
|
||||
N = 0 !No records read.
|
||||
M = 0 !Longest record so far.
|
||||
|
||||
1 READ (IN,2,END = 10) L !How long is this record?
|
||||
2 FORMAT (Q) !Obviously, Q specifies the length, not a content field.
|
||||
N = N + 1 !Anyway, another record has been read.
|
||||
M = MAX(M,L) !And this is the longest so far.
|
||||
GO TO 1 !Go back for more.
|
||||
|
||||
10 REWIND (IN) !We're ready now.
|
||||
WRITE (LINPR,*) N,"Recs, longest rec. length is ",M
|
||||
CALL RAKE(IN,M,"$",-1) !Align left.
|
||||
CALL RAKE(IN,M,"$", 0) !Centre.
|
||||
CALL RAKE(IN,M,"$",+1) !Align right.
|
||||
END !That's all.
|
||||
98
Task/Align-columns/FreeBASIC/align-columns.basic
Normal file
98
Task/Align-columns/FreeBASIC/align-columns.basic
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
' FB 1.05.0 Win64
|
||||
|
||||
Sub Split(s As String, sep As String, result() As String)
|
||||
Dim As Integer i, j, count = 0
|
||||
Dim temp As String
|
||||
Dim As Integer position(Len(s) + 1)
|
||||
position(0) = 0
|
||||
For i = 0 To Len(s) - 1
|
||||
For j = 0 To Len(sep) - 1
|
||||
If s[i] = sep[j] Then
|
||||
count += 1
|
||||
position(count) = i + 1
|
||||
End If
|
||||
Next j
|
||||
Next i
|
||||
position(count + 1) = Len(s) + 1
|
||||
Redim result(count)
|
||||
For i = 1 To count + 1
|
||||
result(i - 1) = Mid(s, position(i - 1) + 1, position(i) - position(i - 1) - 1)
|
||||
Next
|
||||
End Sub
|
||||
|
||||
Sub CSet(buffer As String, s As Const String)
|
||||
Dim As Integer bLength = Len(buffer)
|
||||
Dim As Integer sLength = Len(s)
|
||||
Dim As Integer diff, lSpaces
|
||||
If sLength >= bLength Then
|
||||
LSet buffer, s
|
||||
Else
|
||||
diff = bLength - sLength
|
||||
lSpaces = diff \ 2
|
||||
LSet buffer, Space(lSpaces) + s
|
||||
End If
|
||||
End Sub
|
||||
|
||||
Dim lines() As String
|
||||
Dim count As Integer = 0
|
||||
|
||||
Open "align_columns.txt" For Input As #1
|
||||
|
||||
While Not Eof(1)
|
||||
Redim Preserve lines(count)
|
||||
Line Input #1, lines(count)
|
||||
count +=1
|
||||
Wend
|
||||
|
||||
Close #1
|
||||
|
||||
Dim As Integer i,j, length, numColumns = 0
|
||||
Dim As Integer numLines = UBound(lines) + 1
|
||||
Dim fields() As String
|
||||
|
||||
' Work out the maximum number of columns
|
||||
For i = 0 To numLines - 1
|
||||
Erase fields
|
||||
Split RTrim(lines(i), "$"), "$", fields()
|
||||
length = UBound(fields) + 1
|
||||
If length > numColumns Then numColumns = length
|
||||
Next
|
||||
|
||||
' Split lines into fields and work out maximum size of each column
|
||||
Dim matrix(numLines - 1, numColumns - 1) As String
|
||||
Dim columnSizes(numColumns - 1) As Integer
|
||||
|
||||
For i = 0 To numLines - 1
|
||||
Erase fields
|
||||
Split RTrim(lines(i), "$"), "$", fields()
|
||||
For j = 0 To UBound(fields)
|
||||
matrix(i, j) = fields(j)
|
||||
length = Len(fields(j))
|
||||
If length > columnSizes(j) Then columnSizes(j) = length
|
||||
Next j
|
||||
Next i
|
||||
|
||||
Dim buffer As String
|
||||
|
||||
'Separate each column by 2 spaces
|
||||
Open "align_left_columns.txt" For Output As #1
|
||||
Open "align_right_columns.txt" For Output As #2
|
||||
Open "align_center_columns.txt" For Output As #3
|
||||
|
||||
For i = 0 To UBound(matrix, 1)
|
||||
For j = 0 To UBound(matrix, 2)
|
||||
buffer = Space(columnSizes(j))
|
||||
LSet buffer, matrix(i, j)
|
||||
Print #1, buffer;
|
||||
RSet buffer, matrix(i, j)
|
||||
Print #2, buffer;
|
||||
CSet buffer, matrix(i, j)
|
||||
Print #3, buffer;
|
||||
If j < UBound(matrix, 2) Then
|
||||
Print #1, " "; : Print #2, " "; : Print #3, " ";
|
||||
End If
|
||||
Next j
|
||||
Print #1, : Print #2, : Print #3,
|
||||
Next i
|
||||
|
||||
Close #1 : Close #2 : Close #3
|
||||
45
Task/Align-columns/FutureBasic/align-columns.basic
Normal file
45
Task/Align-columns/FutureBasic/align-columns.basic
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
include "NSLog.incl"
|
||||
|
||||
local fn AlignColumn
|
||||
NSUInteger i
|
||||
|
||||
CFStringRef testStr = @"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."
|
||||
|
||||
CFArrayRef temp = fn StringComponentsSeparatedByString( testStr, @"$" )
|
||||
CFMutableArrayRef arr = fn MutableArrayWithArray( temp )
|
||||
NSUInteger count = fn ArrayCount( arr )
|
||||
ptr a(50)
|
||||
|
||||
NSLog( @"\nLeft aligned:\n" )
|
||||
NSUInteger lineCheck = 1
|
||||
for i = 0 to count -1
|
||||
a( lineCheck ) = (ptr)fn StringUTF8String( arr[i] )
|
||||
if ( lineCheck == 9 )
|
||||
NSLog( @"%-12s %-11s %-12s %-11s %-12s %-12s %-12s %-12s %-12s", a(1),a(2),a(3),a(4),a(5),a(6),a(7),a(8),a(9) )
|
||||
lineCheck = 1
|
||||
else
|
||||
lineCheck++
|
||||
end if
|
||||
next
|
||||
|
||||
NSLog( @"\n\nRight aligned:\n" )
|
||||
|
||||
lineCheck = 1
|
||||
for i = 0 to count -1
|
||||
a( lineCheck ) = (ptr)fn StringUTF8String( arr[i] )
|
||||
if ( lineCheck == 9 )
|
||||
NSLog( @"%12s %11s %12s %11s %12s %12s %12s %12s %12s", a(1),a(2),a(3),a(4),a(5),a(6),a(7),a(8),a(9) )
|
||||
lineCheck = 1
|
||||
else
|
||||
lineCheck++
|
||||
end if
|
||||
next
|
||||
|
||||
end fn
|
||||
|
||||
fn AlignColumn
|
||||
|
||||
HandleEvents
|
||||
44
Task/Align-columns/Gambas/align-columns.gambas
Normal file
44
Task/Align-columns/Gambas/align-columns.gambas
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
Public Sub Main() 'Written in Gambas 3.9.2 as a Command line Application - 15/03/2017
|
||||
Dim siCount, siCounter, siLength As Short 'Counters
|
||||
Dim siLongest As Short = -1 'To store the longest 'Word'
|
||||
Dim sLine, sRows As New String[] 'Arrays
|
||||
Dim sTemp, sAlign As String 'Temp strings
|
||||
Dim sInput As String = "Given$a$text$file$of$many$lines, $where$fields$within$a$line$" & "\n"
|
||||
"are$delineated$by$a$single$ 'dollar'$character,$write$a$program" & "\n"
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$" & "\n"
|
||||
"column$are$separated$by$at$least$one$space." & "\n"
|
||||
"Further, $allow$for$each$word$in$a$column$to$be$either$left$" & "\n"
|
||||
"justified, $right$justified, $or$center$justified$within$its$column." 'Main string (with End Of Line characters added)
|
||||
|
||||
For Each sTemp In Split(sInput, "\n") 'For each Line (split by End of Line character)..
|
||||
sLine.add(sTemp) 'Add the Line to sLine array
|
||||
Next
|
||||
|
||||
For siCount = 0 To sLine.Max 'For each of Lines in the array..
|
||||
For Each sTemp In Split(sLine[siCount], "$") 'For each 'Word' in the Line (Split by the '$')
|
||||
siLength = Len(sTemp) 'Store the length of the current 'Word'
|
||||
If siLength > siLongest Then siLongest = siLength 'Make sure siLength has the length of the longest 'Word'
|
||||
sRows.add(Trim(sTemp)) 'Create an array of the 'Words'
|
||||
Next
|
||||
sRows.add("\n") 'Add a End Of Line character to the sRows array
|
||||
Next
|
||||
|
||||
For siCounter = 0 To 2 'For each alignment (Left, Right and Centre)
|
||||
For Each sTemp In sRows 'For each 'Word' in the sRows array..
|
||||
If sTemp = "\n" Then 'If it's a End Of Line character then..
|
||||
Print 'Print
|
||||
Continue 'Jump to the next iteration of the For Next Loop
|
||||
Endif
|
||||
If siCounter = 0 Then Print sTemp & Space(siLongest - Len(sTemp)); 'Print control for Left align
|
||||
If siCounter = 1 Then Print Space(siLongest - Len(sTemp)) & sTemp; 'Print control for Right align
|
||||
If siCounter = 2 Then 'Print control for Centre align
|
||||
siCount = (siLongest - Len(sTemp)) / 2 'Difference between the length of the longest 'Word' and the current 'Word' / 2
|
||||
sAlign = Space(siCount) & sTemp & Space(siCount) 'Put the string together for printing
|
||||
If Len(sAlign) < siLongest Then sAlign &= " " 'Check it's the correct length if not add a space on the end
|
||||
Print sAlign; 'Print the 'Word'
|
||||
Endif
|
||||
Next
|
||||
Print 'Print an empty line between each alignment list
|
||||
Next
|
||||
|
||||
End
|
||||
61
Task/Align-columns/Go/align-columns.go
Normal file
61
Task/Align-columns/Go/align-columns.go
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const text = `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.`
|
||||
|
||||
type formatter struct {
|
||||
text [][]string
|
||||
width []int
|
||||
}
|
||||
|
||||
func newFormatter(text string) *formatter {
|
||||
var f formatter
|
||||
for _, line := range strings.Split(text, "\n") {
|
||||
words := strings.Split(line, "$")
|
||||
for words[len(words)-1] == "" {
|
||||
words = words[:len(words)-1]
|
||||
}
|
||||
f.text = append(f.text, words)
|
||||
for i, word := range words {
|
||||
if i == len(f.width) {
|
||||
f.width = append(f.width, len(word))
|
||||
} else if len(word) > f.width[i] {
|
||||
f.width[i] = len(word)
|
||||
}
|
||||
}
|
||||
}
|
||||
return &f
|
||||
}
|
||||
|
||||
const (
|
||||
left = iota
|
||||
middle
|
||||
right
|
||||
)
|
||||
|
||||
func (f formatter) print(j int) {
|
||||
for _, line := range f.text {
|
||||
for i, word := range line {
|
||||
fmt.Printf("%-*s ", f.width[i], fmt.Sprintf("%*s",
|
||||
len(word)+(f.width[i]-len(word))*j/2, word))
|
||||
}
|
||||
fmt.Println("")
|
||||
}
|
||||
fmt.Println("")
|
||||
}
|
||||
|
||||
func main() {
|
||||
f := newFormatter(text)
|
||||
f.print(left)
|
||||
f.print(middle)
|
||||
f.print(right)
|
||||
}
|
||||
14
Task/Align-columns/Groovy/align-columns-1.groovy
Normal file
14
Task/Align-columns/Groovy/align-columns-1.groovy
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
def alignColumns = { align, rawText ->
|
||||
def lines = rawText.tokenize('\n')
|
||||
def words = lines.collect { it.tokenize(/\$/) }
|
||||
def maxLineWords = words.collect {it.size()}.max()
|
||||
words = words.collect { line -> line + [''] * (maxLineWords - line.size()) }
|
||||
def columnWidths = words.transpose().collect{ column -> column.collect { it.size() }.max() }
|
||||
|
||||
def justify = [ Right : { width, string -> string.padLeft(width) },
|
||||
Left : { width, string -> string.padRight(width) },
|
||||
Center : { width, string -> string.center(width) } ]
|
||||
def padAll = { pad, colWidths, lineWords -> [colWidths, lineWords].transpose().collect { pad(it) + ' ' } }
|
||||
|
||||
words.each { padAll(justify[align], columnWidths, it).each { print it }; println() }
|
||||
}
|
||||
12
Task/Align-columns/Groovy/align-columns-2.groovy
Normal file
12
Task/Align-columns/Groovy/align-columns-2.groovy
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
def rawTextInput = '''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.'''
|
||||
|
||||
['Left', 'Center', 'Right'].each { align ->
|
||||
println "${align} Justified:"
|
||||
alignColumns(align, rawTextInput)
|
||||
println()
|
||||
}
|
||||
40
Task/Align-columns/Harbour/align-columns-1.harbour
Normal file
40
Task/Align-columns/Harbour/align-columns-1.harbour
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
PROCEDURE Main()
|
||||
LOCAL a := { "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." }
|
||||
LOCAL e, nMax
|
||||
|
||||
// remove trailing dollars
|
||||
AEval( a, {|e,n| Iif( Right(e,1)=="$", a[n] := hb_StrShrink( e, 1 ), NIL ) } )
|
||||
|
||||
// find max word length
|
||||
nMax := 0
|
||||
AEval( a, {|e| AEval( hb_Atokens( e, "$"), {|i| nMax := Max( nMax, Len(i) )} ) } )
|
||||
nMax++
|
||||
|
||||
// start printing, padding words as needed
|
||||
?
|
||||
? "----Left aligned columns----"
|
||||
FOR EACH e IN a
|
||||
?
|
||||
AEval( hb_Atokens( e, "$"), {|i| QQout( PadR(i, nMax) )} )
|
||||
NEXT
|
||||
|
||||
?
|
||||
? "----Center aligned columns----"
|
||||
FOR EACH e IN a
|
||||
?
|
||||
AEval( hb_Atokens( e, "$"), {|i| QQout( PadC(i, nMax) )} )
|
||||
NEXT
|
||||
|
||||
?
|
||||
? "----Right aligned columns----"
|
||||
FOR EACH e IN a
|
||||
?
|
||||
AEval( hb_Atokens( e, "$"), {|i| QQout( PadL(i, nMax) )} )
|
||||
NEXT
|
||||
|
||||
RETURN
|
||||
23
Task/Align-columns/Harbour/align-columns-2.harbour
Normal file
23
Task/Align-columns/Harbour/align-columns-2.harbour
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
----Left aligned columns----
|
||||
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.
|
||||
|
||||
----Center aligned columns----
|
||||
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.
|
||||
|
||||
----Right aligned columns----
|
||||
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.
|
||||
26
Task/Align-columns/Haskell/align-columns-1.hs
Normal file
26
Task/Align-columns/Haskell/align-columns-1.hs
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
import Data.List (unfoldr, transpose)
|
||||
import Control.Arrow (second)
|
||||
|
||||
dat =
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n" ++
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program\n" ++
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\n" ++
|
||||
"column$are$separated$by$at$least$one$space.\n" ++
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n" ++
|
||||
"justified,$right$justified,$or$center$justified$within$its$column.\n"
|
||||
|
||||
brkdwn =
|
||||
takeWhile (not . null) . unfoldr (Just . second (drop 1) . span ('$' /=))
|
||||
|
||||
format j ls = map (unwords . zipWith align colw) rows
|
||||
where
|
||||
rows = map brkdwn $ lines ls
|
||||
colw = map (maximum . map length) . transpose $ rows
|
||||
align cw w =
|
||||
case j of
|
||||
'c' -> replicate l ' ' ++ w ++ replicate r ' '
|
||||
'r' -> replicate dl ' ' ++ w
|
||||
'l' -> w ++ replicate dl ' '
|
||||
where
|
||||
dl = cw - length w
|
||||
(l, r) = (dl `div` 2, dl - l)
|
||||
35
Task/Align-columns/Haskell/align-columns-2.hs
Normal file
35
Task/Align-columns/Haskell/align-columns-2.hs
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
import Prelude as P
|
||||
import Data.Text as T
|
||||
(Text, pack, unpack, splitOn, unlines, unwords, length,
|
||||
justifyLeft, justifyRight, center)
|
||||
import Data.List (transpose, zip, maximumBy)
|
||||
import Data.Ord (comparing)
|
||||
|
||||
rows :: [[Text]]
|
||||
rows =
|
||||
(splitOn (pack "$") . pack) <$>
|
||||
[ "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."
|
||||
]
|
||||
|
||||
cols :: [[Text]]
|
||||
cols =
|
||||
transpose $
|
||||
((++) <*>
|
||||
(flip P.replicate (pack []) .
|
||||
(-) (maximum (P.length <$> rows)) . P.length)) <$>
|
||||
rows
|
||||
|
||||
main :: IO ()
|
||||
main =
|
||||
mapM_ putStrLn $
|
||||
[ (\cols f ->
|
||||
(unpack . T.unlines) $
|
||||
T.unwords <$> transpose ((\(xs, n) -> f (n + 1) ' ' <$> xs) <$> cols))
|
||||
(zip cols ((T.length . maximumBy (comparing T.length)) <$> cols))
|
||||
] <*>
|
||||
[justifyLeft, justifyRight, center]
|
||||
27
Task/Align-columns/HicEst/align-columns.hicest
Normal file
27
Task/Align-columns/HicEst/align-columns.hicest
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
CHARACTER Fnam = "\HicEst\Rosetta\Align columns.txt"
|
||||
|
||||
OPEN(FIle=Fnam, Format="12$", LENgth=rows)
|
||||
! call the DLG function in MatrixExplorer mode:
|
||||
DLG(Edit=Fnam, Format='12A10') ! left adjusted, 12 columns, 10 spaces each
|
||||
|
||||
! or the standard way:
|
||||
CALL Align( "LLLLLLLLLLL ", Fnam, rows) ! left align
|
||||
CALL Align( "CCCCCCCCCCC ", Fnam, rows) ! center align
|
||||
CALL Align( "RRRRRRRRRRR ", Fnam, rows) ! right align
|
||||
END
|
||||
|
||||
SUBROUTINE Align(picture, filename, rows)
|
||||
CHARACTER picture, filename
|
||||
CHARACTER out*400, txt*20
|
||||
|
||||
W = LEN(picture)
|
||||
DO i = 1, rows
|
||||
out = " "
|
||||
DO j = 0, 100
|
||||
txt = filename(i, j+1, *9) ! on error branch to label 9
|
||||
WRITE(Text=out(j*W+1 : ), Format=picture) txt
|
||||
ENDDO
|
||||
9 CONTINUE
|
||||
WRITE() out
|
||||
ENDDO
|
||||
END
|
||||
30
Task/Align-columns/Icon/align-columns.icon
Normal file
30
Task/Align-columns/Icon/align-columns.icon
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
global width
|
||||
|
||||
procedure main(args)
|
||||
lines := []
|
||||
width := 0
|
||||
format := left
|
||||
match("left"|"right"|"center", format <- !args)
|
||||
every put(lines,prepare(!&input))
|
||||
display(lines, proc(format,3))
|
||||
end
|
||||
|
||||
procedure prepare(lines)
|
||||
line := []
|
||||
lines ? {
|
||||
while (not pos(0)) & (field := tab(upto('$')|0)) do {
|
||||
put(line, field)
|
||||
width <:= *field
|
||||
move(1)
|
||||
}
|
||||
}
|
||||
return line
|
||||
end
|
||||
|
||||
procedure display(lines, format)
|
||||
width +:= 1
|
||||
every line := !lines do {
|
||||
every writes(format(!line, width))
|
||||
write()
|
||||
}
|
||||
end
|
||||
18
Task/Align-columns/J/align-columns-1.j
Normal file
18
Task/Align-columns/J/align-columns-1.j
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
'LEFT CENTER RIGHT'=: i.3 NB. justification constants
|
||||
|
||||
NB.* alignCols v Format delimited text in justified columns
|
||||
NB. y: text to format
|
||||
NB. rows marked by last character in text
|
||||
NB. columns marked by $
|
||||
NB. optional x: justification. Default is LEFT
|
||||
NB. result: text table
|
||||
alignCols=: verb define
|
||||
LEFT alignCols y NB. default
|
||||
:
|
||||
global=. dyad def'9!:x y'each
|
||||
oldbox=. 6 16 global '';'' NB. save settings
|
||||
7 17 global (11#' ');,~x NB. apply new settings
|
||||
result=. _2{:\ ": <;._2 @:,&'$';._2 y NB. parse & format text
|
||||
7 17 global oldbox NB. restore settings
|
||||
result
|
||||
)
|
||||
24
Task/Align-columns/J/align-columns-2.j
Normal file
24
Task/Align-columns/J/align-columns-2.j
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
text=: noun define
|
||||
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.
|
||||
)
|
||||
|
||||
alignCols text NB. default justification
|
||||
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.
|
||||
|
||||
CENTER alignCols text NB. specify desired justification as left argument
|
||||
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.
|
||||
144
Task/Align-columns/Java/align-columns.java
Normal file
144
Task/Align-columns/Java/align-columns.java
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
/**
|
||||
* Aligns fields into columns, separated by "|"
|
||||
*/
|
||||
public class ColumnAligner {
|
||||
private List<String[]> words = new ArrayList<>();
|
||||
private int columns = 0;
|
||||
private List<Integer> columnWidths = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Initialize columns aligner from lines in a single string
|
||||
*
|
||||
* @param s
|
||||
* lines in a single string. Empty string does form a column.
|
||||
*/
|
||||
public ColumnAligner(String s) {
|
||||
String[] lines = s.split("\\n");
|
||||
for (String line : lines) {
|
||||
processInputLine(line);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize columns aligner from lines in a list of strings
|
||||
*
|
||||
* @param lines
|
||||
* lines in a single string. Empty string does form a column.
|
||||
*/
|
||||
public ColumnAligner(List<String> lines) {
|
||||
for (String line : lines) {
|
||||
processInputLine(line);
|
||||
}
|
||||
}
|
||||
|
||||
private void processInputLine(String line) {
|
||||
String[] lineWords = line.split("\\$");
|
||||
words.add(lineWords);
|
||||
columns = Math.max(columns, lineWords.length);
|
||||
for (int i = 0; i < lineWords.length; i++) {
|
||||
String word = lineWords[i];
|
||||
if (i >= columnWidths.size()) {
|
||||
columnWidths.add(word.length());
|
||||
} else {
|
||||
columnWidths.set(i, Math.max(columnWidths.get(i), word.length()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
interface AlignFunction {
|
||||
String align(String s, int length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Left-align all columns
|
||||
*
|
||||
* @return Lines, terminated by "\n" of columns, separated by "|"
|
||||
*/
|
||||
public String alignLeft() {
|
||||
return align(new AlignFunction() {
|
||||
@Override
|
||||
public String align(String s, int length) {
|
||||
return StringUtils.rightPad(s, length);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Right-align all columns
|
||||
*
|
||||
* @return Lines, terminated by "\n" of columns, separated by "|"
|
||||
*/
|
||||
public String alignRight() {
|
||||
return align(new AlignFunction() {
|
||||
@Override
|
||||
public String align(String s, int length) {
|
||||
return StringUtils.leftPad(s, length);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Center-align all columns
|
||||
*
|
||||
* @return Lines, terminated by "\n" of columns, separated by "|"
|
||||
*/
|
||||
public String alignCenter() {
|
||||
return align(new AlignFunction() {
|
||||
@Override
|
||||
public String align(String s, int length) {
|
||||
return StringUtils.center(s, length);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private String align(AlignFunction a) {
|
||||
StringBuilder result = new StringBuilder();
|
||||
for (String[] lineWords : words) {
|
||||
for (int i = 0; i < lineWords.length; i++) {
|
||||
String word = lineWords[i];
|
||||
if (i == 0) {
|
||||
result.append("|");
|
||||
}
|
||||
result.append(a.align(word, columnWidths.get(i)) + "|");
|
||||
}
|
||||
result.append("\n");
|
||||
}
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
public static void main(String args[]) throws IOException {
|
||||
if (args.length < 1) {
|
||||
System.out.println("Usage: ColumnAligner file [left|right|center]");
|
||||
return;
|
||||
}
|
||||
String filePath = args[0];
|
||||
String alignment = "left";
|
||||
if (args.length >= 2) {
|
||||
alignment = args[1];
|
||||
}
|
||||
ColumnAligner ca = new ColumnAligner(Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8));
|
||||
switch (alignment) {
|
||||
case "left":
|
||||
System.out.print(ca.alignLeft());
|
||||
break;
|
||||
case "right":
|
||||
System.out.print(ca.alignRight());
|
||||
break;
|
||||
case "center":
|
||||
System.out.print(ca.alignCenter());
|
||||
break;
|
||||
default:
|
||||
System.err.println(String.format("Error! Unknown alignment: '%s'", alignment));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
31
Task/Align-columns/JavaScript/align-columns-1.js
Normal file
31
Task/Align-columns/JavaScript/align-columns-1.js
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
var justification="center",
|
||||
input=["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."],
|
||||
x,y,cols,max,cols=0,diff,left,right
|
||||
|
||||
String.prototype.repeat=function(n){return new Array(1 + parseInt(n)).join(this);}
|
||||
|
||||
for(x=0;x<input.length;x++) {
|
||||
input[x]=input[x].split("$");
|
||||
if(input[x].length>cols) cols=input[x].length;
|
||||
}
|
||||
for(x=0;x<cols;x++) {
|
||||
max=0;
|
||||
for(y=0;y<input.length;y++) if(input[y][x]&&max<input[y][x].length) max=input[y][x].length;
|
||||
for(y=0;y<input.length;y++)
|
||||
if(input[y][x]) {
|
||||
diff=(max-input[y][x].length)/2;
|
||||
left=" ".repeat(Math.floor(diff));
|
||||
right=" ".repeat(Math.ceil(diff));
|
||||
if(justification=="left") {right+=left;left=""}
|
||||
if(justification=="right") {left+=right;right=""}
|
||||
input[y][x]=left+input[y][x]+right;
|
||||
}
|
||||
}
|
||||
for(x=0;x<input.length;x++) input[x]=input[x].join(" ");
|
||||
input=input.join("\n");
|
||||
document.write(input);
|
||||
48
Task/Align-columns/JavaScript/align-columns-2.js
Normal file
48
Task/Align-columns/JavaScript/align-columns-2.js
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
//break up each string by '$'. The assumption is that the user wants the trailing $.
|
||||
var data = [
|
||||
"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."
|
||||
].map(function (str) { return str.split('$'); })
|
||||
|
||||
//boilerplate: get longest array or string in array
|
||||
var getLongest = function (arr) {
|
||||
return arr.reduce(function (acc, item) { return acc.length > item.length ? acc : item; }, 0);
|
||||
};
|
||||
|
||||
//boilerplate: this function would normally be in a library like underscore, lodash, or ramda
|
||||
var zip = function (items, toInsert) {
|
||||
toInsert = (toInsert === undefined) ? null : toInsert;
|
||||
var longestItem = getLongest(items);
|
||||
return longestItem.map(function (_unused, index) {
|
||||
return items.map(function (item) {
|
||||
return item[index] === undefined ? toInsert : item[index];
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
//here's the part that's not boilerplate
|
||||
var makeColumns = function (formatting, data) {
|
||||
var zipData = zip(data, '');
|
||||
var makeSpaces = function (num) { return new Array(num + 1).join(' '); };
|
||||
var formattedCols = zipData.map(function (column) {
|
||||
var maxLen = getLongest(column).length;//find the maximum word length
|
||||
if (formatting === 'left') {
|
||||
return column.map(function (word) { return word + makeSpaces(maxLen - word.length); });
|
||||
} else if (formatting === 'right') {
|
||||
return column.map(function (word) { return makeSpaces(maxLen - word.length) + word; });
|
||||
} else {
|
||||
return column.map(function (word) {
|
||||
var spaces = maxLen - word.length,
|
||||
first = ~~(spaces / 2),
|
||||
last = spaces - first;
|
||||
return makeSpaces(first) + word + makeSpaces(last);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
return zip(formattedCols).map(function (row) { return row.join(' '); }).join('\n');
|
||||
};
|
||||
133
Task/Align-columns/JavaScript/align-columns-3.js
Normal file
133
Task/Align-columns/JavaScript/align-columns-3.js
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
(function (strText) {
|
||||
'use strict';
|
||||
|
||||
// [[a]] -> [[a]]
|
||||
function transpose(lst) {
|
||||
return lst[0].map(function (_, iCol) {
|
||||
return lst.map(function (row) {
|
||||
return row[iCol];
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
// (a -> b -> c) -> [a] -> [b] -> [c]
|
||||
function zipWith(f, xs, ys) {
|
||||
return xs.length === ys.length ? (
|
||||
xs.map(function (x, i) {
|
||||
return f(x, ys[i]);
|
||||
})
|
||||
) : undefined;
|
||||
}
|
||||
|
||||
// (a -> a -> Ordering) -> [a] -> a
|
||||
function maximumBy(f, xs) {
|
||||
return xs.reduce(function (a, x) {
|
||||
return a === undefined ? x : (
|
||||
f(x) > f(a) ? x : a
|
||||
);
|
||||
}, undefined)
|
||||
}
|
||||
|
||||
// [String] -> String
|
||||
function widest(lst) {
|
||||
return maximumBy(length, lst)
|
||||
.length;
|
||||
}
|
||||
|
||||
// [[a]] -> [[a]]
|
||||
function fullRow(lst, n) {
|
||||
return lst.concat(Array.apply(null, Array(n - lst.length))
|
||||
.map(function () {
|
||||
return ''
|
||||
}));
|
||||
}
|
||||
|
||||
// String -> Int -> String
|
||||
function nreps(s, n) {
|
||||
var o = '';
|
||||
if (n < 1) return o;
|
||||
while (n > 1) {
|
||||
if (n & 1) o += s;
|
||||
n >>= 1;
|
||||
s += s;
|
||||
}
|
||||
return o + s;
|
||||
}
|
||||
|
||||
// [String] -> String
|
||||
function unwords(xs) {
|
||||
return xs.join(' ');
|
||||
}
|
||||
|
||||
// [String] -> String
|
||||
function unlines(xs) {
|
||||
return xs.join('\n');
|
||||
}
|
||||
|
||||
// [a] -> Int
|
||||
function length(xs) {
|
||||
return xs.length;
|
||||
}
|
||||
|
||||
// -- Int -> [String] -> [[String]]
|
||||
function padWords(n, lstWords, eAlign) {
|
||||
return lstWords.map(function (w) {
|
||||
var lngPad = n - w.length;
|
||||
|
||||
return (
|
||||
(eAlign === eCenter) ? (function () {
|
||||
var lngHalf = Math.floor(lngPad / 2);
|
||||
|
||||
return [
|
||||
nreps(' ', lngHalf), w,
|
||||
nreps(' ', lngPad - lngHalf)
|
||||
];
|
||||
})() : (eAlign === eLeft) ?
|
||||
['', w, nreps(' ', lngPad)] :
|
||||
[nreps(' ', lngPad), w, '']
|
||||
)
|
||||
.join('');
|
||||
});
|
||||
}
|
||||
|
||||
// MAIN
|
||||
|
||||
var eLeft = -1,
|
||||
eCenter = 0,
|
||||
eRight = 1;
|
||||
|
||||
var lstRows = strText.split('\n')
|
||||
.map(function (x) {
|
||||
return x.split('$');
|
||||
}),
|
||||
|
||||
lngCols = widest(lstRows),
|
||||
lstCols = transpose(lstRows.map(function (r) {
|
||||
return fullRow(r, lngCols)
|
||||
})),
|
||||
lstColWidths = lstCols.map(widest);
|
||||
|
||||
// THREE PARAGRAPHS, WITH VARIOUS WORD COLUMN ALIGNMENTS:
|
||||
|
||||
return [eLeft, eRight, eCenter]
|
||||
.map(function (eAlign) {
|
||||
var fPad = function (n, lstWords) {
|
||||
return padWords(n, lstWords, eAlign);
|
||||
};
|
||||
|
||||
return transpose(
|
||||
zipWith(fPad, lstColWidths, lstCols)
|
||||
)
|
||||
.map(unwords);
|
||||
})
|
||||
.map(unlines)
|
||||
.join('\n\n');
|
||||
|
||||
})(
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n\
|
||||
are$delineated$by$a$single$'dollar'$character,$write$a$program\n\
|
||||
that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\n\
|
||||
column$are$separated$by$at$least$one$space.\n\
|
||||
Further,$allow$for$each$word$in$a$column$to$be$either$left$\n\
|
||||
justified,$right$justified,$or$center$justified$within$its$column."
|
||||
);
|
||||
43
Task/Align-columns/Jq/align-columns-1.jq
Normal file
43
Task/Align-columns/Jq/align-columns-1.jq
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
# transpose a possibly jagged matrix
|
||||
def transpose:
|
||||
if . == [] then []
|
||||
else (.[1:] | transpose) as $t
|
||||
| .[0] as $row
|
||||
| reduce range(0; [($t|length), (.[0]|length)] | max) as $i
|
||||
([]; . + [ [ $row[$i] ] + $t[$i] ])
|
||||
end;
|
||||
|
||||
# left/right/center justification of strings:
|
||||
def ljust(width): . + " " * (width - length);
|
||||
|
||||
def rjust(width): " " * (width - length) + .;
|
||||
|
||||
def center(width):
|
||||
(width - length) as $pad
|
||||
| if $pad <= 0 then .
|
||||
else ($pad / 2 | floor) as $half
|
||||
| $half * " " + . + ($pad-$half) * " "
|
||||
end ;
|
||||
|
||||
# input: a single string, which includes newlines to separate lines, and $ to separate phrases;
|
||||
# method must be "left" "right" or anything else for central justification.
|
||||
def format(method):
|
||||
def justify(width):
|
||||
if method == "left" then ljust(width)
|
||||
elif method == "right" then rjust(width)
|
||||
else center(width)
|
||||
end;
|
||||
|
||||
# max_widths: input: an array of strings, each with "$" as phrase-separator;
|
||||
# return the appropriate column-wise maximum lengths
|
||||
def max_widths:
|
||||
map(split("$") | map(length))
|
||||
| transpose | map(max) ;
|
||||
|
||||
split("\n") as $input
|
||||
| $input
|
||||
| (max_widths | map(.+1)) as $widths
|
||||
| map( split("$") | . as $line | reduce range(0; length) as $i
|
||||
(""; . + ($line[$i]|justify($widths[$i])) ))
|
||||
| join("\n")
|
||||
;
|
||||
3
Task/Align-columns/Jq/align-columns-2.jq
Normal file
3
Task/Align-columns/Jq/align-columns-2.jq
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
"Center:", format("center"), "",
|
||||
"Left:", format("left"), "",
|
||||
"Right:", format("right")
|
||||
24
Task/Align-columns/Jq/align-columns-3.jq
Normal file
24
Task/Align-columns/Jq/align-columns-3.jq
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
$ jq -M -R -r -s -f Align_columns.jq Align_columns.txt
|
||||
Center:
|
||||
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.
|
||||
|
||||
Left:
|
||||
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.
|
||||
|
||||
Right:
|
||||
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.
|
||||
42
Task/Align-columns/Jsish/align-columns.jsish
Normal file
42
Task/Align-columns/Jsish/align-columns.jsish
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/* Align columns, in Jsish */
|
||||
function alignColumns(phrases:array, just:string) {
|
||||
var x, y, max, diff, left, right, cols=0;
|
||||
|
||||
for(x=0; x<phrases.length; x++) {
|
||||
phrases[x] = phrases[x].split("$");
|
||||
if (phrases[x].length>cols) cols=phrases[x].length;
|
||||
}
|
||||
|
||||
for (x=0; x<cols; x++) {
|
||||
max = 0;
|
||||
for (y=0; y<phrases.length; y++) if (phrases[y][x] && max<phrases[y][x].length) max = phrases[y][x].length;
|
||||
for (y=0; y<phrases.length; y++) {
|
||||
if (phrases[y][x]) {
|
||||
diff = (max-phrases[y][x].length)/2;
|
||||
left = " ".repeat(Math.floor(diff));
|
||||
right = " ".repeat(Math.ceil(diff));
|
||||
if (just == "left") { right += left; left=""; }
|
||||
if (just == "right") { left += right; right=""; }
|
||||
phrases[y][x] = left + phrases[y][x] + right;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (x=0; x<phrases.length; x++) phrases[x] = phrases[x].join(" ");
|
||||
phrases = phrases.join("\n");
|
||||
return phrases;
|
||||
}
|
||||
|
||||
if (Interp.conf('unitTest')) {
|
||||
var phrases = ["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."];
|
||||
|
||||
for (var just of ['left', 'center', 'right']) {
|
||||
var trial = phrases.slice(0);
|
||||
puts(just);
|
||||
puts(alignColumns(trial, just), '\n');
|
||||
}
|
||||
}
|
||||
40
Task/Align-columns/Julia/align-columns.julia
Normal file
40
Task/Align-columns/Julia/align-columns.julia
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
txt = """Given\$a\$txt\$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."""
|
||||
|
||||
# left/right/center justification of strings:
|
||||
ljust(s, width) = s * " "^max(0, width - length(s))
|
||||
rjust(s, width) = " "^max(0, width - length(s)) * s
|
||||
function center(s, width)
|
||||
pad = width - length(s)
|
||||
if pad <= 0
|
||||
return s
|
||||
else
|
||||
pad2 = div(pad, 2)
|
||||
return " "^pad2 * s * " "^(pad - pad2)
|
||||
end
|
||||
end
|
||||
|
||||
parts = [split(rstrip(line, '$'), '$') for line in split(txt, '\n')]
|
||||
|
||||
max_widths = zeros(Int, maximum(length, parts))
|
||||
for line in parts
|
||||
for (i, word) in enumerate(line)
|
||||
max_widths[i] = max(max_widths[i], length(word))
|
||||
end
|
||||
end
|
||||
max_widths += 1 # separate cols by at least one space
|
||||
|
||||
for (label, justify) in (("Left", ljust), ("Right",rjust), ("Center",center))
|
||||
println(label, " column-aligned output:")
|
||||
for line in parts
|
||||
for (j, word) in enumerate(line)
|
||||
print(justify(word, max_widths[j]))
|
||||
end
|
||||
println()
|
||||
end
|
||||
println("-"^sum(max_widths))
|
||||
end
|
||||
63
Task/Align-columns/Kotlin/align-columns.kotlin
Normal file
63
Task/Align-columns/Kotlin/align-columns.kotlin
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
import java.nio.charset.StandardCharsets
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.Paths
|
||||
|
||||
enum class AlignFunction {
|
||||
LEFT { override fun invoke(s: String, l: Int) = ("%-" + l + 's').format(("%" + s.length + 's').format(s)) },
|
||||
RIGHT { override fun invoke(s: String, l: Int) = ("%-" + l + 's').format(("%" + l + 's').format(s)) },
|
||||
CENTER { override fun invoke(s: String, l: Int) = ("%-" + l + 's').format(("%" + ((l + s.length) / 2) + 's').format(s)) };
|
||||
|
||||
abstract operator fun invoke(s: String, l: Int): String
|
||||
}
|
||||
|
||||
/** Aligns fields into columns, separated by "|".
|
||||
* @constructor Initializes columns aligner from lines in a list of strings.
|
||||
* @property lines Lines in a single string. Empty string does form a column.
|
||||
*/
|
||||
class ColumnAligner(val lines: List<String>) {
|
||||
operator fun invoke(a: AlignFunction) : String {
|
||||
var result = ""
|
||||
for (lineWords in words) {
|
||||
for (i in lineWords.indices) {
|
||||
if (i == 0)
|
||||
result += '|'
|
||||
result += a(lineWords[i], column_widths[i])
|
||||
result += '|'
|
||||
}
|
||||
result += '\n'
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
private val words = arrayListOf<Array<String>>()
|
||||
private val column_widths = arrayListOf<Int>()
|
||||
|
||||
init {
|
||||
lines.forEach {
|
||||
val lineWords = java.lang.String(it).split("\\$")
|
||||
words += lineWords
|
||||
for (i in lineWords.indices) {
|
||||
if (i >= column_widths.size) {
|
||||
column_widths += lineWords[i].length
|
||||
} else {
|
||||
column_widths[i] = Math.max(column_widths[i], lineWords[i].length)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
if (args.isEmpty()) {
|
||||
println("Usage: ColumnAligner file [L|R|C]")
|
||||
return
|
||||
}
|
||||
val ca = ColumnAligner(Files.readAllLines(Paths.get(args[0]), StandardCharsets.UTF_8))
|
||||
val alignment = if (args.size >= 2) args[1] else "L"
|
||||
when (alignment) {
|
||||
"L" -> print(ca(AlignFunction.LEFT))
|
||||
"R" -> print(ca(AlignFunction.RIGHT))
|
||||
"C" -> print(ca(AlignFunction.CENTER))
|
||||
else -> System.err.println("Error! Unknown alignment: " + alignment)
|
||||
}
|
||||
}
|
||||
38
Task/Align-columns/Lambdatalk/align-columns.lambdatalk
Normal file
38
Task/Align-columns/Lambdatalk/align-columns.lambdatalk
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
{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.}
|
||||
-> txt
|
||||
{def columns // function's name
|
||||
|
||||
{def columns.r // loop function
|
||||
{lambda {:just :a :b}
|
||||
{if {A.empty? :a} // end of loop
|
||||
then :b // return the string
|
||||
else {columns.r :just // justification
|
||||
{A.rest :a}. // loop on next char
|
||||
{if {W.equal? {A.first :a} \} // if end of line
|
||||
then < tr> :b // open a table row
|
||||
else {if {W.equal? {A.first :a} $} // if space between words
|
||||
then < td style="text-align::just;">:b // open a table data with justif
|
||||
else {A.first :a}:b }} } }}} // else add character
|
||||
|
||||
{lambda {:just :txt} // main function
|
||||
{table // open an HTML table
|
||||
{columns.r // call the loop function
|
||||
:just // justification
|
||||
{A.reverse {A.split ${:txt}}} // split and reverse
|
||||
. // end point
|
||||
}}}}
|
||||
-> columns
|
||||
|
||||
|
||||
{columns left 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
|
||||
67
Task/Align-columns/Lasso/align-columns.lasso
Normal file
67
Task/Align-columns/Lasso/align-columns.lasso
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
#!/usr/bin/lasso9
|
||||
|
||||
local(text = "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.
|
||||
")
|
||||
|
||||
|
||||
define go_left(text::array, width::integer) => {
|
||||
local(output = string)
|
||||
with row in #text do {
|
||||
with word in #row do {
|
||||
#output -> append(string(#word) -> padtrailing(#width + 1)&)
|
||||
}
|
||||
#output -> append('\n')
|
||||
}
|
||||
return #output
|
||||
}
|
||||
|
||||
define go_right(text::array, width::integer) => {
|
||||
local(output = string)
|
||||
with row in #text do {
|
||||
with word in #row do {
|
||||
#output -> append(string(#word) -> padleading(#width + 1)&)
|
||||
}
|
||||
#output -> append('\n')
|
||||
}
|
||||
return #output
|
||||
}
|
||||
|
||||
define go_center(text::array, width::integer) => {
|
||||
local(output = string)
|
||||
with row in #text do {
|
||||
with word in #row do {
|
||||
local(
|
||||
padlength = (#width + 1 - #word -> size),
|
||||
padleft = (' ' * (#padlength / 2)),
|
||||
padright = (' ' * (#padlength - #padleft -> size))
|
||||
)
|
||||
#output -> append(#padleft + string(#word) + #padright)
|
||||
}
|
||||
#output -> append('\n')
|
||||
}
|
||||
return #output
|
||||
}
|
||||
|
||||
define prepcols(text::string) => {
|
||||
local(
|
||||
result = array,
|
||||
maxwidth = 0
|
||||
)
|
||||
with row in #text -> split('\n') do {
|
||||
#row -> removetrailing('$')
|
||||
#result -> insert(#row -> split('$'))
|
||||
}
|
||||
with word in delve(#result) do {
|
||||
#word -> size > #maxwidth ? #maxwidth = #word -> size
|
||||
}
|
||||
stdoutnl('Left aligned result: \n' + go_left(#result, #maxwidth))
|
||||
stdoutnl('Right aligned result: \n' + go_right(#result, #maxwidth))
|
||||
stdoutnl('Centered result: \n' + go_center(#result, #maxwidth))
|
||||
}
|
||||
|
||||
prepcols(#text)
|
||||
78
Task/Align-columns/Liberty-BASIC/align-columns.basic
Normal file
78
Task/Align-columns/Liberty-BASIC/align-columns.basic
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
mainwin 140 32
|
||||
|
||||
CRLF$ =chr$( 13)
|
||||
maxlen =0
|
||||
|
||||
read y
|
||||
|
||||
Dim txt$( y)
|
||||
|
||||
For i =1 To y
|
||||
Read i$
|
||||
print i$
|
||||
if right$( i$, 1) <>"$" then i$ =i$ +"$"
|
||||
txt$( i) =i$
|
||||
x =max( CountDollars( txt$( i)), x)
|
||||
Next i
|
||||
|
||||
print x
|
||||
|
||||
Dim matrix$( x, y)
|
||||
|
||||
Print CRLF$; " ---- Left ----"
|
||||
For yy =1 To y
|
||||
For xx =1 To x
|
||||
matrix$( xx, yy) =word$( txt$( yy), xx, "$")
|
||||
print matrix$( xx, yy), "|";
|
||||
maxlen =max( maxlen, Len( matrix$( xx, yy)))
|
||||
Next xx
|
||||
print ""
|
||||
Next yy
|
||||
|
||||
Print CRLF$; " ---- Right ----"
|
||||
For yy =1 To y
|
||||
For xx =1 To x
|
||||
Print right$( " " +matrix$( xx, yy), maxlen +1); "|";
|
||||
' will truncate column words longer than 20. Change to use maxlen....
|
||||
Next xx
|
||||
Print ""
|
||||
Next yy
|
||||
|
||||
Print CRLF$ +" ---- Center ----"
|
||||
For yy =1 to y
|
||||
For xx =1 to x
|
||||
wordLen =Len( matrix$( xx, yy))
|
||||
padNeeded =maxlen -wordLen +4
|
||||
LeftSpaces =padNeeded /2
|
||||
|
||||
if LeftSpaces =int( LeftSpaces) then
|
||||
RightSpaces =LeftSpaces
|
||||
else
|
||||
RightSpaces =LeftSpaces -1
|
||||
end if
|
||||
|
||||
Print space$( LeftSpaces); matrix$( xx, yy); space$( RightSpaces); "|";
|
||||
Next xx
|
||||
Print ""
|
||||
Next yy
|
||||
|
||||
wait
|
||||
|
||||
Data 6
|
||||
|
||||
Data "Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
Data "are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
Data "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
Data "column$are$separated$by$at$least$one$space."
|
||||
Data "Further,$allow$for$each$word$in$a$column$to$be$either$left$"
|
||||
Data "justified,$right$justified,$or$center$justified$within$its$column."
|
||||
|
||||
function CountDollars( src$)
|
||||
c =0
|
||||
for j =1 to len( src$)
|
||||
if mid$( src$, j, 1) ="$" then c =c +1
|
||||
next j
|
||||
CountDollars =c
|
||||
end function
|
||||
|
||||
end
|
||||
60
Task/Align-columns/Lua/align-columns-1.lua
Normal file
60
Task/Align-columns/Lua/align-columns-1.lua
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
local tWord = {} -- word table
|
||||
local tColLen = {} -- maximum word length in a column
|
||||
local rowCount = 0 -- row counter
|
||||
--store maximum column lengths at 'tColLen'; save words into 'tWord' table
|
||||
local function readInput(pStr)
|
||||
for line in pStr:gmatch("([^\n]+)[\n]-") do -- read until '\n' character
|
||||
rowCount = rowCount + 1
|
||||
tWord[rowCount] = {} -- create new row
|
||||
local colCount = 0
|
||||
for word in line:gmatch("[^$]+") do -- read non '$' character
|
||||
colCount = colCount + 1
|
||||
tColLen[colCount] = math.max((tColLen[colCount] or 0), #word) -- store column length
|
||||
tWord[rowCount][colCount] = word -- store words
|
||||
end--for word
|
||||
end--for line
|
||||
end--readInput
|
||||
--repeat space to align the words in the same column
|
||||
local align = {
|
||||
["left"] = function (pWord, pColLen)
|
||||
local n = (pColLen or 0) - #pWord + 1
|
||||
return pWord .. (" "):rep(n)
|
||||
end;--["left"]
|
||||
["right"] = function (pWord, pColLen)
|
||||
local n = (pColLen or 0) - #pWord + 1
|
||||
return (" "):rep(n) .. pWord
|
||||
end;--["right"]
|
||||
["center"] = function (pWord, pColLen)
|
||||
local n = (pColLen or 0) - #pWord + 1
|
||||
local n1 = math.floor(n/2)
|
||||
return (" "):rep(n1) .. pWord .. (" "):rep(n-n1)
|
||||
end;--["center"]
|
||||
}
|
||||
--word table padder
|
||||
local function padWordTable(pAlignment)
|
||||
local alignFunc = align[pAlignment] -- selecting the spacer function
|
||||
for rowCount, tRow in ipairs(tWord) do
|
||||
for colCount, word in ipairs(tRow) do
|
||||
tRow[colCount] = alignFunc(word, tColLen[colCount]) -- save the padded words into the word table
|
||||
end--for colCount, word
|
||||
end--for rowCount, tRow
|
||||
end--padWordTable
|
||||
--main interface
|
||||
--------------------------------------------------[]
|
||||
function alignColumn(pStr, pAlignment, pFileName)
|
||||
--------------------------------------------------[]
|
||||
readInput(pStr) -- store column lengths and words
|
||||
padWordTable(pAlignment or "left") -- pad the stored words
|
||||
local output = ""
|
||||
for rowCount, tRow in ipairs(tWord) do
|
||||
local line = table.concat(tRow) -- concatenate words in one row
|
||||
print(line) -- print the line
|
||||
output = output .. line .. "\n" -- concatenate the line for output, add line break
|
||||
end--for rowCount, tRow
|
||||
if (type(pFileName) == "string") then
|
||||
local file = io.open(pFileName, "w+")
|
||||
file:write(output) -- write output to file
|
||||
file:close()
|
||||
end--if type(pFileName)
|
||||
return output
|
||||
end--alignColumn
|
||||
12
Task/Align-columns/Lua/align-columns-2.lua
Normal file
12
Task/Align-columns/Lua/align-columns-2.lua
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
input =
|
||||
[[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.]]
|
||||
|
||||
|
||||
outputLeft = alignColumn(input)
|
||||
outputRight = alignColumn(input, "right")
|
||||
alignColumn(input, "center", "output.txt")
|
||||
52
Task/Align-columns/M2000-Interpreter/align-columns.m2000
Normal file
52
Task/Align-columns/M2000-Interpreter/align-columns.m2000
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
Module Align_Columns {
|
||||
a$={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.
|
||||
}
|
||||
const cr$=chr$(13), lf$=chr$(10)
|
||||
def c1=0, cmax=0, p1=-1, i
|
||||
flush ' empty stack
|
||||
for i=1 to len(a$)
|
||||
select case mid$(a$,i,1)
|
||||
case "$", cr$
|
||||
if p1<>-1 then data (p1, c1): p1=-1: cmax=max(c1,cmax):c1=0
|
||||
case lf$
|
||||
data (-1,0) ' push to end of stack an array of two items (a tuple in m2000)
|
||||
else case
|
||||
if p1=-1 then p1=i :c1=1 else c1++
|
||||
end select
|
||||
next
|
||||
if p1<>-1 then push (p1, c1): cmax=max(c1,cmax):c1=0
|
||||
\\ so now stack of values hold all tuples.
|
||||
Dim Words(), AlignType$(1 to 3)
|
||||
AlignType$(1)=lambda$ (a$,wd)->field$(a$, wd)
|
||||
AlignType$(2)=lambda$ (a$,wd)->{
|
||||
a$=left$(a$, wd)
|
||||
=left$(string$(" ", (len(a$)-wd) div 2)+a$+string$(" ",wd),wd)
|
||||
}
|
||||
AlignType$(3)= lambda$ (a$,wd)->format$("{0:"+str$(-wd)+"}", a$)
|
||||
\\ [] return a stack object, reference and leave current stack of values a new stack
|
||||
\\ Array( stack_object) empty the stack object moving items to an array
|
||||
Words()=Array([])
|
||||
document export$
|
||||
def aline$
|
||||
cmax++ ' add one space
|
||||
For al=1 to 3
|
||||
For i=0 to len(Words())-1
|
||||
if Words(i)(0)=-1 then
|
||||
' we use rtrim$() to cut trailing spaces
|
||||
export$=rtrim$(aline$)+cr$+lf$ : aline$=""
|
||||
else
|
||||
aline$+=AlignType$(al)(mid$(a$,Words(i)(0), Words(i)(1)),cmax)
|
||||
end if
|
||||
next i
|
||||
next
|
||||
\\ export to clipboard
|
||||
Clipboard export$
|
||||
Rem Form 140, 60
|
||||
Rem Print #-2, export$ ' render text to console without using console's columns
|
||||
}
|
||||
Align_Columns
|
||||
29
Task/Align-columns/MATLAB/align-columns.m
Normal file
29
Task/Align-columns/MATLAB/align-columns.m
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
function r = align_columns(f)
|
||||
fid = fopen('align_column_data.txt', 'r');
|
||||
D = {};
|
||||
M = 0;
|
||||
while ~feof(fid)
|
||||
s = fgetl(fid);
|
||||
strsplit(s,'$');
|
||||
m = diff([0,find(s=='$')])-1;
|
||||
M = max([M,zeros(1,length(m)-length(M))], [m,zeros(1,length(M)-length(m))]);
|
||||
D{end+1}=s;
|
||||
end
|
||||
fclose(fid);
|
||||
|
||||
fprintf(1,'%%-- right-justified --%%\n')
|
||||
FMT = sprintf('%%%ds ',M);
|
||||
for k=1:length(D)
|
||||
d = strsplit(D{k},'$');
|
||||
fprintf(1,FMT,d{:});
|
||||
fprintf(1,'\n');
|
||||
end
|
||||
|
||||
fprintf(1,'%%-- left-justified --%%\n')
|
||||
FMT = sprintf('%%-%ds ',M);
|
||||
for k=1:length(D)
|
||||
d = strsplit(D{k},'$');
|
||||
fprintf(1,FMT,d{:});
|
||||
fprintf(1,'\n');
|
||||
end
|
||||
end;
|
||||
57
Task/Align-columns/ML-I/align-columns.mli
Normal file
57
Task/Align-columns/ML-I/align-columns.mli
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
MCSKIP "WITH" NL
|
||||
"" Align columns - assumes macros on input stream 1, data on stream 2
|
||||
MCPVAR 102
|
||||
"" Set P102 to alignment required:
|
||||
"" 1 = centre
|
||||
"" 2 = left
|
||||
"" 3 = right
|
||||
MCSET P102 = 1
|
||||
MCSKIP MT,<>
|
||||
MCINS %.
|
||||
MCSKIP SL WITH *
|
||||
"" Assume no more than 100 columns - P101 used for max number of fields
|
||||
"" Set P variables 1-101 to 0
|
||||
MCDEF ZEROPS WITHS NL AS <MCSET T1=1
|
||||
%L1.MCSET PT1=0
|
||||
MCSET T1=T1+1
|
||||
MCGO L1 UNLESS T1 EN 102
|
||||
>
|
||||
ZEROPS
|
||||
"" First pass - macro to accumulate max columns, and max widths
|
||||
MCDEF SL N1 OPT $ N1 OR $ WITHS NL OR SPACE WITHS NL OR NL ALL
|
||||
AS <MCGO L3 UNLESS T1 GR P101
|
||||
MCSET P101=T1
|
||||
%L3.MCSET T2=1
|
||||
%L1.MCGO L0 IF T2 GR T1
|
||||
MCSET T3=MCLENG(%WBT2.)
|
||||
MCGO L2 UNLESS T3 GR PT2
|
||||
MCSET PT2=T3
|
||||
%L2.MCSET T2=T2+1
|
||||
MCGO L1
|
||||
>
|
||||
MCSET S1=1
|
||||
*MCSET S10=2
|
||||
*MCSET S1=0
|
||||
MCSET S4=1
|
||||
""MCNOTE Max field is %P101.
|
||||
""MCDEF REP NL AS <MCSET T1=1
|
||||
""%L1.%PT1. MCSET T1=T1+1
|
||||
""MCGO L1 UNLESS T1 GR P101
|
||||
"">
|
||||
""REP
|
||||
MCDEF SL N1 OPT $ N1 OR $ WITHS NL OR SPACE WITHS NL OR NL ALL
|
||||
AS <MCSET T2=1
|
||||
%L5.MCGO L6 IF T2 GR T1
|
||||
MCGO LP102
|
||||
%L1.MCSET T3=%%%PT2.-MCLENG(%WBT2.)./2.
|
||||
MCGO L7 IF T3 EN 0
|
||||
MCSUB(< >,1,T3)%L7.%WBT2.""
|
||||
MCSUB(< >,1,PT2-T3-MCLENG(%WBT2.)+1)MCGO L4
|
||||
%L2.MCSUB(%WBT2.< >,1,PT2)MCGO L4
|
||||
%L3.MCSUB(< >%WBT2.,1-PT2,0)""
|
||||
%L4. MCSET T2=T2+1
|
||||
MCGO L5
|
||||
%L6.
|
||||
>
|
||||
MCSET S1=1
|
||||
*MCSET S10=102
|
||||
53
Task/Align-columns/MUMPS/align-columns.mumps
Normal file
53
Task/Align-columns/MUMPS/align-columns.mumps
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
columns(how) ; how = "Left", "Center" or "Right"
|
||||
New col,half,ii,max,spaces,word
|
||||
Set ii=0
|
||||
Set ii=ii+1,line(ii)="Given$a$text$file$of$many$lines,$where$fields$within$a$line$"
|
||||
Set ii=ii+1,line(ii)="are$delineated$by$a$single$'dollar'$character,$write$a$program"
|
||||
Set ii=ii+1,line(ii)="that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"
|
||||
Set ii=ii+1,line(ii)="column$are$separated$by$at$least$one$space."
|
||||
Set ii=ii+1,line(ii)="Further,$allow$for$each$word$in$a$column$to$be$either$left$"
|
||||
Set ii=ii+1,line(ii)="justified,$right$justified,$or$center$justified$within$its$column."
|
||||
Set ii="" For Set ii=$Order(line(ii)) Quit:ii="" Do
|
||||
. For col=1:1:$Length(line(ii),"$") Do
|
||||
. . Set max=$Length($Piece(line(ii),"$",col))
|
||||
. . Set:max>$Get(max(col)) max(col)=max
|
||||
. . Quit
|
||||
. Quit
|
||||
Set ii="" For Set ii=$Order(line(ii)) Quit:ii="" Do
|
||||
. Write ! For col=1:1:$Length(line(ii),"$") Do:$Get(max(col))
|
||||
. . Set word=$Piece(line(ii),"$",col)
|
||||
. . Set spaces=$Justify("",max(col)-$Length(word))
|
||||
. . If how="Left" Write word,spaces," " Quit
|
||||
. . If how="Right" Write spaces,word," " Quit
|
||||
. . Set half=$Length(spaces)\2
|
||||
. . Write $Extract(spaces,1,half),word,$Extract(spaces,half+1,$Length(spaces))," "
|
||||
. . Quit
|
||||
. Quit
|
||||
Write !
|
||||
Quit
|
||||
Do columns("Left")
|
||||
|
||||
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.
|
||||
|
||||
Do columns("Center")
|
||||
|
||||
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.
|
||||
|
||||
Do columns("Right")
|
||||
|
||||
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.
|
||||
7
Task/Align-columns/Maple/align-columns-1.maple
Normal file
7
Task/Align-columns/Maple/align-columns-1.maple
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
txt :=
|
||||
"Given$a$text$file$of$many$lines,$where$fields$within$a$line$\n"
|
||||
"are$delineated$by$a$single$'dollar'$character,$write$a$program\n"
|
||||
"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$\n"
|
||||
"column$are$separated$by$at$least$one$space.\n"
|
||||
"Further,$allow$for$each$word$in$a$column$to$be$either$left$\n"
|
||||
"justified,$right$justified,$or$center$justified$within$its$column.\n":
|
||||
24
Task/Align-columns/Maple/align-columns-2.maple
Normal file
24
Task/Align-columns/Maple/align-columns-2.maple
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
AlignColumns := proc( txt, align :: { "left", "right", "centre" } := "centre" )
|
||||
uses StringTools;
|
||||
|
||||
# Get a list of lists of fields
|
||||
local A := map( Split, Split( txt ), "$" );
|
||||
|
||||
# Calculate the column width
|
||||
local width := 1 + max( map( L -> max( map( length, L ) ), A ) );
|
||||
|
||||
# Add spacing according to the requested type of alignment
|
||||
if align = "left" then
|
||||
local J := map( line -> map( PadRight, line, width ), A )
|
||||
elif align = "right" then
|
||||
J := map( line -> map( PadLeft, line, width ), A )
|
||||
else
|
||||
J := map( line -> map( Center, line, width ), A )
|
||||
end if;
|
||||
|
||||
# Join up the fields in each line.
|
||||
J := map( cat@op, J );
|
||||
|
||||
# Re-assemble the lines into a single string.
|
||||
Join( J, "\n" )
|
||||
end proc:
|
||||
28
Task/Align-columns/Maple/align-columns-3.maple
Normal file
28
Task/Align-columns/Maple/align-columns-3.maple
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
> printf( "%s\n", AlignColumns( 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.
|
||||
> printf( "%s\n", AlignColumns( txt, "center" ) ): # same as above
|
||||
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.
|
||||
> printf( "%s\n", AlignColumns( txt, "left" ) ):
|
||||
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.
|
||||
> printf( "%s\n", AlignColumns( txt, "right" ) ):
|
||||
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.
|
||||
1
Task/Align-columns/Mathematica/align-columns.math
Normal file
1
Task/Align-columns/Mathematica/align-columns.math
Normal file
|
|
@ -0,0 +1 @@
|
|||
TableForm[StringSplit[StringSplit[a,"\n"],"$"],TableAlignments -> Center]
|
||||
25
Task/Align-columns/Nim/align-columns.nim
Normal file
25
Task/Align-columns/Nim/align-columns.nim
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
from strutils import splitLines, split
|
||||
from sequtils import mapIt
|
||||
from strfmt import format, write
|
||||
|
||||
let textinfile = """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."""
|
||||
|
||||
var words = textinfile.splitLines.mapIt(it.split '$')
|
||||
var maxs = newSeq[int](max words.mapIt(it.len))
|
||||
|
||||
for line in words:
|
||||
for j,w in line:
|
||||
maxs[j] = max(maxs[j], w.len+1)
|
||||
|
||||
for i, align in ["<",">","^"]:
|
||||
echo(["Left", "Right", "Center"][i], " column-aligned output:")
|
||||
for line in words:
|
||||
for j,w in line:
|
||||
stdout.write(w.format align & $maxs[j])
|
||||
stdout.write "\n"
|
||||
stdout.write "\n"
|
||||
49
Task/Align-columns/Nit/align-columns.nit
Normal file
49
Task/Align-columns/Nit/align-columns.nit
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
# Task: Align columns
|
||||
#
|
||||
# Uses `Text::justify` from the standard library.
|
||||
module align_columns
|
||||
|
||||
fun aligner(text: String, left: Float)
|
||||
do
|
||||
# Each row is a sequence of fields
|
||||
var rows = new Array[Array[String]]
|
||||
for line in text.split('\n') do
|
||||
rows.add line.split("$")
|
||||
end
|
||||
|
||||
# Compute the final length of each column
|
||||
var lengths = new Array[Int]
|
||||
for fields in rows do
|
||||
var i = 0
|
||||
for field in fields do
|
||||
var fl = field.length
|
||||
if lengths.length <= i or fl > lengths[i] then
|
||||
lengths[i] = fl
|
||||
end
|
||||
i += 1
|
||||
end
|
||||
end
|
||||
|
||||
# Process each line and align each field
|
||||
for fields in rows do
|
||||
var line = new Array[String]
|
||||
var i = 0
|
||||
for field in fields do
|
||||
line.add field.justify(lengths[i], left)
|
||||
i += 1
|
||||
end
|
||||
print line.join(" ")
|
||||
end
|
||||
end
|
||||
|
||||
var text = """
|
||||
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."""
|
||||
|
||||
aligner(text, 0.0)
|
||||
aligner(text, 1.0)
|
||||
aligner(text, 0.5)
|
||||
54
Task/Align-columns/OCaml/align-columns.ocaml
Normal file
54
Task/Align-columns/OCaml/align-columns.ocaml
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
#load "str.cma"
|
||||
open Str
|
||||
|
||||
let input = "\
|
||||
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."
|
||||
|
||||
let () =
|
||||
let lines = split (regexp_string "\n") input in
|
||||
let fields_l = List.map (split (regexp_string "$")) lines in
|
||||
let fields_l = List.map Array.of_list fields_l in
|
||||
let n = (* number of columns *)
|
||||
List.fold_left
|
||||
(fun n fields -> max n (Array.length fields))
|
||||
0 fields_l
|
||||
in
|
||||
let pads = Array.make n 0 in
|
||||
List.iter (
|
||||
(* calculate the max padding for each column *)
|
||||
Array.iteri
|
||||
(fun i word -> pads.(i) <- max pads.(i) (String.length word))
|
||||
) fields_l;
|
||||
|
||||
let print f =
|
||||
List.iter (fun fields ->
|
||||
Array.iteri (fun i word ->
|
||||
f word (pads.(i) - (String.length word))
|
||||
) fields;
|
||||
print_newline()
|
||||
) fields_l;
|
||||
in
|
||||
|
||||
(* left column-aligned output *)
|
||||
print (fun word pad ->
|
||||
let spaces = String.make pad ' ' in
|
||||
Printf.printf "%s%s " word spaces);
|
||||
|
||||
(* right column-aligned output *)
|
||||
print (fun word pad ->
|
||||
let spaces = String.make pad ' ' in
|
||||
Printf.printf "%s%s " spaces word);
|
||||
|
||||
(* center column-aligned output *)
|
||||
print (fun word pad ->
|
||||
let pad1 = pad / 2 in
|
||||
let pad2 = pad - pad1 in
|
||||
let sp1 = String.make pad1 ' ' in
|
||||
let sp2 = String.make pad2 ' ' in
|
||||
Printf.printf "%s%s%s " sp1 word sp2);
|
||||
;;
|
||||
107
Task/Align-columns/Oberon-2/align-columns.oberon
Normal file
107
Task/Align-columns/Oberon-2/align-columns.oberon
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
MODULE Columns;
|
||||
IMPORT
|
||||
NPCT:Tools,
|
||||
Object,
|
||||
Out;
|
||||
|
||||
TYPE
|
||||
Parts = ARRAY 32 OF STRING;
|
||||
Formatter = PROCEDURE (s: STRING; len: LONGINT): STRING;
|
||||
VAR
|
||||
lines: ARRAY 6 OF STRING;
|
||||
words: ARRAY 6 OF Parts;
|
||||
columnWidth: ARRAY 128 OF INTEGER;
|
||||
lineIdx: INTEGER;
|
||||
|
||||
(*
|
||||
* Size: returns de number of words in a line
|
||||
*)
|
||||
PROCEDURE Size(p: Parts): INTEGER;
|
||||
VAR
|
||||
i: INTEGER;
|
||||
BEGIN
|
||||
i := 0;
|
||||
WHILE (i < LEN(p)) & (p[i] # NIL) DO
|
||||
INC(i);
|
||||
END;
|
||||
RETURN i
|
||||
END Size;
|
||||
(*
|
||||
* Max: returns maximum number of words in the lines
|
||||
*)
|
||||
PROCEDURE Max(w: ARRAY OF Parts): INTEGER;
|
||||
VAR
|
||||
i, max, resp: INTEGER;
|
||||
BEGIN
|
||||
i := 0;resp := 0;
|
||||
WHILE (i < LEN(w)) DO
|
||||
max := Size(w[i]);
|
||||
IF (max > resp) THEN resp := max END;
|
||||
INC(i)
|
||||
END;
|
||||
RETURN resp;
|
||||
END Max;
|
||||
|
||||
(*
|
||||
* MaxColumnWidth: returns the maximum width of a column
|
||||
*)
|
||||
PROCEDURE MaxColumnWidth(w: ARRAY OF Parts;column: INTEGER): INTEGER;
|
||||
VAR
|
||||
line,max: LONGINT;
|
||||
BEGIN
|
||||
line := 0;
|
||||
max := MIN(INTEGER);
|
||||
WHILE (line < LEN(w)) DO;
|
||||
IF (w[line,column] # NIL) & (w[line,column](Object.String8).length > max) THEN max := w[line,column](Object.String8).length END;
|
||||
INC(line)
|
||||
END;
|
||||
RETURN SHORT(max)
|
||||
END MaxColumnWidth;
|
||||
|
||||
(*
|
||||
* PrintWords: prints the words in 'w' using the formatter passed in 'format'
|
||||
*)
|
||||
PROCEDURE PrintWords(w: ARRAY OF Parts; format: Formatter);
|
||||
VAR
|
||||
i,j: INTEGER;
|
||||
BEGIN
|
||||
i := 0;
|
||||
WHILE (i < LEN(words)) DO
|
||||
j := 0;
|
||||
WHILE (j < Max(words)) & (words[i,j] # NIL) DO
|
||||
Out.Object(format(words[i,j],columnWidth[j] + 1));
|
||||
INC(j)
|
||||
END;
|
||||
Out.Ln;
|
||||
INC(i)
|
||||
END;
|
||||
Out.Ln
|
||||
END PrintWords;
|
||||
|
||||
BEGIN
|
||||
lines[0] := "Given$a$text$file$of$many$lines,$where$fields$within$a$line$";
|
||||
lines[1] := "are$delineated$by$a$single$'dollar'$character,$write$a$program";
|
||||
lines[2] := "that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$";
|
||||
lines[3] := "column$are$separated$by$at$least$one$space.";
|
||||
lines[4] := "Further,$allow$for$each$word$in$a$column$to$be$either$left$";
|
||||
lines[5] := "justified,$right$justified,$or$center$justified$within$its$column.";
|
||||
|
||||
(* Split line in words *)
|
||||
lineIdx := 0;
|
||||
WHILE lineIdx < LEN(lines) DO
|
||||
Tools.Split(lines[lineIdx],"$",words[lineIdx]);
|
||||
INC(lineIdx)
|
||||
END;
|
||||
|
||||
(* Calculate width of the column *)
|
||||
lineIdx := 0;
|
||||
WHILE (lineIdx < Max(words)) DO
|
||||
columnWidth[lineIdx] := MaxColumnWidth(words,lineIdx);
|
||||
INC(lineIdx)
|
||||
END;
|
||||
|
||||
(* Print Results *)
|
||||
PrintWords(words,Tools.AdjustLeft);
|
||||
PrintWords(words,Tools.AdjustCenter);
|
||||
PrintWords(words,Tools.AdjustRight);
|
||||
END Columns.
|
||||
21
Task/Align-columns/Oforth/align-columns.fth
Normal file
21
Task/Align-columns/Oforth/align-columns.fth
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
import: mapping
|
||||
import: file
|
||||
|
||||
: <<nbl \ stream n -- stream
|
||||
#[ ' ' <<c ] times ;
|
||||
|
||||
String method: justify( n just -- s )
|
||||
| l m |
|
||||
n self size - dup ->l 2 / ->m
|
||||
String new
|
||||
just $RIGHT if=: [ l <<nbl self << return ]
|
||||
just $LEFT if=: [ self << l <<nbl return ]
|
||||
m <<nbl self << l m - <<nbl
|
||||
;
|
||||
|
||||
: align( file just -- )
|
||||
| lines maxsize |
|
||||
#[ wordsWith( '$' ) ] file File new map ->lines
|
||||
0 #[ apply( #[ size max ] ) ] lines apply ->maxsize
|
||||
#[ apply( #[ justify( maxsize , just) . ] ) printcr ] lines apply
|
||||
;
|
||||
74
Task/Align-columns/OoRexx/align-columns.rexx
Normal file
74
Task/Align-columns/OoRexx/align-columns.rexx
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
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", -
|
||||
"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 = 0
|
||||
parsedText = .array~new
|
||||
-- split each line of text into words and figure out how many columns we need
|
||||
loop line over text
|
||||
parsedLine = line~makearray("$")
|
||||
parsedText~append(parsedLine)
|
||||
columns = max(columns, parsedLine~items)
|
||||
end
|
||||
|
||||
-- now figure out how wide we need to make each column
|
||||
columnWidths = .array~new(columns)
|
||||
linelength = 0
|
||||
loop i = 1 to columns
|
||||
width = 0
|
||||
loop line over parsedText
|
||||
word = line[i]
|
||||
if word \= .nil then width = max(width, word~length)
|
||||
end
|
||||
columnWidths[i] = width
|
||||
-- keep track of the total width, including space for a separator
|
||||
linelength += width + 1
|
||||
end
|
||||
|
||||
say "align left:"
|
||||
say
|
||||
out = .mutableBuffer~new(linelength)
|
||||
loop line over parsedText
|
||||
-- mutable buffers are more efficient than repeated string concats
|
||||
-- reset the working buffer to zero
|
||||
out~setbuffersize(0)
|
||||
loop col = 1 to line~items
|
||||
word = line[col]
|
||||
if word == .nil then word = ''
|
||||
out~append(word~left(columnwidths[col] + 1))
|
||||
end
|
||||
say out~string
|
||||
end
|
||||
say
|
||||
say "align right:"
|
||||
say
|
||||
|
||||
loop line over parsedText
|
||||
-- mutable buffers are more efficient than repeated string concats
|
||||
-- reset the working buffer to zero
|
||||
out~setbuffersize(0)
|
||||
loop col = 1 to line~items
|
||||
word = line[col]
|
||||
if word == .nil then word = ''
|
||||
out~append(word~right(columnwidths[col] + 1))
|
||||
end
|
||||
say out~string
|
||||
end
|
||||
say
|
||||
say "align center:"
|
||||
say
|
||||
|
||||
loop line over parsedText
|
||||
-- mutable buffers are more efficient than repeated string concats
|
||||
-- reset the working buffer to zero
|
||||
out~setbuffersize(0)
|
||||
loop col = 1 to line~items
|
||||
word = line[col]
|
||||
if word == .nil then word = ''
|
||||
out~append(word~center(columnwidths[col] + 1))
|
||||
end
|
||||
say out~string
|
||||
end
|
||||
60
Task/Align-columns/OpenEdge-Progress/align-columns.openedge
Normal file
60
Task/Align-columns/OpenEdge-Progress/align-columns.openedge
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
FUNCTION alignColumns RETURNS CHAR (
|
||||
i_c AS CHAR,
|
||||
i_calign AS CHAR
|
||||
):
|
||||
|
||||
DEF VAR ipass AS INT.
|
||||
DEF VAR iline AS INT.
|
||||
DEF VAR icol AS INT.
|
||||
DEF VAR iwidth AS INT EXTENT.
|
||||
DEF VAR cword AS CHAR.
|
||||
DEF VAR cspace AS CHAR.
|
||||
DEF VAR cresult AS CHAR.
|
||||
|
||||
EXTENT( iwidth ) = NUM-ENTRIES( ENTRY( 1, i_c, "~n" ), "$" ).
|
||||
|
||||
DO ipass = 0 TO 1:
|
||||
DO iline = 1 TO NUM-ENTRIES( i_c, "~n" ):
|
||||
DO icol = 1 TO NUM-ENTRIES( ENTRY( iline, i_c, "~n" ), "$" ):
|
||||
cword = ENTRY( icol, ENTRY( iline, i_c, "~n" ), "$" ).
|
||||
IF ipass = 0 THEN
|
||||
iwidth = MAXIMUM( LENGTH( cword ), iwidth[ icol ] ).
|
||||
ELSE DO:
|
||||
cspace = FILL( " ", iwidth[ icol ] - LENGTH( cword ) ).
|
||||
CASE i_calign:
|
||||
WHEN "left" THEN cresult = cresult + cword + cspace.
|
||||
WHEN "right" THEN cresult = cresult + cspace + cword.
|
||||
WHEN "center" THEN DO:
|
||||
cword = FILL( " ", INTEGER( LENGTH( cspace ) / 2 ) ) + cword.
|
||||
cresult = cresult + cword + FILL( " ", iwidth[icol] - LENGTH( cword ) ).
|
||||
END.
|
||||
END CASE. /* i_calign */
|
||||
cresult = cresult + " ".
|
||||
END.
|
||||
END. /* DO icol = 1 TO ... */
|
||||
IF ipass = 1 THEN
|
||||
cresult = cresult + "~n".
|
||||
END. /* DO iline = 1 TO ... */
|
||||
END. /* DO ipass = 0 TO 1 */
|
||||
|
||||
RETURN cresult.
|
||||
|
||||
END FUNCTION.
|
||||
|
||||
DEF VAR cc AS CHAR.
|
||||
|
||||
cc = SUBSTITUTE(
|
||||
"&1~n&2~n&3~n&4~n&5~n&6",
|
||||
"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."
|
||||
).
|
||||
|
||||
MESSAGE
|
||||
alignColumns( cc, "left" ) SKIP
|
||||
alignColumns( cc, "right" ) SKIP
|
||||
alignColumns( cc, "center" )
|
||||
VIEW-AS ALERT-BOX.
|
||||
75
Task/Align-columns/Oz/align-columns.oz
Normal file
75
Task/Align-columns/Oz/align-columns.oz
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
declare
|
||||
%% Lines: list of strings
|
||||
%% Alignment: function like fun {Left Txt ExtraSpace} ... end
|
||||
%% Returns: list of aligned (virtual) strings
|
||||
fun {Align Lines Alignment}
|
||||
ParsedLines = {Map Lines ParseLine}
|
||||
NumColumns = {Maximum {Map ParsedLines Record.width}}
|
||||
%% maps column index to column width:
|
||||
WidthOfColumn = {Record.map {TupleRange NumColumns}
|
||||
fun {$ ColumnIndex}
|
||||
fun {LengthOfThisColumn ParsedLine}
|
||||
{Length {CondSelect ParsedLine ColumnIndex nil}}
|
||||
end
|
||||
in
|
||||
{Maximum {Map ParsedLines LengthOfThisColumn}}
|
||||
end}
|
||||
in
|
||||
{Map ParsedLines
|
||||
fun {$ Columns}
|
||||
{Record.mapInd Columns
|
||||
fun {$ ColumnIndex ColumnText}
|
||||
Extra = WidthOfColumn.ColumnIndex - {Length ColumnText}
|
||||
in
|
||||
{Alignment ColumnText Extra}#" "
|
||||
end}
|
||||
end}
|
||||
end
|
||||
|
||||
%% A parsed line is a tuple of columns.
|
||||
%% "a$b$c" -> '#'(1:"a" 2:"b" 3:"c")
|
||||
fun {ParseLine Line}
|
||||
{List.toTuple '#' {String.tokens Line &$}}
|
||||
end
|
||||
|
||||
%% possible alignments:
|
||||
|
||||
fun {Left Txt Extra}
|
||||
Txt#{Spaces Extra}
|
||||
end
|
||||
|
||||
fun {Right Txt Extra}
|
||||
{Spaces Extra}#Txt
|
||||
end
|
||||
|
||||
fun {Center Txt Extra}
|
||||
Half = Extra div 2
|
||||
in
|
||||
{Spaces Half}#Txt#{Spaces Half + Extra mod 2}
|
||||
end
|
||||
|
||||
%% helpers:
|
||||
|
||||
%% 3 -> unit(1 2 3)
|
||||
fun {TupleRange Max}
|
||||
{List.toTuple unit {List.number 1 Max 1}}
|
||||
end
|
||||
|
||||
fun {Maximum X|Xr}
|
||||
{FoldL Xr Value.max X}
|
||||
end
|
||||
|
||||
fun {Spaces N}
|
||||
case N of 0 then nil
|
||||
else & |{Spaces N-1}
|
||||
end
|
||||
end
|
||||
|
||||
Lines = ["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."]
|
||||
in
|
||||
{ForAll {Align Lines Left} System.showInfo}
|
||||
47
Task/Align-columns/PHP/align-columns.php
Normal file
47
Task/Align-columns/PHP/align-columns.php
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
<?php
|
||||
$j2justtype = array('L' => STR_PAD_RIGHT,
|
||||
'R' => STR_PAD_LEFT,
|
||||
'C' => STR_PAD_BOTH);
|
||||
|
||||
/**
|
||||
Justify columns of textual tabular input where the record separator is the newline
|
||||
and the field separator is a 'dollar' character.
|
||||
justification can be L, R, or C; (Left, Right, or Centered).
|
||||
|
||||
Return the justified output as a string
|
||||
*/
|
||||
function aligner($str, $justification = 'L') {
|
||||
global $j2justtype;
|
||||
assert(array_key_exists($justification, $j2justtype));
|
||||
$justtype = $j2justtype[$justification];
|
||||
|
||||
$fieldsbyrow = array();
|
||||
foreach (explode("\n", $str) as $line)
|
||||
$fieldsbyrow[] = explode('$', $line);
|
||||
$maxfields = max(array_map('count', $fieldsbyrow));
|
||||
|
||||
foreach (range(0, $maxfields - 1) as $col) {
|
||||
$maxwidth = 0;
|
||||
foreach ($fieldsbyrow as $fields)
|
||||
$maxwidth = max($maxwidth, strlen(array_key_exists($col, $fields) ? $fields[$col] : 0));
|
||||
foreach ($fieldsbyrow as &$fields)
|
||||
$fields[$col] = str_pad(array_key_exists($col, $fields) ? $fields[$col] : "", $maxwidth, ' ', $justtype);
|
||||
unset($fields); // see http://bugs.php.net/29992
|
||||
}
|
||||
$result = '';
|
||||
foreach ($fieldsbyrow as $fields)
|
||||
$result .= implode(' ', $fields) . "\n";
|
||||
return $result;
|
||||
}
|
||||
|
||||
$textinfile = '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.';
|
||||
|
||||
foreach (array('L', 'R', 'C') as $j)
|
||||
echo aligner($textinfile, $j);
|
||||
|
||||
?>
|
||||
37
Task/Align-columns/PL-I/align-columns.pli
Normal file
37
Task/Align-columns/PL-I/align-columns.pli
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
declare text character (300) varying;
|
||||
declare word character (20) varying;
|
||||
declare justification character (1);
|
||||
declare k fixed binary;
|
||||
declare input file, output file output;
|
||||
|
||||
open file (input) title ( '/CENTER.DAT,type(text),recsize(1000)' );
|
||||
open file (output) title ( '/OUT.TXT,type(text),recsize(1000)' );
|
||||
on endfile (input) stop;
|
||||
|
||||
display ('Specify whether justification is left, centered, or right');
|
||||
display ('Reply with a single letter: L, C, or R');
|
||||
get edit (justification) (A(1));
|
||||
|
||||
do forever;
|
||||
get file (input) edit (text) (L);
|
||||
put skip list (text);
|
||||
text = trim(text, '$', '$');
|
||||
do until (k = 0);
|
||||
k = index(text, '$');
|
||||
if k = 0 then /* last word in line */
|
||||
word = text;
|
||||
else
|
||||
do;
|
||||
word = substr(text, 1, k-1);
|
||||
text = substr(text, k);
|
||||
text = trim(text, '$');
|
||||
end;
|
||||
select (justification);
|
||||
when ('C', 'c') word = center(word, maxlength(word));
|
||||
when ('R', 'r') word = right (word, maxlength(word));
|
||||
otherwise ; /* The default is left adjusted. */
|
||||
end;
|
||||
put file (output) edit (word) (a(maxlength(word)));
|
||||
end;
|
||||
put file (output) skip;
|
||||
end;
|
||||
74
Task/Align-columns/Pascal/align-columns.pas
Normal file
74
Task/Align-columns/Pascal/align-columns.pas
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
program Project1;
|
||||
|
||||
{$H+}//Use ansistrings
|
||||
uses
|
||||
Classes,
|
||||
SysUtils,
|
||||
StrUtils;
|
||||
|
||||
procedure AlignByColumn(Align: TAlignment);
|
||||
const
|
||||
TextToAlign =
|
||||
'Given$a$text$file$of$many$lines,$where$fields$within$a$line$'#$D#$A +
|
||||
'are$delineated$by$a$single$''dollar''$character,$write$a$program'#$D#$A +
|
||||
'that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$'#$D#$A +
|
||||
'column$are$separated$by$at$least$one$space.'#$D#$A +
|
||||
'Further,$allow$for$each$word$in$a$column$to$be$either$left$'#$D#$A +
|
||||
'justified,$right$justified,$or$center$justified$within$its$column.';
|
||||
var
|
||||
TextLine: TStringList;
|
||||
TextLines: array of TStringList;
|
||||
OutPutString, EmptyString, Item: string;
|
||||
MaxLength, i, j: Int32;
|
||||
begin
|
||||
try
|
||||
MaxLength := 0;
|
||||
TextLine := TStringList.Create;
|
||||
TextLine.Text := TextToAlign;
|
||||
setlength(Textlines, TextLine.Count);
|
||||
for i := 0 to TextLine.Count - 1 do
|
||||
begin
|
||||
Textlines[i] := TStringList.Create;
|
||||
Textlines[i].Text := AnsiReplaceStr(TextLine[i], '$', #$D#$A);
|
||||
end;
|
||||
|
||||
for i := 0 to High(TextLines) do
|
||||
for j := 0 to Textlines[i].Count - 1 do
|
||||
if MaxLength < Length(TextLines[i][j]) then
|
||||
MaxLength := Length(TextLines[i][j]);
|
||||
if MaxLength > 0 then
|
||||
MaxLength := MaxLength + 2; // Add two empty spaces to it
|
||||
|
||||
for i := 0 to High(TextLines) do
|
||||
begin
|
||||
OutPutString := '';
|
||||
for j := 0 to Textlines[i].Count - 1 do
|
||||
begin
|
||||
EmptyString := StringOfChar(' ', MaxLength);
|
||||
if j <> 0 then
|
||||
EmptyString[1] := '|';
|
||||
Item := TextLines[i][j];
|
||||
case Align of
|
||||
taLeftJustify: Move(Item[1], EmptyString[2], Length(Item));
|
||||
taRightJustify: Move(Item[1], EmptyString[MaxLength - Length(Item) + 1],
|
||||
Length(Item));
|
||||
taCenter: Move(Item[1], EmptyString[(MaxLength - Length(Item) + 1) div
|
||||
2 + 1], Length(Item));
|
||||
end;
|
||||
OutPutString := OutPutString + EmptyString;
|
||||
end;
|
||||
writeln(OutPutString);
|
||||
end;
|
||||
finally
|
||||
writeln;
|
||||
FreeAndNil(TextLine);
|
||||
for i := High(TextLines) downto 0 do
|
||||
FreeAndNil(TextLines[i]);
|
||||
end;
|
||||
end;
|
||||
|
||||
begin
|
||||
AlignByColumn(taLeftJustify);
|
||||
AlignByColumn(taCenter);
|
||||
AlignByColumn(taRightJustify);
|
||||
end.
|
||||
56
Task/Align-columns/Perl/align-columns-1.pl
Normal file
56
Task/Align-columns/Perl/align-columns-1.pl
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
#/usr/bin/perl -w
|
||||
use strict ;
|
||||
|
||||
die "Call : perl columnaligner.pl <inputfile> <printorientation>!\n" unless
|
||||
@ARGV == 2 ; #$ARGV[ 0 ] contains example file , $ARGV[1] any of 'left' , 'right' or 'center'
|
||||
die "last argument must be one of center, left or right!\n" unless
|
||||
$ARGV[ 1 ] =~ /center|left|right/ ;
|
||||
sub printLines( $$$ ) ;
|
||||
open INFILE , "<" , "$ARGV[ 0 ]" or die "Can't open $ARGV[ 0 ]!\n" ;
|
||||
my @lines = <INFILE> ;
|
||||
close INFILE ;
|
||||
chomp @lines ;
|
||||
my @fieldwidths = map length, split /\$/ , $lines[ 0 ] ;
|
||||
foreach my $i ( 1..$#lines ) {
|
||||
my @words = split /\$/ , $lines[ $i ] ;
|
||||
foreach my $j ( 0..$#words ) {
|
||||
if ( $j <= $#fieldwidths ) {
|
||||
if ( length $words[ $j ] > $fieldwidths[ $j ] ) {
|
||||
$fieldwidths[ $j ] = length $words[ $j ] ;
|
||||
}
|
||||
}
|
||||
else {
|
||||
push @fieldwidths, length $words[ $j ] ;
|
||||
}
|
||||
}
|
||||
}
|
||||
printLine( $_ , $ARGV[ 1 ] , \@fieldwidths ) foreach @lines ;
|
||||
################################################################## ####
|
||||
sub printLine {
|
||||
my $line = shift ;
|
||||
my $orientation = shift ;
|
||||
my $widthref = shift ;
|
||||
my @words = split /\$/, $line ;
|
||||
foreach my $k ( 0..$#words ) {
|
||||
my $printwidth = $widthref->[ $k ] + 1 ;
|
||||
if ( $orientation eq 'center' ) {
|
||||
$printwidth++ ;
|
||||
}
|
||||
if ( $orientation eq 'left' ) {
|
||||
print $words[ $k ] ;
|
||||
print " " x ( $printwidth - length $words[ $k ] ) ;
|
||||
}
|
||||
elsif ( $orientation eq 'right' ) {
|
||||
print " " x ( $printwidth - length $words[ $k ] ) ;
|
||||
print $words[ $k ] ;
|
||||
}
|
||||
elsif ( $orientation eq 'center' ) {
|
||||
my $left = int( ( $printwidth - length $words[ $k ] ) / 2 ) ;
|
||||
my $right = $printwidth - length( $words[ $k ] ) - $left ;
|
||||
print " " x $left ;
|
||||
print $words[ $k ] ;
|
||||
print " " x $right ;
|
||||
}
|
||||
}
|
||||
print "\n" ;
|
||||
}
|
||||
24
Task/Align-columns/Perl/align-columns-2.pl
Normal file
24
Task/Align-columns/Perl/align-columns-2.pl
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
use List::Util qw(max);
|
||||
|
||||
sub columns {
|
||||
my @lines = map [split /\$/] => split /\n/ => shift;
|
||||
my $pos = {qw/left 0 center 1 right 2/}->{+shift};
|
||||
for my $col (0 .. max map {$#$_} @lines) {
|
||||
my $max = max my @widths = map {length $_->[$col]} @lines;
|
||||
for my $row (0 .. $#lines) {
|
||||
my @pad = map {' ' x $_, ' ' x ($_ + 0.5)} ($max - $widths[$row]) / 2;
|
||||
for ($lines[$row][$col])
|
||||
{$_ = join '' => @pad[0 .. $pos-1], $_, @pad[$pos .. $#pad]}
|
||||
}
|
||||
}
|
||||
join '' => map {"@$_\n"} @lines
|
||||
}
|
||||
|
||||
print columns <<'END', $_ for qw(left right center);
|
||||
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.
|
||||
END
|
||||
69
Task/Align-columns/Phix/align-columns.phix
Normal file
69
Task/Align-columns/Phix/align-columns.phix
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
-->
|
||||
<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: #008000;">"are$delineated$by$a$single$'dollar'$character,$write$a$program"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"column$are$separated$by$at$least$one$space."</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"Further,$allow$for$each$word$in$a$column$to$be$either$left$"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"justified,$right$justified,$or$center$justified$within$its$column."</span>
|
||||
<span style="color: #0000FF;">}</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">out</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">first</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">delim</span>
|
||||
<span style="color: #008080;">while</span> <span style="color: #000000;">first</span><span style="color: #0000FF;"><=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">delim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">find_from</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">first</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">delim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">delim</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #000000;">out</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">out</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">first</span><span style="color: #0000FF;">..</span><span style="color: #000000;">delim</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
|
||||
<span style="color: #000000;">first</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">delim</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">out</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">align</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">width</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">alignment</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">width</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
|
||||
<span style="color: #008080;">elsif</span> <span style="color: #000000;">alignment</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">&</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">elsif</span> <span style="color: #000000;">alignment</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">s</span>
|
||||
<span style="color: #008080;">else</span>
|
||||
<span style="color: #000080;font-style:italic;">-- (PL if I'd written this, I'd have n-floor(n/2) on the rhs)</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">&</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">+</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">AlignColumns</span><span style="color: #0000FF;">()</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">llij</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">lines</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">li</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">maxlens</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
|
||||
<span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">data</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">data</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">li</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">data</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">'$'</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">li</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">)></span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">maxlens</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">maxlens</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">)-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">maxlens</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">llij</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">])</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">llij</span><span style="color: #0000FF;">></span><span style="color: #000000;">maxlens</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span> <span style="color: #000000;">maxlens</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">llij</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span> <span style="color: #000080;font-style:italic;">-- (alignment = left/centre/right)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">align</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span><span style="color: #000000;">maxlens</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">' '</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">getc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
|
||||
|
||||
<span style="color: #000000;">AlignColumns</span><span style="color: #0000FF;">()</span>
|
||||
<!--
|
||||
46
Task/Align-columns/Phixmonti/align-columns.phixmonti
Normal file
46
Task/Align-columns/Phixmonti/align-columns.phixmonti
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
include ..\Utilitys.pmt
|
||||
|
||||
0 40 repeat var gap
|
||||
|
||||
( "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." )
|
||||
|
||||
len var lines
|
||||
|
||||
def alignWords /# -1/0/1 for left/center/right #/
|
||||
>ps
|
||||
|
||||
lines for
|
||||
get len for >ps
|
||||
tps get gap ps> get nip 1 +
|
||||
tps -1 == if -1 * align else
|
||||
tps 0 == if tostr align else
|
||||
tps 1 == if align else
|
||||
drop drop "Wrong!" exitfor
|
||||
endif endif endif
|
||||
print
|
||||
endfor
|
||||
drop
|
||||
nl
|
||||
endfor
|
||||
ps> drop
|
||||
enddef
|
||||
|
||||
lines for var i
|
||||
i get "$" " " subst split
|
||||
len for var j
|
||||
j get len dup
|
||||
gap j get rot
|
||||
< if swap j set else swap drop endif var gap drop
|
||||
endfor
|
||||
i set
|
||||
endfor
|
||||
|
||||
-1 alignWords nl
|
||||
0 alignWords nl
|
||||
1 alignWords nl
|
||||
drop
|
||||
46
Task/Align-columns/Picat/align-columns.picat
Normal file
46
Task/Align-columns/Picat/align-columns.picat
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
import util.
|
||||
|
||||
main =>
|
||||
Text =
|
||||
"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.",
|
||||
Lines = split(Text,"\n"),
|
||||
Lines = [Line1|_],
|
||||
N = len(split(strip(Line1,"$ "), "$")), % number of columns
|
||||
WidthArr = {0 : _ in 1..N},
|
||||
foreach (Line in Lines)
|
||||
Words = split(strip(Line,"$ "), "$"),
|
||||
foreach ({I,Word} in zip(1..N, Words))
|
||||
WidthArr[I] := max(WidthArr[I], len(Word))
|
||||
end
|
||||
end,
|
||||
foreach (I in 1..N)
|
||||
WidthArr[I] := WidthArr[I]+1 % separate cols by at least one space
|
||||
end,
|
||||
foreach (Align in [left, right, center])
|
||||
output_lines(Lines,N,WidthArr,Align),
|
||||
nl,nl
|
||||
end.
|
||||
|
||||
output_lines(Lines,N,WidthArr,Align) =>
|
||||
foreach (Line in Lines)
|
||||
Words = split(strip(Line,"$ "), "$"),
|
||||
foreach ({I,Word} in zip(1..N, Words))
|
||||
output_word(Word,WidthArr[I],Align)
|
||||
end,
|
||||
nl
|
||||
end.
|
||||
|
||||
output_word(Word,Width,left) =>
|
||||
printf("%-*s",Width,Word).
|
||||
output_word(Word,Width,right) =>
|
||||
printf("%*s",Width,Word).
|
||||
output_word(Word,Width,_) =>
|
||||
Pad = len(Word)-Width,
|
||||
Pad1 is Pad div 2,
|
||||
Pad2 is Pad-Pad1,
|
||||
printf("%*s%s%*s",Pad1,"",Word,Pad2,"").
|
||||
21
Task/Align-columns/PicoLisp/align-columns.l
Normal file
21
Task/Align-columns/PicoLisp/align-columns.l
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
(let Sizes NIL # Build a list of sizes
|
||||
(let Lines # and of lines
|
||||
(make
|
||||
(in "input.txt" # Reading input file
|
||||
(while (split (line) "$") # delimited by '$'
|
||||
(let (L (link (mapcar pack @)) S Sizes)
|
||||
(setq Sizes # Maintain sizes
|
||||
(make
|
||||
(while (or L S)
|
||||
(link
|
||||
(max
|
||||
(inc (length (pop 'L)))
|
||||
(pop 'S) ) ) ) ) ) ) ) ) )
|
||||
(for L Lines # Print lines
|
||||
(prinl (apply align L (mapcar - Sizes))) ) # left aligned
|
||||
(prinl)
|
||||
(for L Lines
|
||||
(prinl (apply align L Sizes)) ) # right aligned
|
||||
(prinl)
|
||||
(for L Lines
|
||||
(prinl (apply center L Sizes)) ) ) ) # and centered
|
||||
22
Task/Align-columns/PowerShell/align-columns.psh
Normal file
22
Task/Align-columns/PowerShell/align-columns.psh
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
$file =
|
||||
@'
|
||||
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.
|
||||
'@.Split("`n")
|
||||
|
||||
$arr = @()
|
||||
$file | foreach {
|
||||
$line = $_
|
||||
$i = 0
|
||||
$hash = [ordered]@{}
|
||||
$line.split('$') | foreach{
|
||||
$hash["$i"] = "$_"
|
||||
$i++
|
||||
}
|
||||
$arr += @([pscustomobject]$hash)
|
||||
}
|
||||
$arr | Format-Table -HideTableHeaders -Wrap *
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue