langs a-z

Task/100-doors/NetRexx/100-doors-1.netrexx

@@ -0,0 +1,20 @@
+/* NetRexx */
+options replace format comments java crossref savelog symbols binary
+
+True  = Rexx(1 == 1)
+False = Rexx(\True)
+
+doors = False
+
+loop i_ = 1 to 100
+  loop j_ = 1 to 100
+    if 0 = (j_ // i_) then doors[j_] = \doors[j_]
+    end j_
+  end i_
+
+loop d_ = 1 to 100
+  if doors[d_] then  state = 'open'
+  else  state = 'closed'
+
+  say 'Door Nr.' Rexx(d_).right(4) 'is' state
+  end d_

Task/100-doors/NetRexx/100-doors-2.netrexx

@@ -0,0 +1,18 @@
+/* NetRexx */
+options replace format comments java crossref savelog symbols binary
+
+True  = (1 == 1)
+False = \True
+
+doors = boolean[100]
+
+loop i_ = 0 to 9
+  doors[(i_ + 1) * (i_ + 1) - 1] = True;
+  end i_
+
+loop i_ = 0 to 99
+  if doors[i_] then  state = 'open'
+  else  state = 'closed'
+
+  say 'Door Nr.' Rexx(i_ + 1).right(4) 'is' state
+  end i_

Task/100-doors/NetRexx/100-doors-3.netrexx

@@ -0,0 +1,10 @@
+/* NetRexx */
+options replace format comments java crossref savelog symbols binary
+
+resultstring = ''
+
+loop i_ = 1 to 10
+  resultstring = resultstring || 'Door Nr.' Rexx(i_ * i_).right(4) 'is open\n'
+  end i_
+
+say resultstring

Task/100-doors/NetRexx/100-doors-4.netrexx

@@ -0,0 +1,5 @@
+/* NetRexx */
+
+loop i = 1 to 10
+   say 'Door Nr.' i * i 'is open.'
+  end i

Task/100-doors/OCaml/100-doors-1.ocaml

@@ -0,0 +1,19 @@
+let max_doors = 100
+
+let show_doors =
+  Array.iteri (fun i x -> Printf.printf "Door %d is %s\n" (i+1)
+                                        (if x then "open" else "closed"))
+
+let flip_doors doors =
+  for i = 1 to max_doors do
+    let rec flip idx =
+      if idx < max_doors then begin
+        doors.(idx) <- not doors.(idx);
+        flip (idx + i)
+      end
+    in flip (i - 1)
+  done;
+  doors
+
+let () =
+  show_doors (flip_doors (Array.make max_doors false))

Task/100-doors/OCaml/100-doors-2.ocaml

@@ -0,0 +1,8 @@
+let optimised_flip_doors doors =
+  for i = 1 to int_of_float (sqrt (float_of_int max_doors)) do
+    doors.(i*i - 1) <- true
+  done;
+  doors
+
+let () =
+  show_doors (optimised_flip_doors (Array.make max_doors false))

Task/100-doors/Objeck/100-doors.objeck

@@ -0,0 +1,21 @@
+bundle Default {
+  class Doors {
+    function : Main(args : String[]) ~ Nil {
+      doors := Bool->New[100];
+
+      for(pass := 0; pass < 10; pass += 1;) {
+        doors[(pass + 1) * (pass + 1) - 1] := true;
+      };
+
+      for(i := 0; i < 100; i += 1;) {
+        IO.Console->GetInstance()->Print("Door #")->Print(i + 1)->Print(" is ");
+        if(doors[i]) {
+          "open."->PrintLine();
+        }
+        else {
+          "closed."->PrintLine();
+        };
+      };
+    }
+  }
+}

Task/100-doors/Octave/100-doors.octave

@@ -0,0 +1,14 @@
+doors = false(100,1);
+for i = 1:100
+  for j = i:i:100
+    doors(j) = !doors(j);
+  endfor
+endfor
+for i = 1:100
+  if ( doors(i) )
+    s = "open";
+  else
+    s = "closed";
+  endif
+  printf("%d %s\n", i, s);
+endfor

Task/100-doors/OpenEdge-Progress/100-doors.openedge

@@ -0,0 +1,21 @@
+DEFINE VARIABLE lopen   AS LOGICAL     NO-UNDO EXTENT 100.
+DEFINE VARIABLE idoor   AS INTEGER     NO-UNDO.
+DEFINE VARIABLE ipass   AS INTEGER     NO-UNDO.
+DEFINE VARIABLE cresult AS CHARACTER   NO-UNDO.
+
+DO ipass = 1 TO 100:
+   idoor = 0.
+   DO WHILE idoor <= 100:
+      idoor = idoor + ipass.
+      IF idoor <= 100 THEN
+         lopen[ idoor ] = NOT lopen[ idoor ].
+   END.
+END.
+
+DO idoor = 1 TO 100:
+   cresult = cresult + STRING( lopen[ idoor ], "1  /0  " ).
+   IF idoor MODULO 10 = 0 THEN
+      cresult = cresult + "~r":U.
+END.
+
+MESSAGE cresult VIEW-AS ALERT-BOX.

Task/100-doors/Oz/100-doors.oz

@@ -0,0 +1,34 @@
+declare
+  NumDoors = 100
+  NumPasses = 100
+
+  fun {NewDoor} closed end
+
+  fun {Toggle Door}
+     case Door of closed then open
+     [] open then closed
+     end
+  end
+
+  fun {Pass Doors I}
+     {List.mapInd Doors
+      fun {$ Index Door}
+         if Index mod I == 0 then {Toggle Door}
+         else Door
+         end
+      end}
+  end
+
+  Doors0 = {MakeList NumDoors}
+  {ForAll Doors0 NewDoor}
+
+  DoorsN = {FoldL {List.number 1 NumPasses 1} Pass Doors0}
+in
+  %% print open doors
+  {List.forAllInd DoorsN
+   proc {$ Index Door}
+      if Door == open then
+	 {System.showInfo "Door "#Index#" is open."}
+      end
+   end
+  }

Task/100-doors/PARI-GP/100-doors-1.pari

@@ -0,0 +1,3 @@
+v=vector(d=100);/*set 100 closed doors*/
+for(i=1,d,forstep(j=i,d,i,v[j]=1-v[j]));
+for(i=1,d,if(v[i],print("Door ",i," is open.")))

Task/100-doors/PARI-GP/100-doors-2.pari

@@ -0,0 +1 @@
+for(n=1,sqrt(100),print("Door ",n^2," is open."))

Task/100-doors/PL-I/100-doors.pli

@@ -0,0 +1,19 @@
+declare door(100) bit (1) aligned;
+declare closed bit (1) static initial ('0'b),
+        open   bit (1) static initial ('1'b);
+declare (i, inc) fixed binary;
+
+door = closed;
+inc = 1;
+do until (inc >= 100);
+   do i = inc to 100 by inc;
+      door(i) = ^door(i); /* close door if open; open it if closed. */
+   end;
+   inc = inc+1;
+end;
+
+do i = 1 to 100;
+   put skip edit ('Door ', trim(i), ' is ') (a);
+   if door(i) then put edit (' open.') (a);
+   else put edit (' closed.') (a);
+end;

Task/100-doors/Pascal/100-doors-1.pascal

@@ -0,0 +1,24 @@
+Program OneHundredDoors;
+
+var
+   doors : Array[1..100] of Boolean;
+   i, j	 : Integer;
+
+begin
+   for i := 1 to 100 do
+      doors[i] := False;
+   for i := 1 to 100 do begin
+      j := i;
+      while j <= 100 do begin
+	 doors[j] := not doors[j];
+	 j := j + i
+      end
+   end;
+   for i := 1 to 100 do begin
+      Write(i, ' ');
+      if doors[i] then
+	 WriteLn('open')
+      else
+	 WriteLn('closed');
+   end
+end.

Task/100-doors/Pascal/100-doors-2.pascal

@@ -0,0 +1,24 @@
+program OneHundredDoors;
+
+{$APPTYPE CONSOLE}
+
+uses
+  math, sysutils;
+
+var
+   AOpendoors  : String;
+   ACloseDoors : String;
+   i	       : Integer;
+
+begin
+   for i := 1 to 100 do
+   begin
+      if (sqrt(i) = floor(sqrt(i))) then
+        AOpenDoors := AOpenDoors + IntToStr(i) + ';'
+      else
+        ACloseDoors := ACloseDoors + IntToStr(i) +';';
+   end;
+
+   WriteLn('Open doors: ' + AOpenDoors);
+   WriteLn('Close doors: ' + ACloseDoors);
+end.

Task/100-doors/Perl-6/100-doors-1.pl6

@@ -0,0 +1,5 @@
+my @doors = False xx 101;
+
+($_ = !$_ for @doors[0, * + $_ ...^ * > 100]) for 1..100;
+
+say "Door $_ is ", <closed open>[ @doors[$_] ] for 1..100;

Task/100-doors/Perl-6/100-doors-2.pl6

@@ -0,0 +1 @@
+say "Door $_ is open" for map {$^n ** 2}, 1..10;

Task/100-doors/Perl-6/100-doors-3.pl6

@@ -0,0 +1 @@
+ say "Door $_ is open" for 1..10 X** 2;

Task/100-doors/Perl-6/100-doors-4.pl6

@@ -0,0 +1 @@
+say "Door $_ is ", <closed open>[.sqrt == .sqrt.floor] for 1..100;

Task/100-doors/Pike/100-doors-1.pike

@@ -0,0 +1,8 @@
+array onehundreddoors()
+{
+    array doors = allocate(100);
+    foreach(doors; int i;)
+        for(int j=i; j<100; j+=i+1)
+            doors[j] = !doors[j];
+    return doors;
+}

Task/100-doors/Pike/100-doors-2.pike

@@ -0,0 +1,4 @@
+array doors = map(enumerate(100,1,1), lambda(int x)
+                                      {
+                                          return sqrt((float)x)%1 == 0.0;
+                                      });

Task/100-doors/Pike/100-doors-3.pike

@@ -0,0 +1 @@
+write("%{%d %d %d %d %d %d %d %d %d %d\n%}\n", doors/10)

Task/100-doors/Pop11/100-doors-1.pop11

@@ -0,0 +1,12 @@
+lvars i;
+lvars doors = {% for i from 1 to 100 do false endfor %};
+for i from 1 to 100 do
+   for j from i by i to 100 do
+      not(doors(j)) -> doors(j);
+   endfor;
+endfor;
+;;; Print state
+for i from 1 to 100 do
+   printf('Door ' >< i >< ' is ' ><
+            if doors(i) then 'open' else 'closed' endif, '%s\n');
+endfor;

Task/100-doors/Pop11/100-doors-2.pop11

@@ -0,0 +1,4 @@
+for i to 100 do
+    lvars root = sqrt(i);
+    i; if root = round(root) then ' open' ><; else ' closed' ><; endif; =>
+endfor;

Task/100-doors/PostScript/100-doors-1.ps

@@ -0,0 +1,6 @@
+/doors [ 100 { false } repeat ] def
+
+1 1 100 { dup 1 sub exch 99 {
+        dup doors exch get not doors 3 1 roll put
+} for } for
+doors pstack

Task/100-doors/PostScript/100-doors-2.ps

@@ -0,0 +1 @@
+[true false false true false false false false true false ...<90 doors later>... true]

Task/100-doors/PowerShell/100-doors-1.psh

@@ -0,0 +1,14 @@
+$doors = @(0..99)
+for($i=0; $i -lt 100; $i++) {
+  $doors[$i] = 0  # start with all doors closed
+}
+for($i=0; $i -lt 100; $i++) {
+  $step = $i + 1
+  for($j=$i; $j -lt 100; $j = $j + $step) {
+    $doors[$j] = $doors[$j] -bxor 1
+  }
+}
+foreach($doornum in 1..100) {
+  if($doors[($doornum-1)] -eq $true) {"$doornum open"}
+  else {"$doornum closed"}
+}

Task/100-doors/PowerShell/100-doors-2.psh

@@ -0,0 +1,2 @@
+$doors = 1..100 | ForEach-Object {0}
+1..100 | ForEach-Object { $a=$_;1..100 | Where-Object { -not ( $_ % $a )  } | ForEach-Object { $doors[$_-1] = $doors[$_-1] -bxor 1 }; if ( $doors[$a-1] ) { "door opened" } else { "door closed" } }

Task/100-doors/PowerShell/100-doors-3.psh

@@ -0,0 +1,3 @@
+$doors = 1..100 | ForEach-Object {0}
+$visited = 1..100
+1..100 | ForEach-Object { $a=$_;$visited[0..([math]::floor(100/$a)-1)] | Where-Object { -not ( $_ % $a )  } | ForEach-Object { $doors[$_-1] = $doors[$_-1] -bxor 1;$visited[$_/$a-1]+=($_/$a) }; if ( $doors[$a-1] ) { "door opened" } else { "door closed" } }

Task/100-doors/ProDOS/100-doors.dos

@@ -0,0 +1,13 @@
+enableextensions
+enabledelayedexpansion
+editvar /newvar /value=0 /title=closed
+editvar /newvar /value=1 /title=open
+editvar /newvar /range=1-100 /increment=1 /from=2
+editvar /newvar /value=2 /title=next
+:doors
+for /alloccurrences (!next!-!102!) do editvar /modify /value=-open-
+editvar /modify /value=-next-=+1
+if -next- /hasvalue=100 goto :cont else goto :doors
+:cont
+printline !1!-!102!
+stoptask

Task/100-doors/PureBasic/100-doors-1.purebasic

@@ -0,0 +1,18 @@
+Dim doors.i(100)
+
+For x = 1 To 100
+  y = x
+  While y <= 100
+    doors(y) = 1 - doors(y)
+    y + x
+  Wend
+Next
+
+OpenConsole()
+PrintN("Following Doors are open:")
+For x = 1 To 100
+  If doors(x)
+    Print(Str(x) + ", ")
+  EndIf
+Next
+Input()

Task/100-doors/PureBasic/100-doors-2.purebasic

@@ -0,0 +1,9 @@
+OpenConsole()
+PrintN("Following Doors are open:")
+For i = 1 To 100
+    root.f = Sqr(i)
+    If root = Int(root)
+    	Print (Str(i) + ", ")
+    EndIf
+Next
+Input()

Task/100-doors/Q/100-doors-1.q

@@ -0,0 +1 @@
+`closed`open mod[;2]count each 1 _ group raze where each 0=t mod\:/:t:til 101

Task/100-doors/Q/100-doors-2.q

@@ -0,0 +1 @@
+`closed`open (1+til 100) in `int$xexp[;2] 1+til 10

Task/100-doors/REALbasic/100-doors.realbasic

@@ -0,0 +1,7 @@
+'True=Open; False=Closed
+  Dim doors(100) As Boolean   'Booleans default to false
+  For j As Integer = 1 To 100
+    For i As Integer = 1 to 100
+      If i Mod j = 0 Then doors(i) = Not doors(i)
+    Next
+  Next

Task/100-doors/REBOL/100-doors-1.rebol

@@ -0,0 +1,5 @@
+doors: array/initial 100 'closed
+repeat i 100 [
+    door: at doors i
+    forskip door i [change door either 'open = first door ['closed] ['open]]
+]

Task/100-doors/REBOL/100-doors-2.rebol

@@ -0,0 +1,2 @@
+doors: array/initial 100 'closed
+repeat i 10 [doors/(i * i): 'open]

Task/100-doors/Retro/100-doors.retro

@@ -0,0 +1,3 @@
+: squared ( n-n  ) dup * ;
+: doors   ( n-   ) [ 1 repeat 2over squared > 0; drop dup squared putn space 1+ again ] do 2drop ;
+100 doors

Task/100-doors/Run-BASIC/100-doors.run

@@ -0,0 +1,8 @@
+dim doors(100)
+print "Open doors ";
+for i = 1 to 100
+    for door = i to 100 step i
+        doors(door) = (doors(door) <> 1)
+        if i = door and doors(door) = 1 then   print i;" ";
+    next door
+next i

Task/100-doors/Rust/100-doors.rust

@@ -0,0 +1,15 @@
+fn main() {
+    let mut door_open = [false, ..100];
+
+    for uint::range(1, 101) |pass| {
+        for uint::range(1, 101) |door| {
+            if door % pass == 0 {
+                door_open[door - 1] = !door_open[door - 1]
+            }
+        };
+    }
+    for door_open.eachi |i, state| {
+        io::println(fmt!("Door %u is %s.", i + 1,
+                          if *state { "open" } else { "closed" }));
+    }
+}

Task/100-doors/S-lang/100-doors.slang

@@ -0,0 +1,21 @@
+variable door,
+    isOpen = Char_Type [101],
+    pass;
+
+for (door = 1; door <= 100; door++) {
+    isOpen[door] = 0;
+}
+
+for (pass = 1; pass <= 100; pass++) {
+    for (door = pass; door <= 100; door += pass) {
+        isOpen[door] = not isOpen[door];
+    }
+}
+
+for (door = 1; door <= 100; door++) {
+    if (isOpen[door]) {
+        print("Door " + string(door) + ":open");
+    } else {
+        print("Door " + string(door) + ":close");
+    }
+}

Task/100-doors/SAS/100-doors.sas

@@ -0,0 +1,14 @@
+data _null_;
+   open=1;
+   close=0;
+   array Door{100};
+   do Pass = 1 to 100;
+      do Current = Pass to 100 by Pass;
+         if Door{Current} ne open
+            then Door{Current} = open;
+            else Door{Current} = close;
+      end;
+   end;
+   NumberOfOpenDoors = sum(of Door{*});
+   put "Number of Open Doors:  " NumberOfOpenDoors;
+run;

Task/100-doors/SETL/100-doors-1.setl

@@ -0,0 +1,18 @@
+program hundred_doors;
+
+const toggle := {['open', 'closed'], ['closed', 'open']};
+
+doorStates := ['closed'] * 100;
+
+(for interval in [1..100])
+  doorStates := [if i mod interval = 0 then
+                    toggle(prevState) else
+                    prevState end:
+                 prevState = doorStates(i)];
+end;
+
+(for finalState = doorStates(i))
+  print('door', i, 'is', finalState);
+end;
+
+end program;

Task/100-doors/SETL/100-doors-2.setl

@@ -0,0 +1,9 @@
+program hundred_doors;
+
+doorStates := (+/ [['closed'] * oddNum with 'open': oddNum in [1,3..17]]);
+
+(for finalState = doorStates(i))
+  print('door', i, 'is', finalState);
+end;
+
+end program;

Task/100-doors/SNOBOL4/100-doors-1.sno

@@ -0,0 +1,20 @@
+		DEFINE('PASS(A,I),O')		:(PASS.END)
+PASS		O = 0
+PASS.LOOP	O = O + I
+		EQ(A<O>,1)			:S(PASS.1)F(PASS.0)
+PASS.0		A<O> = 1			:S(PASS.LOOP)F(RETURN)
+PASS.1		A<O> = 0			:S(PASS.LOOP)F(RETURN)
+PASS.END
+
+MAIN		D = ARRAY(100,0)
+		I = 0
+
+MAIN.LOOP	I = LE(I,100) I + 1		:F(OUTPUT)
+		PASS(D,I)			:(MAIN.LOOP)
+
+OUTPUT		I = 1 ; OPEN = 'Opened doors are: '
+OUTPUT.LOOP	OPEN = OPEN EQ(D<I>,1) " " I
+		I = LE(I,100) I + 1		:S(OUTPUT.LOOP)F(OUTPUT.WRITE)
+OUTPUT.WRITE	OUTPUT = OPEN
+
+END

Task/100-doors/SNOBOL4/100-doors-2.sno

@@ -0,0 +1,12 @@
+MAIN		D = ARRAY(100,0)
+		I = 1
+
+MAIN.LOOP	LE(I, 10)			:F(OUTPUT)
+		D<I ** 2> = 1		
+		I = I + 1			:(MAIN.LOOP)
+
+OUTPUT		I = 1 ; O = 'Opened doors are: '
+OUTPUT.LOOP	O = O EQ(D<I>,1) " " I
+		I = LE(I,100) I + 1		:S(OUTPUT.LOOP)F(OUTPUT.WRITE)
+OUTPUT.WRITE	OUTPUT = O
+END

Task/100-doors/Salmon/100-doors-1.salmon

@@ -0,0 +1,7 @@
+variable open := <<(* --> false)>>;
+for (pass; 1; pass <= 100)
+    for (door_num; pass; door_num <= 100; pass)
+        open[door_num] := !(open[door_num]);;;
+iterate (door_num; [1...100])
+    print("Door ", door_num, " is ",
+          (open[door_num] ? "open.\n" : "closed.\n"));;

Task/100-doors/Salmon/100-doors-2.salmon

@@ -0,0 +1 @@
+iterate (x; [1...10]) { iterate (y; [(x-1)*(x-1)+1...x*x-1]) { print("Door ", y, " is closed.\n"); }; print("Door ", x*x, " is open.\n"); };

Task/100-doors/Salmon/100-doors-3.salmon

@@ -0,0 +1 @@
+variable y:=1;for(x;1;x<101)"Door "~sprint(x)~" is "~(x==y*y?{++y;return"open";}:"closed")!;

Task/100-doors/Seed7/100-doors-1.seed7

@@ -0,0 +1,23 @@
+$ include "seed7_05.s7i";
+
+const proc: main is func
+  local
+    var array boolean: doorOpen is 100 times FALSE;
+    var integer: pass is 0;
+    var integer: index is 0;
+    var array[boolean] string: closedOrOpen is [boolean] ("closed", "open");
+  begin
+    for pass range 1 to 100 do
+      for key index range doorOpen do
+        if index rem pass = 0 then
+          doorOpen[index] := not doorOpen[index];
+        end if;
+      end for;
+    end for;
+    for key index range doorOpen do
+      write(index lpad 3 <& " is " <& closedOrOpen[doorOpen[index]] rpad 7);
+      if index rem 5 = 0 then
+        writeln;
+      end if;
+    end for;
+  end func;

Task/100-doors/Seed7/100-doors-2.seed7

@@ -0,0 +1,16 @@
+$ include "seed7_05.s7i";
+
+const proc: main is func
+  local
+    var integer: index is 0;
+    var integer: number is 0;
+    var array[boolean] string: closedOrOpen is [boolean] ("closed", "open");
+  begin
+    for index range 1 to 100 do
+      number := sqrt(index);
+      write(index lpad 3 <& " is " <& closedOrOpen[number**2 = index] rpad 7);
+      if index rem 5 = 0 then
+        writeln;
+      end if;
+    end for;
+  end func;

Task/100-doors/Slate/100-doors-1.slate

@@ -0,0 +1,9 @@
+define: #a -> (Array newSize: 100).
+a infect: [| :_ | False].
+
+a keysDo: [| :pass |
+  pass to: a indexLast by: pass do: [| :door |
+    a at: door infect: #not `er]].
+
+a keysAndValuesDo: [| :door :isOpen |
+  inform: 'door #' ; door ; ' is ' ; (isOpen ifTrue: ['open'] ifFalse: ['closed'])].

Task/100-doors/Slate/100-doors-2.slate

@@ -0,0 +1,6 @@
+define: #a -> (Array newSize: 100).
+a infect: [| :_ | False].
+
+0 below: 10 do: [| :door | a at: door squared put: True].
+a keysAndValuesDo: [| :door :isOpen |
+  inform: 'door #' ; door ; ' is ' ; (isOpen ifTrue: ['open'] ifFalse: ['closed'])].

Task/100-doors/TI-83-BASIC/100-doors-1.ti-83

@@ -0,0 +1,16 @@
+PROGRAM:DOORS100
+:ClrHome
+:Disp "SETTING UP LIST"
+:Disp "PLEASE WAIT..."
+:For(I,1,100,1)
+:0→L1(I)
+:End
+:ClrHome
+:Disp "Pass"
+:For(I,1,100,1)
+:For(J,I,100,I)
+:Output(2,1,I)
+:not(L1(J))→L1(J)
+:End
+:End
+:ClrHome

Task/100-doors/TI-83-BASIC/100-doors-2.ti-83

@@ -0,0 +1,4 @@
+PROGRAM:DOORSOPT
+:For(I,1,100,1)
+:not(fPart(√(I)))→L1(I)
+:End

Task/100-doors/TI-89-BASIC/100-doors.ti-89

@@ -0,0 +1,16 @@
+Define doors(fast) = Func
+  Local doors,i,j
+  seq(false,x,1,100) → doors
+  If fast Then
+    For i,1,10,1
+      true → doors[i^2]
+    EndFor
+  Else
+    For i,1,100,1
+      For j,i,100,i
+        not doors[j] → doors[j]
+      EndFor
+    EndFor
+  EndIf
+  Return doors
+EndFunc

Task/100-doors/TSE-SAL/100-doors.tse

@@ -0,0 +1,85 @@
+// library: math: get: task: door: open: close100 <description></description> <version control></version control> <version>1.0.0.0.11</version> <version control></version control> (filenamemacro=getmaocl.s) [<Program>] [<Research>] [kn, ri, mo, 31-12-2012 22:03:16]
+PROC PROCMathGetTaskDoorOpenClose( INTEGER doorMaxI, INTEGER passMaxI )
+ // e.g. PROC Main()
+ // e.g.  PROCMathGetTaskDoorOpenClose( 100, 100 )
+ // e.g. END
+ // e.g.
+ // e.g. <F12> Main()
+ //
+ // ===
+ //
+ // The output will be:
+ //
+ // door 1 is open
+ // door 4 is open
+ // door 9 is open
+ // door 16 is open
+ // door 25 is open
+ // door 36 is open
+ // door 49 is open
+ // door 64 is open
+ // door 81 is open
+ // door 100 is open
+ // all other doors are closed
+ //
+ // ===
+ //
+ INTEGER passMinI = 1
+ INTEGER passI = 0
+ //
+ INTEGER doorminI = 1
+ INTEGER doorI = 0
+ //
+ STRING s[255] = ""
+ //
+ INTEGER bufferI = 0
+ //
+ PushPosition()
+ bufferI = CreateTempBuffer()
+ PopPosition()
+ //
+ FOR doorI = doorMinI TO doorMaxI
+  //
+  SetGlobalInt( Format( "doorsI", doorI ), 0 )
+  //
+ ENDFOR
+ //
+ FOR passI = passMinI TO passMaxI
+  //
+  doorI = passI - passI
+  //
+  REPEAT
+   //
+   doorI = doorI + passI
+   //
+   SetGlobalInt( Format( "doorsI", doorI ), NOT( GetGlobalInt( Format( "doorsI", doorI ) ) ) )
+   //
+  UNTIL ( doorI >= doorMaxI )
+  //
+ ENDFOR
+ //
+ FOR doorI = doorMinI TO doorMaxI
+  //
+  IF ( GetGlobalInt( Format( "doorsI", doorI ) ) > 0 )
+   //
+   s = "open"
+   //
+   AddLine( Format( "door", " ", doorI, " ", "is", " ", s ), bufferI )
+   //
+  ELSE
+   //
+   s = "closed"
+   //
+  ENDIF
+  //
+ ENDFOR
+ //
+ AddLine( "all other doors are closed", bufferI )
+ //
+ GotoBufferId( bufferI )
+ //
+END
+
+PROC Main()
+ PROCMathGetTaskDoorOpenClose( 100, 100 )
+END

Task/100-doors/TUSCRIPT/100-doors.tuscript

@@ -0,0 +1,24 @@
+$$ MODE TUSCRIPT
+DICT doors create
+COMPILE
+LOOP door=1,100
+ LOOP pass=1,100
+ SET go=MOD (door,pass)
+ DICT doors lookup door,num,cnt,status
+   IF (num==0) THEN
+     SET status="open"
+     DICT doors add  door,num,cnt,status
+   ELSE
+    IF (go==0) THEN
+       IF (status=="closed") THEN
+         SET status="open"
+       ELSE
+         SET status="closed"
+       ENDIF
+     DICT doors update door,num,cnt,status
+     ENDIF
+   ENDIF
+ ENDLOOP
+ENDLOOP
+ENDCOMPILE
+DICT doors unload door,num,cnt,status

Task/100-doors/TXR/100-doors.txr

@@ -0,0 +1,9 @@
+@(do (defun 100-doors ()
+       (let ((doors (vector 100)))
+         (each ((i (range 0 99)))
+           (for ((j i)) ((< j 100)) ((inc j (+ i 1)))
+             (flip [doors j])))
+         doors))
+     (each ((counter (range 1))
+            (door (list-vector (100-doors))))
+        (format t "door ~a is ~a\n" counter (if door "open" "closed"))))

Task/100-doors/TorqueScript/100-doors.torquescript

@@ -0,0 +1,5 @@
+for(%steps = 1; %a <= 100; %a++)
+	for(%current = %steps; %current <= 100; %current += %steps)
+		%door[%current] = !%door[%current];
+for(%a = 1; %a <= 100; %a++)
+	echo("Door #" @ %a @ " is" SPC %door[%current] ? "Open" : "Closed" @ ".");

Task/100-doors/UNIX-Shell/100-doors-1.sh

@@ -0,0 +1,22 @@
+#! /bin/bash
+
+declare -a doors
+for((i=1; i <= 100; i++)); do
+    doors[$i]=0
+done
+
+for((i=1; i <= 100; i++)); do
+    for((j=i; j <= 100; j += i)); do
+	echo $i $j
+	doors[$j]=$(( doors[j] ^ 1 ))
+    done
+done
+
+for((i=1; i <= 100; i++)); do
+    if [[ ${doors[$i]} -eq 0 ]]; then
+	op="closed"
+    else
+	op="open"
+    fi
+    echo $i $op
+done

Task/100-doors/UNIX-Shell/100-doors-2.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+for i in {1..100}; do
+  door[$i*$i]=1
+  [ -z ${door[$i]} ] && echo "$i closed" || echo "$i open"
+done

Task/100-doors/Ursala/100-doors-1.ursala

@@ -0,0 +1,10 @@
+#import std
+#import nat
+
+doors = 0!* iota 100
+
+pass("n","d") = remainder\"n"?l(~&r,not ~&r)* num "d"
+
+#cast %nL
+
+main = ~&rFlS num pass=>doors nrange(100,1)

Task/100-doors/Ursala/100-doors-2.ursala

@@ -0,0 +1,5 @@
+#import nat
+
+#cast %nL
+
+main = product*tiiXS iota10

Task/100-doors/VBScript/100-doors.vbscript

@@ -0,0 +1,21 @@
+Dim doorIsOpen(100), pass, currentDoor, text
+
+For currentDoor = 0 To 99
+	doorIsOpen(currentDoor) = False
+Next
+
+For pass = 0 To 99
+	For currentDoor = pass To 99 Step pass + 1
+		doorIsOpen(currentDoor) = Not doorIsOpen(currentDoor)
+	Next
+Next
+
+For currentDoor = 0 To 99
+	text = "Door #" & currentDoor + 1 & " is "
+	If doorIsOpen(currentDoor) Then
+		text = text & "open."
+	Else
+		text = text & "closed."
+	End If
+	WScript.Echo(text)
+Next

Task/100-doors/VHDL/100-doors-1.vhdl

@@ -0,0 +1,28 @@
+library IEEE;
+use IEEE.STD_LOGIC_1164.ALL;
+
+entity DOORS is
+	port (CLK: in std_logic; OUTPUT: out std_logic_vector(1 to 100));
+end DOORS;
+
+architecture Behavioral of DOORS is
+begin
+	process (CLK)
+	variable TEMP: std_logic_vector(1 to 100);
+	begin
+		--setup closed doors
+		TEMP := (others => '0');
+		
+		--looping through
+		for i in 1 to TEMP'length loop
+			for j in i to TEMP'length loop
+				if (j mod i) = 0 then
+					TEMP(j) := not TEMP(j);
+				end if;
+			end loop;
+		end loop;
+		
+		--assign output
+		OUTPUT <= TEMP;
+	end process;
+end Behavioral;

Task/100-doors/VHDL/100-doors-2.vhdl

@@ -0,0 +1,34 @@
+LIBRARY ieee;
+USE ieee.std_logic_1164.all;
+
+
+entity doors is
+  port (
+        clk   : in std_logic;
+        reset : in std_logic;
+        door  : buffer std_logic_vector(1 to 100)
+        );
+end entity doors;
+
+
+architecture rtl of doors is
+  signal step : integer range 1 to 101;
+  signal addr : integer range 1 to 201;
+begin
+  proc_step: process(clk, reset)
+  begin
+    if reset = '1' then
+      step  <= 1;
+      addr  <= 1;
+      door <= (others => '0');
+    elsif rising_edge(clk) then
+      if addr <= 100 then
+        door(addr) <= not door(addr);
+        addr <= addr + step;
+      elsif step <= 100 then
+        addr <= step + 1;
+        step <= step + 1;
+      end if;
+    end if;
+  end process;
+end;

Task/100-doors/Vala/100-doors-1.vala

@@ -0,0 +1,10 @@
+int main() {
+	bool doors_open[101];
+	for(int i = 1; i < doors_open.length; i++) {
+		for(int j = 1; i*j < doors_open.length; j++) {
+			doors_open[i*j] = !doors_open[i*j];
+		}
+		stdout.printf("%d: %s\n", i, (doors_open[i] ? "open" : "closed"));
+	}
+	return 0;
+}

Task/100-doors/Vala/100-doors-2.vala

@@ -0,0 +1,8 @@
+int main() {
+	int i = 1;
+	while(i*i <= 100) {
+		stdout.printf("${i*i} open\n");
+		i++;
+	}
+	return 0;
+}

Task/100-doors/Vedit-macro-language/100-doors-1.vedit

@@ -0,0 +1,8 @@
+Buf_Switch(Buf_Free)
+Ins_Char('-', COUNT, 100)                      // All doors closed
+for (#1 = 1; #1 <= 100; #1++) {
+    for (#2 = #1; #2 <= 100; #2 += #1) {
+        Goto_Col(#2)
+        Ins_Char((Cur_Char^0x62), OVERWRITE)   // Toggle between '-' and 'O'
+    }
+}

Task/100-doors/Vedit-macro-language/100-doors-2.vedit

@@ -0,0 +1,6 @@
+Buf_Switch(Buf_Free)
+Ins_Char('-', COUNT, 100)
+for (#1=1; #1 <= 10; #1++) {
+    Goto_Col(#1*#1)
+    Ins_Char('O', OVERWRITE)
+}

Task/100-doors/Visual-Basic-.NET/100-doors-1.visual

@@ -0,0 +1,19 @@
+Module Module1
+
+   Sub Main()
+       Dim doors(100) As Boolean 'Door 1 is at index 0
+
+       For pass = 1 To 100
+           For door = pass - 1 To 99 Step pass
+               doors(door) = Not doors(door)
+           Next
+       Next
+
+       For door = 0 To 99
+           Console.WriteLine("Door # " & (door + 1) & " is " & If(doors(door), "Open", "Closed"))
+       Next
+
+       Console.ReadLine()
+   End Sub
+
+End Module

Task/100-doors/Visual-Basic-.NET/100-doors-2.visual

@@ -0,0 +1,17 @@
+Module Module1
+
+   Sub Main()
+       Dim doors(100) As Boolean 'Door 1 is at index 0
+
+       For i = 1 To 10
+           doors(i ^ 2 - 1) = True
+       Next
+
+       For door = 0 To 99
+           Console.WriteLine("Door # " & (door + 1) & " is " & If(doors(door), "Open", "Closed"))
+       Next
+
+       Console.ReadLine()
+   End Sub
+
+End Module

Task/100-doors/Wrapl/100-doors-1.wrapl

@@ -0,0 +1,15 @@
+MOD Doors;
+
+IMP Agg.Table;
+IMP Std.String;
+IMP IO.Terminal USE Out;
+
+VAR door <- {}; EVERY door[1:to(100), "closed"];
+
+DEF toggle(num) door[num] <- door[num] = "open" => "closed" // "open";
+
+EVERY WITH pass <- 1:to(100), num <- pass:to(100, pass) DO toggle(num);
+
+Out:write('Doors {door @ String.T}.');
+
+END Doors.

Task/100-doors/Wrapl/100-doors-2.wrapl

@@ -0,0 +1,11 @@
+MOD Doors;
+
+IMP IO.Terminal USE Out;
+
+DEF open <- ALL 1:to(100) ^ 2 \ $ <= 100;
+DEF closed <- ALL 1:to(100) \ NOT $ IN open;
+
+Out:write('Doors {open} are open.\n');
+Out:write('Doors {closed} are closed.\n');
+
+END Doors.

Task/100-doors/XPL0/100-doors.xpl0

@@ -0,0 +1,37 @@
+include c:\cxpl\codes;          \intrinsic 'code' declarations
+int     Door(100);              \You have 100 doors in a row
+define  Open, Closed;
+int     D, Pass, Step;
+
+[for D:= 0 to 100-1 do          \that are all initially closed
+        Door(D):= Closed;
+
+Step:= 1;                       \The first time through, you visit every door
+for Pass:= 1 to 100 do          \You make 100 passes by the doors
+        [D:= Step-1;
+        repeat  \if the door is closed, you open it; if it is open, you close it
+                if Door(D)=Closed then Door(D):= Open else Door(D):= Closed;
+                D:= D+Step;
+        until   D>=100;
+        Step:= Step+1;          \The second time you only visit every 2nd door
+        ];                      \The third time, every 3rd door
+                                \until you only visit the 100th door
+\What state are the doors in after the last pass?
+Text(0, "Open: ");              \Which are open?
+for D:= 0 to 100-1 do
+        if Door(D)=Open then [IntOut(0, D+1); ChOut(0,^ )];
+CrLf(0);
+
+Text(0, "Closed: ");            \Which are closed?
+for D:= 0 to 100-1 do
+        if Door(D)=Closed then [IntOut(0, D+1); ChOut(0,^ )];
+CrLf(0);
+
+\Optimized: The only doors that remain open are those that are perfect squares
+Text(0, "Open: ");
+D:= 1;
+repeat  IntOut(0, D*D); ChOut(0,^ );
+        D:= D+1;
+until   D*D>100;
+CrLf(0);
+]

Task/100-doors/XSLT-1.0/100-doors-1.xslt

@@ -0,0 +1,8 @@
+<hallway>
+  <door number="1">closed</door>
+  <door number="2">closed</door>
+  <door number="3">closed</door>
+  <door number="4">closed</door>
+  ... etc ...
+  <door number="100">closed</door>
+<hallway>

Task/100-doors/XSLT-1.0/100-doors-2.xslt

@@ -0,0 +1,34 @@
+<xsl:stylesheet version="1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  xmlns:exsl="http://exslt.org/common"
+  exclude-result-prefixes="xsl exsl">
+<xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>
+
+<xsl:template match="/*">
+  <xsl:copy>
+    <xsl:apply-templates select="door" />
+  </xsl:copy>
+</xsl:template>
+
+<xsl:template match="door">
+  <xsl:variable name="door-num" select="@number" />
+  <xsl:variable name="knocks">
+    <xsl:for-each select="/*/door">
+      <xsl:if test="$door-num mod position() = 0">
+        <xsl:text>!</xsl:text>
+      </xsl:if>
+    </xsl:for-each>
+  </xsl:variable>
+  <door number="{$door-num}">
+   <xsl:choose>
+     <xsl:when test="string-length($knocks) mod 2 = 1">
+        <xsl:text>open</xsl:text>
+     </xsl:when>
+     <xsl:otherwise>
+        <xsl:text>closed</xsl:text>
+     </xsl:otherwise>
+   </xsl:choose>
+  </door>
+</xsl:template>
+
+</xsl:stylesheet>

Task/100-doors/XSLT-2.0/100-doors.xslt

@@ -0,0 +1,18 @@
+<xsl:stylesheet version="2.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>
+
+<xsl:template match="/">
+  <hallway>
+    <xsl:for-each select="1 to 100">
+      <xsl:variable name="door-num" select="position()" />
+      <door number="{$door-num}">
+        <xsl:value-of select="('closed','open')[
+	    number( sum( for $pass in 1 to 100 return
+	    number(($door-num mod $pass) = 0)) mod 2 = 1) + 1]" />
+      </door>
+    </xsl:for-each>
+  </hallway>
+</xsl:template>
+
+</xsl:stylesheet>

Task/100-doors/Yorick/100-doors-1.yorick

@@ -0,0 +1,5 @@
+doors = array(0, 100);
+for(i = 1; i <= 100; i++)
+    for(j = i; j <= 100; j += i)
+        doors(j) ~= 1;
+print, where(doors);

Task/100-doors/Yorick/100-doors-2.yorick

@@ -0,0 +1,4 @@
+doors = array(0, 100);
+for(i = 1; i <= 100; i++)
+    doors(i::i) ~= 1;
+print, where(doors);

Task/100-doors/Yorick/100-doors-3.yorick

@@ -0,0 +1 @@
+print, indgen(1:long(sqrt(100)))^2

Task/100-doors/ZED/100-doors.zed

@@ -0,0 +1,54 @@
+("100doors")
+100doors
+(always)
+(message) (first) 100 (100passes) (doors)
+
+(doors)
+an infinite list of closed doors
+(always)
+(c) "'closed" (doors)
+
+(100passes) doors
+[open closed closed closed ...]
+(always)
+(100passes1) 1 doors
+
+(100passes1) count doors
+101 [open closed closed open ...]
+(>) count 100
+doors
+
+(100passes1) count doors
+3 [open closed open closed ...]
+(always)
+(100passes1) (add1) count
+             (flip-and-count) count doors
+
+(flip-and-count) frequency doors
+3 [open closed open closed ...]
+(always)
+(flip-and-count1) frequency frequency doors
+
+(flip-and-count1) frequency count doors
+3 1 [open closed open closed ...]
+(=) count 1
+(c) (flip-door-state) (1) doors
+    (flip-and-count) frequency (!) doors
+
+(flip-and-count1) frequency count doors
+3 3 [open closed open closed ...]
+(always)
+(c) (1) doors
+    (flip-and-count1) frequency
+                      (sub1) count
+                      (!) doors
+
+(flip-door-state) state
+'closed
+(=) state "'closed"
+"'open"
+
+(flip-door-state) state
+'open
+(=) state "'open"
+"'closed"