Sorry your browser is not supported!

global Dim binaries[60] as string
global dim shuffle[16]
global oneAmount


do
createBinaries
for x=1 to 26
    print (binaries[x])
next

 Sync()
loop


Function CreateBinaries
rem create 26 unique random binary string variables delimited by comma
rem first set the number of 1's allowed

oneAmount=7

rem create the array with the sixteen binary numbers and the allowed number of 1's

for tileDots=1 to 16
    if oneDone<=oneAmount
        shuffle[tileDots]=1
        else
        shuffle[tileDots]=0
    endif
        oneDone=oneDone+1
next
rem Create 26 unique binary strings
for binaryToMake=1 to 26
    done=0
    duplicate=0
    while done=0
        oneShuffle()
        binaries[binaryToMake]=""
            for x=1 to 16
                binaries[binaryToMake]=binaries[binaryToMake]+str(shuffle[x])+","
            next
            rem comparing the strings to check for duplication
            for binaryToTest=1 to 26
                if binaryToTest<>binaryToMake
                    if binaries[binaryToMake]=binaries[binaryToTest]
                    duplicate=1
                    endif
                endif

            next
             if duplicate=0 then done=1
    endwhile
next
endFunction

Function oneShuffle()
for n=1 to 1000
    element1 = Random(1,16)
    element2 = random(1,16)
    tempnumber = shuffle[element1]
    shuffle[element1] = shuffle[element2]
    shuffle[element2] = tempnumber
next
endfunction

 ; Seed the first bit
  Value = 2^rnd(15)

; loop through for the next couple of times
  For lp =2 to 4
    repeat
      Mask=2^Rnd(15)
    until (Mask and Value) =0 
    Value = Value or Mask
  next

  print bin$(Value)
		
  Sync
  waitkey
	

rem
rem AGK Application
rem

rem A Wizard Did It!
do
rem Seed the first bit
value=2^random(0,15)


rem loop through for the next couple of times
  For lp =2 to 4
    repeat
        Mask=2^random(0,15)

    until (Mask and Value) =0
    Value = Value or Mask
  next

  print( bin(Value))

  Sync
  sleep(1000)
loop

function padLeft$(s$, length, padChar$)
    if len(s$) < length then s$ = padLeft$(padChar$+s$, length, padChar$)
endfunction s$

global bindex = 0
dim binary[26]

// create the random numbers and add them to the array
repeat
    n = 2^random(1,15)
    for i = 2 to 4
        repeat
            k = 2^random(0,15)
        until (n && k) = 0
        n = n + k
    next i
    insertIntoArray(n)
until bindex = 26


repeat

    for i = 1 to 26
        print(padLeft$(str(binary[i]),5," ")+" : "+padLeft$(bin(binary[i]), 16, "0"))
    next i

    Sync
until getRawKeyPressed(27) = 1
end


function padLeft$(s$, length, padChar$)
    if len(s$) < length then s$ = padLeft$(padChar$+s$, length, padChar$)
endfunction s$


function insertIntoArray(n)
    for j = 1 to bindex
        if binary[j] = n then exitfunction 0
    next j
    inc bindex
    binary[bindex] = n
endfunction 1

rem
rem AGK Application 108 B11
rem MR

dim bit[15]
dim number[25] as integer
dim numberstr[25] as string
#constant AmountOne=7

SetDisplayAspect( 4.0/3.0 )

for i=0 to 25
 MakeRandom(i)
next

do
 for i=0 to 25
    print(numberstr[i] + " "+str(number[i]))
 next

 Sync()
loop

function MakeRandom(index)

again:
 //clear bits
 for i =0 to 15
    bit[i]=0
 next
 //fill bits
 for i=1 to AmountOne
    b=random(0,15)
    bit[b]=1
 next

 //make number
 no=0
 for i=0 to 15
  if bit[i]
   no=no+2^i
  endif
 next

 //only once
 found=0
 for i=0 to index-1
  if number[i]=no
   found=1
   exit
  endif
 next
 if found=1 then goto again

 //memory
 number[index]=no

 //make string from bits
 s$=""
 for i=0 to 15
  if bit[i]
   s$=s$+"1"
  else
   s$=s$+"0"
  endif
 next

 //memory
 numberstr[index]=s$

endfunction

procedure GenerateList(const bits:cardinal; commas: boolean; var tsl: TStringList; usearray:boolean = true);
var i    : integer;
    mask : array[0..MaxArray] of Masker; // only used in array method
    n,f  : TTime;
    m    : Masker;
    start, finish : Masker;
    iHours, IMinutes, iSeconds, iMillisecs : word;

begin
  if not assigned(tsl) then exit; // avoid null pointer

  tsl.Clear;  // clear the stringlist

  n := Time;  // start time

  // get lowest and highest possible numbers
  start.st := []; finish.st := [];
  for i := 0  to bits-1 do include(start.st,i);
  for i := 15 downto 16-bits do include(finish.st,i);
  tsl.Add(format('start %d end %d',[start.number,finish.number]));

  if usearray then //--------------------------------------------------------------
  begin

  fillchar(mask, sizeof(mask),#0);  // clear the array to zero

  // first fill the array with the numbers from start to finish
   for i := start.number to finish.number do begin

    mask[i].number := i;

  end;

  // zero those with the wrong number of bits
  for i := start.number to finish.number do if CountBits(mask[i])<>bits then mask[i].number := 0;

  // now generate the output strings according to whether we need commas
   for i := start.number to finish.number do if mask[i].number <> 0 then tsl.AddObject(GenString(mask[i],commas), pointer(mask[i].number));

  end  // using array //-----------------------------------------------------------

  else

  begin // not using array //------------------------------------------------------
    for i := start.number to finish.number do begin

      m.number := i;
      if countbits(m)=bits then tsl.AddObject(GenString(m,commas), pointer(m.number));

    end;

  end; //--------------------------------------------------------------------------

  f := time;
  n := f-n;
  decodetime(n,ihours,iminutes,iSeconds,iMillisecs);
  tsl.Add(format('time %d seconds %d milliseconds',[iseconds,iMillisecs]));

end;