add tasks starting with a number

Task/100-doors/0DESCRIPTION

@@ -0,0 +1,5 @@
+Problem: You have 100 doors in a row that are all initially closed. You make 100 [[task feature::Rosetta Code:multiple passes|passes]] by the doors. The first time through, you visit every door and toggle the door (if the door is closed, you open it; if it is open, you close it). The second time you only visit every 2nd door (door #2, #4, #6, ...). The third time, every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 100th door.
+
+Question: What state are the doors in after the last pass? Which are open, which are closed? [http://www.techinterview.org/Puzzles/fog0000000079.html]
+
+'''[[task feature::Rosetta Code:extra credit|Alternate]]:'''  As noted in this page's [[Talk:100 doors|discussion page]], the only doors that remain open are whose numbers are perfect squares of integers.  Opening only those doors is an [[task feature::Rosetta Code:optimization|optimization]] that may also be expressed.

Task/100-doors/4DOS-Batch/100-doors-1.4dos

@@ -0,0 +1,7 @@
+@echo off
+set doors=%@repeat[C,100]
+do step = 1 to 100
+  do door = %step to 100 by %step
+    set doors=%@left[%@eval[%door-1],%doors]%@if[%@instr[%@eval[%door-1],1,%doors]==C,O,C]%@right[%@eval[100-%door],%doors]
+  enddo
+enddo

Task/100-doors/4DOS-Batch/100-doors-2.4dos

@@ -0,0 +1,3 @@
+%@left[n,string]                      ^: Return n leftmost chars in string
+%@right[n,string]                     ^: Return n rightmost chars in string
+%@if[condition,true-val,false-val]    ^: Evaluate condition; return true-val if true, false-val if false

Task/100-doors/6502-Assembly/100-doors.6502

@@ -0,0 +1,10 @@
+                        ;assume all memory is initially set to 0
+          inc $1        ;start out with a delta of 1
+openloop: inc $200,X    ;open a door at X
+          inc $1        ;add 2 to delta
+          inc $1
+          txa           ;add delta to X
+          adc $1
+          tax
+          cpx #$65      ;check to see if we're at the 100th door
+          bmi openloop  ;jump back to openloop if less than 100

Task/100-doors/ABAP/100-doors-1.abap

@@ -0,0 +1,30 @@
+form open_doors_unopt.
+  data: lv_door  type i,
+        lv_count type i value 1.
+  data: lt_doors type standard table of c initial size 100.
+  field-symbols: <wa_door> type c.
+  do 100 times.
+    append initial line to lt_doors assigning <wa_door>.
+    <wa_door> = 'X'.
+  enddo.
+
+  while lv_count < 100.
+    lv_count = lv_count + 1.
+    lv_door = lv_count.
+    while lv_door < 100.
+      read table lt_doors index lv_door assigning <wa_door>.
+      if <wa_door> = ' '.
+        <wa_door> = 'X'.
+      else.
+        <wa_door> = ' '.
+      endif.
+      add lv_count to lv_door.
+    endwhile.
+  endwhile.
+
+  loop at lt_doors assigning <wa_door>.
+    if <wa_door> = 'X'.
+      write : / 'Door', (4) sy-tabix right-justified, 'is open' no-gap.
+    endif.
+  endloop.
+endform.

Task/100-doors/ABAP/100-doors-2.abap

@@ -0,0 +1,14 @@
+form open_doors_opt.
+  data: lv_square type i value 1,
+        lv_inc    type i value 3.
+  data: lt_doors  type standard table of c initial size 100.
+  field-symbols: <wa_door> type c.
+  do 100 times.
+    append initial line to lt_doors assigning <wa_door>.
+    if sy-index = lv_square.
+      <wa_door> = 'X'.
+      add: lv_inc to lv_square, 2 to lv_inc.
+      write : / 'Door', (4) sy-index right-justified, 'is open' no-gap.
+    endif.
+  enddo.
+endform.

Task/100-doors/ACL2/100-doors.acl2

@@ -0,0 +1,21 @@
+(defun rep (n x)
+   (if (zp n)
+       nil
+       (cons x
+             (rep (- n 1) x))))
+
+(defun toggle-every-r (n i bs)
+   (if (endp bs)
+       nil
+       (cons (if (zp i)
+                 (not (first bs))
+                 (first bs))
+             (toggle-every-r n (mod (1- i) n) (rest bs)))))
+
+(defun toggle-every (n bs)
+   (toggle-every-r n (1- n) bs))
+
+(defun 100-doors (i doors)
+   (if (zp i)
+       doors
+       (100-doors (1- i) (toggle-every i doors))))

Task/100-doors/ALGOL-68/100-doors-1.alg

@@ -0,0 +1,25 @@
+# declare some constants #
+INT limit = 100;
+
+PROC doors = VOID:
+(
+  MODE DOORSTATE = BOOL;
+  BOOL closed = FALSE;
+  BOOL open = NOT closed;
+  MODE DOORLIST = [limit]DOORSTATE;
+
+  DOORLIST the doors;
+  FOR i FROM LWB the doors TO UPB the doors DO the doors[i]:=closed OD;
+
+  FOR i FROM LWB the doors TO UPB the doors DO
+    FOR j FROM LWB the doors TO UPB the doors DO
+      IF j MOD i = 0 THEN
+        the doors[j] :=  NOT the doors[j]
+      FI
+    OD
+  OD;
+  FOR i FROM LWB the doors TO UPB the doors DO
+    printf(($g" is "gl$,i,(the doors[i]|"opened"|"closed")))
+  OD
+);
+doors;

Task/100-doors/ALGOL-68/100-doors-2.alg

@@ -0,0 +1,7 @@
+PROC doors optimised = ( INT limit )VOID:
+  FOR i TO limit DO
+    REAL num := sqrt(i);
+    printf(($g" is "gl$,i,(ENTIER num = num |"opened"|"closed") ))
+  OD
+;
+doors optimised(limit)

Task/100-doors/APL/100-doors-1.apl

@@ -0,0 +1,11 @@
+out←doors num
+⍝ Simulates the 100 doors problem for any number of doors
+⍝ Returns a boolean vector with 1 being open
+
+out←⍳num            ⍝ num steps
+out←⍳¨out           ⍝ Count out the spacing for each step
+out←1=out           ⍝ Make that into a boolean vector
+out←⌽¨out           ⍝ Flip each vector around
+out←(num∘⍴)¨out     ⍝ Copy each out to the right size
+out←≠/out           ⍝ XOR each vector, toggling each marked door
+out←⊃out            ⍝ Disclose the results to get a vector

Task/100-doors/APL/100-doors-2.apl

@@ -0,0 +1,7 @@
+out←doorsOptimized num;marks
+⍝ Returns a boolean vector of the doors that would be left open
+
+marks←⌊num*0.5        ⍝ Take the square root of the size, floored
+marks←(⍳marks)*2      ⍝ Get each door to be opened
+out←num⍴0             ⍝ Make a vector of 0s
+out[marks]←1          ⍝ Set the marked doors to 1

Task/100-doors/AWK/100-doors-1.awk

@@ -0,0 +1,17 @@
+BEGIN {
+  for(i=1; i <= 100; i++)
+  {
+    doors[i] = 0 # close the doors
+  }
+  for(i=1; i <= 100; i++)
+  {
+    for(j=i; j <= 100; j += i)
+    {
+      doors[j] = (doors[j]+1) % 2
+    }
+  }
+  for(i=1; i <= 100; i++)
+  {
+    print i, doors[i] ? "open" : "close"
+  }
+}

Task/100-doors/AWK/100-doors-2.awk

@@ -0,0 +1,14 @@
+BEGIN {
+  for(i=1; i <= 100; i++) {
+    doors[i] = 0 # close the doors
+  }
+  for(i=1; i <= 100; i++) {
+    if ( int(sqrt(i)) == sqrt(i) ) {
+      doors[i] = 1
+    }
+  }
+  for(i=1; i <= 100; i++)
+  {
+    print i, doors[i] ? "open" : "close"
+  }
+}

Task/100-doors/ActionScript/100-doors.as

@@ -0,0 +1,21 @@
+package {
+    import flash.display.Sprite;
+
+    public class Doors extends Sprite {
+        public function Doors() {
+
+            // Initialize the array
+            var doors:Array = new Array(100);
+            for (var i:Number = 0; i < 100; i++) {
+                doors[i] = false;
+
+            // Do the work
+            for (var pass:Number = 0; pass < 100; pass++) {
+                for (var j:Number = pass; j < 100; j += (pass+1)) {
+                    doors[j] = !doors[j];
+                }
+            }
+            trace(doors);
+        }
+    }
+}

Task/100-doors/Ada/100-doors-1.ada

@@ -0,0 +1,22 @@
+with Ada.Text_Io; use Ada.Text_Io;
+
+ procedure Doors is
+    type Door_State is (Closed, Open);
+    type Door_List is array(Positive range 1..100) of Door_State;
+    The_Doors : Door_List := (others => Closed);
+ begin
+    for I in 1..100 loop
+       for J in The_Doors'range loop
+          if J mod I = 0 then
+             if The_Doors(J) = Closed then
+                 The_Doors(J) := Open;
+             else
+                The_Doors(J) := Closed;
+             end if;
+          end if;
+       end loop;
+    end loop;
+    for I in The_Doors'range loop
+       Put_Line(Integer'Image(I) & " is " & Door_State'Image(The_Doors(I)));
+    end loop;
+ end Doors;

Task/100-doors/Ada/100-doors-2.ada

@@ -0,0 +1,16 @@
+with Ada.Text_Io; use Ada.Text_Io;
+ with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
+
+ procedure Doors_Optimized is
+    Num : Float;
+ begin
+    for I in 1..100 loop
+       Num := Sqrt(Float(I));
+       Put(Integer'Image(I) & " is ");
+       if Float'Floor(Num) = Num then
+          Put_Line("Opened");
+       else
+          Put_Line("Closed");
+       end if;
+    end loop;
+ end Doors_Optimized;

Task/100-doors/Aikido/100-doors.aikido

@@ -0,0 +1,13 @@
+var doors = new int [100]
+
+foreach pass 100 {
+    for (var door = pass ; door < 100 ; door += pass+1) {
+        doors[door] = !doors[door]
+    }
+}
+
+var d = 1
+foreach door doors {
+    println ("door " + d++ + " is " + (door ? "open" : "closed"))
+
+}

Task/100-doors/AmigaE/100-doors.amiga

@@ -0,0 +1,14 @@
+PROC main()
+  DEF t[100]: ARRAY,
+      pass, door
+  FOR door := 0 TO 99 DO t[door] := FALSE
+  FOR pass := 0 TO 99
+    door := pass
+    WHILE door <= 99
+      t[door] := Not(t[door])
+      door := door + pass + 1
+    ENDWHILE
+  ENDFOR
+  FOR door := 0 TO 99 DO WriteF('\d is \s\n', door+1,
+                                IF t[door] THEN 'open' ELSE 'closed')
+ENDPROC

Task/100-doors/AppleScript/100-doors.applescript

@@ -0,0 +1,17 @@
+set is_open to {}
+repeat 100 times
+   set end of is_open to false
+end
+repeat with pass from 1 to 100
+  repeat with door from pass to 100 by pass
+    set item door of is_open to not item door of is_open
+  end
+end
+set open_doors to {}
+repeat with door from 1 to 100
+   if item door of is_open then
+     set end of open_doors to door
+   end
+end
+set text item delimiters to ", "
+display dialog "Open doors: " & open_doors

Task/100-doors/Arbre/100-doors.arbre

@@ -0,0 +1,12 @@
+openshut(n):
+  for x in [1..n]
+    x%n==0
+
+pass(n):
+  if n==100
+    openshut(n)
+  else
+    openshut(n) xor pass(n+1)
+
+100doors():
+  pass(1) -> io

Task/100-doors/Argile/100-doors.argile

@@ -0,0 +1,16 @@
+use std, array
+
+close all doors
+for each pass from 1 to 100
+  for (door = pass) (door <= 100) (door += pass)
+    toggle door
+
+let int pass, door.
+
+.: close all doors :. {memset doors 0 size of doors}
+.:toggle <int door>:. {    !!(doors[door - 1])     }
+
+let doors be an array of 100 bool
+
+for each door from 1 to 100
+  printf "#%.3d %s\n" door (doors[door - 1]) ? "[ ]", "[X]"

Task/100-doors/AutoHotkey/100-doors-1.ahk

@@ -0,0 +1,27 @@
+Loop, 100
+  Door%A_Index% := "closed"
+
+Loop, 100 {
+  x := A_Index, y := A_Index
+  While (x <= 100)
+  {
+    CurrentDoor := Door%x%
+    If CurrentDoor contains closed
+    {
+      Door%x% := "open"
+      x += y
+    }
+    else if CurrentDoor contains open
+    {
+      Door%x% := "closed"
+      x += y
+    }
+  }
+}
+
+Loop, 100 {
+   CurrentDoor := Door%A_Index%
+   If CurrentDoor contains open
+      Res .= "Door " A_Index " is open`n"
+}
+MsgBox % Res

Task/100-doors/AutoHotkey/100-doors-2.ahk

@@ -0,0 +1,6 @@
+increment := 3, square := 1
+Loop, 100
+    If (A_Index = square)
+        outstring .= "`nDoor " A_Index " is open"
+        ,square += increment, increment += 2
+MsgBox,, Succesfull, % SubStr(outstring, 2)

Task/100-doors/AutoHotkey/100-doors-3.ahk

@@ -0,0 +1,3 @@
+While (Door := A_Index ** 2) <= 100
+   Result .= "Door " Door " is open`n"
+MsgBox, %Result%

Task/100-doors/AutoIt/100-doors.autoit

@@ -0,0 +1,17 @@
+#include <array.au3>
+$doors = 100
+
+;door array, 0 = closed, 1 = open
+Local $door[$doors +1]
+
+For $ii = 1 To $doors
+	For $i = $ii To $doors Step $ii
+		$door[$i] = Not $door[$i]
+	next
+Next
+
+;display to screen
+For $i = 1 To $doors
+	ConsoleWrite (Number($door[$i])& " ")
+	If Mod($i,10) = 0 Then ConsoleWrite(@CRLF)
+Next

Task/100-doors/Axiom/100-doors-1.axiom

@@ -0,0 +1,6 @@
+(open,closed,change,open?) := (true,false,not,test);
+doors := bits(100,closed);
+for i in 1..#doors repeat
+  for j in i..#doors by i repeat
+    doors.j := change doors.j
+[i for i in 1..#doors | open? doors.i]

Task/100-doors/Axiom/100-doors-2.axiom

@@ -0,0 +1,2 @@
+[i for i in 1..100 | perfectSquare? i] -- or
+[i^2 for i in 1..sqrt(100)::Integer]

Task/100-doors/BASIC/100-doors-1.bas

@@ -0,0 +1,16 @@
+DIM doors(0 TO 99)
+FOR pass = 0 TO 99
+	FOR door = pass TO 99 STEP pass + 1
+		PRINT doors(door)
+		PRINT NOT doors(door)
+		doors(door) = NOT doors(door)
+	NEXT door
+NEXT pass
+FOR i = 0 TO 99
+	PRINT "Door #"; i + 1; " is ";
+	IF NOT doors(i) THEN
+		PRINT "closed"
+	ELSE
+		PRINT "open"
+	END IF
+NEXT i

Task/100-doors/BASIC/100-doors-2.bas

@@ -0,0 +1,12 @@
+DIM doors(0 TO 99)
+FOR door = 0 TO 99
+	IF INT(SQR(door)) = SQR(door) THEN doors(door) = -1
+NEXT door
+FOR i = 0 TO 99
+	PRINT "Door #"; i + 1; " is ";
+	IF NOT doors(i) THEN
+		PRINT "closed"
+	ELSE
+		PRINT "open"
+	END IF
+NEXT i

Task/100-doors/BASIC/100-doors-3.bas

@@ -0,0 +1,10 @@
+'lrcvs 04.11.12
+cls
+x = 1 : y = 3 : z = 0
+print x + " Open"
+do
+z = x + y
+print z + " Open"
+x = z : y = y + 2
+until z >= 100
+end

Task/100-doors/Befunge/100-doors.bf

@@ -0,0 +1,4 @@
+108p0>:18p;;>:9g!18g9p08g]
+*`!0\|+relet|-1`*aap81::+]
+;::+1<r]!g9;>$08g1+:08paa[
+*`#@_^._aa

Task/100-doors/C/100-doors-1.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+int main()
+{
+  char is_open[100] = { 0 };
+  int pass, door;
+
+  // do the 100 passes
+  for (pass = 0; pass < 100; ++pass)
+    for (door = pass; door < 100; door += pass+1)
+      is_open[door] = !is_open[door];
+
+  // output the result
+  for (door = 0; door < 100; ++door)
+    printf("door #%d is %s.\n", door+1, (is_open[door]? "open" : "closed"));
+
+  return 0;
+}

Task/100-doors/C/100-doors-2.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+int main()
+{
+  int square = 1, increment = 3, door;
+  for (door = 1; door <= 100; ++door)
+  {
+    printf("door #%d", door);
+    if (door == square)
+    {
+      printf(" is open.\n");
+      square += increment;
+      increment += 2;
+    }
+    else
+      printf(" is closed.\n");
+  }
+  return 0;
+}

Task/100-doors/C/100-doors-3.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main()
+{
+  int door, square, increment;
+  for (door = 1, square = 1, increment = 1; door <= 100; door++ == square && (square += increment += 2))
+    printf("door #%d is %s.\n", door, (door == square? "open" : "closed"));
+  return 0;
+}

Task/100-doors/C/100-doors-4.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main()
+{
+	int i;
+	for (i = 1; i * i <= 100; i++)
+		printf("door %d open\n", i * i);
+
+	return 0;
+}

Task/100-doors/Clojure/100-doors-1.clj

@@ -0,0 +1,13 @@
+(defn doors []
+  (let [doors (into-array (repeat 100 false))]
+    (doseq [pass   (range 1 101)
+            i      (range (dec pass) 100 pass) ]
+      (aset doors i (not (aget doors i))))
+    doors))
+
+(defn open-doors [] (for [[d n] (map vector (doors) (iterate inc 1)) :when d] n))
+
+(defn print-open-doors []
+  (println
+    "Open doors after 100 passes:"
+    (apply str (interpose ", " (open-doors)))))

Task/100-doors/Clojure/100-doors-2.clj

@@ -0,0 +1,13 @@
+(defn doors []
+  (reduce (fn [doors toggle-idx] (update-in doors [toggle-idx] not))
+          (into [] (repeat 100 false))
+          (for [pass   (range 1 101)
+                i      (range (dec pass) 100 pass) ]
+            i)))
+
+(defn open-doors [] (for [[d n] (map vector (doors) (iterate inc 1)) :when d] n))
+
+(defn print-open-doors []
+  (println
+    "Open doors after 100 passes:"
+    (apply str (interpose ", " (open-doors)))))

Task/100-doors/Clojure/100-doors-3.clj

@@ -0,0 +1,11 @@
+(defn doors []
+	(reduce (fn [doors idx] (assoc doors idx true))
+	        (into [] (repeat 100 false))
+	        (map #(dec (* % %)) (range 1 11))))
+
+(defn open-doors [] (for [[d n] (map vector (doors) (iterate inc 1)) :when d] n))
+
+(defn print-open-doors []
+  (println
+    "Open doors after 100 passes:"
+    (apply str (interpose ", " (open-doors)))))

Task/100-doors/CoffeeScript/100-doors-1.coffee

@@ -0,0 +1,10 @@
+doors = []
+
+for pass in [1..100]
+  for i in [pass..100] by pass
+    doors[i] = !doors[i]
+
+console.log "Doors #{index for index, open of doors when open} are open"
+
+# matrix output
+console.log doors.map (open) -> +open

Task/100-doors/CoffeeScript/100-doors-2.coffee

@@ -0,0 +1,3 @@
+isInteger = (i) -> Math.floor(i) == i
+
+console.log door for door in [1..100] when isInteger Math.sqrt door

Task/100-doors/CoffeeScript/100-doors-3.coffee

@@ -0,0 +1 @@
+console.log Math.pow(i,2) for i in [1..10]

Task/100-doors/Dylan/100-doors.dylan

@@ -0,0 +1,13 @@
+define method doors()
+  let doors = make(<array>, fill: #f, size: 100);
+  for (x from 0 below 100)
+    for (y from x below 100 by x + 1)
+      doors[y] := ~doors[y]
+    end
+  end;
+  for (x from 1 to 100)
+    if (doors[x - 1])
+      format-out("door %d open\n", x)
+    end
+  end
+end

Task/100-doors/Eiffel/100-doors-1.e

@@ -0,0 +1,64 @@
+note
+	description: "100 Doors problem"
+	date: "07-AUG-2011"
+	revision: "1.0"
+
+class
+	APPLICATION
+
+create
+	make
+
+feature {NONE} -- Initialization
+
+	doors: LINKED_LIST [DOOR]
+			-- A set of doors
+		once
+			create Result.make
+		end
+
+	make
+			-- Run application.
+		local
+			count, i: INTEGER
+		do
+				--initialize doors
+			count := 100
+			from
+				i := 1
+			until
+				i > count
+			loop
+				doors.extend (create {DOOR}.make (i, false))
+				i := i + 1
+			end
+
+			-- toggle doors
+			from
+				i := 1
+			until
+				i > count
+			loop
+				across
+					doors as this
+				loop
+					if this.item.address \\ i = 0 then
+						this.item.open := not this.item.open
+					end
+				end -- across doors
+				i := i + 1
+			end -- for i
+
+				-- print results
+			doors.do_all (agent  (door: DOOR)
+				do
+					if door.open then
+						io.put_string ("Door " + door.address.out + " is open.")
+					elseif not door.open then
+						io.put_string ("Door " + door.address.out + " is closed.")
+					end
+					io.put_new_line
+				end)
+		end -- make
+
+end -- APPLICATION

Task/100-doors/Eiffel/100-doors-2.e

@@ -0,0 +1,44 @@
+note
+	description: "A door with an address and an open or closed state."
+	date: "07-AUG-2011"
+	revision: "1.0"
+
+class
+	DOOR
+
+create
+	make
+
+feature -- initialization
+
+	make (addr: INTEGER; status: BOOLEAN)
+			-- create door with address and status
+		require
+			valid_address: addr /= '%U'
+			valid_status: status /= '%U'
+		do
+			address := addr
+			open := status
+		ensure
+			address_set: address = addr
+			status_set: open = status
+		end
+
+feature -- access
+
+	address: INTEGER
+
+	open: BOOLEAN assign set_open
+
+feature -- mutators
+
+	set_open (status: BOOLEAN)
+		require
+			valid_status: status /= '%U'
+		do
+			open := status
+		ensure
+			open_updated: open = status
+		end
+
+end

Task/100-doors/Erlang/100-doors.erl

@@ -0,0 +1,5 @@
+doors() ->
+     F = fun(X) -> Root = math:pow(X,0.5), Root == trunc(Root) end,
+     Out = fun(X, true) -> io:format("Door ~p: open~n",[X]);
+              (X, false)-> io:format("Door ~p: close~n",[X]) end,
+     [Out(X,F(X)) || X <- lists:seq(1,100)].

Task/100-doors/Forth/100-doors-1.fth

@@ -0,0 +1,18 @@
+: toggle ( c-addr -- )  \ toggle the byte at c-addr
+    dup c@ 1 xor swap c! ;
+
+100  1+ ( 1-based indexing ) constant ndoors
+create doors  ndoors allot
+
+: init ( -- )  doors ndoors erase ;  \ close all doors
+
+: pass ( n -- )  \ toggle every nth door
+    ndoors over do
+        doors i + toggle
+    dup ( n ) +loop drop ;
+
+: run ( -- )  ndoors 1 do  i pass  loop ;
+: display ( -- )  \ display open doors
+    ndoors 1 do  doors i + c@ if  i .  then loop cr ;
+
+init run display

Task/100-doors/Forth/100-doors-2.fth

@@ -0,0 +1,6 @@
+: squared ( n -- n' )  dup * ;
+: doors ( n -- )
+    1 begin 2dup squared >= while
+        dup squared .
+    1+ repeat 2drop ;
+100 doors

Task/100-doors/Fortran/100-doors-1.f

@@ -0,0 +1,22 @@
+PROGRAM DOORS
+
+  INTEGER, PARAMETER :: n = 100    ! Number of doors
+  INTEGER :: i, j
+  LOGICAL :: door(n) = .TRUE.      ! Initially closed
+
+  DO i = 1, n
+    DO j = i, n, i
+      door(j) = .NOT. door(j)
+    END DO
+  END DO
+
+  DO i = 1, n
+    WRITE(*,"(A,I3,A)", ADVANCE="NO") "Door ", i, " is "
+    IF (door(i)) THEN
+      WRITE(*,"(A)") "closed"
+    ELSE
+      WRITE(*,"(A)") "open"
+    END IF
+  END DO
+
+END PROGRAM DOORS

Task/100-doors/Fortran/100-doors-2.f

@@ -0,0 +1,20 @@
+PROGRAM DOORS
+
+  INTEGER, PARAMETER :: n = 100    ! Number of doors
+  INTEGER :: i
+  LOGICAL :: door(n) = .TRUE.      ! Initially closed
+
+  DO i = 1, SQRT(REAL(n))
+    door(i*i) = .FALSE.
+  END DO
+
+  DO i = 1, n
+    WRITE(*,"(A,I3,A)", ADVANCE="NO") "Door ", i, " is "
+    IF (door(i)) THEN
+      WRITE(*,"(A)") "closed"
+    ELSE
+      WRITE(*,"(A)") "open"
+    END IF
+  END DO
+
+END PROGRAM DOORS

Task/100-doors/Go/100-doors-1.go

@@ -0,0 +1,30 @@
+package main
+
+import "fmt"
+
+func main() {
+    doors := make([]bool, 100)
+
+    // the 100 passes called for in the task description
+    for pass := 1; pass <= 100; pass++ {
+        for door := pass-1; door < 100; door += pass {
+            doors[door] = !doors[door]
+        }
+    }
+
+    // one more pass to answer the question
+    for i, v := range doors {
+        if v {
+            fmt.Print("1")
+        } else {
+            fmt.Print("0")
+        }
+
+        if i%10 == 9 {
+            fmt.Print("\n")
+        } else {
+            fmt.Print(" ")
+        }
+
+    }
+}

Task/100-doors/Go/100-doors-2.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func main() {
+    var door int = 1
+    var incrementer = 0
+
+    for current := 1; current <= 100; current++ {
+        fmt.Printf("Door %d ", current)
+
+        if current == door {
+            fmt.Printf("Open\n")
+            incrementer++
+            door += 2*incrementer + 1
+        } else {
+            fmt.Printf("Closed\n")
+        }
+    }
+}

Task/100-doors/Haskell/100-doors-1.hs

@@ -0,0 +1,10 @@
+data Door = Open | Closed deriving Show
+
+toggle Open   = Closed
+toggle Closed = Open
+
+toggleEvery :: [Door] -> Int -> [Door]
+toggleEvery xs k = zipWith ($) fs xs
+    where fs = cycle $ (replicate (k-1) id) ++ [toggle]
+
+run n = foldl toggleEvery (replicate n Closed) [0..n]

Task/100-doors/Haskell/100-doors-2.hs

@@ -0,0 +1,6 @@
+gate :: Eq a => [a] -> [a] -> [Door]
+gate (x:xs) (y:ys) | x == y  =  Open   : gate xs ys
+gate (x:xs) ys               =  Closed : gate xs ys
+gate []     _                =  []
+
+run n = gate [1..n] [k*k | k <- [1..]]

Task/100-doors/Haskell/100-doors-3.hs

@@ -0,0 +1 @@
+run n = takeWhile (< n) [k*k | k <- [1..]]

Task/100-doors/Java/100-doors-1.java

@@ -0,0 +1,13 @@
+public class HundredDoors {
+    public static void main(String[] args) {
+        boolean[] doors = new boolean[101];
+        for (int i = 1; i <= 100; i++) {
+            for (int j = i; j <= 100; j++) {
+                if(j % i == 0) doors[j] = !doors[j];
+            }
+        }
+        for (int i = 1; i <= 100; i++) {
+            System.out.printf("Door %d: %s%n", i, doors[i] ? "open" : "closed");
+        }
+    }
+}

Task/100-doors/Java/100-doors-2.java

@@ -0,0 +1,13 @@
+public class Doors
+{
+ public static void main(final String[] args)
+ {
+  boolean[] doors = new boolean[100];
+
+  for (int pass = 0; pass < 10; pass++)
+   doors[(pass + 1) * (pass + 1) - 1] = true;
+
+  for(int i = 0; i < 100; i++)
+   System.out.println("Door #" + (i + 1) + " is " + (doors[i] ? "open." : "closed."));
+ }
+}

Task/100-doors/Java/100-doors-3.java

@@ -0,0 +1,12 @@
+public class Doors
+{
+ public static void main(final String[] args)
+ {
+  StringBuilder sb = new StringBuilder();
+
+  for (int i = 1; i <= 10; i++)
+   sb.append("Door #").append(i*i).append(" is open\n");
+
+  System.out.println(sb.toString());
+ }
+}

Task/100-doors/Java/100-doors-4.java

@@ -0,0 +1,13 @@
+public class Doors{
+   public static void main(String[] args){
+      int i;		
+      for(i = 1; i < 101; i++){
+         double sqrt = Math.sqrt(i);
+         if(sqrt != (int)sqrt){
+            System.out.println("Door " + i + " is closed");
+         }else{
+            System.out.println("Door " + i + " is open");
+         }
+      }
+   } 	
+}

Task/100-doors/JavaScript/100-doors-1.js

@@ -0,0 +1,11 @@
+var doors = [], n = 100, i, j;
+
+for (i = 1; i <= n; i++) {
+	for (j = i; j <= n; j += i) {
+		doors[j] = !doors[j];
+	}
+}
+
+for (i = 1 ; i <= n ; i++) {
+	if (doors[i]) console.log("Door " + i + " is open");
+}

Task/100-doors/JavaScript/100-doors-2.js

@@ -0,0 +1,19 @@
+var
+ n = 100,
+ doors = [n],
+ step,
+ idx;
+// now, start opening and closing
+for (step = 1; step <= n; step += 1)
+ for (idx = step; idx <= n; idx += step)
+ // toggle state of door
+ doors[idx] = !doors[idx];
+
+// find out which doors are open
+var open = doors.reduce(function(open, val, idx) {
+    if (val) {
+        open.push(idx);
+    }
+    return open;
+}, []);
+document.write("These doors are open: " + open.join(', '));

Task/100-doors/Lua/100-doors.lua

@@ -0,0 +1,17 @@
+is_open = {}
+
+for door = 1,100 do is_open[door] = false end
+
+for pass = 1,100 do
+    for door = pass,100,pass do
+        is_open[door] = not is_open[door]
+    end
+end
+
+for i,v in next,is_open do
+    if v then
+        print ('Door '..i..':','open')
+    else
+        print ('Door '..i..':', 'close')
+    end
+end

Task/100-doors/PHP/100-doors-1.php

@@ -0,0 +1,7 @@
+<?php
+for ($i = 1; $i <= 100; $i++) {
+	$root = sqrt($i);
+	$state = ($root == ceil($root)) ? 'open' : 'closed';
+	echo "Door {$i}: {$state}\n";
+}
+?>

Task/100-doors/PHP/100-doors-2.php

@@ -0,0 +1,13 @@
+<?php
+$toggleState = array('open' => 'closed', 'closed' => 'open');
+$doors = array_fill(1, 100, 'closed');
+for ($pass = 1; $pass <= 100; ++$pass) {
+	for ($nr = 1; $nr <= 100; ++$nr) {
+		if ($nr % $pass == 0) {
+			$doors[$nr] = $toggleState[$doors[$nr]];
+		}
+	}
+}
+for ($nr = 1; $nr <= 100; ++$nr)
+	printf("Door %d is %s\n", $nr, $doors[$nr]);
+?>

Task/100-doors/Perl/100-doors-1.pl

@@ -0,0 +1,10 @@
+my @doors;
+for my $pass (1 .. 100) {
+    for (1 .. 100) {
+        if (0 == $_ % $pass) {
+            $doors[$_] = not $doors[$_];
+        };
+    };
+};
+
+print "Door $_ is ", $doors[$_] ? "open" : "closed", "\n" for 1 .. 100;

Task/100-doors/Perl/100-doors-2.pl

@@ -0,0 +1 @@
+print "Door $_ is open\n" for map $_**2, 1 .. 10;

Task/100-doors/Perl/100-doors-3.pl

@@ -0,0 +1 @@
+print "Door $_ is ", qw"closed open"[int sqrt == sqrt], "\n" for 1..100;

Task/100-doors/Perl/100-doors-4.pl

@@ -0,0 +1,12 @@
+while( ++$i <= 100 )
+{
+    $root = sqrt($i);
+    if ( int( $root ) == $root )
+    {
+        print "Door $i is open\n";
+    }
+    else
+    {
+        print "Door $i is closed\n";
+    }
+}

Task/100-doors/PicoLisp/100-doors-1.l

@@ -0,0 +1,5 @@
+(let Doors (need 100)
+   (for I 100
+      (for (D (nth Doors I)  D  (cdr (nth D I)))
+         (set D (not (car D))) ) )
+   (println Doors) )

Task/100-doors/PicoLisp/100-doors-2.l

@@ -0,0 +1,4 @@
+(let Doors (need 100)
+   (for I (sqrt 100)
+      (set (nth Doors (* I I)) T) )
+   (println Doors) )

Task/100-doors/PicoLisp/100-doors-3.l

@@ -0,0 +1,6 @@
+(let Doors (need 100)
+   (for I (sqrt 100)
+      (set (nth Doors (* I I)) T) )
+   (make
+      (for (N . D) Doors
+         (when D (link N)) ) ) )

Task/100-doors/Prolog/100-doors-1.pro

@@ -0,0 +1,34 @@
+doors_unoptimized(N) :-
+	length(L, N),
+	maplist(init, L),
+	doors(N, N, L, L1),
+	affiche(N, L1).
+
+init(close).
+
+doors(Max, 1, L, L1) :-
+	!,
+       inverse(1, 1, Max, L, L1).
+
+doors(Max, N, L, L1) :-
+	N1 is N - 1,
+	doors(Max, N1, L, L2),
+	inverse(N, 1, Max, L2, L1).
+
+
+inverse(N, Max, Max, [V], [V1]) :-
+	!,
+	0 =:= Max mod N -> inverse(V, V1); V1 = V.
+
+inverse(N, M, Max, [V|T], [V1|T1]) :-
+	M1 is M+1,
+	inverse(N, M1, Max, T, T1),
+	(   0 =:= M mod N -> inverse(V, V1); V1 = V).
+
+
+inverse(open, close).
+inverse(close, open).
+
+affiche(N, L) :-
+	forall(between(1, N, I),
+	       (   nth1(I, L, open) -> format('Door ~w is open.~n', [I]); true)).

Task/100-doors/Prolog/100-doors-2.pro

@@ -0,0 +1,4 @@
+doors_optimized(N) :-
+	Max is floor(sqrt(N)),
+	forall(between(1, Max, I),
+	       (   J is I*I,format('Door ~w is open.~n',[J]))).

Task/100-doors/Python/100-doors-1.py

@@ -0,0 +1,5 @@
+doors = [False] * 100
+for i in xrange(100):
+    for j in xrange(i, 100, i+1):
+        doors[j] = not doors[j]
+    print "Door %d:" % (i+1), 'open' if doors[i] else 'close'

Task/100-doors/Python/100-doors-2.py

@@ -0,0 +1,3 @@
+for i in xrange(1, 101):
+    root = i ** 0.5
+    print "Door %d:" % i, 'open' if root == int(root) else 'close'

Task/100-doors/Python/100-doors-3.py

@@ -0,0 +1 @@
+print '\n'.join(['Door %s is %s' % (i, ('closed', 'open')[(i**0.5).is_integer()]) for i in xrange(1, 101)])

Task/100-doors/Python/100-doors-4.py

@@ -0,0 +1 @@
+print '\n'.join('Door %s is %s' % (i, 'closed' if i**0.5 % 1 else 'open') for i in range(1, 101))

Task/100-doors/Python/100-doors-5.py

@@ -0,0 +1,4 @@
+for i in list(range(1, 101)):
+    if i**0.5 % 1: state='open'
+    else: state='close'
+    print ("Door {}:{}".format(i, state))

Task/100-doors/R/100-doors-1.r

@@ -0,0 +1,10 @@
+doors_puzzle <- function(ndoors=100,passes=100) {
+    doors <- rep(FALSE,ndoors)
+    for (ii in seq(1,passes)) {
+        mask <- seq(0,ndoors,ii)
+        doors[mask] <- !doors[mask]	
+    }
+    return (which(doors == TRUE))
+}
+
+doors_puzzle()

Task/100-doors/R/100-doors-2.r

@@ -0,0 +1,5 @@
+x <- rep(1, 100)
+for (i in 1:100-1) {
+    x <- xor(x, rep(c(rep(0,i),1), length.out=100))
+}
+which(!x)

Task/100-doors/R/100-doors-3.r

@@ -0,0 +1,5 @@
+doors_puzzle <- function(ndoors=100,passes=100) {
+names(which(table(unlist(sapply(1:passes, function(X) seq(0, ndoors, by=X)))) %% 2 == 1))
+}
+
+doors_puzzle()

Task/100-doors/REXX/100-doors-1.rexx

@@ -0,0 +1,11 @@
+/*rexx*/
+door. = 0
+do inc = 1 to 100
+  do d = inc to 100 by inc
+    door.d = \door.d
+  end
+end
+say "The open doors after 100 passes:"
+do i = 1 to 100
+  if door.i = 1 then say i
+end

Task/100-doors/REXX/100-doors-2.rexx

@@ -0,0 +1,18 @@
+/*REXX program to solve the 100 door puzzle, the hard-way version.  */
+parse arg doors .            /*get the first argument (# of doors.) */
+if doors=='' then doors=100  /*not specified?  Then assume 100 doors*/
+                                    /*   0 = closed.  */
+                                    /*   1 = open.    */
+door.=0                      /*assume all that all doors are closed.*/
+
+     do j=1 for doors        /*process a pass-through for all doors.*/
+       do k=j by j to doors  /* ... every Jth door from this point. */
+       door.k=\door.k        /*toggle the  "openness"  of the door. */
+       end   /*k*/
+     end     /*j*/
+say
+say 'After' doors "passes, the following doors are open:"
+say
+          do n=1 for doors
+          if door.n then say right(n,20)
+          end    /*n*/

Task/100-doors/REXX/100-doors-3.rexx

@@ -0,0 +1,14 @@
+/*REXX program to solve the 100 door puzzle, the easy-way version.  */
+parse arg doors .            /*get the first argument (# of doors.) */
+if doors=='' then doors=100  /*not specified?  Then assume 100 doors*/
+                                    /*   0 = closed.  */
+                                    /*   1 = open.    */
+door.=0                      /*assume all that all doors are closed.*/
+say
+say 'For the' doors "doors problem, the following doors are open:"
+say
+      do j=1 for doors       /*process an easy pass-through.        */
+      p=j**2                 /*square the door number.              */
+      if p>doors then leave  /*if too large, we're done.            */
+      say right(p,20)
+      end   /*j*/

Task/100-doors/REXX/100-doors-4.rexx

@@ -0,0 +1,12 @@
+/*REXX program to solve the 100 door puzzle, the easy-way version 2.*/
+parse arg doors .            /*get the first argument (# of doors.) */
+if doors=='' then doors=1000 /*not specified? Then assume 1000 doors*/
+                                    /*   0 = closed.  */
+                                    /*   1 = open.    */
+door.=0                      /*assume all that all doors are closed.*/
+say
+say 'For the' doors "doors problem, the open doors are:"
+say
+      do j=1 for doors while j**2<=doors      /*limit pass-throughs.*/
+      say right(j**2,20)
+      end   /*j*/

Task/100-doors/Racket/100-doors-1.rkt

@@ -0,0 +1,28 @@
+#lang racket
+
+;; Like "map", but the proc must take an index as well as the element.
+(define (map-index proc seq)
+  (for/list ([(elt i) (in-indexed seq)])
+    (proc elt i)))
+
+;; Applies PROC to every STEPth element of SEQ, leaving the others
+;; unchanged.
+(define (map-step proc step seq)
+  (map-index
+   (lambda (elt i)
+     ((if (zero? (remainder i step) )
+          proc
+          values) elt))
+   seq))
+
+(define (toggle-nth n seq)
+  (map-step not n seq))
+
+(define (solve seq)
+  (for/fold ([result seq])
+      ([(_ pass) (in-indexed  seq)])
+      (toggle-nth (add1 pass) result)))
+
+(for ([(door index) (in-indexed (solve (make-vector 100 #f)))])
+  (when door
+    (printf "~a is open~%" index)))

Task/100-doors/Racket/100-doors-2.rkt

@@ -0,0 +1,6 @@
+#lang racket
+
+(for-each (lambda (x) (printf "~a is open\n" x))
+            (filter (lambda (x)
+                      (exact-integer? (sqrt x)))
+                    (sequence->list (in-range 1 101))))

Task/100-doors/Racket/100-doors-3.rkt

@@ -0,0 +1,20 @@
+#lang slideshow
+(define-syntax-rule (vector-neg-set! vec pos)
+  (vector-set! vec pos (not (vector-ref vec pos))))
+
+(define (make-doors)
+  (define doors (make-vector 100 #f))
+  (for ([i (in-range 100)])
+    (for ([j (in-range i 100 (add1 i))])
+      (vector-neg-set! doors j)))
+  doors)
+
+(displayln (list->string (for/list ([d (make-doors)])
+                           (if d #\o #\-))))
+
+(define (closed-door) (inset (filled-rectangle 4 20) 2))
+(define (open-door) (inset (rectangle 4 20) 2))
+
+(for/fold ([doors (rectangle 0 0)])
+          ([open? (make-doors)])
+  (hc-append doors (if open? (open-door) (closed-door))))

Task/100-doors/Ruby/100-doors-1.rb

@@ -0,0 +1,31 @@
+class Door
+	attr_reader :state
+	def initialize
+		@state=:closed
+	end
+	
+	def close; @state=:closed; end
+	def open; @state=:open; end
+	
+	def closed?; @state==:closed; end
+	def open?; @state==:open; end
+	
+	def toggle
+		if closed?
+			open
+		else
+			close
+		end
+	end
+	
+	def to_s; @state.to_s; end
+end
+
+doors=Array.new(100){Door.new}
+1.upto(100) do |multiplier|
+	doors.each_with_index do |door, i|
+		door.toggle if (i+1)%multiplier==0
+	end
+end
+
+doors.each_with_index{|door, i| puts "Door #{i+1} is #{door}."}

Task/100-doors/Ruby/100-doors-2.rb

@@ -0,0 +1,19 @@
+n = 100
+Open = "open"
+Closed = "closed"
+def Open.f
+    Closed
+end
+def Closed.f
+    Open
+end
+doors = [Closed] * (n+1)
+for mul in 1..n
+    for x in 1..n
+        doors[mul*x] = (doors[mul*x] || break).f
+    end
+end
+doors.each_with_index {
+    |b, i|
+    puts "Door #{i} is #{b}" if i>0
+}

Task/100-doors/Ruby/100-doors-3.rb

@@ -0,0 +1,4 @@
+n = 100
+(1..n).each do |i|
+    puts "Door #{i} is #{i**0.5 == (i**0.5).round ? "open" : "closed"}"
+end

Task/100-doors/Ruby/100-doors-4.rb

@@ -0,0 +1,7 @@
+doors = [false] * 100
+100.times do |i|
+  (i .. doors.length).step(i+1) do |j|
+    doors[j] = !doors[j]
+  end
+end
+puts doors.inspect

Task/100-doors/Sather/100-doors.sa

@@ -0,0 +1,22 @@
+class MAIN is
+  main is
+    pass, door :INT;
+    doors :ARRAY{BOOL} := #(100);
+    loop
+      doors[0.upto!(99)] := false;
+    end;
+    pass := 0;
+    loop while!(pass < 100);
+      door := pass;
+      loop while! (door < 100);
+        doors[door] := ~doors[door];
+	door := door + pass + 1
+      end;
+      pass := pass + 1;
+    end;
+    loop
+      door := 0.upto!(99);
+      #OUT + (door+1) + " " + doors[door] + "\n";
+    end;
+  end;
+end;

Task/100-doors/Scala/100-doors-1.scala

@@ -0,0 +1,3 @@
+for { i <- 1 to 100
+      r = 1 to 100 map (i % _ == 0) reduceLeft (_^_)
+    } println (i +" "+ (if (r) "open" else "closed"))

Task/100-doors/Scala/100-doors-2.scala

@@ -0,0 +1,17 @@
+def openDoors(length : Int = 100) = {
+    var isDoorOpen = new Array[Boolean](length)
+
+    for (i <- 0 until length) {
+        for (j <- i until length by i + 1) {
+            isDoorOpen(j) ^= true
+        }
+    }
+    isDoorOpen
+}
+
+val doorState  = scala.collection.immutable.Map(false -> "closed", true -> "open")
+val isDoorOpen = openDoors()
+
+for (doorNo <- 0 until isDoorOpen.length) {
+    println("Door %d is %s".format(doorNo + 1, doorState(isDoorOpen(doorNo))))
+}

Task/100-doors/Scala/100-doors-3.scala

@@ -0,0 +1,3 @@
+val o = 1 to 10 map (i => i * i)
+println("open: " + o)
+println("closed: " + (1 to 100 filterNot o.contains))

Task/100-doors/Scheme/100-doors-1.ss

@@ -0,0 +1,26 @@
+(define *max-doors* 100)
+
+(define (show-doors doors)
+  (let door ((i 0)
+             (l (vector-length doors)))
+    (cond ((= i l)
+           (newline))
+          (else
+           (printf "~nDoor ~a is ~a"
+                   (+ i 1)
+                   (if (vector-ref doors i) "open" "closed"))
+           (door (+ i 1) l)))))
+
+(define (flip-doors doors)
+  (define (flip-all i)
+    (cond ((> i *max-doors*) doors)
+          (else
+           (let flip ((idx (- i 1)))
+             (cond ((>= idx *max-doors*)
+                    (flip-all (+ i 1)))
+                   (else
+                    (vector-set! doors idx (not (vector-ref doors idx)))
+                    (flip (+ idx i))))))))
+  (flip-all 1))
+
+(show-doors (flip-doors (make-vector *max-doors* #f)))

Task/100-doors/Scheme/100-doors-2.ss

@@ -0,0 +1,9 @@
+(define (optimised-flip-doors doors)
+  (define (flip-all i)
+    (cond ((> i (floor (sqrt *max-doors*))) doors)
+          (else
+           (vector-set! doors (- (* i i) 1) #t)
+           (flip-all (+ i 1)))))
+  (flip-all 1))
+
+(show-doors (optimised-flip-doors (make-vector *max-doors* #f)))

Task/100-doors/Smalltalk/100-doors-1.st

@@ -0,0 +1,15 @@
+|a|
+a := Array new: 100 .
+1 to: 100 do: [ :i | a at: i put: false ].
+
+1 to: 100 do: [ :pass |
+  pass to: 100 by: pass do: [ :door |
+    a at: door put: (a at: door) not .
+  ]
+].
+
+"output"
+1 to: 100 do: [ :door |
+   ( 'door #%1 is %2' %
+     { door . (a at: door) ifTrue: [ 'open' ] ifFalse: [ 'closed' ] } ) displayNl
+]

Task/100-doors/Smalltalk/100-doors-2.st

@@ -0,0 +1,9 @@
+|a|
+a := (1 to: 100) collect: [ :x | false ].
+1 to: 10 do: [ :i | a at: (i squared) put: true ].
+1 to: 100 do: [ :i |
+   ( 'door #%1 is %2' % { i .
+           (a at: i) ifTrue: [ 'open' ]
+                     ifFalse: [ 'closed' ] }
+   ) displayNl
+]

Task/100-doors/Smalltalk/100-doors-3.st

@@ -0,0 +1,29 @@
+| m w h smh smw delay closedDoor border subMorphList |
+
+closedDoor := Color black.
+border := Color veryLightGray.
+delay := Delay forMilliseconds: 50.
+w := World bounds corner x.
+h := (World bounds corner y) / 2.
+smw := w/100.
+smh := h/2.
+
+m := BorderedMorph new position: 0@h.
+m height: smh; width: w; borderColor: border.
+m color: Color veryLightGray.
+
+1 to: 100 do: [ :pos || sm |
+	sm := BorderedMorph new height: smh ; width: smw ;
+		borderColor: border; color: closedDoor;
+		position: (smw*pos)@h.
+	m addMorph: sm asElementNumber: pos].
+
+m openInWorld.
+delay wait.
+subMorphList := m submorphs.
+"display every step"
+[1 to: 100 do: [ :step |
+	step to: 100 by: step do: [ :pos | | subMorph |
+		subMorph := subMorphList at: pos.
+		subMorph color: subMorph color negated.
+		delay wait]]] fork.