AutoHotkey Community

MsgBox % PermSort("")
MsgBox % PermSort("xxx")
MsgBox % PermSort("3,2,1")
MsgBox % PermSort("dog,000000,xx,cat,pile,abcde,1,cat")

PermSort(var) {                          ; SORT COMMA SEPARATED LIST
   Local i, sorted
   StringSplit a, var, `,                ; make array, size = a0

   v0 := a0                              ; auxiliary array for permutations
   Loop %v0%
      v%A_Index% := A_Index

   While unSorted("a","v")               ; until sorted
      NextPerm("v")                      ; try new permutations

   Loop % a0                             ; construct string from sorted array
      i := v%A_Index%, sorted .= "," . a%i%
   Return SubStr(sorted,2)               ; drop leading comma
}

unSorted(a,v) {
   Loop % %a%0-1 {
      i := %v%%A_Index%, j := A_Index+1, j := %v%%j%
      If (%a%%i% > %a%%j%)
         Return 1
   }
}

NextPerm(v) { ; the lexicographically next LARGER permutation of v1..v%v0%
   Local i, i1, j, t
   i := %v%0, i1 := i-1
   While %v%%i1% >= %v%%i% {
      --i, --i1
      IfLess i1,1, Return 1 ; Signal the end
   }
   j := %v%0
   While %v%%j% <= %v%%i1%
      --j
   t := %v%%i1%, %v%%i1% := %v%%j%, %v%%j% := t,  j := %v%0
   While i < j
      t := %v%%i%, %v%%i% := %v%%j%, %v%%j% := t, ++i, --j
}

n := 8, a := 8*atan(1)/n
Loop %n%
   i := A_Index-1, t .= cos(a*i) ((s:=sin(a*i))<0 ? " - i*" . -s : " + i*" . s) "`n"
Msgbox % t

MsgBox % SEDOL("710889")  ;7108899
MsgBox % SEDOL("B0YBKJ")  ;B0YBKJ7
MsgBox % SEDOL("406566")  ;4065663
MsgBox % SEDOL("B0YBLH")  ;B0YBLH2
MsgBox % SEDOL("228276")  ;2282765
MsgBox % SEDOL("B0YBKL")  ;B0YBKL9
MsgBox % SEDOL("557910")  ;5579107
MsgBox % SEDOL("B0YBKR")  ;B0YBKR5
MsgBox % SEDOL("585284")  ;5852842
MsgBox % SEDOL("B0YBKT")  ;B0YBKT7

SEDOL(w) {
   Static w1:=1,w2:=3,w3:=1,w4:=7,w5:=3,w6:=9
   Loop Parse, w
      s += ((c:=Asc(A_LoopField))>=Asc("A") ? c-Asc("A")+10 : c-Asc("0")) * w%A_Index%
   Return w mod(10-mod(s,10),10)
}

Loop 22
   t .= (A_Index + floor(0.5 + sqrt(A_Index))) "  "
MsgBox %t%

s := 0
Loop 1000000
   x := A_Index + floor(0.5 + sqrt(A_Index)), s += x = round(sqrt(x))**2
Msgbox Number of bad squares = %s% ; 0

MsgBox % MovingAverage()   ; reset: blank
MsgBox % MovingAverage(1)  ; 1
MsgBox % MovingAverage(3)  ; 2
MsgBox % MovingAverage(-1) ; 1

MovingAverage(x="") {
  Static sum:=0, n:=0
  If (x="")           ; blank parameter: reset
     sum := 0, n := 0
  Else
     sum += x, n++    ; update state
  Return sum/n
}

std(2),std(4),std(4),std(4),std(5),std(5),std(7)
MsgBox % std(9) ; 2

std(x="") {
  Static sum:=0, sqr:=0, n:=0
  If (x="")                    ; blank parameter: reset
     sum := 0, sqr := 0, n := 0
  Else
     sum += x, sqr += x*x, n++ ; update state
  Return sqrt((sqr-sum*sum/n)/n)
}

MsgBox % SelecSort("")
MsgBox % SelecSort("xxx")
MsgBox % SelecSort("3,2,1")
MsgBox % SelecSort("dog,000000,xx,cat,pile,abcde,1,cat,zz,xx,z")

SelecSort(var) {                         ; SORT COMMA SEPARATED LIST
   StringSplit a, var, `,                ; make array, size = a0

   Loop % a0-1 {
      i := A_Index, mn := a%i%, j := m := i
      Loop % a0-i {                      ; find minimum
          j++
          If (a%j% < mn)
             mn := a%j%, m := j
      }
      t := a%i%, a%i% := a%m%, a%m% := t ; swap first with minimum
   }
   Loop % a0                             ; construct string from sorted array
      sorted .= "," . a%A_Index%
   Return SubStr(sorted,2)               ; drop leading comma
}

MsgBox % MillerRabin(999983,10) ; 1
MsgBox % MillerRabin(999809,10) ; 1
MsgBox % MillerRabin(999727,10) ; 1
MsgBox % MillerRabin(52633,10)  ; 0
MsgBox % MillerRabin(60787,10)  ; 0
MsgBox % MillerRabin(999999,10) ; 0
MsgBox % MillerRabin(999995,10) ; 0
MsgBox % MillerRabin(999991,10) ; 0

MillerRabin(n,k) { ; 0: composite, 1: probable prime (n < 2**31)
   d := n-1, s := 0
   While !(d&1)
      d>>=1, s++

   Loop %k% {
      Random a, 2, n-2 ; if n < 4,759,123,141, it is enough to test a = 2, 7, and 61.
      x := PowMod(a,d,n)
      If (x=1 || x=n-1)
         Continue
      Cont := 0
      Loop % s-1 {
         x := PowMod(x,2,n)
         If (x = 1)
            Return 0
         If (x = n-1) {
            Cont = 1
            Break
         }
      }
      IfEqual Cont,1, Continue
      Return 0
   }
   Return 1
}

PowMod(x,n,m) { ; x**n mod m
   y := 1, i := n, z := x
   While i>0
      y := i&1 ? mod(y*z,m) : y, z := mod(z*z,m), i >>= 1
   Return y
}

n := 5, dx := x := y := v := 1, dy := 0

Loop % n*n {
   a_%x%_%y% := v++
   nx := x+dx, ny := y+dy
   If (1 > nx || nx > n || 1 > ny || ny > n || a_%nx%_%ny%)
      t := dx, dx := -dy, dy := t
   x := x+dx, y := y+dy
}

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

---------------------------
1   2   3   4   5 
16  17  18  19  6 
15  24  25  20  7 
14  23  22  21  8 
13  12  11  10  9 
---------------------------

#SingleInstance

#SingleInstance Force

#SingleInstance Ignore

#SingleInstance Off

dllcall("CreateMutex", "int", 0, "int", 1, "str", A_ScriptName)
Msgbox % ErrorLevel
msgbox % result := dllcall("GetLastError")

MsgBox % MovingAverage(5,3)  ; 5, averaging length <- 3
MsgBox % MovingAverage(1)    ; 3
MsgBox % MovingAverage(-3)   ; 1
MsgBox % MovingAverage(8)    ; 2
MsgBox % MovingAverage(7)    ; 4

MovingAverage(x,len="") {    ; for integers (faster)
  Static
  Static sum:=0, n:=0, m:=10 ; default averaging length = 10
  If (len>"")                ; non-blank 2nd parameter: set length, reset
     sum := n := i := 0, m := len
  If (n < m)                 ; until the buffer is not full
     sum += x, n++           ;   keep summing data
  Else                       ; when buffer is full
     sum += x-v%i%           ;   add new, subtract oldest
  v%i% := x, i := mod(i+1,m) ; remember last m inputs, cycle insertion point
  Return sum/n
}

MovingAverage(x,len="") {    ; for floating point numbers
  Static
  Static n:=0, m:=10         ; default averaging length = 10
  If (len>"")                ; non-blank 2nd parameter: set length, reset
     n := i := 0, m := len
  n += n < m, sum := 0
  v%i% := x, i := mod(i+1,m) ; remember last m inputs, cycle insertion point
  Loop %n%                   ; recompute sum to avoid error accumulation
     j := A_Index-1, sum += v%j%
  Return sum/n
}