100 doors: Difference between revisions

{{task}}

 

 

 

=={{header|4DOS Batch}}==

 

@echo off

set doors=%@repeat[C,100]

enddo

enddo

 

The SET line consists of three functions:

%@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

 

Here @IF is used to toggle between C and O.

 

=={{header|6502 Assembly}}==

 

'''optimized'''

inc $1 ;add 2 to delta

inc $1

adc $1

tax

 

=={{header|8086 Assembly}}==

See [[100 doors/8086 Assembly]]

 

=={{header|ABAP}}==

'''unoptimized'''

data: lv_door type i,

lv_count type i value 1.

endif.

endloop.

 

'''optimized'''

 

Using <math>\sum_{i=1}^n (2i-1) = n^2</math>

data: lv_square type i value 1,

lv_inc type i value 3.

endif.

enddo.

 

=={{header|ACL2}}==

 

(if (zp n)

nil

(if (zp i)

doors

 

=={{header|ActionScript}}==

{{works with|ActionScript|3.0}}

'''unoptimized'''

import flash.display.Sprite;

 

}

}

 

=={{header|Ada}}==

'''unoptimized'''

procedure Doors is

Put_Line(Integer'Image(I) & " is " & Door_State'Image(The_Doors(I)));

end loop;

 

'''optimized'''

with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;

end if;

end loop;

 

=={{header|Aikido}}==

var doors = new int [100]

 

}

 

 

=={{header|ALGOL 68}}==

'''unoptimized'''

 

 

'''optimized'''

=={{header|AmigaE}}==

DEF t[100]: ARRAY,

pass, door

FOR door := 0 TO 99 DO WriteF('\d is \s\n', door+1,

IF t[door] THEN 'open' ELSE 'closed')

 

=={{header|APL}}==

 

 

'''optimized'''

Note that &#9109;IO = 1

<pre>

</pre>

The idea is that the <i>n</i>:th door will be flipped the same number of times as there are divisors for <i>n</i>. So first we make D all ints 1..100 (D&#8592;&#9075;100).<br>The next step is to find the remainders of every such int when divided by every other (D&#8728;.|D).<br> This results in a 100&#215;100 matrix which we turn into a binary one by testing if the values are equal to zero i.e. divisors.<br>Next: sum along axis 1, i.e. the columns. This tells us the number of divisors. Finally calculate the remainder of these when divided by 2, i.e. find which <i>n</i> have an odd number of divisors, i.e. will be flipped an odd number of times and thus end up open.

 

=={{header|AppleScript}}==

repeat 100 times

set end of is_open to false

end

set text item delimiters to ", "

 

=={{header|Arbre}}==

openshut(n):

for x in [1..n]

100doors():

pass(1) -> io

 

=={{header|Argile}}==

 

close all doors

 

for each door from 1 to 100

 

=={{header|AutoHotkey}}==

=== Standard Approach ===

Door%A_Index% := "closed"

 

Res .= "Door " A_Index " is open`n"

}

 

=== Alternative Approach ===

 

<math>\sum_{i=1}^n (2i-1) = n^2</math>

Loop, 100

If (A_Index = square)

outstring .= "`nDoor " A_Index " is open"

,square += increment, increment += 2

=== Optimized ===

Result .= "Door " Door " is open`n"

 

=={{header|AWK}}==

'''unoptimized'''

for(i=1; i <= 100; i++)

{

print i, doors[i] ? "open" : "close"

}

'''optimized'''

for(i=1; i <= 100; i++) {

doors[i] = 0 # close the doors

print i, doors[i] ? "open" : "close"

}

 

 

 

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

 

'''unoptimized'''

FOR pass = 0 TO 99

FOR door = pass TO 99 STEP pass + 1

PRINT "open"

END IF

'''optimized'''

FOR door = 0 TO 99

IF INT(SQR(door)) = SQR(door) THEN doors(door) = -1

PRINT "open"

END IF

 

=={{header|BBC BASIC}}==

 

=={{header|Befunge}}==

{{works with|CCBI|2.1}}

*`!0\|+relet|-1`*aap81::+]

;::+1<r]!g9;>$08g1+:08paa[

 

=={{header|BlitzMax}}==

 

'''optimized'''

i=1

While ((i*i)<=100)

Wend

Flip

 

=={{header|Bracmat}}==

 

Solution 1. Use an indexable array. Local variables are stored in stacks. Each stack corresponds to one variable name and vice versa. Stacks can also be used as arrays, but because of how local variables are implemented, arrays cannot be declared as local variables.

= door step

. tbl$(doors.101) { Create an array. Indexing is 0-based. Add one extra for addressing element nr. 100 }

)

& tbl$(doors.0) { clean up the array }

 

Solution 2. Use one variable for each door. In Bracmat, a variable name can be any non-empty string, even a number, so we use the numbers 1 .. 100 as variable names, but also as door numbers. When used as variable an extra level of indirection is needed. See the occurrences of <code>?!</code> and <code>!!</code> in the following code.

= step door

. 0:?door

& tbl$(!door.0) { cleanup the variable }

)

 

Solution 3. Use a list and a dedicated positioning pattern to address the right door in the list. Create a new list by concatenating the skipped elements with the toggled elements. This solution is computationally unfavourable because of the many concatenations.

= doors door doorIndex step

. :?doors

)

& out$!doors

 

Solution 4. Use a list of objects. Each object can be changed without the need to re-create the whole list.

= doors door doorIndex step

. :?doors

)

& out$!doors

 

These four functions are called in the following way:

& 100doors-var$

& 100doors-list$

 

=={{header|C}}==

===unoptimized===

{{uses from|Library|C Runtime|component1=printf}}

 

int main()

int pass, door;

 

for (pass = 0; pass < 100; ++pass)

for (door = pass; door < 100; door += pass+1)

is_open[door] = !is_open[door];

 

for (door = 0; door < 100; ++door)

printf("door #%d is %s.\n", door+1, (is_open[door]? "open" : "closed"));

 

return 0;

 

===optimized===

 

{{uses from|Library|C Runtime|component1=printf}}

 

int main()

}

return 0;

 

The following ultra-short optimized version demonstrates the flexibility of C loops, but isn't really considered good C style:

 

 

int main()

printf("door #%d is %s.\n", door, (door == square? "open" : "closed"));

return 0;

 

 

int main()

 

return 0;

 

=={{header|C++}}==

 

'''unoptimized '''

 

int main()

std::cout << "door #" << door+1 << (is_open[door]? " is open." : " is closed.") << std::endl;

return 0;

 

'''optimized '''

This optimized version makes use of the fact that finally only the doors with square index are open, as well as the fact that <math>(n+1)^2 = 1 + 3 + 5 + \ldots + (2n+1)</math>.

 

 

int main()

}

return 0;

 

The only calculation that's really needed:

 

int main()

for(int i=1; i*i<=100; i++)

std::cout<<"Door "<<i*i<<" is open!"<<std::endl;

 

{

{

{

 

=={{header|C1R}}==

=={{header|CLIPS}}==

 

'''Unoptimized'''

 

(door-count 100)

)

(printout t crlf "All other doors are closed." crlf)

)

 

'''Optimized'''

 

(door-count 100)

)

)

(printout t crlf "All other doors are closed." crlf)

 

=={{header|Clojure}}==

'''Unoptimized / mutable array'''

(let [doors (into-array (repeat 100 false))]

(doseq [pass (range 1 101)

(aset doors i (not (aget doors i))))

doors))

(println

"Open doors after 100 passes:"

 

'''Unoptimized / functional '''

(reduce (fn [doors toggle-idx] (update-in doors [toggle-idx] not))

(into [] (repeat 100 false))

(for [pass (range 1 101)

i)))

 

(println

"Open doors after 100 passes:"

 

'''Optimized / functional'''

(reduce (fn [doors idx] (assoc doors idx true))

(into [] (repeat 100 false))

(println

"Open doors after 100 passes:"

 

=={{header|COBOL}}==

PROGRAM-ID. 100Doors.

 

DATA DIVISION.

WORKING-STORAGE SECTION.

01 DoorTable.

02 Doors PIC 9(1) OCCURS 100 TIMES.

01 Idx PIC 9(3).

 

PROCEDURE DIVISION.

Begin.

END-PERFORM

END-PERFORM

PERFORM VARYING Idx FROM 1 BY 1

UNTIL Idx > 100

DISPLAY Idx " is closed."

ELSE

END-IF

END-PERFORM

 

=={{header|CoffeeScript}}==

'''unoptimized''':

for pass in [1..100]

# matrix output

console.log doors.map (open) -> +open

 

'''optimized''':

 

 

 

'''ultra-optimized''':

 

=={{header|ColdFusion}}==

'''Basic Solution: Returns List of 100 values: 1=open 0=closed'''

doorCount = 1;

doorList = "";

loopCount = loopCount + 1;

}

 

'''Squares of Integers Solution: Returns List of 100 values: 1=open 0=closed'''

doorCount = 1;

doorList = "";

loopCount = loopCount + 1;

}

 

'''Display only'''

 

 

=={{header|Common Lisp}}==

 

'''Unoptimized / functional '''

 

 

(defun visit-every (doors num iter value1 value2)

 

(defun do-all-visits (doors cnt value1 value2)

 

(defun print-doors (doors)

 

(defun start (&optional (size 100))

 

 

 

(defun 100-doors ()

(dotimes (i 100)

(loop for j from i below 100 by (1+ i)

do (toggle (svref doors j))))

(dotimes (i 100)

 

'''Optimized '''

 

(defun open-door (doors num open)

(defun visit-all (doors vlist open)

(defun start2 (&optional (size 100))

 

'''Optimized (2) '''

 

(mapcar (lambda (x)

(if (zerop (mod (sqrt (incf i)) 1))

"_" "#"))

 

=={{header|D}}==

 

 

else

return doors;

}

 

return doors;

}

 

void main() {

auto doors = new Doors(100);

 

{{out}}

 

=={{header|Dart}}==

'''unoptimized'''

for (var k = 1, x = new List(101); k <= 100; k++) {

for (int i = k; i <= 100; i += k)

if (x[k]) print("$k open");

}

 

'''optimized version''' (including generating squares without multiplication)

for(int i=1,s=3;i<=100;i+=s,s+=2)

print("door $i is open");