AutoHotkey Community

=={{Header|AutoHotkey}}==
{{AutoHotkey case}}
Source: [http://www.autohotkey.com/forum/topic44657.html AutoHotkey forum] by yournick
<lang autohotkey>
Your code here
</lang>

MsgBox % Comb(1,1)
MsgBox % Comb(3,3)
MsgBox % Comb(3,2)
MsgBox % Comb(2,3)
MsgBox % Comb(5,3)

CR(n,t) { ; List all n choose t combinations of 1..n, recursively
   Return t<1 || t>n ? "" : n=1 ? 1 : CR(n-1,t) (n-1<t ? "" : "`n") RegExReplace(CR(n-1,t-1),"`am)$",t=1 ? n : " " n)
}

Comb(n,t) { ; List all n choose t combinations of 1..n, lexicographically
   c := CR(n,t)
   Sort c
   Return c
}

Comb(n,t) { ; Generate all n choose t combinations of 1..n, lexicographically
   IfLess n,%t%, Return
   Loop %t%
      c%A_Index% := A_Index
   i := t+1, c%i% := n+1

   Loop {
      Loop %t%
         i := t+1-A_Index, c .= c%i% " "
      c .= "`n"     ; combinations in new lines
      j := 1, i := 2
      Loop
         If (c%j%+1 = c%i%)
             c%j% := j, ++j, ++i
         Else Break
      If (j > t)
         Return c
      c%j% += 1
   }
}

MsgBox % BC("FF",16,3) ; -> 100110 in base 3 = FF in hex = 256 in base 10

BC(NumStr,InputBase=8,OutputBase=10) {
  Static S = 12345678901234567890123456789012345678901234567890123456789012345
  DllCall("msvcrt\_i64toa","Int64",DllCall("msvcrt\_strtoui64","Str",NumStr,"Uint",0,"UInt",InputBase,"CDECLInt64"),"Str",S,"UInt",OutputBase,"CDECL")
  Return S
}

MsgBox % ToBase(29,3)
MsgBox % ToBase(255,16)

MsgBox % FromBase("100",8)
MsgBox % FromBase("ff",16)

ToBase(n,b) { ; n >= 0, 1 < b <= 36
   Return (n < b ? "" : ToBase(n//b,b)) . ((d:=mod(n,b)) < 10 ? d : Chr(d+87))
}

FromBase(s,b) { ; convert base b number s=strings of 0..9,a..z, to AHK number
   Return (L:=StrLen(s))=0 ? "":(L>1 ? FromBase(SubStr(s,1,L-1),b)*b:0) + ((c:=Asc(SubStr(s,0)))>57 ? c-87:c-48)
}

Loop 40
   R .= RandN(1,0.5) "`n"  ; mean = 1.0, standard deviation = 0.5
MsgBox %R%

RandN(m,s) { ; Normally distributed random numbers of mean = m, std.dev = s by Box-Muller method
   Static i, Y
   If (i := !i) { ; every other call
      Random U, 0, 1.0
      Random V, 0, 6.2831853071795862
      U := sqrt(-2*ln(U))*s
      Y := m + U*sin(V)
      Return m + U*cos(V)
   }
   Return Y
}

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


MsgBox % ColumnJustify(lines, "r")


ColumnJustify(lines, lcr = "l", del="$")
{
   Loop, Parse, lines, `n, `r
      Loop, Parse, A_LoopField, %del%
         c%A_Index% := c%A_Index% > StrLen(A_LoopField) ? c%A_Index% : StrLen(A_LoopField)
         , max := max > c%A_Index% ? max : c%A_Index%
   blank := Fill( " ", max )
   Loop, Parse, lines, `n, `r
   {
      Loop, Parse, A_LoopField, %del%
         out .= (A_Index = 1 ? "" : " ")
         . (lcr = "l"
            ? SubStr(A_LoopField blank, 1, c%A_Index%)
         : lcr = "r"
            ? SubStr(blank A_LoopField, -c%A_Index%+1)
         : SubStr(blank A_LoopField blank
         , (Ceil((max * 2 + StrLen(A_LoopField))/2) - Ceil(c%A_Index%/2) + 1)
         , c%A_Index%))
      out .= "`n"
   }
   return out
}


Fill(chr, len)
{
   static y
   if !y
      VarSetCapacity(x, 64), VarSetCapacity(x, 0), y := True
   return x, VarSetCapacity(x, len, Asc(chr))
}

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


MsgBox % ColumnJustify(lines, "l")


ColumnJustify(lines, lcr = "l", del="$")
{
   Loop, Parse, lines, `n, `r
      Loop, Parse, A_LoopField, %del%
      {
         If ((t := StrLen(A_LoopField)) > c%A_Index% )
            c%A_Index% :=  t
         If (t > max)
            max := t
      }
   blank := Fill( " ", max )
   If (lcr = "l") ;left-justify
      Loop, Parse, lines, `n, `r
         Loop, Parse, A_LoopField, %del%
            out .= (A_Index = 1 ? "`n" : " ") SubStr(A_LoopField blank, 1, c%A_Index%)
   Else If (lcr = "r") ;right-justify
      Loop, Parse, lines, `n, `r
         Loop, Parse, A_LoopField, %del%
            out .= (A_Index = 1 ? "`n" : " ") SubStr(blank A_LoopField, -c%A_Index%+1)
   Else If (lcr = "c") ;center-justify
      Loop, Parse, lines, `n, `r
         Loop, Parse, A_LoopField, %del%
            out .= (A_Index = 1 ? "`n" : " ") SubStr(blank A_LoopField blank
               , (Ceil((max * 2 + StrLen(A_LoopField))/2) - Ceil(c%A_Index%/2) + 1)
               , c%A_Index%)
   return SubStr(out, 2)
}


Fill(chr, len)
{
   static y
   if !y
      VarSetCapacity(x, 64), VarSetCapacity(x, 0), y := True
   return x, VarSetCapacity(x, len, Asc(chr))
}

MsgBox % PowerSet("")
MsgBox % PowerSet("-")
MsgBox % PowerSet("a bb")
MsgBox % PowerSet("4,1,2,3,4,5",",")

PS(s,d=" ") { ; The power set of a list s, separated by d (space), with extra delimiters
   Return s="" ? "{}" : (p:=InStr(s,d)) ? (w:=PS(SubStr(s,p+1),d)) "`n" RegExReplace(w,"}",d SubStr(s,1,p-1) "}") : "{}`n{" s "}"
}
PowerSet(s,d=" ") { ; The power set of a list s, separated by d (space)
   Sort s, RUD%d%   ; Sort input for nicer output, remove duplicates
   P := PS(s,d)
   StringReplace P, P, {%d%, {, All
   Return P
}

s1 := "aleph",   p1 := 1/5.0                       ; Input
s2 := "beth",    p2 := 1/6.0
s3 := "gimel",   p3 := 1/7.0
s4 := "daleth",  p4 := 1/8.0
s5 := "he",      p5 := 1/9.0
s6 := "waw",     p6 := 1/10.0
s7 := "zayin",   p7 := 1/11.0
s8 := "heth",    p8 := 1-p1-p2-p3-p4-p5-p6-p7
n := 8, r0 := 0, r%n% := 1                         ; auxiliary data

Loop % n-1
   i := A_Index-1, r%A_Index% := r%i% + p%A_Index% ; cummulative distribution

Loop 1000000 {
   Random R, 0, 1.0
   Loop %n%                                        ; linear search
      If (R < r%A_Index%) {
          c%A_Index%++
          Break
      }
}
                                                   ; Output
Loop %n%
   t .= s%A_Index% "`t" p%A_Index% "`t" c%A_Index%*1.0e-6 "`n"
Msgbox %t%

---------------------------
aleph  0.200000   0.199960
beth   0.166667   0.166146
gimel  0.142857   0.142624
daleth 0.125000   0.124924
he     0.111111   0.111226
waw    0.100000   0.100434
zayin  0.090909   0.091344
heth   0.063456   0.063342
---------------------------

n = 5                           ; size
v := x := y := 1                ; initial values
Loop % n*n {                    ; for every array element
   a_%x%_%y% := v++             ; assign the next index
   If ((x+y)&1)                 ; odd diagonal
      If (x < n)                ; while inside the square
         y -= y>1, x++          ; move right-up
      Else y++                  ; on the edge increment y, but not x: to even diagonal
   Else                         ; even diagonal
      If (y < n)                ; while inside the square
         x -= x>1, y++          ; move left-down
      Else x++                  ; on the edge increment x, but not y: to odd diagonal
}

Loop %n% {                      ; generate printout
   x := A_Index                 ; for each row
   Loop %n%                     ; and for each column
      t .= a_%x%_%A_Index% "`t" ; attach stored index
   t .= "`n"                    ; row is complete
}
MsgBox %t%                      ; show output

MsgBox % anagrams("able")

anagrams(word) {
   Static dict
   IfEqual dict,, FileRead dict, unixdict.txt ; file in the script directory
   w := sort(word)
   Loop Parse, dict, `n, `r
      If (w = sort(A_LoopField))
         t .= A_LoopField "`n"
   Return t
}

sort(word) {
   a := RegExReplace(word,".","$0`n")
   Sort a
   Return a
}