100 doors: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

L(i) 100

L(j) (i .< 100).step(i + 1)

 

=={{header|360 Assembly}}==

HUNDOOR CSECT

USING HUNDOOR,R12

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

 

@echo off

set doors=%@repeat[C,100]

 

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

'''unoptimized'''

Based on BASIC QB64 unoptimized version

; Written for the original MOS Technology, Inc. NMOS version of the 6502, but should work with any version.

; Based on BASIC QB64 unoptimized version: http://rosettacode.org/wiki/100_doors#BASIC

Largely inspired by the optimized C implementation - makes use of the fact that finally only the doors whose numbers are squares of integers are open, as well as the fact that

<math>n^2 = 1 + 3 + 5 + \ldots + (2n-1)</math>.

;the 1 to 100 door byte array will be at $0200-$0263 (decimal 512 to 611)

;Zero-page location $01 will hold delta

{{works with|http://www.easy68k.com/ EASy68K v5.13.00}}

Some of the macro code is derived from the examples included with EASy68K.

* Title : 100Doors.X68

* Written by : G. A. Tippery

=={{header|8080 Assembly}}==

 

doors: equ 100 ; 100 doors

puts: equ 9 ; CP/M string output

 

=={{header|8th}}==

\ Array of doors; init to empty; accessing a non-extant member will return

\ 'null', which is treated as 'false', so we don't need to initialize it:

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

'''unoptimized'''

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program 100doors64.s */

</syntaxhighlight>

'''optimized'''

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program 100doors64_1.s */

=={{header|ABAP}}==

'''unoptimized'''

data: lv_door type i,

lv_count type i value 1.

 

'''unoptimized / functional'''

cl_demo_output=>display( REDUCE stringtab( INIT list TYPE stringtab

aux TYPE i

 

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

data: lv_square type i value 1,

lv_inc type i value 3.

 

'''ultra-optimized / imperative'''

DO 10 TIMES.

DATA(val) = sy-index * sy-index.

 

'''ultra-optimized / functional'''

cl_demo_output=>display( REDUCE stringtab( INIT list TYPE stringtab

FOR i = 1 WHILE i <= 10

NEXT list = VALUE #( BASE list ( i * i ) ) ) ).

</syntaxhighlight>

 

=={{header|ACL2}}==

 

(if (zp n)

nil

 

=={{header|Action!}}==

 

PROC Main()

{{works with|ActionScript|3.0}}

'''unoptimized'''

import flash.display.Sprite;

 

Using #HASH-OFF, OPTION OICC ="^" , CICC ="^"

</pre>

VAR sStatus: SHORT

VAR sArray: SHORT

=={{header|Ada}}==

'''unoptimized'''

procedure Doors is

 

'''optimized'''

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

=={{header|Agena}}==

Translation of Algol W. Tested with Agena 2.9.5 Win32

scope

 

 

=={{header|Aikido}}==

var doors = new int [100]

 

=={{header|ALGOL 60}}==

{{works with|A60}}

 

{{out}}

<pre>

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

'''unoptimized'''

 

 

'''optimized'''

 

=={{header|ALGOL W}}==

 

{{out}}

<pre>

 

=={{header|ALGOL-M}}==

BEGIN

 

 

=={{header|AmigaE}}==

DEF t[100]: ARRAY,

pass, door

{{works with|GNU APL}}

 

≠⌿⊃doors¨ ⍳100</syntaxhighlight>

 

'''optimized'''

 

{{works with|Dyalog APL}}

{{out}}

<pre>

 

=={{header|AppleScript}}==

===Iteration===

 

repeat 100 times

set end of is_open to false

display dialog "Open doors: " & open_doors</syntaxhighlight>

 

===Functional composition===

 

 

-- finalDoors :: Int -> [(Int, Bool)]

end zip</syntaxhighlight>

{{Out}}

 

===Odd numbers of integer factors===

The question of which doors are flipped an odd number of times reduces to the question of which numbers in the range have an odd number of integer factors (for an AppleScript implementation of integerFactors(n) see Factors of An Integer). Using '''map''' from the functional composition example above:

 

 

on factorCountMod2(n)

This, on inspection, and further reflection, then collapses to the even simpler question of which numbers are perfect squares, since all other numbers have an even number of integer factors (n factors below the square root, plus n paired cofactors above the square root). Using '''map''' and '''enumFromTo''' from the functional composition example above:

 

on perfectSquaresUpTo(n)

script squared

end run</syntaxhighlight>

{{Out}}

 

=={{header|Arbre}}==

openshut(n):

for x in [1..n]

 

=={{header|Argile}}==

 

close all doors

 

'''unoptimized'''

 

/* ARM assembly Raspberry PI */

</syntaxhighlight>

'''optimized'''

/*********************************************/

/* optimized version */

 

=={{header|Arturo}}==

loop 1..100 'pass ->

 

=={{header|Astro}}==

 

for a in 1..100: for b in a..a..100:

 

=={{header|Asymptote}}==

if (i % i^2 < 11) {

write("Door ", i^2, suffix=none);

 

=={{header|ATS}}==

#include "share/atspre_staload.hats"

 

=={{header|AutoHotkey}}==

=== Standard Approach ===

Door%A_Index% := "closed"

 

 

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

Loop, 100

If (A_Index = square)

MsgBox,, Succesfull, % SubStr(outstring, 2)</syntaxhighlight>

=== Optimized ===

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

MsgBox, %Result%</syntaxhighlight>

 

=={{header|AutoIt}}==

#include <array.au3>

$doors = 100

=={{header|AWK}}==

'''unoptimized'''

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

{

}</syntaxhighlight>

'''optimized'''

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

doors[i] = 0 # close the doors

 

=={{header|Axiom}}==

doors := bits(100,closed);

for i in 1..#doors repeat

doors.j := change doors.j

[i for i in 1..#doors | open? doors.i]

[i^2 for i in 1..sqrt(100)::Integer]</syntaxhighlight>

 

=={{header|B}}==

{{works with|The Amsterdam Compiler Kit - B|V6.1pre1}}

{

auto doors[100]; /* != 0 means open */

return(0);

}</syntaxhighlight>

 

=={{header|BaCon}}==

OPTION BASE 1

 

81

100

</pre>

 

==={{header|Applesoft BASIC}}===

Based on the Sinclair ZX81 BASIC implementation.

100 :

110 REM 100 DOORS PROBLEM

 

==={{header|BASIC256}}===

dim d(100)

 

 

'''ultra optimizado''': portado desde la versión Julia<br>

for i = 1 to 10 : if i % i^2 < 11 then print "La puerta "; int(i^2); " esta abierta" : end if : next i : end

</syntaxhighlight>

 

 

==={{header|Commodore BASIC}}===

Based on the Sinclair ZX81 BASIC implementation.

20 FOR I=1 TO 100

30 FOR J=I TO 100 STEP I

80 IF D(I) THEN PRINT I,

90 NEXT I</syntaxhighlight>

 

==={{header|IS-BASIC}}===

110 NUMERIC D(1 TO 100)

120 FOR I=1 TO 100

220 NEXT</syntaxhighlight>

Optimized:

110 LET NR=1:LET D=3

120 DO

140 LET NR=NR+D:LET D=D+2

150 LOOP WHILE NR<=100</syntaxhighlight>

 

===QBasic===

{{works with|QBASIC, QB64}}

'''unoptimized'''

REM Author: G. A. Tippery

REM Date: 12-Feb-2014

 

'''unoptimized'''

FOR pass = 0 TO 99

FOR door = pass TO 99 STEP pass + 1

NEXT i</syntaxhighlight>

'''optimized'''

FOR door = 0 TO 99

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

END IF

NEXT i</syntaxhighlight>

 

==={{header|Sinclair ZX81 BASIC}}===

Works with only 1k of RAM, although it doesn't leave too much to play with.

20 FOR I=1 TO 100

30 FOR J=I TO 100 STEP I

80 IF D(I) THEN PRINT I,

90 NEXT I</syntaxhighlight>

 

=={{header|Batch File}}==

 

'''unoptimized'''

@echo off

setlocal enableDelayedExpansion

 

'''optimized'''

@echo off

setlocal enableDelayedExpansion

 

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

FOR pass% = 1 TO 100

FOR door% = pass% TO 100 STEP pass%

 

=={{header|bc}}==

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

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

 

=={{header|BCPL}}==

 

let start() be

====Unoptimized====

Requires an interpreter with working read-write memory support. Padding the code page with extra blank lines can sometimes help.

$.v_^#!$::$_^#`"c":+g00p+9/9\%<

::<_@#`$:\*:+55:+1p27g1g+9/9\%9

====Optimized====

Just calculates the first 10 perfect squares.

</syntaxhighlight>

 

===Befunge-98===

{{works with|CCBI|2.1}}

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

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

*`#@_^._aa</syntaxhighlight>

 

=={{header|Blade}}==

===Unoptimized version===

for i in 0..100 {

iter var j = i; j < 100; j += i + 1 {

 

===Optimized version===

echo 'Door ${i} is ${i ** 0.5 % 1 > 0 ? "closed" : "open"}'

}</syntaxhighlight>

 

===Ultra-optimized version===

 

=={{header|BlitzMax}}==

 

'''optimized'''

i=1

While ((i*i)<=100)

=={{header|BlooP}}==

The currently available BlooP interpreters don't really allow iterating over cells with any level of ease, so instead I loop over each door in turn, running it through all 100 cycles and toggling it when it is a multiple of the step number.

DEFINE PROCEDURE ''DIVIDE'' [A,B]:

BLOCK 0: BEGIN

 

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 }

 

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

 

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

 

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

 

These four functions are called in the following way:

& 100doors-var$

& 100doors-list$

Version using square numbers:

 

blsq ) 10ro2?^

{1 4 9 16 25 36 49 64 81 100}

 

=={{header|BQN}}==

¯1↓∾{𝕩∾@+10}¨•Fmt¨⟨swch,/swch⟩</syntaxhighlight>

⟨ 0 3 8 15 24 35 48 63 80 99 ⟩"</syntaxhighlight>

 

The second line then formats the boolean array and the truthy indices into a string for display.

===unoptimized===

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

 

int main()

Using defensive programming, pointers, sentinel values and some other standard programming practices,

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

 

#define NUM_DOORS 100

 

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

 

int main()

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

 

 

int main()

}</syntaxhighlight>

 

 

int main()

 

===Unoptimized with Modulus % Operator===

{

using System;

===Optimized for Orthogonality===

(This version demonstrates a different thought pattern during development, where operation and presentation are separated. It could easily be refactored so that the operations to determine which doors are opened and to display the list of doors would be in separate methods, at which point it would become simple to extract them to separate classes and employ a DI pattern to switch the algorithm or display mechanism being used. It also keeps the calculation clear and concise.)

{

using System;

 

===Unoptimized but Concise===

{

using System;

 

===Optimized for brevity===

{

using System;

===Optimized for Flexibility===

This version supports altering the number of doors through console commands. Its main intent is to be flexible and easy to use.

using System;

using System.IO;

 

'''unoptimized '''

 

int main()

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()

 

The only calculation that's really needed:

 

int main()

 

Compile time computation using C++17 to produce fastest runtime.

#include <type_traits> // or g++ (GCC) 7.3.1 20180406 -- from hare1039

namespace functional_list // basic building block for template meta programming

 

=={{header|C1R}}==

 

=={{header|Caché ObjectScript}}==

for i=1:1:100 {

set doors(i) = 0

</syntaxhighlight>

Output:

1: open

4: open

 

=={{header|Ceylon}}==

print("Open doors (naive): ``naive()``

Open doors (optimized): ``optimized()``");

 

=={{header|Clarion}}==

program

 

'''Unoptimized'''

 

if step > 100: doors

else:

'''Optimized'''

 

i ^ 0.5

-> eq @ (transform i: floor)

'''Unoptimized'''

 

(door-count 100)

)

'''Optimized'''

 

(door-count 100)

)

=={{header|Clojure}}==

'''Unoptimized / mutable array'''

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

(doseq [pass (range 1 101)

 

'''Unoptimized / functional '''

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

(into [] (repeat 100 false))

 

'''Alternative Unoptimized / functional '''

(->> (for [step (range 1 101), occ (range step 101 step)] occ)

frequencies

 

'''Optimized / functional'''

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

(into [] (repeat 100 false))

 

'''Alternative Optimized / functional'''

 

(defn print-open-doors []

 

=={{header|CLU}}==

max = 100

po: stream := stream$primary_output()

 

=={{header|COBOL}}==

PROGRAM-ID. 100Doors.

 

We use the naive algorithm.

 

 

for pass til doors.length

=={{header|CoffeeScript}}==

'''unoptimized''':

for pass in [1..100]

'''optimized''':

 

 

console.log door for door in [1..100] when isInteger Math.sqrt door</syntaxhighlight>

 

'''ultra-optimized''':

 

=={{header|ColdFusion}}==

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

doorCount = 1;

doorList = "";

 

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

doorCount = 1;

doorList = "";

 

'''Display only'''

<cfloop from="1" to="100" index="x">

Door #x# Open: #YesNoFormat(ListGetAt(doorList,x))#<br />

 

'''Another Route'''

<cfloop from="1" to="100" index="i">

<Cfset doorlist = doorlist & 'c,'>

 

=={{header|Comal}}==

0020 FOR pass#:=1 TO 100 DO

0030 FOR door#:=pass# TO 100 STEP pass# DO doors#(door#):=NOT doors#(door#)

 

=={{header|Commodore BASIC}}==

10 D=100: DIMD(D): P=1

20 PRINT CHR$(147);"PASS: ";P

It emphasizes the functional way of solving this problem.

 

"visits a door, swapping the value1 to value2 or vice-versa"

(let ((d (copy-list doors))

This is a version that closely follows the problem description and is still quite short. Of all the presented solutions it might be closest to "idiomatic Common Lisp".

 

 

(defun 100-doors ()

 

'''Unoptimized, ''' n-doors.

(if (> n z) w (doors z (toggle w n z) (1+ n))))

 

 

'''Optimized, ''' n-doors.

(loop for a from 1 to n collect

(zerop (mod (sqrt a) 1))))

This is an optimized version, using the perfect square algorithm.

 

(let ((doors (make-array 100)))

(dotimes (i 10)

Another optimized version, with finer granular separation of functionality (might be a bit excessive).

 

"Generates a list of perfect squares from 0 up to n"

(loop for i from 1 to (isqrt n) collect (expt i 2)))

This version displays a much more functional solution through the use of MAPCAR.

 

(mapcar (lambda (x)

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

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Doors100;

IMPORT StdLog;

=={{header|Coq}}==

Basic solution:

 

Fixpoint rep {A} (a : A) n :=

 

Optimized version ((n+1)^2 = n^2 + 2n + 1):

 

Fixpoint prisoo' nd n k accu :=

 

Unit test:

 

Full proof at [https://github.com/spanjel/rosetta github]:

 

=={{header|Cowgol}}==

 

 

var doors: uint8[101]; # one extra so we can start at 1

100 is open</pre>

 

 

=={{header|Crystal}}==

 

1.upto(100) do |i|

=={{header|D}}==

===Unoptimized===

const N = 101; // #doors + 1

void main() {

This optimized version prints these squares using an alternative algorithm based on <math>\sum_{i=1}^n (2i-1) = n^2</math>

 

const N = 101; // #doors + 1

void main() {

 

===Other proposals===

 

enum DoorState : bool { closed, open }

'''Unoptimized. Demonstrates very basic language syntax/features.

Program output allows to see what the code is doing:'''

import std.stdio;

 

The InitializeDoors function demonstrates some of Dafny's advanced features.

 

datatype Door = Closed | Open

 

=={{header|Dart}}==

'''unoptimized'''

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

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

 

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

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

print("door $i is open");

 

'''comprehensible (not "code golf") version for a pedestrian language'''

 

final numDoors = 100;

'''Unoptimized''':

{{works with|GNU dc|1.3.95}}

## NB: This code uses the dc command "r" via register "r".

## You may comment out the unwanted version.

=={{header|DCL}}==

'''Adapted from optimized Batch example'''

$! doors.com

$! Excecute by running @doors at prompt.

 

=={{header|Draco}}==

byte DOORS = 100;

[DOORS+1] bool door_open;

 

=={{header|DUP}}==

%

[s;[$101<][$$;~\:s;+]#%]d: {function d, switch door state function}

Result:

 

2 closed

3 closed

=={{header|DWScript}}==

'''Unoptimized'''

var i, j : Integer;

 

Outputs only open doors to save up space:

 

for p in 0..99 {

=={{header|Dylan}}==

'''Unoptimized'''

doors[y] := ~doors[y]

end

end;

end

end

 

=={{header|Déjà Vu}}==

 

for i range 1 100:

This version animates the changes of the doors (as checkboxes).

 

 

var toggles := []

 

=={{header|EasyLang}}==

for p = 1 to 100

.

for i = 1 to 100

 

=={{header|EchoLisp}}==

The result is obviously the same in we run the process backwards. So, we check the state of each door during the 100-th step (opening/closing every door)

; initial state = closed = #f

(define doors (make-vector 101 #f))

'''optimized version'''

 

Doors := RECORD

UNSIGNED1 DoorNumber;

'''unoptimized version - demonstrating LOOP'''

 

Doors := RECORD

UNSIGNED1 DoorNumber;

This is a bit more efficient than the LOOP version

 

DoorSet := DATASET(100,TRANSFORM({UNSIGNED1 DoorState},SELF.DoorState := 1));

SetDoors := SET(DoorSet,DoorState);

PROJECT(Res,TRANSFORM({STRING20 txt},SELF.Txt := 'Door ' + COUNTER + ' is ' + IF(LEFT.DoorState=1,'Open','Closed')));

</syntaxhighlight>

 

=={{header|EDSAC order code}}==

orders (instructions). This would be considered bad practice today,

but was quite usual on the EDSAC.

[Hundred doors problem from Rosetta Code website]

[EDSAC program, Initial Orders 2]

 

=={{header|Eero}}==

#import <Foundation/Foundation.h>

 

=={{header|Egel}}==

 

import "prelude.eg"

 

=={{header|EGL}}==

 

program OneHundredDoors

 

 

'''file: application.e'''

description: "100 Doors problem"

date: "08-JUL-2015"

 

'''file: door.e'''

description: "A door with an address and an open or closed state."

date: "08-JUL-2015"

'''Standard Approach'''

 

 

type Door = Open | Closed

 

'''Alternate Approach'''

run n = takeWhile (<n) [& k*k \\ k <- [1..]]</syntaxhighlight>

 

=={{header|Elena}}==

import extensions;

 

public program()

{

{

{

Doors[j] := Doors[j].Inverted

};

{

console.printLine("Door #",i + 1," :",Doors[i].iif("Open","Closed"))

 

=={{header|Elixir}}==

def doors(n \\ 100) do

List.duplicate(false, n)

 

=={{header|Elm}}==

import List exposing (indexedMap, foldl, repeat, range)

import Html exposing (text)

'''Unoptimized'''

 

"Returns a list of closed doors

 

;; Print the final solution on the buffer

(print-doors (main-program))</syntaxhighlight>

 

=={{header|Erlang}}==

'''non-optimized'''

-module(hundoors).

 

</syntaxhighlight>

 

 

'''optimized'''

F = fun(X) -> Root = math:pow(X,0.5), Root == trunc(Root) end,

Out = fun(X, true) -> io:format("Door ~p: open~n",[X]);

=={{header|ERRE}}==

 

! "100 Doors" program for ERRE LANGUAGE

! Author: Claudio Larini

END PROGRAM

</syntaxhighlight>

 

=={{header|Euler Math Toolbox}}==

>function Doors () ...

$ doors:=zeros(1,100);

=={{header|Euphoria}}==

unoptimised

include std/console.e

sequence doors

 

Cell C2:

=IF($A2/C$1=INT($A2/C$1),IF(B2=0,1,IF(B2=1,0)),B2)

</syntaxhighlight>

Cell C3:

=IF($A3/C$1=INT($A3/C$1),IF(B3=0,1,IF(B3=1,0)),B3)

</syntaxhighlight>

Cell D2:

=IF($A2/D$1=INT($A2/D$1),IF(C2=0,1,IF(C2=1,0)),C2)

</syntaxhighlight>

 

=={{header|F_Sharp|F#}}==

</syntaxhighlight>

Following is the solution using perfect squares. The coercions in PerfectSquare are, I believe, slightly different in versions prior to 2010 beta and, again, #light is required in those versions.

let answer2 =

let PerfectSquare n =

 

Simple single line solution using nothing but List

[1..100] |> List.fold (fun doors pass->List.mapi (fun i x->if ((i + 1) % pass)=0 then not x else x) doors) (List.init 100 (fun _->false))

</syntaxhighlight>

=={{header|Factor}}==

'''Unoptimized'''

sequences ;

IN: rosetta.doors

 

'''Optimized'''

USING:

formatting

=={{header|Falcon}}==

'''Unoptimized code'''

 

for pass in [ 0 : doors.len() ]

</syntaxhighlight>

'''Optimized code'''

for door in [ 1 : 101 ]: > "Door ", $door, " is: ", fract( door ** 0.5 ) ? "closed" : "open"</syntaxhighlight>

 

=={{header|FALSE}}==

%

[s;[$101\>][$$;~\:s;+]#%]d: {function d, switch door state function}

Result:

 

2 closed

3 closed

=={{header|Fantom}}==

'''Unoptimized'''

states := (1..100).toList

100.times |i| {

</syntaxhighlight>

'''Optimized'''

echo("Open doors are " + (1..100).toList.findAll { it.toFloat.pow(0.5f).toInt.pow(2) == it})

</syntaxhighlight>

=={{header|FBSL}}==

'''Unoptimised'''

 

Dim doors[], n As Integer = 100

Pause</syntaxhighlight>

'''Optimised''' (by ML)

 

DIM i = 0, j = 0, door = 1

 

PAUSE</syntaxhighlight>

=={{header|Fhidwfe}}==

unoptomized

doors = malloc$ 100u

for uint [0u, sizeof$ doors) with l1 {

 

'''Unoptimized'''

>0101-p02.

>101-g001-g+:::aa*)?v101-p03.

 

=={{header|FOCAL}}==

1.2 F M=1,100;F N=M,M,100;S D(N)=1-D(N)

1.3 F N=1,100;D 2.0

 

'''Unoptimized'''

dup c@ 1 xor swap c! ;

 

 

'''Optimized'''

: doors ( n -- )

1 begin 2dup squared >= while

'''unoptimized'''

 

implicit none

integer, allocatable :: door(:)

'''optimized'''

 

 

INTEGER, PARAMETER :: n = 100 ! Number of doors

 

=={{header|Free Pascal}}==

program OneHundredIsOpen;

 

=={{header|FreeBASIC}}==

===Toggle===

' compile with: fbc -s console

 

There are 10 doors open</pre>

===Count===

' compile with: fbc -s console

 

Output is the same as the first version.

=== Optimized===

' compile with: fbc -s console

 

 

===Ultra optimizado===

' portado desde Julia

 

 

'''Unoptimized'''

set doors

 

 

'''Optimized'''

set doors

 

 

=={{header|Frink}}==

doors = new array[[101], false]

for pass=1 to 100

print["$door "]

</syntaxhighlight>

 

=={{header|FunL}}==

=== Unoptimized ===

r = foldl1( \a, b -> a xor b, [(a|i) | a <- 1..100] )

println( i + ' ' + (if r then 'open' else 'closed') )</syntaxhighlight>

 

=== Optimized ===

 

for i <- 1..100

 

 

let main(n: i32): [n]bool =

loop is_open = replicate n false for i < n do

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

 

Output:

Door 1 is open.

Door 2 is closed.

 

=={{header|FUZE BASIC}}==

PRINT "Open doors: ";x;" ";

CYCLE

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=10f109e90581b04b9cbc30fdaf49892b Click this link to run this code]'''

Dim bDoor As New Boolean[101]

Dim siCount1, siCount2, siStart As Short

 

=={{header|GAP}}==

local a,j,s;

a := [ ];

 

=={{header|GDScript}}==

var doors : Array

doors.resize(door_count)

=={{header|Genie}}==

 

// 100 doors problem

// Author: Sinuhe masan (2019)

 

=={{header|Glee}}==

:for (1..100[.s]){ $$ loop s from 1 to 100

d^(100` %s *=0 )=>d;} $$ d = d xor (bit pattern of vector 1..100 % s)

The resulting output is the bit pattern showing the state of the 100 doors:

 

10010000 10000001 00000000 10000000 00010000 00000000 10000000 00000001 00000000 00000000 10000000 00000000 0001</syntaxhighlight>

 

=={{header|GML}}==

//Sets up the array for all of the doors.

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

=={{header|Go}}==

'''unoptimized'''

 

import "fmt"

</pre>

'''optimized'''

 

import "fmt"

 

'''optimized 2'''

 

package main

 

=={{header|Golfscript}}==

c,{.c,>\)%{.d<\.d=1^\)d>++:d;}/}/

[c,{)"door "\+" is"+}%d{{"open"}{"closed"}if}%]zip

added easily; the code was tested using a work-in-progress C interpreter

for a language compatible enough with Golfscript)

{:d.sqrt 2?=

{"open"}{"close"}if"door "d+" is "+\+puts}/</syntaxhighlight>

 

'''optimized without sqrt'''

10,{)2?(.d<\["open"]\)d>++:d;}/

[100,{)"door "\+" is"+}%d]zip

=={{header|Gosu}}==

'''unoptimized'''

uses java.util.Arrays

 

 

'''optimized'''

var door = 1

var delta = 0

=={{header|Groovy}}==

'''unoptimized'''

(0..99).each {

it.step(100, it + 1) {

Using square roots

 

println("Door #${it} is ${Math.sqrt(it).with{it==(int)it} ? 'open' : 'closed'}.")

}</syntaxhighlight>

'''optimized b'''

Without using square roots

(1..10).each { doors[it**2 - 1] = 'open' }

(0..99).each {

 

=={{header|GW-BASIC}}==

20 FOR OFFSET = 1 TO 100

30 FOR I = 0 TO 100 STEP OFFSET

 

'''Unoptimized code:'''

PROCEDURE Main()

LOCAL aDoors := Array( ARRAY_ELEMENTS )

 

'''Optimized code'''

PROCEDURE Main()

LOCAL aDoors := Array( ARRAY_ELEMENTS )

 

=={{header|Haskell}}==

= Open

| Closed

<pre>[(1,Open),(4,Open),(9,Open),(16,Open),(25,Open),(36,Open),(49,Open),(64,Open),(81,Open),(100,Open)]</pre>

 

(without using square roots)

gate (x:xs) (y:ys) | x == y = Open : gate xs ys

gate (x:xs) ys = Closed : gate xs ys

run n = gate [1..n] [k*k | k <- [1..]]</syntaxhighlight>

 

 

 

=={{header|Haxe}}==

{

static public function main()

while((i*i) <= n)

{

i++;

}

=={{header|HicEst}}==

Unoptimized

 

door = 1 - open ! = closed

DLG(Text=door, TItle=SUM(door)//" doors open") </syntaxhighlight>

Optimized

DO i = 1, n^0.5

door(i*i) = open

=={{header|HolyC}}==

{{trans|C}}

U8 pass = 0, door = 0;

 

 

=={{header|Hoon}}==

=/ doors=(list ?) (reap 100 %.n)

=/ passes=(list (list ?)) (turn (gulf 1 100) pass-n)

 

=={{header|Huginn}}==

exec huginn --no-argv -E "${0}"

#! huginn

{{trans|Coco}}

 

 

(for [pass (range (len doors))]

 

=={{header|I}}==

var doors = len(100)

 

'''Unoptimized solution.'''

procedure main()

door := table(0) # default value of entries is 0

 

'''Optimized solution.'''

procedure main()

every write("Door ", i := 1 to 100, " is ", if integer(sqrt(i)) = sqrt(i) then "open" else "closed")

or

 

dMap := table("closed")

every dMap[(1 to sqrt(100))^2] := "open"

 

=={{header|Idris}}==

 

-- Creates list from 0 to n (not including n)

{{works with|Z-machine|8}}

{{works with|Glulx virtual machine}}

 

A toggle door is a kind of thing.

 

=={{header|Informix 4GL}}==

MAIN

DEFINE

END MAIN

</syntaxhighlight>

 

=={{header|Io}}==

simple boolean list solution:

100 repeat(doors append(false))

for(i,1,100,

doors foreach(i, x, if(x, "Door #{i + 1} is open" interpolate println))</syntaxhighlight>

Optimized solution:

Sample output:<pre>Door 1 is open.

Door 4 is open.

=={{header|Ioke}}==

'''Unoptimized Object Oriented solution.'''

 

NDoors Toggle = Origin mimic do(

 

=={{header|Isabelle}}==

imports Main

begin

=={{header|J}}==

'''unoptimized'''

1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 ...

~:/ 0=|/~ >:i.100 NB. alternative

'''optimized'''

1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 ...

1 (<:*:i.10)} 100$0 NB. alternative

 

'''with formatting'''

these doors are open: 1 4 9 16 25 36 49 64 81 100

</syntaxhighlight>

=={{header|Janet}}==

 

(def doors (seq [_ :range [0 100]] false))

 

=={{header|Java}}==

=== With an array of boolean ===

public static void main(String[] args) {

boolean[] doors = new boolean[101];

 

=== With a BitSet ===

 

public class HundredDoors {

=== Only print the result ===

 

public static void main(String[] args) {

for (int i = 1; i <= 10; i++)

 

'''If only printing the result is required, using streams.'''

import java.util.stream.IntStream;

 

=== ES5 ===

==== Iterative ====

for (var i=0;i<100;i++)

doors[i]=false;

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

doors[i2]=!doors[i2];

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

console.log("Door %d is %s",i,doors[i-1]?"open":"closed")</syntaxhighlight>

====Functional Composition====

Naive search

"use strict";

function finalDoors(n) {

})(100);</syntaxhighlight>

==== Optimized (iterative)====

var sqrt = Math.sqrt(door);

if (sqrt === (sqrt | 0)) {

}</syntaxhighlight>

Simple for loop. Optimizing the optimized?

console.log("Door %d is open",i*i);

}</syntaxhighlight>

The question of which doors are flipped an odd number of times reduces to the question of which numbers have an odd number of integer factors.

We can simply search for these:

"use strict";

return range(1, 100)

})(100);</syntaxhighlight>

Or we can note, on inspection and further reflection, that only perfect squares have odd numbers of integer factors - all other numbers have only matched pairs of factors - low factors below the non-integer square root, and the corresponding quotients above the square root. In the case of perfect squares, the additional integer square root (not paired with any other factor than itself) makes the total number of distinct factors odd.

"use strict";

return perfectSquaresUpTo(100);

=== ES6 ===

 

Array.apply(null, { length: 100 })

.map((v, i) => i + 1)

}

});</syntaxhighlight>

[ for (i of Array.apply(null, { length: 100 })) i ].forEach((_, i) => {

var door = i + 1

 

if (sqrt === (sqrt | 0)) {

}

});</syntaxhighlight>

Or using a more general function for listing perfect squares:

 

{{Out}}

 

 

 

{{works with|JavaScript|Node.js 16.13.0 (LTS)}}

 

 

// Doors can be open or closed.

=={{header|jq}}==

jq arrays have 0 as their index origin, but in the following, the 100 doors are numbered from 1 to 100.

def doors(n):

 

 

</syntaxhighlight>

def solution:

range(1;11) | "Door \(. * .) is open";

* string concatenation by '*'.

<br>

for a in 1:100, b in a:a:100

doors[b] = !doors[b]

 

'''Gimmicky-optimized''':

 

=={{header|K}}==

 

=={{header|Klingphix}}==

 

%n 100 !n

=={{header|Klong}}==

===unoptimized===

flip::{,/{(1-*x),1_x}'x:#y}

i::0;(100{i::i+1;flip(i;x)}:*100:^0)?1

 

===optimized===

(1+!9)^2

</syntaxhighlight>

 

=={{header|Kotlin}}==

doors[j] = !doors[j]

}

}

return doors

 

=={{header|KQL}}==

| extend DoorsVisited=range(InitialDoor, 100, InitialDoor)

| mvexpand DoorVisited=DoorsVisited to typeof(int)

{{VI solution|LabVIEW_100_doors.png}}

 

 

Translation from Python

 

1) unoptimized version

 

-> 1 4 9 16 25 36 49 64 81 100

</syntaxhighlight>

 

=={{header|langur}}==

=== not optimized ===

 

}

}

 

 

Or, we could use the foldfrom() function to produce the output.

 

=== optimized ===

 

{{out}}

=={{header|Lasso}}==

=== Loop ===

local(root = math_sqrt(loop_count))

local(state = (#root == math_ceil(#root) ? '<strong>open</strong>' | 'closed'))

 

=={{header|Latitude}}==

 

doors := Object clone.

This implementation defines 100 variables, named "1 through "100, rather than using a list. Thanks to Pavel Boytchev, the author of Lhogho, for help with the code.

 

;Problem 100 Doors

;Lhogho

 

=={{header|Liberty BASIC}}==

for pass = 1 to 100

for door = pass to 100 step pass

 

=={{header|Lily}}==

 

for i in 0...99:

=={{header|xTalk}}==

{{works with|HyperCard}} {{works with|LiveCode}}

on mouseUp

repeat with tStep = 1 to 100

 

;Problem 100 Doors

;FMSLogo

 

=={{header|LOLCODE}}==

 

I HAS A doors ITZ A BUKKIT

 

=={{header|Lua}}==

 

for pass = 1,100 do

 

 

Module Doors100 {

Dim Doors(1 to 100)

 

=={{header|M4}}==

define(`_get', `defn(`$1[$2]')')dnl

define(`for',`ifelse($#,0,``$0'',`ifelse(eval($2<=$3),1,

for(`x',`1',upper,`1',`door x is _get(`door',x)

')dnl</syntaxhighlight>

 

=={{header|MAD}}==

 

DIMENSION OPEN(100)

PRINT COMMENT $ $

DOOR 100 IS OPEN.</pre>

 

 

=={{header|Maple}}==

 

NDoors := proc( N :: posint )

# Initialise, using 0 to represent "closed"

</syntaxhighlight>

To solve the problem, call it with 100 as argument (output not shown here).

> NDoors( 100 );

</syntaxhighlight>

Here is the optimised version, which outputs only the open doors.

> seq( i^2, i = 1 .. isqrt( 100 ) );

1, 4, 9, 16, 25, 36, 49, 64, 81, 100

</syntaxhighlight>

Alternatively,

> [seq]( 1 .. 10 )^~2;

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

=={{header|Mathematica}}/{{header|Wolfram Language}}==

'''unoptimized 1'''

tmp=ConstantArray[-1,n];

Do[tmp[[i;;;;i]]*=-1;,{i,n}];

 

'''unoptimized 2'''

Do[Do[If[f[n] == "Closed", f[n] = "Open", f[n] = "Closed"], {n, k, 100, k}], {k, 1, 100}];

Table[f[n], {n, 1, 100}]</syntaxhighlight>

 

Mathematica also supports immutable data paradigms, like so:

Fold[

ReplacePart[#1, (i_ /; Mod[i, #2] == 0) :> (-#1[[i]])] &,

 

'''optimized 1'''

 

'''optimized 2'''

a=Range[1,Sqrt[n]]^2

Do[Print["door ",i," is ",If[MemberQ[a,i],"open","closed"]],{i,100}]</syntaxhighlight>

 

'''optimized 3'''

nn=1

a=0

These will only give the indices for the open doors:

'''unoptimized 2'''

 

'''optimized 4'''

 

=={{header|MATLAB}} / {{header|Octave}}==

===Iterative Method===

'''Unoptimized'''

for b=1:100

for i = b:b:100

</syntaxhighlight>

'''Optimized'''

for x=1:100;

if sqrt(x) == floor(sqrt(x))

end

a

</syntaxhighlight>

'''More Optimized'''

a = zeros(100,1);

for counter = 1:sqrt(100);

 

===Vectorized Method===

 

%Initialize the doors, make them booleans for easy vectorization

 

===Known-Result Method===

doors((1:10).^2) = 1;

 

 

=={{header|Maxima}}==

v: makelist(true, n),

for i: 2 thru n do

sublist_indices(v, 'identity));</syntaxhighlight>

Usage:

/* [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] */</syntaxhighlight>

 

=={{header|MAXScript}}==

'''unoptimized'''

 

for pass in 1 to 100 do

)</syntaxhighlight>

'''optimized'''

(

root = pow i 0.5

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

 

=={{header|Metafont}}==

for i = 1 upto 100: doors[i] := false; endfor

for i = 1 upto 100:

=={{header|Microsoft Small Basic}}==

{{trans|GW-BASIC}}

For offset = 1 To 100

For i = 0 To 100 Step offset

 

Using a map to hold the set of open doors:

for p in range(1, 100)

for t in range(p, 100, p)

 

Using an array of boolean values to keep track of door state, and a separate list of indexes of the open doors:

open = []

for p in range(1, 100)

 

=={{header|MIPS Assembly}}==

doors: .space 100

num_str: .asciiz "Number "

=={{header|Mirah}}==

 

 

class Door

end

</syntaxhighlight>

 

=={{header|mIRC Scripting Language}}==

while (%m <= 100) {

var %n = 1

 

=={{header|ML/I}}==

"" 100 doors

MCINS %.

=={{header|Modula-2}}==

'''unoptimized'''

IMPORT InOut;

 

 

'''optimized'''

IMPORT InOut;

 

=={{header|Modula-3}}==

'''unoptimized'''

 

IMPORT IO, Fmt;

'''optimized'''

 

 

IMPORT IO, Fmt;

 

=={{header|MontiLang}}==

 

for l 0 endfor

 

=={{header|MOO}}==

for pass in [1..100]

for door in [pass..100]

 

=={{header|MoonScript}}==

for pass = 1,100

 

=={{header|MUMPS}}==

For door=1:1:100 Set door(door)=0

For pass=1:1:100 For door=pass:pass:100 Set door(door)='door(door)

 

=={{header|Myrddin}}==

use std

 

=={{header|MySQL}}==

 

DROP PROCEDURE IF EXISTS one_hundred_doors;

 

 

=={{header|Nanoquery}}==

// we need 101 since there will technically be a door 0

doors = {false} * 101

=={{header|NetRexx}}==

'''unoptimized'''

options replace format comments java crossref symbols binary

 

'''optimized''' (Based on the Java 'optimized' version)

{{trans|Java}}

options replace format comments java crossref symbols binary

 

'''optimized 2''' (Based on the Java 'optimized 2' version)

{{trans|Java}}

options replace format comments java crossref savelog symbols binary

 

 

'''optimized 3'''

 

loop i = 1 to 10

 

=={{header|newLISP}}==

(let ((x (int (sqrt door-num))))

(if

 

Not optimized:

(set 'Doors (array 100)) ;; Default value: nil (Closed)

 

Output of the boolean array showing the status of the doors. Truth values in Nial arrays are shown as <code>l</code>(true) and <code>o</code>(false):

 

looloooolooooooloooooooolooooooooooloooooooooooolooooooooooooooloooooooooooooooo

 

Indices of the open doors:

 

1 4 9 16 25 36 49 64 81 100</syntaxhighlight>

 

optimized solution:

 

1 4 9 16 25 36 49 64 81 100</syntaxhighlight>

 

=={{header|Nim}}==

unoptimized:

 

const numDoors = 100

Challenging C++'s compile time computation: https://rosettacode.org/wiki/100_doors#C.2B.2B <br>''outputString'' is evaluated at compile time. Check the resulting binary in case of doubt.

 

 

const numDoors = 100

echo outputString</syntaxhighlight>

 

[http://oberon07.com/ Oberon-07], by [http://people.inf.ethz.ch/wirth/index.html Niklaus Wirth].

 

Execute: Doors.Do<br/>

{{out}}

=={{header|Objeck}}==

'''optimized'''

bundle Default {

class Doors {

 

It uses modern Objective-C syntax such as literals, blocks, and a compiler module import statement.

@import Foundation;

 

In a real world program classes are normally separated into different files.

 

@import Foundation;

 

=={{header|OCaml}}==

'''unoptimized'''

 

let show_doors =

 

'''optimized'''

for i = 1 to int_of_float (sqrt (float_of_int max_doors)) do

doors.(i*i - 1) <- true

 

This variant is more '''functional style''' (loops are recursions), unoptimized, and we do rather 100 passes on first element, then 100 * second, to avoid mutable data structures and many intermediate lists.

 

let flipdoor = function Open -> Closed | Closed -> Open

 

=={{header|Octave}}==

for i = 1:100

for j = i:i:100

=={{header|Oforth}}==

 

| i j l |

100 false Array newWith dup ->l

 

=={{header|Ol}}==

(define (flip doors every)

(map (lambda (door num)

<pre>

100th doors: (1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

</pre>

 

=={{header|Onyx}}==

 

1 1 100 {Door exch false put} for

$Toggle {dup Door exch get not Door up put} def

 

=={{header|ooRexx}}==

do i = 1 to doors~size -- initialize with a collection of closed doors

doors[i] = .door~new(i)

 

=={{header|OpenEdge/Progress}}==

DEFINE VARIABLE idoor AS INTEGER NO-UNDO.

DEFINE VARIABLE ipass AS INTEGER NO-UNDO.

 

=={{header|Oz}}==

NumDoors = 100

NumPasses = 100

=={{header|PARI/GP}}==

'''Unoptimized version.'''

v=vector(d=100);/*set 100 closed doors*/

for(i=1,d,forstep(j=i,d,i,v[j]=1-v[j]));

</syntaxhighlight>

'''Optimized version.'''

 

'''Unoptimized version.'''

doors =vector(100);

print("open doors are : ");

 

=={{header|Pascal}}==

 

var

'''Optimized version.'''

 

 

{$APPTYPE CONSOLE}

WriteLn('Close doors: ' + ACloseDoors);

end. </syntaxhighlight>

 

=={{header|Perl}}==

'''unoptimized'''

{{works with|Perl|5.x}}

for my $pass (1 .. 100) {

for (1 .. 100) {

{{works with|Perl|5.x}}

This version flips doors, but doesn't visit (iterate over) doors that aren't toggled. Note: I represent open doors as 0 and closed as 1 just for preference. (When I print it as a bit vector, 0 looks more like an open door to me.)

#!/usr/bin/perl

use strict;

'''optimized'''

{{works with|Perl|5.x}}

{

$root = sqrt($i);

 

=={{header|Perl5i}}==

use perl5i::2;

 

=={{header|Phix}}==

===unoptimised===

<span style="color: #004080;">sequence</span> <span style="color: #000000;">doors</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat<span style="color: #0000FF;">(<span style="color: #004600;">false<span style="color: #0000FF;">,<span style="color: #000000;">100<span style="color: #0000FF;">)</span>

 

===optimised===

<span style="color: #008080;">function</span> <span style="color: #000000;">doors<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">n<span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- returns the perfect squares<=n</span>

 

=={{header|Phixmonti}}==

0 l repeat

 

endfor</syntaxhighlight>

Another way

0 n repeat /# Make the doors #/

 

endfor</syntaxhighlight>

Optimized

 

=={{header|PHL}}==

===unoptimized===

 

 

extern printf;

{{trans|C#}}

 

 

extern printf;

See: [http://www.thomporter.com/100doors.php Demo]

'''optimized'''

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

$root = sqrt($i);

 

'''unoptimized'''

$doors = array_fill(1, 100, false);

for ($pass = 1; $pass <= 100; ++$pass) {

=={{header|Picat}}==

Non-optimized:

Doors = new_array(N),

foreach(I in 1..N) Doors[I] := 0 end,

optimized version 1:

foreach(I in 1..N)

Root = sqrt(I),

 

optimized version 2:

println([I**2 : I in 1..N, I**2 <= N]).

</syntaxhighlight>

=={{header|PicoLisp}}==

unoptimized

(for I 100

(for (D (nth Doors I) D (cdr (nth D I)))

(println Doors) )</syntaxhighlight>

optimized

(for I (sqrt 100)

(set (nth Doors (* I I)) T) )

 

With formatting:

(for I (sqrt 100)

(set (nth Doors (* I I)) T) )

 

=={{header|Pike}}==

{

array doors = allocate(100);

}</syntaxhighlight>

optimized version:

{

return sqrt((float)x)%1 == 0.0;

});</syntaxhighlight>

 

output:

1 0 0 1 0 0 0 0 1 0

 

=={{header|PL/I}}==

declare door(100) bit (1) aligned;

declare closed bit (1) static initial ('0'b),

 

==={{header|PL/I-80}}===

/* Solution to the 100 doors problem in PLI-80 */

 

=={{header|PL/M}}==

{{Trans|ALGOL W}}

 

/* BDOS SYSTEM CALL */

'''Unoptimized'''

 

DECLARE

TYPE doorsarray IS VARRAY(100) OF BOOLEAN;

END;

</syntaxhighlight>

 

=={{header|Pointless}}==

 

range(1, 100)

|> map(visit(100))

The PL/I include file "pg.inc" can be found on the [[Polyglot:PL/I and PL/M]] page.

Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.

doors_100H: procedure options (main);

 

 

Probably also rather pointless in its use of actors, but, after all, they're cheap.

actor Toggler

let doors:Array[Bool]

=={{header|Pop11}}==

'''unoptimized'''

lvars doors = {% for i from 1 to 100 do false endfor %};

for i from 1 to 100 do

 

'''optimized'''

lvars root = sqrt(i);

i; if root = round(root) then ' open' ><; else ' closed' ><; endif; =>

 

=={{header|PostScript}}==

 

1 1 100 { dup 1 sub exch 99 {

dup doors exch get not doors 3 1 roll put

} for } for

 

=={{header|Potion}}==

1 to 100(door):

if (door == square):

=={{header|PowerShell}}==

===unoptimized===

for($i=0; $i -lt 100; $i++) {

$doors[$i] = 0 # start with all doors closed

}</syntaxhighlight>

===Alternative Method===

{

begin

}</syntaxhighlight>

===unoptimized Pipeline===

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" } }

</syntaxhighlight>

===unoptimized Pipeline 2===

$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" } }

</syntaxhighlight>

===unoptimized Pipeline 3 (dynamically build pipeline)===

filter toggle($pass) {$_.door = $_.door -xor !($_.index % $pass);$_}

invoke-expression "1..100| foreach-object {@{index=`$_;door=`$false}} | $pipe out-host"

 

===Using Powershell Workflow for Parallelism===

 

Workflow Calc-Doors {

 

=== optimized ===

1..10|%{"Door "+ $_*$_ + " is open"}

</syntaxhighlight>

=={{header|Processing}}==

'''Unoptimized:'''

 

void setup() {

==={{header|Processing.R}}===

'''Unoptimized:'''

for(door in doors(100, 100)) {

stdout$print(paste(door, ""))

=={{header|ProDOS}}==

Uses math module.

enabledelayedexpansion

editvar /newvar /value=0 /title=closed

Declarative:

 

forall(between(1,100,Door), ignore(display(Door))).

 

Doors as a list:

 

length(L, N),

maplist(init, L),

Using dynamic-rules. Tried to be ISO:

 

forall(( everyNth(1,Passes,1,Pass)

, forall((everyNth(Pass,Num,Pass,Door), toggle(Door)))

 

===optimized===

Max is floor(sqrt(N)),

forall(between(1, Max, I),

( J is I*I,format('Door ~w is open.~n',[J]))).

 

</syntaxhighlight>

 

=={{header|Pure}}==

 

// initialize doors as pairs: number, status where 0 means open

 

=={{header|Pure Data}}==

 

#N canvas 241 375 414 447 10;

=={{header|PureBasic}}==

'''unoptimized'''

For x = 1 To 100

 

'''optimized'''

PrintN("Following Doors are open:")

For i = 1 To 100

 

=={{header|Pyret}}==

data Door:

| open

{{works with|Python|2.5+}}

'''unoptimized'''

doors = [False] * 100

for i in range(100):

A version that only visits each door once:

 

root = i ** 0.5

print "Door %d:" % i, 'open' if root == int(root) else 'close'</syntaxhighlight>

One liner using a list comprehension, item lookup, and is_integer

 

 

One liner using a generator expression, ternary operator, and modulo

 

 

{{works with|Python|3.x}}

for i in range(1, 101):

if i**0.5 % 1:

 

'''ultra-optimized''': ported from Julia version<br>

 

=={{header|Q}}==

'''unoptimized'''

 

Binary function <code>{@[x;where y;not]}</code> is applied using [https://code.kx.com/q/ref/accumulators/#binary-application Over]. The initial state is <code>100#0b</code> and the right argument is a list of 100 boolean masks. The boolean vector result is used to index the pair of states.

 

'''optimized'''

 

'''alternative'''

 

 

 

=={{header|QB64}}==

Const Opened = -1, Closed = 0

Dim Doors(1 To 100) As Integer, Passes As Integer, Index As Integer

=={{header|Quackery}}==

'''unoptimized'''

...

... [ 0

=={{header|R}}==

'''Using a loop'''

doors <- logical(ndoors)

for (ii in seq(passes)) {

 

'''optimized'''

for (i in 1:100-1) {

x <- xor(x, rep(c(rep(0,i),1), length.out=100))

 

'''Using a **ply function'''

names(which(table(unlist(sapply(1:passes, function(X) seq(0, ndoors, by=X)))) %% 2 == 1))

}

===Using Reduce===

 

f=rep(F,H)

which(Reduce(function(d,n) xor(replace(f,seq(n,H,n),T),d), 1:H, f))</syntaxhighlight>

 

=={{header|Racket}}==

#lang racket

 

 

Optimized:

#lang racket

(for ([x (in-range 1 101)] #:when (exact-integer? (sqrt x)))

 

Unoptimized imperative, with graphic rendering:

#lang slideshow

(define-syntax-rule (vector-neg! vec pos)

===unoptimized===

{{works with|Rakudo|2015.09"}}

(.=not for @doors[0, $_ ... 100]) for 1..100;

===optimized===

 

 

===probably the most compact idiom===

 

 

===Here's a version using the cross meta-operator instead of a map:===

 

 

This one prints both opened and closed doors:

 

 

===verbose version, but uses ordinary components===

{{works with|Rakudo|2016.07 Tom Legrady}}

 

sub output( @arr, $max ) {

my $output = 1;

 

=={{header|RapidQ}}==

dim x as integer, y as integer

dim door(1 to 100) as byte

 

===Unoptimized===

repeat i 100 [

door: at doors i

 

===Optimized===

repeat i 10 [doors/(i * i): 'open]

</syntaxhighlight>

 

===Unoptimized===

Purpose: "100 Doors Problem (Perfect Squares)"

Author: "Barry Arthur"

</syntaxhighlight>

===Using bitset! type===

 

doors: make bitset! len: 100

repeat n len [if doors/:n [print n]]

</syntaxhighlight>

 

=={{header|Relation}}==

relation door, state

set i = 1

 

=={{header|Retro}}==

#100 doors</syntaxhighlight>

 

=={{header|REXX}}==

===the idiomatic way===

parse arg doors . /*obtain the optional argument from CL.*/

if doors=='' | doors=="," then doors=100 /*not specified? Then assume 100 doors*/

 

===the shortcut way===

parse arg doors . /*obtain the optional argument from CL.*/

if doors=='' | doors=="," then doors=100 /*not specified? Then assume 100 doors*/

 

'''Unoptimized'''

for i = 1 to 100

doors[i] = false

 

'''Optimized'''

for i = 1 to 100

doors[i] = false

see nl

Next</syntaxhighlight>

 

=={{header|Ruby}}==

print "Open doors "

(1..100).step(){ |i|

'''unoptimized; Ruby-way'''

 

attr_reader :state

 

'''unoptimized'''

 

Open = "open"

Closed = "closed"

'''optimized'''

 

(1..n).each do |i|

puts "Door #{i} is #{i**0.5 == (i**0.5).round ? "open" : "closed"}"

'''generic true/false, with another way of handling the inner loop demonstrating Range#step'''

 

100.times do |i|

(i ... doors.length).step(i + 1) do |j|

 

=={{header|Run BASIC}}==

print "Open doors ";

for i = 1 to 100

 

=={{header|Rust}}==

let mut door_open = [false; 100];

for pass in 1..101 {

}

for (i, &is_open) in door_open.iter().enumerate() {

}

}</syntaxhighlight>

 

Declarative version of above: <br>

 

println!("{:?}", doors);

Optimized version: <br>

(In this case the printing is the bottleneck so this version is not faster than the above one.)

let is_square = |num| squares.binary_search(&num).is_ok();

 

for i in 1..101 {

println!("Door {} is {}", i, state);

}

 

ultra-optimized: ported from Julia version

println!("Door {} is open", i.pow(2));

}

 

=={{header|S-BASIC}}==

$constant DOOR_OPEN = 1

$constant DOOR_CLOSED = 0

 

=={{header|S-lang}}==

isOpen = Char_Type [101],

pass;

=={{header|Salmon}}==

Here's an unoptimized version:

for (pass; 1; pass <= 100)

for (door_num; pass; door_num <= 100; pass)

And here's an optimized one-line version:

 

 

And a shorter optimized one-line version:

 

 

=={{header|SAS}}==

open=1;

close=0;

 

=={{header|Sather}}==

main is

doors :ARRAY{BOOL} := #(100);

 

=={{header|Scala}}==

r = 1 to 100 map (i % _ == 0) reduceLeft (_^_)

} println (i +" "+ (if (r) "open" else "closed"))</syntaxhighlight>

 

I made a version that optional accepts an argument for the number of doors. It is also a little more a ‘classical’ solution:

def openDoors(length : Int = 100) = {

var isDoorOpen = new Array[Boolean](length)

 

"Optimized" version:

println("open: " + o)

println("closed: " + (1 to 100 filterNot o.contains))</syntaxhighlight>

=={{header|Scheme}}==

'''unoptimized'''

 

(define (show-doors doors)

 

'''optimized'''

(define (flip-all i)

(cond ((> i (floor (sqrt *max-doors*))) doors)

 

'''the 3rd version'''

(define (init)

(define (str n)

=={{header|Scilab}}==

{{trans|Octave}}

for i = 1:100

for j = i:i:100

=={{header|Seed7}}==

'''unoptimized'''

const proc: main is func

 

'''optimized'''

 

const proc: main is func

 

=={{header|SenseTalk}}==

put false repeated 100 times as a list into Doors100

 

=={{header|SequenceL}}==

'''Unoptimized'''

import <Utilities/Sequence.sl>;

 

 

'''Optimized'''

main := flipDoors([1], 2);

 

=={{header|SETL}}==

'''Unoptimized'''

 

const toggle := {['open', 'closed'], ['closed', 'open']};

'''Optimized'''

Exploits the fact that squares are separated by successive odd numbers. Use array replication to insert the correct number of closed doors in between the open ones.

 

doorStates := (+/ [['closed'] * oddNum with 'open': oddNum in [1,3..17]]);

 

=={{header|SheerPower 4GL}}==

!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

! I n i t i a l i z a t i o n

 

'''Unoptimized'''

 

{ |pass|

 

'''Optimized'''

"Door %3d is %s\n".printf(i, <closed open>[i.is_sqr])

} << 1..100</syntaxhighlight>

 

=={{header|Simula}}==

INTEGER LIMIT = 100, door, stride;

BOOLEAN ARRAY DOORS(1:LIMIT);

=={{header|Slate}}==

'''Unoptimized'''

a infect: [| :_ | False].

 

 

'''Optimized'''

a infect: [| :_ | False].

 

{{works with|GNU Smalltalk}}

'''Unoptimized'''

a := Array new: 100 .

1 to: 100 do: [ :i | a at: i put: false ].

'''Optimized'''

 

a := (1 to: 100) collect: [ :x | false ].

1 to: 10 do: [ :i | a at: (i squared) put: true ].

{{works with|Squeak Smalltalk}}

'''Unoptimized, using Morphs'''

| m w h smh smw delay closedDoor border subMorphList |

 

 

=={{header|smart BASIC}}==

PRINT "Open doors: ";x;" ";

DO

 

'''unoptimized'''

DEFINE('PASS(A,I),O') :(PASS.END)

PASS O = 0

 

'''optimized'''

MAIN D = ARRAY(100,0)

I = 1

 

The output of this version is almost identical to the above.

 

=={{header|Sparkling}}==

'''unoptimized'''

 

var isOpen = {};

var pass, door;

'''optimized'''

 

var door_sqrt = 1;

var door;

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1+pll16x

_clkfreq = 80_000_000

=={{header|SQL}}==

'''optimized'''

DECLARE @sqr int,

@i int,

</syntaxhighlight>

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

With SQL only:

--#SET TERMINATOR @

 

 

=={{header|Standard ML}}==

datatype Door = Closed | Opened

 

 

=={{header|Stata}}==

set obs 100

gen doors=0

| 100 |

+-------+</syntaxhighlight>

 

=={{header|SuperCollider}}==

var n = 100, doors = false ! n;

var pass = { |j| (0, j .. n-1).do { |i| doors[i] = doors[i].not } };

'''unoptimized'''

 

enum DoorState : String {

case Opened = "Opened"

'''optimized'''

 

enum DoorState : String {

case Opened = "Opened"

println("Door \(index+1) is \(item.rawValue)")

}</syntaxhighlight>

 

=={{header|Tailspin}}==

source hundredDoors

@: [ 1..100 -> 0 ];

'''unoptimized'''

 

set n 100

set doors [concat - [lrepeat $n 0]]

'''optimized'''

 

set doors [lrepeat [expr {$n + 1}] closed]

for {set i 1} {$i <= sqrt($n)} {incr i} {

{{libheader|Tk}}

Inspired by the E solution, here's a visual representation

package require Tk

 

 

=={{header|TI-89 BASIC}}==

Local doors,i,j

seq(false,x,1,100) ? doors

 

=={{header|TorqueScript}}==

for(%current = %steps; %current <= 100; %current += %steps)

%door[%current] = !%door[%current];

 

=={{header|Transact-SQL}}==

WITH OneToTen (N)

AS ( SELECT N

{{works with|Transact-SQL|SQL Server 2017}}

 

 

-- Doors can be open or closed.

 

=={{header|Transd}}==

 

MainModule: {

 

=={{header|True BASIC}}==

! Optimized solution with True BASIC

 

 

=={{header|TSE SAL}}==

 

// 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]

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

DICT doors create

100 = open

</pre>

 

=={{header|TypeScript}}==

interface Door {

id: number;

 

=={{header|TXR}}==

(let ((doors (vector 100)))

(each ((i (range 0 99)))

{{trans|BBC BASIC}}

Deliberately unoptimized.

FOR d = p TO 100 STEP p

@(d) = @(d) = 0

IF @(d) PRINT "Door ";d;" is open"

NEXT d</syntaxhighlight>

 

=={{header|Uniface}}==

{{works with|Uniface 9.6}}

 

entry LP_DO_IT

 

 

=={{header|Unison}}==

hundredDoors =

toggleEachNth : Nat -> [Boolean] -> [Boolean]

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

 

declare -a doors

 

Optimised version

 

for i in {1..100}; do

 

=={{header|Ursa}}==

#

# 100 doors

 

The doors are represented as a list of 100 booleans initialized to false. The pass function takes a number and a door list to a door list with doors toggled at indices that are multiples of the number. The main program folds the pass function (to the right) over the list of pass numbers from 100 down to 1, numbers the result, and filters out the numbers of the open doors.

#import nat

 

main = ~&rFlS num pass=>doors nrange(100,1)</syntaxhighlight>

optimized version:

 

#cast %nL

 

=={{header|UTFool}}==

···

http://rosettacode.org/wiki/100_doors

=={{header|Vala}}==

'''Unoptimized'''

bool doors_open[101];

for(int i = 1; i < doors_open.length; i++) {

...</pre>

'''Optimized'''

int i = 1;

while(i*i <= 100) {

=={{header|VAX Assembly}}==

 

00000064 0000 1 n = 100

0000 0000 2 .entry doors, ^m<>

 

=={{header|VBA}}==

Sub Rosetta_100Doors()

Dim Door(100) As Boolean, i As Integer, j As Integer

{{works with|Windows Script Host|5.7}}

'''Unoptimized'''

 

For currentDoor = 0 To 99

This implementation uses a free edit buffer as data array and for displaying the results.<br>

A closed door is represented by a character <tt>'-'</tt> and an open door by character <tt>'O'</tt>.

Ins_Char('-', COUNT, 100) // All doors closed

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

 

'''Optimized'''

Ins_Char('-', COUNT, 100)

for (#1=1; #1 <= 10; #1++) {