Movatterモバイル変換

[0]ホーム
URL:

Jump to content
Rosetta Code
Search

100 doors

From Rosetta Code
Task
100 doors
You are encouraged tosolve this task according to the task description, using any language you may know.

There are 100 doors in a row that are all initially closed.

You make 100passes by the doors.

The first time through, visit every door andtoggle the door (if the door is closed, open it; if it is open, close it).

The second time, only visit every 2nd door (door #2, #4, #6, ...), and toggle it.

The third time, visit every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 100th door.


Task

Answer the question: what state are the doors in after the last pass? Which are open, which are closed?


Alternate: As noted in this page'sdiscussion page, the only doors that remain open are those whose numbers are perfect squares.

Opening only those doors is anoptimization that may also be expressed; however, as should be obvious, this defeats the intent of comparing implementations across programming languages.

Why doesn't syntax highlighting work on this page ?

Currently, there is a limit on how many <syntaxhighlight> tags can appear on a page, so only the first few languages get highlighting, the rest are shown in monochrome.
You could try "manual highlighting", possibly using one of the highlighters onSyntax highlighting using Mediawiki formatting or something similar.


11l

Translation of:Python
V doors = [0B] * 100L(i) 100   L(j) (i .< 100).step(i + 1)      doors[j] = !doors[j]   print(‘Door ’(i + 1)‘: ’(I doors[i] {‘open’} E ‘close’))

360 Assembly

*        100 doors                 13/08/2015HUNDOOR  CSECT         USING  HUNDOOR,R12         LR     R12,R15         LA     R6,0         LA     R8,1               step 1         LA     R9,100LOOPI    BXH    R6,R8,ELOOPI       do ipass=1 to 100 (R6)         LR     R7,R6         SR     R7,R6         LR     R10,R6             step ipass         LA     R11,100LOOPJ    BXH    R7,R10,ELOOPJ      do idoor=ipass to 100 by ipass (R7)         LA     R5,DOORS-1         AR     R5,R7         XI     0(R5),X'01'        doors(idoor)=not(doors(idoor))NEXTJ    B      LOOPJELOOPJ   B      LOOPIELOOPI   LA     R10,BUFFER         R10 address of the buffer         LA     R5,DOORS           R5 address of doors item         LA     R6,1               idoor=1 (R6)         LA     R9,100             loop counterLOOPN    CLI    0(R5),X'01'        if doors(idoor)=1         BNE    NEXTN         XDECO  R6,XDEC            idoor to decimal         MVC    0(4,R10),XDEC+8    move decimal to buffer         LA     R10,4(R10)NEXTN LA     R6,1(R6)           idoor=idoor+1         LA     R5,1(R5)         BCT    R9,LOOPN           loopELOOPN   XPRNT  BUFFER,80RETURN   XR     R15,R15         BR     R14DOORS    DC     100X'00'BUFFER   DC     CL80' 'XDEC     DS     CL12         YREGS         END    HUNDOOR
Output:
   1   4   9  16  25  36  49  64  81 100

4DOS Batch

@echo offset 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]  enddoenddo

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.

6502 Assembly

Works with: [www.6502asm.com] version beta

unoptimizedBased on BASIC QB64 unoptimized version

; 100 DOORS in  6502 assembly language for: http://www.6502asm.com/beta/index.html; 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;; Notes:;    Doors array[1..100] is at $0201..$0264. On the specified emulator, this is in video memory, so tbe results will ; be directly shown as pixels in the display.;    $0200 (door 0) is cleared for display purposes but is not involved in the open/close loops.;    Y register holds Stride;    X register holds Index;    Zero Page address $01 used to add Stride to Index (via A) because there's no add-to-X or add-Y-to-A instruction.  ; First, zero door array    LDA #00    LDX #100Z_LOOP:    STA 200,X    DEX    BNE Z_LOOP    STA 200,X  ; Now do doors repeated open/close    LDY #01        ; Initial value of StrideS_LOOP:    CPY #101    BCS S_DONE    TYA            ; Initial value of IndexI_LOOP:    CMP #101    BCS I_DONE    TAX            ; Use as Door array index    INC $200,X     ; Toggle bit 0 to reverse state of door    STY 01         ; Add stride (Y) to index (X, via A)    ADC 01    BCC I_LOOPI_DONE:    INY    BNE S_LOOPS_DONE:  ; Finally, format array values for output: 0 for closed, 1 for open    LDX #100C_LOOP:    LDA $200,X    AND #$01    STA $200,X    DEX    BNE C_LOOP

48. bytes of code; the specified emulator does not report cycles.


Works with: [6502asm.com] version 1.2

optimizedLargely 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

n2=1+3+5+…+(2n−1){\displaystyle {\displaystyle n^{2}=1+3+5+\ldots +(2n-1)}}.
  ;assumes memory at $02xx is initially set to 0 and stack pointer is initialized  ;the 1 to 100 door byte array will be at $0200-$0263 (decimal 512 to 611)  ;Zero-page location $01 will hold delta  ;At end, closed doors = $00, open doors = $01start:    ldx #0        ;initialize index - first door will be at $200 + $0          stx $1          inc $1        ;start out with a delta of 1 (0+1=1)openloop: inc $200,X    ;open X'th door          inc $1        ;add 2 to delta          inc $1          txa           ;add delta to X by transferring X to A, adding delta to A, then transferring back to X          clc           ;  clear carry before adding (6502 has no add-without-carry instruction)          adc $1          tax          cpx #$64      ;check to see if we're at or past the 100th door (at $200 + $63)          bmi openloop  ;jump back to openloop if less than 100

22. bytes of code; the specified emulator does not report cycles.

68000 Assembly

Works with: [EASy68K v5.13.00]

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

*-----------------------------------------------------------*Title:100Doors.X68*Writtenby:G.A.Tippery*Date:2014-01-17*Description:Solves"100Doors"problem,see:http://rosettacode.org/wiki/100_doors*Notes:TranslatedfromC"Unoptimized"version,http://rosettacode.org/wiki/100_doors#unoptimized*:NooptimizationsdonerelativetoCversion; "for("-equivalent loops could be optimized.*-----------------------------------------------------------**System-specificgeneralconsoleI/Omacros(Sim68K,inthiscase)*PUTSMACRO**Printanull-terminatedstringw/oCRLF****Usage:PUTSstringaddress**ReturnswithD0,A1modifiedMOVEQ#14,D0; task number 14 (display null string)LEA\1,A1; address of stringTRAP#15; display itENDM*PRINTNMACRO**Printdecimalintegerfromnumberinregister**Usage:PRINTNregister**ReturnswithD0,D1modifiedIFNC'\1','D1';if some register other than D1MOVE.L\1,D1;put number to display in D1ENDCMOVE.B#3,D0TRAP#15;display number in D1**Genericconstants*CREQU13;ASCII Carriage ReturnLFEQU10;ASCII Line Feed**Definitionsspecifictothisprogram**Registerusage:*D3==pass(index)*D4==door(index)*A2==Doorsarraypointer*SIZEEQU100;Define a symbolic constant for # of doorsORG$1000;Specify load address for program -- actual address system-specificSTART:; Execution starts hereLEADoors,A2; make A2 point to Doors byte arrayMOVEQ#0,D3PassLoop:CMP#SIZE,D3BCCExitPassLoop; Branch on Carry Clear - being used as Branch on Higher or EqualMOVED3,D4DoorLoop:CMP#SIZE,D4BCCExitDoorLoopNOT.B0(A2,D4)ADDD3,D4ADDQ#1,D4BRADoorLoopExitDoorLoop:ADDQ#1,D3BRAPassLoopExitPassLoop:*$28=40.bytesofcodetothispoint.32626cyclessofar.*Atthispoint,theresultexistsasthe100bytesstartingataddressDoors.*Togetoutput,wemustusemethodsspecifictotheparticularhardware,OS,or*emulatorsystemthatthecodeisrunningon.Iusemacrosto"hide"someofthe*system-specificdetails; equivalent macros would be written for another system.MOVEQ#0,D4PrintLoop:CMP#SIZE,D4BCCExitPrintLoopPUTSDoorMsg1MOVED4,D1ADDQ#1,D1; Convert index to 1-based instead of 0-basedPRINTND1PUTSDoorMsg2TST.B0(A2,D4); Is this door open (!= 0)?BNEItsOpenPUTSDoorMsgCBRANextItsOpen:PUTSDoorMsgONext:ADDQ#1,D4BRAPrintLoopExitPrintLoop:*Whattodoatendofprogramisalsosystem-specificSIMHALT;Halt simulator**$78=120.bytesofcodetothispoint,butthiswilldependonhowtheI/Omacrosareactuallywritten.*Cyclecountisnearlymeaningless,astheI/Ohardwareandroutineswilldominatethetiming.**Datamemoryusage*ORG$2000DoorsDCB.BSIZE,0;Reserve 100 bytes, prefilled with zerosDoorMsg1DC.B'Door',0DoorMsg2DC.B'is',0DoorMsgCDC.B'closed',CR,LF,0DoorMsgODC.B'open',CR,LF,0ENDSTART;last line of source

8080 Assembly

page:equ2; Store doors in page 2doors:equ100; 100 doorsputs:equ9; CP/M string outputorg100hxraa; Set all doors to zerolxih,256*pagemvic,doorszero:movm,ainxhdcrcjnzzeromvim,'$'; CP/M string terminator (for easier output later)movd,a; D=0 so that DE=E=pass countermove,a; E=0, first passmvia,doors-1; Last pass and doorpass:movl,e; L=door counter, start at first door in passdoor:inrm; Incrementing always toggles the low bitdadd; Go to next door in passinrlcmpl; Was this the last door?jncdoor; If not, do the next doorinre; Next passcmpe; Was this the last pass?jncpass; If not, do the next passlxih,256*pagemvic,doors; Door counterlxid,130h; D=1 (low bit), E=30h (ascii 0)char:mova,m; Get dooranad; Low bit gives door statusorae; ASCII 0 or 1movm,a; Write character backinxh; Next doordcrc; Any doors left?jnzchar; If so, next doorlxid,256*pagemvic,puts; CP/M system call to print the stringjmp5
Output:
1001000010000001000000001000000000010000000000001000000000000001000000000000000010000000000000000001

OptimizedOf course, calling it a solution is stretching a point, since the various optimized solutions presented for the task do not actually solve the puzzle; they merely print out the answer the programmer has already deduced. Still, generating a sequence of squares is an interesting exercise in its own right, and the elegant C example works particularly well here, since the 8080 lacks a built-in multiply instruction. 16-bit arithmetic is overkill for the stated task, but could be useful in other contexts. I/O and program entry/exit assume the CP/M operating system.

;------------------------------------------------------; useful equates;------------------------------------------------------wbootequ0; jump to BIOS warm boot routinebdosequ 5; BDOS entry conoutequ 2; BDOS console output functionputstrequ9; BDOS print string functionndoorsequ100;org100hlxisp,stack  ; set our own stacklxid,signon  ; print signon messagemvic,putstrcall bdos;; generate sequence of squares from 1 to specified limit;gensqr:    lxih,1; starting value of squarelxid,3; starting value of incrementlxib,ndoors+1sqrs2:    call cmpbchl  ; have we exceeded the limit?jncdone  ; we're finishedcall putdec  ; otherwise print current squaremvia,' '  ; separate with a spacecall putchrdadd      ; square += incrememntinxd      ; increment += 2inxdjmpsqrs2; repeat until finished;done:jmpwboot; exit to command prompt;;---------------------------------------------------; 16-bit unsigned comparison of HL and BC; if HL = BC then Z flag set; if HL < BC then CY flag set (NC if HL >= BC);------------------------------------------------------cmpbchl:mova,hcmpbrnzmova,lcmpcret;---------------------------------------------------; console output of char in A register;---------------------------------------------------putchr:push hpush dpush bmove,amvic,conoutcall bdospopbpopdpophret;---------------------------------------------------; Output decimal number to console; HL holds 16-bit unsigned binary number to print;---------------------------------------------------putdec: push bpush dpush hlxib,-10lxid,-1putdec2:dadbinxdjcputdec2lxib,10dadbxchgmova,horalcnzputdec; recursive callmova,eadi'0'call putchrpophpopdpopbret;---------------------------------------------------; data area and stack;---------------------------------------------------signon: db'The open doors are: $'stackequ$+128; 64-level stack;end
Output:
The open doors are: 1 4 9 16 25 36 49 64 81 100

8086 Assembly

See100 doors/8086 Assembly

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:[]var,doors\ given a door number, get the value and toggle it::toggle-door\ n --doors@overa:@notrotswapa:!drop;\ print which doors are open::.doors(doors@overa:@nipif.spaceelsedropthen)1100loop;\ iterate over the doors, skipping 'n'::main-pass\ n --0truerepeatdropduptoggle-doorovern:+dup101<while2dropdrop;\ calculate the first 100 doors:'main-pass1100loop\ print the results:.doorscrbye
Output:

1 4 9 16 25 36 49 64 81 100

AArch64 Assembly

Works with:as version Raspberry Pi 3B version Buster 64 bits

unoptimized

/* ARM assembly AARCH64 Raspberry PI 3B *//*  program 100doors64.s   */ /*******************************************//* Constantes file                         *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc".equ NBDOORS,   100/*********************************//* Initialized data              *//*********************************/.datasMessResult:       .asciz "The door @ is open.\n" /*********************************//* UnInitialized data            *//*********************************/.bss  stTableDoors:    .skip   8 * NBDOORSsZoneConv:       .skip 24/*********************************//*  code section                 *//*********************************/.text.global main main:                             // entry of program     // display first line    ldr x3,qAdrstTableDoors       // table address    mov x5,1             1:    mov x4,x52:                               // begin loop    ldr x2,[x3,x4,lsl #3]        // read doors index x4    cmp x2,#0    cset x2,eq    //moveq x2,#1                // if x2 = 0   1 -> x2    //movne x2,#0                // if x2 = 1   0 -> x2    str x2,[x3,x4,lsl #3]        // store value of doors    add x4,x4,x5                 // increment x4 with  x5 value    cmp x4,NBDOORS               // number of doors ?    ble 2b                       // no -> loop    add x5,x5,#1                 // increment the increment !!    cmp x5,NBDOORS               // number of doors ?    ble 1b                       // no -> loop                                  // loop display state doors    mov x4,#0              3:    ldr x2,[x3,x4,lsl #3]        // read state doors x4 index    cmp x2,#0    beq 4f    mov x0,x4                    // open -> display message    ldr x1,qAdrsZoneConv          // display value index    bl conversion10              // call function    ldr x0,qAdrsMessResult    ldr x1,qAdrsZoneConv     bl strInsertAtCharInc        // insert result at first @ character    bl affichageMess             // display message4:    add x4,x4,1    cmp x4,NBDOORS    ble 3b                       // loop  100:                             // standard end of the program     mov x0,0                     // return code    mov x8,EXIT                  // request to exit program    svc 0                        // perform the system call qAdrstTableDoors:        .quad stTableDoorsqAdrsMessResult:         .quad sMessResultqAdrsZoneConv:           .quad sZoneConv/***********************************************//*        File Include fonctions                        *//********************************************************//* for this file see task include a file in language AArch64 assembly */.include "../includeARM64.inc"

optimized

/* ARM assembly AARCH64 Raspberry PI 3B *//*  program 100doors64_1.s   */ /*******************************************//* Constantes file                         *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc".equ NBDOORS,   100/*********************************//* Initialized data              *//*********************************/.datasMessResult:       .asciz "The door @ is open.\n" /*********************************//* UnInitialized data            *//*********************************/.bss  sZoneConv:        .skip 24/*********************************//*  code section                 *//*********************************/.text.global main main:                             // entry of program      mov x5,3    mov x4,11:    mov x0,x4    ldr x1,qAdrsZoneConv          // display value index    bl conversion10              // call function    ldr x0,qAdrsMessResult    ldr x1,qAdrsZoneConv     bl strInsertAtCharInc        // insert result at first @ character    bl affichageMess             // display message    add x4,x4,x5    add x5,x5,2    cmp x4,NBDOORS    ble 1b                       // loop  100:                             // standard end of the program     mov x0,0                     // return code    mov x8,EXIT                  // request to exit program    svc 0                        // perform the system call qAdrsMessResult:         .quad sMessResultqAdrsZoneConv:           .quad sZoneConv/***********************************************//*        File Include fonctions                        *//********************************************************//* for this file see task include a file in language AArch64 assembly */.include "../includeARM64.inc"

ABAP

unoptimized

formopen_doors_unopt.data:lv_doortypei,lv_counttypeivalue1.data:lt_doorstype standard table ofcinitialsize100.field-symbols:<wa_door>typec.do100times.append initial line tolt_doorsassigning<wa_door>.<wa_door>='X'.enddo.whilelv_count<100.lv_count=lv_count+1.lv_door=lv_count.whilelv_door<100.readtablelt_doorsindexlv_doorassigning<wa_door>.if<wa_door>=' '.<wa_door>='X'.else.<wa_door>=' '.endif.addlv_counttolv_door.endwhile.endwhile.loop atlt_doorsassigning<wa_door>.if<wa_door>='X'.write:/'Door',(4)sy-tabixright-justified,'is open'no-gap.endif.endloop.endform.

unoptimized / functional

cl_demo_output=>display(REDUCEstringtab(INITlistTYPEstringtabauxTYPEiFORdoor=1WHILEdoor<=100FORpass=1WHILEpass<=100NEXTaux=COND#(WHENpass=1THEN1WHENdoorMODpass=0THENaux+1ELSEaux)list=COND#(WHENpass=100THENCOND#(WHENauxMOD2<>0THENVALUE#(BASElist(CONV#(door)))ELSElist)ELSElist))).

optimized

Using∑i=1n(2i−1)=n2{\displaystyle {\displaystyle \sum _{i=1}^{n}(2i-1)=n^{2}}}

formopen_doors_opt.data:lv_squaretypeivalue1,lv_inctypeivalue3.data:lt_doorstype standard table ofcinitialsize100.field-symbols:<wa_door>typec.do100times.append initial line tolt_doorsassigning<wa_door>.ifsy-index=lv_square.<wa_door>='X'.add:lv_inctolv_square,2tolv_inc.write:/'Door',(4)sy-indexright-justified,'is open'no-gap.endif.enddo.endform.


ultra-optimized / imperative

DO10TIMES.DATA(val)=sy-index*sy-index.WRITE:/val.ENDDO.

ultra-optimized / functional

cl_demo_output=>display(REDUCEstringtab(INITlistTYPEstringtabFORi=1WHILEi<=10NEXTlist=VALUE#(BASElist(i*i)))).

ABC

HOW TO INITIALIZE:    SHARE doors    PUT {} IN doors    FOR door IN {1..100}:        PUT 0 IN doors[door]HOW TO TOGGLE door:    SHARE doors    PUT 1-doors[door] IN doors[door]HOW TO WALK step:    SHARE doors    PUT step IN door    WHILE door <= 100:        TOGGLE door        PUT door+step IN doorHOW TO DISPLAY OPEN DOORS:    SHARE doors    FOR door IN {1..100}:        IF doors[door] = 1:            WRITE "Door", door, "is open"/INITIALIZEFOR pass IN {1..100}: WALK passDISPLAY OPEN DOORS
Output:
Door 1 is openDoor 4 is openDoor 9 is openDoor 16 is openDoor 25 is openDoor 36 is openDoor 49 is openDoor 64 is openDoor 81 is openDoor 100 is open

ACL2

(defunrep(nx)(if(zpn)nil(consx(rep(-n1)x))))(defuntoggle-every-r(nibs)(if(endpbs)nil(cons(if(zpi)(not(firstbs))(firstbs))(toggle-every-rn(mod(1-i)n)(restbs)))))(defuntoggle-every(nbs)(toggle-every-rn(1-n)bs))(defun100-doors(idoors)(if(zpi)doors(100-doors(1-i)(toggle-everyidoors))))

Action!

DEFINE COUNT="100"PROC Main()  BYTE ARRAY doors(COUNT+1)  BYTE door,pass  FOR door=1 TO COUNT  DO    doors(door)=0  OD    PrintE("Following doors are open:")  FOR pass=1 TO COUNT  DO    FOR door=pass TO COUNT STEP pass    DO      doors(door)==!$FF    OD    IF doors(pass)=$FF THEN      PrintB(pass) Put(32)    FI  ODRETURN
Output:

Screenshot from Atari 8-bit computer

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

ActionScript

Works with:ActionScript version 3.0

unoptimized

package{importflash.display.Sprite;publicclassDoorsextendsSprite{publicfunctionDoors(){// Initialize the arrayvardoors:Array=newArray(100);for(vari:Number=0;i<100;i++){doors[i]=false;// Do the workfor(varpass:Number=0;pass<100;pass++){for(varj:Number=pass;j<100;j+=(pass+1)){doors[j]=!doors[j];}}trace(doors);}}}

Acurity Architect

Using #HASH-OFF, OPTION OICC ="^" , CICC ="^"
VAR sStatus: SHORTVAR sArray: SHORTVAR sCount: SHORTVAR sDoor: SHORTVAR sPass: SHORTVAR zIndex: STRINGVAR zState: STRING//SET sStatus = GET_UNUSED_ARRAY_HANDLE(sArray)SET sStatus = INIT_SORTED_ARRAY(sArray, 0, 0, 1)//DO sCount = 1 TO 100  DO sPass = 1 TO 100    SET sDoor = sCount * sPass    IF sDoor <= 100      SET zIndex = REPEAT("0", 3 - LENGTH(STR(sDoor))) + STR(sDoor)      SET sStatus = READ_ARRAY_REC("=", sArray, zIndex)      SET zState = "OPEN"      IF GET_STRING_SAY(sArray, 1) = "OPEN"        SET zState = "CLOSE"      ENDIF      //      SET sStatus = ADD_ARRAY_REC(sArray, zIndex)      SET sStatus = PUT_STRING_SAY(sArray, 1, zState)    ELSE      BREAK    ENDIF  ENDDOENDDO//SET zIndex = ""SET sStatus = READ_ARRAY_REC(">=", sArray, zIndex)DO WHILE sStatus = 0  >>Door:  ^zIndex^  State: ^GET_STRING_SAY(sArray, 1)^  SET sStatus = READ_ARRAY_REC("+", sArray, zIndex)ENDDO
Output:
Door:  001  State: OPENDoor:  002  State: CLOSEDoor:  003  State: CLOSEDoor:  004  State: OPENDoor:  005  State: CLOSEDoor:  006  State: CLOSEDoor:  007  State: CLOSEDoor:  008  State: CLOSEDoor:  009  State: OPENDoor:  010  State: CLOSEDoor:  011  State: CLOSEDoor:  012  State: CLOSEDoor:  013  State: CLOSEDoor:  014  State: CLOSEDoor:  015  State: CLOSEDoor:  016  State: OPENDoor:  017  State: CLOSEDoor:  018  State: CLOSEDoor:  019  State: CLOSEDoor:  020  State: CLOSEDoor:  021  State: CLOSEDoor:  022  State: CLOSEDoor:  023  State: CLOSEDoor:  024  State: CLOSEDoor:  025  State: OPENDoor:  026  State: CLOSEDoor:  027  State: CLOSEDoor:  028  State: CLOSEDoor:  029  State: CLOSEDoor:  030  State: CLOSEDoor:  031  State: CLOSEDoor:  032  State: CLOSEDoor:  033  State: CLOSEDoor:  034  State: CLOSEDoor:  035  State: CLOSEDoor:  036  State: OPENDoor:  037  State: CLOSEDoor:  038  State: CLOSEDoor:  039  State: CLOSEDoor:  040  State: CLOSEDoor:  041  State: CLOSEDoor:  042  State: CLOSEDoor:  043  State: CLOSEDoor:  044  State: CLOSEDoor:  045  State: CLOSEDoor:  046  State: CLOSEDoor:  047  State: CLOSEDoor:  048  State: CLOSEDoor:  049  State: OPENDoor:  050  State: CLOSEDoor:  051  State: CLOSEDoor:  052  State: CLOSEDoor:  053  State: CLOSEDoor:  054  State: CLOSEDoor:  055  State: CLOSEDoor:  056  State: CLOSEDoor:  057  State: CLOSEDoor:  058  State: CLOSEDoor:  059  State: CLOSEDoor:  060  State: CLOSEDoor:  061  State: CLOSEDoor:  062  State: CLOSEDoor:  063  State: CLOSEDoor:  064  State: OPENDoor:  065  State: CLOSEDoor:  066  State: CLOSEDoor:  067  State: CLOSEDoor:  068  State: CLOSEDoor:  069  State: CLOSEDoor:  070  State: CLOSEDoor:  071  State: CLOSEDoor:  072  State: CLOSEDoor:  073  State: CLOSEDoor:  074  State: CLOSEDoor:  075  State: CLOSEDoor:  076  State: CLOSEDoor:  077  State: CLOSEDoor:  078  State: CLOSEDoor:  079  State: CLOSEDoor:  080  State: CLOSEDoor:  081  State: OPENDoor:  082  State: CLOSEDoor:  083  State: CLOSEDoor:  084  State: CLOSEDoor:  085  State: CLOSEDoor:  086  State: CLOSEDoor:  087  State: CLOSEDoor:  088  State: CLOSEDoor:  089  State: CLOSEDoor:  090  State: CLOSEDoor:  091  State: CLOSEDoor:  092  State: CLOSEDoor:  093  State: CLOSEDoor:  094  State: CLOSEDoor:  095  State: CLOSEDoor:  096  State: CLOSEDoor:  097  State: CLOSEDoor:  098  State: CLOSEDoor:  099  State: CLOSEDoor:  100  State: OPEN

Ada

unoptimized

withAda.Text_Io;useAda.Text_Io;procedureDoorsistypeDoor_Stateis(Closed,Open);typeDoor_Listisarray(Positiverange1..100)ofDoor_State;The_Doors:Door_List:=(others=>Closed);beginforIin1..100loopforJinThe_Doors'rangeloopifJmodI=0thenifThe_Doors(J)=ClosedthenThe_Doors(J):=Open;elseThe_Doors(J):=Closed;endif;endif;endloop;endloop;forIinThe_Doors'rangeloopPut_Line(Integer'Image(I)&" is "&Door_State'Image(The_Doors(I)));endloop;endDoors;

optimized

withAda.Text_Io;useAda.Text_Io;withAda.Numerics.Elementary_Functions;useAda.Numerics.Elementary_Functions;procedureDoors_OptimizedisNum:Float;beginforIin1..100loopNum:=Sqrt(Float(I));Put(Integer'Image(I)&" is ");ifFloat'Floor(Num)=NumthenPut_Line("Opened");elsePut_Line("Closed");endif;endloop;endDoors_Optimized;

Adina

двери = новый-массив 100 ложьцикл  шаг    в-диапазоне 1 101  цикл    номер      в-диапазоне (шаг - 1) 100 шаг    двери[номер] := не двери[номер]цикл  номер 100  вывести/перенос    формат «Дверь ~a ~a»      номер + 1      двери[номер] ? «открыта» «закрыта»

or in english

english()doors = make-vector 100 #ffor  $ step    in-range 1 101  for    $ number      in-range (step - 1) 100 step    doors[number] := not doors[number]for  $ number 100  displayln    format "Door ~a ~a"      number + 1      if doors[number] "open" "closed"

Agena

Translation of Algol W. Tested with Agena 2.9.5 Win32

# find the first few squares via the unoptimised door flipping methodscopelocal doorMax := 100;local door;createregister door( doorMax );# set all doors to closedfor ito doorMaxdo door[ i ] :=falseod;# repeatedly flip the doorsfor ito doorMaxdofor jfrom ito doorMaxby ido door[ j ] :=not door[ j ]odod;# display the resultsfor ito doorMaxdoif door[ i ]then write( " ", i )fiod; print()epocs

Aikido

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

ALGOL 60

Works with:A60
begincomment - 100 doors problem in ALGOL-60;booleanarray doors[1:100];integer i, j;boolean open, closed; open :=true;closed :=nottrue; outstring(1,"100 Doors Problem\n");comment - all doors are initially closed;for i := 1step 1until 100do  doors[i] := closed;comment  cycle through at increasing intervals  and flip each door encountered;for i := 1step 1until 100dofor j := istep iuntil 100do    doors[j] :=not doors[j];comment - show which doors are open;outstring(1,"The open doors are:");for i := 1step 1until 100doif doors[i]then     outinteger(1,i);end
Output:
100 Doors ProblemThe open doors are: 1  4  9  16  25  36  49  64  81  100

ALGOL 68

unoptimized

PROC doors = (INT limit)VOID:(MODEDOORSTATE =BOOL;BOOL closed =FALSE;BOOL open =NOT closed;MODEDOORLIST = [limit]DOORSTATE;DOORLIST the doors;FOR iFROMLWB the doorsTOUPB the doorsDO the doors[i]:=closedOD;FOR iFROMLWB the doorsTOUPB the doorsDOFOR jFROMLWB the doorsBY iTOUPB the doorsDO      the doors[j] :=NOT the doors[j]ODOD;FOR iFROMLWB the doorsTOUPB the doorsDO    print((whole(i,-12)," is ",(the doors[i]|"opened"|"closed"),newline))OD);doors(100)

optimized

PROC doors optimised = (INT limit )VOID:FOR iTO limitDOREAL num := sqrt(i);    print((whole(i,0)," is ",(ENTIER num = num |"opened"|"closed"),newline))OD;doors optimised(100)

ALGOL W

begin% find the first few squares via the unoptimised door flipping method   %integer doorMax;    doorMax := 100;begin% need to start a new block so the array can have variable bounds   %% array of doors - door( i ) is true if open, false if closed       %logicalarray door( 1 :: doorMax );% set all doors to closed                                           %for i := 1until doorMaxdo door( i ) :=false;% repeatedly flip the doors                                         %for i := 1until doorMaxdobeginfor j := istep iuntil doorMaxdobegin                door( j ) :=not door( j )endend;% display the results                                               %        i_w := 1;% set integer field width                                 %        s_w := 1;% and separator width                                     %for i := 1until doorMaxdoif door( i )then writeon( i )endend.
Output:
 1 4 9 16 25 36 49 64 81 100

ALGOL-M

BEGININTEGER ARRAY DOORS[1:100];INTEGER I, J, OPEN, CLOSED;OPEN := 1;CLOSED := 0;% ALL DOORS ARE INITIALLY CLOSED %FOR I := 1 STEP 1 UNTIL 100 DO  BEGIN    DOORS[I] := CLOSED;  END;% PASS THROUGH AT INCREASING INTERVALS AND FLIP %FOR I := 1 STEP 1 UNTIL 100 DO  BEGIN     FOR J := I STEP I UNTIL 100 DO       BEGIN         DOORS[J] := 1 - DOORS[J];       END;  END;% SHOW RESULTS %WRITE("THE OPEN DOORS ARE:");WRITE("");FOR I := 1 STEP 1 UNTIL 100 DO  BEGIN    IF DOORS[I] = OPEN THEN      WRITEON(I);  END;END
Output:
THE OPEN DOORS ARE:     1     4     9    16    25    36    49    64    81   100

AmigaE

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

APL

Works with:GNU APL
doors←{100⍴((⍵-1)⍴0),1}≠⌿⊃doors¨⍳100

optimizedNote that ⎕IO = 1

2|+/[1]0=D∘.|D←⍳100

The idea is that then:th door will be flipped the same number of times as there are divisors forn. So first we make D all ints 1..100 (D←⍳100).
The next step is to find the remainders of every such int when divided by every other (D∘.|D).
This results in a 100×100 matrix which we turn into a binary one by testing if the values are equal to zero i.e. divisors.
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 whichn have an odd number of divisors, i.e. will be flipped an odd number of times and thus end up open.

Works with:Dyalog APL
Works with:GNU APL
≠⌿0=(⍳100)∘.|⍳100

Each of the above solutions produces the same output:

Output:
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 1

However the result is obtained, applying the ⍸ function (which has been in Dyalog since 16.0 and was added to GNU APL in SVN r1368, 2020-12-03) will transform the Boolean array into a list of the indices of the true values (open doors):

⍸≠⌿0=(⍳100)∘.|⍳100
Output:
1 4 9 16 25 36 49 64 81 100

AppleScript

Iteration

setis_opento{}repeat100timessetendofis_opentofalseendrepeatwithpassfrom1to100repeatwithdoorfrompassto100bypasssetitemdoorofis_opentonotitemdoorofis_openendendsetopen_doorsto{}repeatwithdoorfrom1to100ifitemdoorofis_openthensetendofopen_doorstodoorendendsettext item delimitersto", "display dialog"Open doors: "&open_doors

This is similar to the above, but makes use of the fact that the final status of the first door in each pass is known as it's about to be set and the door number can thus be logged at that point if needed. It makes a separate checking repeat at the end unnecessary, the toggled status boolean doesn't need to be put back into the list, and the door number can be stored in the redundant list slot instead of a separate results list having to be built. It would be satisfying if the first pass, opening all the doors, could be combined with the initial creation of the doors list, but the task description does say "all initially closed"!

on_100doors()scriptopropertydoors:{}endscriptrepeat100timessetendofo'sdoorstofalse-- false = "not open".endrepeatrepeatwithpassfrom1to100if(notitempassofo'sdoors)thensetitempassofo'sdoorstopassrepeatwithdfrom(pass+pass)to100bypasssetitemdofo'sdoorsto(notitemdofo'sdoors)endrepeatendrepeatreturno'sdoors'sintegersend_100doorsonjoin(lst,delim)setastidtoAppleScript'stext item delimiterssetAppleScript'stext item delimiterstodelimsettxttolstastextsetAppleScript'stext item delimiterstoastidreturntxtendjoinreturn"Open doors:"&join(_100doors(),", ")
Output:
"Open doors:1, 4, 9, 16, 25, 36, 49, 64, 81, 100"

Functional composition

-- FINAL DOOR STATES ----------------------------------------------------------- finalDoors :: Int -> [(Int, Bool)]onfinalDoors(n)-- toggledCorridor :: [(Int, Bool)] -> (Int, Bool) -> Int -> [(Int, Bool)]scripttoggledCorridoron|λ|(a,_,k)-- perhapsToggled :: Bool -> Int -> BoolscriptperhapsToggledon|λ|(x,i)ifimodk=0then{i,notitem2ofx}else{i,item2ofx}endifend|λ|endscriptmap(perhapsToggled,a)end|λ|endscriptsetxstoenumFromTo(1,n)foldl(toggledCorridor,¬zip(xs,replicate(n,{false})),xs)endfinalDoors-- TEST ----------------------------------------------------------------------onrun-- isOpenAtEnd :: (Int, Bool) -> BoolscriptisOpenAtEndon|λ|(door)(item2ofdoor)end|λ|endscript-- doorNumber :: (Int, Bool) -> IntscriptdoorNumberon|λ|(door)(item1ofdoor)end|λ|endscriptmap(doorNumber,filter(isOpenAtEnd,finalDoors(100)))--> {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}endrun-- GENERIC FUNCTIONS ----------------------------------------------------------- enumFromTo :: Int -> Int -> [Int]onenumFromTo(m,n)ifn<mthensetdto-1elsesetdto1endifsetlstto{}repeatwithifrommtonbydsetendoflsttoiendrepeatreturnlstendenumFromTo-- filter :: (a -> Bool) -> [a] -> [a]onfilter(f,xs)tellmReturn(f)setlstto{}setlngtolengthofxsrepeatwithifrom1tolngsetvtoitemiofxsif|λ|(v,i,xs)thensetendoflsttovendrepeatreturnlstendtellendfilter-- foldl :: (a -> b -> a) -> a -> [b] -> aonfoldl(f,startValue,xs)tellmReturn(f)setvtostartValuesetlngtolengthofxsrepeatwithifrom1tolngsetvto|λ|(v,itemiofxs,i,xs)endrepeatreturnvendtellendfoldl-- map :: (a -> b) -> [a] -> [b]onmap(f,xs)tellmReturn(f)setlngtolengthofxssetlstto{}repeatwithifrom1tolngsetendoflstto|λ|(itemiofxs,i,xs)endrepeatreturnlstendtellendmap-- min :: Ord a => a -> a -> aonmin(x,y)ify<xthenyelsexendifendmin-- Lift 2nd class handler function into 1st class script wrapper-- mReturn :: Handler -> ScriptonmReturn(f)ifclassoffisscriptthenfelsescriptproperty|λ|:fendscriptendifendmReturn-- replicate :: Int -> a -> [a]onreplicate(n,a)setoutto{}ifn<1thenreturnoutsetdblto{a}repeatwhile(n>1)if(nmod2)>0thensetouttoout&dblsetnto(ndiv2)setdblto(dbl&dbl)endrepeatreturnout&dblendreplicate-- zip :: [a] -> [b] -> [(a, b)]onzip(xs,ys)setlngtomin(lengthofxs,lengthofys)setlstto{}repeatwithifrom1tolngsetendoflstto{itemiofxs,itemiofys}endrepeatreturnlstendzip
Output:
{1,4,9,16,25,36,49,64,81,100}

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). Usingmap from the functional composition example above:

map(factorCountMod2,enumFromTo(1,100))onfactorCountMod2(n){n,(lengthofintegerFactors(n))mod2=1}endfactorCountMod2

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). Usingmap andenumFromTo from the functional composition example above:

-- perfectSquaresUpTo :: Int -> [Int]onperfectSquaresUpTo(n)scriptsquared-- (Int -> Int)on|λ|(x)x*xend|λ|endscriptsetrealRootton^(1/2)setintRoottorealRootasintegersetblnNotPerfectSquaretonot(intRoot=realRoot)map(squared,enumFromTo(1,intRoot-(blnNotPerfectSquareasinteger)))endperfectSquaresUpToonrunperfectSquaresUpTo(100)endrun
Output:
{1,4,9,16,25,36,49,64,81,100}

Arbre

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

Argile

use std, arrayclose all doorsfor each pass from 1 to 100  for (door = pass) (door <= 100) (door += pass)    toggle doorlet 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 boolfor each door from 1 to 100  printf "#%.3d %s\n" door (doors[door - 1]) ? "[ ]", "[X]"

ArkScript

Works with:ArkScript version 4.0.0
(import std.Range :range :forEach)(import std.List)(mut doors (list:fill 100 false))(let r (range 0 100))(forEach r  (fun (i) {    (mut j i)    (while (< j 100) {      (@= doors j (not (@ doors j)))      (set j (+ j i 1)) })    (print doors) }))(print  (list:map    (list:filter      (list:zipWithIndex doors)      (fun (e)        (@ e 1)))    (fun (e) (@ e 0))))
Output:
[true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true]...[true false false true false false false false true false false false false false false true false false false false false false false false true false false false false false false false false false false true false false false false false false false false false false false false true false false false false false false false false false false false false false false true false false false false false false false false false false false false false false false false true false false false false false false false false false false false false false false false false false false true][0 3 8 15 24 35 48 63 80 99]

ARM Assembly

Works with:as version Raspberry Pi

unoptimized

/* ARM assembly Raspberry PI  *//*  program 100doors.s   *//************************************//* Constantes                       *//************************************/.equ STDOUT, 1                                 @ Linux output console.equ EXIT,   1                                 @ Linux syscall.equ WRITE,  4                                 @ Linux syscall.equ NBDOORS,   100/*********************************//* Initialized data              *//*********************************/.datasMessResult:       .ascii "The door "sMessValeur:       .fill 11, 1, ' '            @ size => 11                      .asciz "is open.\n"/*********************************//* UnInitialized data            *//*********************************/.bss  stTableDoors:.skip   4 * NBDOORS/*********************************//*  code section                 *//*********************************/.text.global main main:                                         @ entry of program     push {fp,lr}                              @ saves 2 registers     @ display first line    ldr r3,iAdrstTableDoors                   @ table address    mov r5,#1            1:    mov r4,r52:                                            @ begin loop    ldr r2,[r3,r4,lsl #2]                     @ read doors index r4    cmp r2,#0    moveq r2,#1                               @ if r2 = 0   1 -> r2    movne r2,#0                               @ if r2 = 1   0 -> r2    str r2,[r3,r4,lsl #2]                     @ store value of doors    add r4,r5                                 @ increment r4 with  r5 value    cmp r4,#NBDOORS                           @ number of doors ?    ble 2b                                    @ no -> loop    add r5,#1                                 @ increment the increment !!    cmp r5,#NBDOORS                           @ number of doors ?    ble 1b                                    @ no -> loop                                              @ loop display state doors    mov r4,#0              3:    ldr r2,[r3,r4,lsl #2]                     @ read state doors r4 index    cmp r2,#0    beq 4f    mov r0,r4                                 @ open -> display message    ldr r1,iAdrsMessValeur                    @ display value index    bl conversion10                           @ call function    ldr r0,iAdrsMessResult    bl affichageMess                          @ display message4:    add r4,#1    cmp r4,#NBDOORS    ble 3b                                    @ loop 100:                                          @ standard end of the program     mov r0, #0                                @ return code    pop {fp,lr}                               @restaur 2 registers    mov r7, #EXIT                             @ request to exit program    svc #0                                    @ perform the system calliAdrsMessValeur:                .int sMessValeuriAdrstTableDoors:.int stTableDoorsiAdrsMessResult:.int sMessResult/******************************************************************//*     display text with size calculation                         */ /******************************************************************//* r0 contains the address of the message */affichageMess:    push {r0,r1,r2,r7,lr}                     @ save  registres    mov r2,#0                                 @ counter length 1:                                            @ loop length calculation     ldrb r1,[r0,r2]                           @ read octet start position + index     cmp r1,#0                                 @ if 0 its over     addne r2,r2,#1                            @ else add 1 in the length     bne 1b                                    @ and loop                                               @ so here r2 contains the length of the message     mov r1,r0              @ address message in r1     mov r0,#STDOUT            @ code to write to the standard output Linux     mov r7, #WRITE                            @ code call system "write"     svc #0                                    @ call systeme     pop {r0,r1,r2,r7,lr}                      @ restaur des  2 registres */     bx lr                                     @ return  /******************************************************************//*     Converting a register to a decimal unsigned                */ /******************************************************************//* r0 contains value and r1 address area   *//* r0 return size of result (no zero final in area) *//* area size => 11 bytes          */.equ LGZONECAL,   10conversion10:    push {r1-r4,lr}                            @ save registers     mov r3,r1    mov r2,#LGZONECAL1:                                       @ start loop    bl divisionpar10U                          @unsigned  r0 <- dividende. quotient ->r0 reste -> r1    add r1,#48                                 @ digit    strb r1,[r3,r2]                            @ store digit on area    cmp r0,#0                                  @ stop if quotient = 0     subne r2,#1                                @ else previous position    bne 1b                               @ and loop    // and move digit from left of area    mov r4,#02:    ldrb r1,[r3,r2]    strb r1,[r3,r4]    add r2,#1    add r4,#1    cmp r2,#LGZONECAL    ble 2b    // and move spaces in end on area    mov r0,r4                                 @ result length     mov r1,#' '                               @ space3:    strb r1,[r3,r4]                           @ store space in area    add r4,#1                                 @ next position    cmp r4,#LGZONECAL    ble 3b                                    @ loop if r4 <= area size100:    pop {r1-r4,lr}                            @ restaur registres     bx lr                                     @return/***************************************************//*   division par 10   unsigned                    *//***************************************************//* r0 dividende   *//* r0 quotient *//* r1 remainder  */divisionpar10U:    push {r2,r3,r4, lr}    mov r4,r0                                        @ save value    //mov r3,#0xCCCD                                 @ r3 <- magic_number  lower   @ for Raspberry pi 3    //movt r3,#0xCCCC                                @ r3 <- magic_number  upper   @ for Raspberry pi 3    ldr r3,iMagicNumber                              @ for Raspberry pi 1 2    umull r1, r2, r3, r0                             @ r1<- Lower32Bits(r1*r0) r2<- Upper32Bits(r1*r0)     mov r0, r2, LSR #3                               @ r2 <- r2 >> shift 3    add r2,r0,r0, lsl #2                             @ r2 <- r0 * 5     sub r1,r4,r2, lsl #1                             @ r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10)    pop {r2,r3,r4,lr}    bx lr                                            @ leave function iMagicNumber:            .int 0xCCCCCCCD

optimized

/*********************************************//* optimized version                         *//*********************************************//* ARM assembly Raspberry PI  *//*  program 100doors.s   *//************************************//* Constantes                       *//************************************/.equ STDOUT, 1     @ Linux output console.equ EXIT,   1     @ Linux syscall.equ WRITE,  4     @ Linux syscall.equ NBDOORS,   100/*********************************//* Initialized data              *//*********************************/.datasMessResult:       .ascii "The door "sMessValeur:       .fill 11, 1, ' '                 @ size => 11                   .asciz "is open.\n"/*********************************//* UnInitialized data            *//*********************************/.bss  /*********************************//*  code section                 *//*********************************/.text.global main main:                                               @ entry of program     push {fp,lr}                                    @ saves 2 registers                                                     @ display first line    mov r5,#3                                       @ start value of increment    mov r4,#1                                       @ start doors                                                    @ loop display state doors1:    mov r0,r4                                       @ open -> display message    ldr r1,iAdrsMessValeur                          @ display value index    bl conversion10                                 @ call function    ldr r0,iAdrsMessResult    bl affichageMess                                @ display message    add r4,r5                                       @ add increment    add r5,#2                                       @ new increment    cmp r4,#NBDOORS    ble 1b                                          @ loop 100:   @ standard end of the program     mov r0, #0                                      @ return code    pop {fp,lr}                                     @ restaur 2 registers    mov r7, #EXIT                                   @ request to exit program    svc #0                                          @ perform the system calliAdrsMessValeur:                .int sMessValeuriAdrsMessResult:.int sMessResult/******************************************************************//*     display text with size calculation                         */ /******************************************************************//* r0 contains the address of the message */affichageMess:    push {r0,r1,r2,r7,lr}                           @ save  registres    mov r2,#0                                       @ counter length 1:                                                  @ loop length calculation     ldrb r1,[r0,r2]                                 @ read octet start position + index     cmp r1,#0                                       @ if 0 its over     addne r2,r2,#1                                  @ else add 1 in the length     bne 1b                                          @ and loop                                                     @ so here r2 contains the length of the message     mov r1,r0                    @ address message in r1     mov r0,#STDOUT                  @ code to write to the standard output Linux     mov r7, #WRITE                                  @ code call system "write"     svc #0                                          @ call systeme     pop {r0,r1,r2,r7,lr}                            @ restaur des  2 registres */     bx lr                                           @ return  /******************************************************************//*     Converting a register to a decimal unsigned                */ /******************************************************************//* r0 contains value and r1 address area   *//* r0 return size of result (no zero final in area) *//* area size => 11 bytes          */.equ LGZONECAL,   10conversion10:    push {r1-r4,lr}                                 @ save registers     mov r3,r1    mov r2,#LGZONECAL1:                                            @ start loop    bl divisionpar10U                               @ unsigned  r0 <- dividende. quotient ->r0 reste -> r1    add r1,#48                                      @ digit    strb r1,[r3,r2]                                 @ store digit on area    cmp r0,#0                                       @ stop if quotient = 0     subne r2,#1                                     @ else previous position    bne 1b                                    @ and loop                                                    @ and move digit from left of area    mov r4,#02:    ldrb r1,[r3,r2]    strb r1,[r3,r4]    add r2,#1    add r4,#1    cmp r2,#LGZONECAL    ble 2b                                                    @ and move spaces in end on area    mov r0,r4                                       @ result length     mov r1,#' '                                     @ space3:    strb r1,[r3,r4]                                 @ store space in area    add r4,#1                                       @ next position    cmp r4,#LGZONECAL    ble 3b                                          @ loop if r4 <= area size100:    pop {r1-r4,lr}                                  @ restaur registres     bx lr                                           @return/***************************************************//*   division par 10   unsigned                    *//***************************************************//* r0 dividende   *//* r0 quotient *//* r1 remainder  */divisionpar10U:    push {r2,r3,r4, lr}    mov r4,r0                                       @ save value    //mov r3,#0xCCCD                                @ r3 <- magic_number  lower   @ for raspberry 3    //movt r3,#0xCCCC                               @ r3 <- magic_number  upper   @ for raspberry 3    ldr r3,iMagicNumber                             @ for raspberry 1 2    umull r1, r2, r3, r0                            @ r1<- Lower32Bits(r1*r0) r2<- Upper32Bits(r1*r0)     mov r0, r2, LSR #3                              @ r2 <- r2 >> shift 3    add r2,r0,r0, lsl #2                            @ r2 <- r0 * 5     sub r1,r4,r2, lsl #1                            @ r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10)    pop {r2,r3,r4,lr}    bx lr                                           @ leave function iMagicNumber:            .int 0xCCCCCCCD

Arturo

isOpen:map1..101=>falseloop1..100'pass->loop(range.step:passpass100)'door[isOpen\[door]:not?isOpen\[door]]loop1..100'x->ifisOpen\[x][print["Door"x"is open."]]
Output:
Door 1 is open. Door 4 is open. Door 9 is open. Door 16 is open. Door 25 is open. Door 36 is open. Door 49 is open. Door 64 is open. Door 81 is open. Door 100 is open.

Astro

vardoors=falses(100)forain1..100:forbina..a..100:doors[b]=notdoors[b]forain1..100:print"Door $a is ${(doors[a]) ? 'open.': 'closed.'}"

Asymptote

for(inti=1;i<100;++i){if(i%i^2<11){write("Door ",i^2,suffix=none);write(" is open");}}

ATS

#include "share/atspre_staload.hats"implementmain0((*void*)) = let//var A = @[bool][100](false)val A = $UNSAFE.cast{arrayref(bool,100)}(addr@A)//fnxloop(  pass: intGte(0)) : void =  if pass < 100    then loop2 (pass, pass)  // end of [if]andloop2(  pass: natLt(100), door: intGte(0)) : void =  if door < 100    then (A[door] := ~A[door]; loop2(pass, door+pass+1))    else loop(pass+1)  // end of [if]//funloop3(  door: intGte(0)) : void =  if door < 100    then (      println!("door #", door+1, " is ", (if A[door] then "open" else "closed"): string, ".");      loop3(door+1)    ) (* end of [then] *)  // end of [if]//in  loop(0); loop3 (0)end // end of [main0]

AutoHotkey

Standard Approach

Loop,100Door%A_Index%:="closed"Loop,100{x:=A_Index,y:=A_IndexWhile(x<=100){CurrentDoor:=Door%x%IfCurrentDoorcontainsclosed{Door%x%:="open"x+=y}elseifCurrentDoorcontainsopen{Door%x%:="closed"x+=y}}}Loop,100{CurrentDoor:=Door%A_Index%IfCurrentDoorcontainsopenRes.="Door "A_Index" is open`n"}MsgBox%Res

Alternative Approach

Making use of the identity:

∑i=1n(2i−1)=n2{\displaystyle {\displaystyle \sum _{i=1}^{n}(2i-1)=n^{2}}}

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

Optimized

While(Door:=A_Index**2)<=100Result.="Door "Door" is open`n"MsgBox,%Result%

AutoIt

#include<array.au3>$doors=100;door array, 0 = closed, 1 = openLocal$door[$doors+1]For$ii=1To$doorsFor$i=$iiTo$doorsStep$ii$door[$i]=Not$door[$i]nextNext;display to screenFor$i=1To$doorsConsoleWrite(Number($door[$i])&" ")IfMod($i,10)=0ThenConsoleWrite(@CRLF)Next

AutoLISP

(defunCreateDoors(n/doors)(repeatn(setqdoors(consnildoors))))(defunDoors(doors/cnt)(setqcnt0)(mapcar'(lambda(d)(zerop(rem(sqrt(setqcnt(1+cnt)))1)))doors))>(Doors(CreateDoors100))(TnilnilTnilnilnilnilTnilnilnilnilnilnilTnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilnilTnilnilnilnil)

AWK

unoptimized

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

optimized

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

Axiom

Unoptimized:

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

Optimized:

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

B

Works with:The Amsterdam Compiler Kit - B version V6.1pre1
main(){  auto doors[100]; /* != 0 means open */  auto pass, door;  door = 0;  while( door<100 ) doors[door++] = 0;  pass = 0;  while( pass<100 )  {    door = pass;    while( door<100 )    {      doors[door] = !doors[door];      door =+ pass+1;    }    ++pass;  }  door = 0;  while( door<100 )  {    printf("door #%d is %s.*n", door+1, doors[door] ? "open" : "closed");    ++door;  }  return(0);}

BabyCobol

      * NB: the implementation is rather vanilla      * besides using the idiomatic buffer overrun.      * LOOP is what PERFORM in COBOL is, with defaults.      * MOVE in this language acts like OVE CORRESPONDING,      * which is actually good here.IDENTIFICATIONDIVISION.PROGRAM-ID.ONEHUNDREDDOORS.DATADIVISION.01IPICTURE IS9(3).01JLIKEI.01DOORPICTURE IS9OCCURS100TIMES.01STOPLIKEDOOR.PROCEDUREDIVISION.      * Initialise the dataMOVEHIGH-VALUESTOSTOPMOVESPACESTODOOR.      * Do the main algorithmLOOPVARYINGIUNTILDOOR(I)=9LOOPVARYINGJFROMITO100BYISUBTRACTDOOR(J)FROM1GIVINGDOOR(J)ENDEND.      * Print the resultsLOOPVARYINGIUNTILDOOR(I)=9DISPLAY"Door"I"is"WITHNOADVANCINGIFDOOR(I)=1THENDISPLAY"open"ELSEDISPLAY"closed".END.


BaCon

OPTION BASE1DECLAREdoors[100]FORsize=1TO100FORpass=0TO100STEPsizedoors[pass]=NOT(doors[pass])NEXTNEXTFORwhich=1TO100IFdoors[which]THENPRINTwhichNEXT
Output:
149162536496481100

Bait

const NUM_DOORS := 100fun main() {// All doors are closed by default (`false`)mut is_open := []bool{length = NUM_DOORS}// Make 100 passes by the doorsfor pass := 0; pass < 100; pass += 1 {// Only visit every `pass + 1`th doorfor door := pass; door < NUM_DOORS; door += pass + 1 {is_open[door] = not is_open[door]}}// Print the doors that are openfor i, open in is_open {if open {println("Door #${i + 1} is open.")}}}
Output:
Door #1 is open.Door #4 is open.Door #9 is open.Door #16 is open.Door #25 is open.Door #36 is open.Door #49 is open.Door #64 is open.Door #81 is open.Door #100 is open.

BASIC

ANSI BASIC

Translation of:ALGOL 68
Works with:Decimal BASIC
100REM 100 doors110REM The unoptimised door flipping method120REM which simulates the process130DIMIsDoorOpen(1TO100)140LETDoorMax=UBOUND(IsDoorOpen)150REM Set all doors to closed160FORI=1TODoorMax170LETIsDoorOpen(I)=0180NEXTI190REM Repeatedly flip the doors200FORI=1TODoorMax210FORJ=ITODoorMaxSTEPI220LETIsDoorOpen(J)=1-IsDoorOpen(J)230NEXTJ240NEXTI250REM Display the results260FORI=1TODoorMax270IFIsDoorOpen(I)<>0THENPRINTI;280NEXTI290PRINT300END
Output:
 1  4  9  16  25  36  49  64  81  100

Applesoft BASIC

Based on the Sinclair ZX81 BASIC implementation.

100:110REM100DOORSPROBLEM120:130DIMD(100)140FORP=1TO100150FORT=PTO100STEPP160D(T)=NOTD(T):NEXTT170NEXTP180FORI=1TO100190IFD(I)THENPRINTI;" ";200NEXTI
Output:
                                        ]RUN1 4 9 16 25 36 49 64 81 100

BASIC256

# 100 doors problemdim d(100)# simple solutionprint "simple solution"gosub initializefor t = 1 to 100   for j = t to 100 step t      d[j-1] = not d[j-1]   next jnext tgosub showopen# more optimized solutionprint "more optimized solution"gosub initializefor t = 1 to 10      d[t^2-1] = truenext tgosub showopenendinitialize:for t = 1 to d[?]   d[t-1] = false # closednext treturnshowopen:for t = 1 to d[?]   print d[t-1]+ " ";   if t%10 = 0 then printnext treturn


ultra optimizado: portado desde la versión Julia

fori=1to10:ifi%i^2<11thenprint"La puerta ";int(i^2);" esta abierta":endif:nexti:end

CBASIC

Works with:CBASIC 2
Works with:CB80
dimdoors%(100)print"Finding solution to the 100 Doors Problem"rem-alldoorsareinitiallyclosedfori%=1to100doors%(i%)=0nexti%rem-passthroughatincreasingintervalsfori%=1to100forj%=i%to100stepi%rem-flipeachdoorencountereddoors%(j%)=1-doors%(j%)nextj%nexti%rem-showwhichdoorsareopenprint"The open doors are: ";fori%=1to100ifdoors%(i%)=1thenprinti%;nexti%printprint"Thanks for consulting the puzzle guru!"end
Output:
Finding solution to the 100 Doors ProblemThe open doors are: 1 4 9 15 25 36 47 64 81 100Thanks for consulting the puzzle guru!

Chipmunk Basic

Works with:Chipmunk Basic version 3.6.4
Works with:Applesoft BASIC
Works with:QBasic
Works with:GW-BASIC

Based on the Sinclair ZX81 BASIC implementation.

100CLS:REM10HOMEforApplesoftBASIC110DIMD(100)120FORP=1TO100130FORT=PTO100STEPP140D(T)=NOTD(T)150NEXTT160NEXTP170' Print "opened" doors180FORI=1TO100190IFD(I)THENPRINTI;" ";200NEXTI210END
Output:
>RUN1  4  9  16  25  36  49  64  81  100  >

Commodore BASIC

Based on the Sinclair ZX81 BASIC implementation.

10DIMD(100)20FORI=1TO10030FORJ=ITO100STEPI40D(J)=NOTD(J)50NEXTJ60NEXTI70FORI=1TO10080IFD(I)THENPRINTI,90NEXTI

GW-BASIC

Works with:Applesoft BASIC
Works with:Chipmunk Basic
Works with:QBasic

Based on the Sinclair ZX81 BASIC implementation.

100CLS:REM10HOMEforApplesoftBASIC110DIMD(100)120FORP=1TO100130FORT=PTO100STEPP140D(T)=NOTD(T)150NEXTT160NEXTP170' Print "opened" doors180FORI=1TO100190IFD(I)THENPRINTI;" ";200NEXTI210END
Output:
  1  4  9  16  25  36  49  64  81  100

IS-BASIC

100 PROGRAM "100doors.bas"110 NUMERIC D(1 TO 100)120 FOR I=1 TO 100130   LET D(I)=0140 NEXT150 FOR I=1 TO 100160   FOR J=I TO 100 STEP I170     LET D(J)=NOT D(J)180   NEXT 190 NEXT200 FOR I=1 TO 100210   IF D(I) THEN PRINT I220 NEXT

Optimized:

100 PROGRAM "100doors.bas"110 LET NR=1:LET D=3120 DO130   PRINT NR140   LET NR=NR+D:LET D=D+2150 LOOP WHILE NR<=100

Minimal BASIC

Works with:IS-BASIC
10PRINT"FOLLOWING DOORS ARE OPEN:"20LETI=030REM LOOP40LETI=I+150PRINTI*I;" ";60IFI*I<100THEN3070END

MSX Basic

Based on the Sinclair ZX81 BASIC implementation.

10DIMD(100)20FORI=1TO10030FORJ=iTO100STEPI40D(J)=NOTD(J)50NEXTJ60NEXTI70FORI=1TO10080IFD(I)THENPRINTI;90NEXTI100END
Output:
                                        ]RUN1 4 9 16 25 36 49 64 81 100

QBasic

Works with:QBASIC, QB64

unoptimized

REM "100 Doors" program for QB64 BASIC (http://www.qb64.net/), a QuickBASIC-like compiler.REM Author: G. A. TipperyREM Date: 12-Feb-2014REMREM   Unoptimized (naive) version, per specifications at http://rosettacode.org/wiki/100_doorsDEFINTA-ZCONSTN=100DIMdoor(N)FORstride=1TONFORindex=strideTONSTEPstrideLETdoor(index)=NOT(door(index))NEXTindexNEXTstridePRINT"Open doors:"FORindex=1TONIFdoor(index)THENPRINTindexNEXTindexEND
Works with:QuickBasic version 4.5

unoptimized

DIMdoors(0TO99)FORpass=0TO99FORdoor=passTO99STEPpass+1PRINTdoors(door)PRINTNOTdoors(door)doors(door)=NOTdoors(door)NEXTdoorNEXTpassFORi=0TO99PRINT"Door #";i+1;" is ";IFNOTdoors(i)THENPRINT"closed"ELSEPRINT"open"ENDIFNEXTi

optimized

DIMdoors(0TO99)FORdoor=0TO99IFINT(SQR(door))=SQR(door)THENdoors(door)=-1NEXTdoorFORi=0TO99PRINT"Door #";i+1;" is ";IFNOTdoors(i)THENPRINT"closed"ELSEPRINT"open"ENDIFNEXTi

Quite BASIC

100ARRAYD110FORP=1TO100120FORT=PTO100STEPP130LETD[T]=(D[T]<>1)140NEXTT150NEXTP160FORI=1TO100170IFD[I]THENPRINTI;" ";180NEXTI190END

Tiny BASIC

    PRINT "Open doors are:"    LET I = 110  IF I = 100 THEN END     rem funcion SQR    LET B = I*I    rem funcion MODULO    LET A = I - (I / B) * B    IF A < 11 THEN PRINT B    LET I = I + 1    GOTO 10

Sinclair ZX81 BASIC

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

10DIMD(100)20FORI=1TO10030FORJ=ITO100STEPI40LETD(J)=NOTD(J)50NEXTJ60NEXTI70FORI=1TO10080IFD(I)THENPRINTI,90NEXTI

Batch File

unoptimized

@echo offsetlocal enableDelayedExpansion:: 0 = closed:: 1 = open:: SET /A treats undefined variable as 0:: Negation operator ! must be escaped because delayed expansion is enabledfor/l%%pin(11100)dofor/l%%din(%%p%%p100)doset/a"door%%d=^!door%%d"for/l%%din(11100)doif!door%%d!==1(echo door%%d is open)elseecho door%%d is closed

optimized

@echo offsetlocal enableDelayedExpansionset/asquare=1,incr=3for/l%%din(11100)do(if%%dneq!square!(echo door%%d is closed)else(echo door%%d is openset/asquare+=incr,incr+=2))

BBC BASIC

DIMdoors%(100)FORpass%=1TO100FORdoor%=pass%TO100STEPpass%doors%(door%)=NOTdoors%(door%)NEXTdoor%NEXTpass%FORdoor%=1TO100IFdoors%(door%)PRINT"Door ";door%" is open"NEXTdoor%

bc

/* 0 means door is closed, 1 means door is open */for(i=0; i<100; i++){for(j= i; j<100; j+=(i+1)){        d[j]=1- d[j]/* Toggle door */}}"Open doors:"for(i=0; i<100; i++){if(d[i]==1)(i+1)}

BCPL

get "libhdr"let start() be $(  let doors = vec 100    // close all doors    for n = 1 to 100 do doors!n := 0    // make 100 passes    for pass = 1 to 100 do    $(  let n = pass        while n <= 100 do        $(  doors!n := ~doors!n            n := n + pass        $)    $)        // report which doors are open    for n = 1 to 100 do        if doors!n then            writef("Door %N is open.*N", n)$)
Output:
Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

Befunge

Befunge-93

Unoptimized

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

>"d">:00p1-:>:::9%\9/9+g2%!\:9v$.v_^#!$::$_^#`"c":+g00p+9/9\%<::<_@#`$:\*:+55:+1p27g1g+9/9\%9

Optimized

Just calculates the first 10 perfect squares.

1+:::*.9`#@_

Befunge-98

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

Binary Lambda Calculus

This computes the characteristic sequence of squares by flipping every i'th door in round i, for infinitely many rounds i. But since it's computed lazily and the prefix stabilizes, we can still take the first 100 bits and print them! See corresponding source code athttps://github.com/tromp/AIT/blob/master/characteristic_sequences/squares.lam

0001000100010101000110100000010110000011001110110010100011010000000000101111111000000101111101011001011001000110100001111100110100101111101111000000001011111111110110011001111111011100000000101111110000001011111010110011011100101011000000101111011001011110011110011110110100000000001011011100111011110000000001000000111001110100000000101101110110

Output

1001000010000001000000001000000000010000000000001000000000000001000000000000000010000000000000000001

Blade

Unoptimized version

var doors = [false] * 100for i in 0..100 {  iter var j = i; j < 100; j += i + 1 {    doors[j] = !doors[j]  }  var state = doors[i] ? 'open' : 'closed'  echo 'Door ${i + 1} is ${state}'}

Optimized version

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

Ultra-optimized version

for i in 1..11 echo 'Door ${i**2} is open'

BlitzMax

Works with:BlitzMax version 1.37

optimized

Graphics640,480i=1While((i*i)<=100)a$=i*iDrawTexta$,10,20*iPrinti*ii=i+1WendFlipWaitKey

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  IF A < B, THEN:    QUIT BLOCK 0;  CELL(0) <= 1;  OUTPUT <= 1;  LOOP AT MOST A TIMES:  BLOCK 2: BEGIN    IF OUTPUT * B = A, THEN:    QUIT BLOCK 0;    OUTPUT <= OUTPUT + 1;    IF OUTPUT * B > A, THEN:    BLOCK 3: BEGIN      OUTPUT <= CELL(0);      QUIT BLOCK 0;    BLOCK 3: END;    CELL(0) <= OUTPUT;  BLOCK 2: END;BLOCK 0: END.DEFINE PROCEDURE ''MINUS'' [A,B]:BLOCK 0: BEGIN  IF A < B, THEN:    QUIT BLOCK 0;  LOOP AT MOST A TIMES:  BLOCK 1: BEGIN    IF OUTPUT + B = A, THEN:      QUIT BLOCK 0;    OUTPUT <= OUTPUT + 1;  BLOCK 1: END;BLOCK 0: END.DEFINE PROCEDURE ''MODULUS'' [A,B]:BLOCK 0: BEGIN  CELL(0) <= DIVIDE[A,B];  OUTPUT <= MINUS[A,CELL(0) * B];BLOCK 0: END.DEFINE PROCEDURE ''TOGGLE'' [DOOR]:BLOCK 0: BEGIN  IF DOOR = 1, THEN:    QUIT BLOCK 0;  OUTPUT <= 1;BLOCK 0: END.DEFINE PROCEDURE ''NUMBERS'' [DOOR, COUNT]:BLOCK 0: BEGIN  CELL(0) <= 1; /*each number*/  OUTPUT <= 0; /*current door state*/    LOOP COUNT TIMES:  BLOCK 1: BEGIN    IF MODULUS[DOOR, CELL(0)] = 0, THEN:      OUTPUT <= TOGGLE[OUTPUT];        CELL(0) <= CELL(0) + 1;  BLOCK 1: END;BLOCK 0: END.DEFINE PROCEDURE ''DOORS'' [COUNT]:BLOCK 0: BEGIN  CELL(0) <= 1; /*each door*/  LOOP COUNT TIMES:  BLOCK 1: BEGIN    CELL(1) <= NUMBERS[CELL(0), COUNT];  /*iterate over the states of this door to get its final state*/    IF CELL(1) = 1, THEN: /*door state = open*/      PRINT[CELL(0), '   '];        CELL(0) <= CELL(0) + 1;  BLOCK 1: END;BLOCK 0: END.DOORS[100];
Output:
 > 1    > 4    > 9    > 16    > 25    > 36    > 49    > 64    > 81    > 100

Bracmat

Bracmat is not really at home in tasks that involve addressing things by index number. Here are four solutions that each do the task, but none should win a price for cleanliness.

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.

( 100doors-tbl=   door step  .   tbl$(doors.101) { Create an array. Indexing is 0-based. Add one extra for addressing element nr. 100 }    & 0:?step    &   whl      ' ( 1+!step:~>100:?step   { ~> means 'not greater than', i.e. 'less than or equal' }        & 0:?door        &   whl          ' ( !step+!door:~>100:?door            & 1+-1*!(!door$doors):?doors  { <number>$<variable> sets the current index, which stays the same until explicitly changed. }            )        )    & 0:?door    &   whl      ' ( 1+!door:~>100:?door        &   out          $ ( door              !door              is              ( !(!door$doors):1&open              | closed              )            )        )    & 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?! and!! in the following code.

( 100doors-var=   step door  .   0:?door    &   whl      ' ( 1+!door:~>100:?door        & closed:?!door { this creates a variable and assigns a value 'closed' to it }        )    & 0:?step    &   whl      ' ( 1+!step:~>100:?step        & 0:?door        &   whl          ' ( !step+!door:~>100:?door            &   ( !!door:closed&open                | closed                )              : ?!door               )        )    & 0:?door    &   whl      ' ( 1+!door:~>100:?door        & out$(door !door is !!door)        )    & 0:?door    &   whl      ' ( 1+!door:~>100:?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.

( 100doors-list=   doors door doorIndex step  .   :?doors    & 0:?door    &   whl      ' ( 1+!door:~>100:?door        & closed !doors:?doors        )    & 0:?skip    &   whl      ' ( :?ndoors        &   whl          ' ( !doors:?skipped [!skip %?door ?doors  { the [<number> pattern only succeeds when the scanning cursor is at position <number> }            &     !ndoors                  !skipped                  ( !door:open&closed                  | open                  )              : ?ndoors            )        & !ndoors !doors:?doors        & 1+!skip:<100:?skip        )    & out$!doors)

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

( 100doors-obj=   doors door doorIndex step  .   :?doors    & 0:?door    &   whl      ' ( 1+!door:~>100:?door        & new$(=closed) !doors:?doors        )    & 0:?skip    &   whl      ' ( !doors:?tododoors        &   whl          ' ( !tododoors:? [!skip %?door ?tododoors            &   ( !(door.):open&closed                | open                )              : ?(door.)            )        & 1+!skip:<100:?skip        )    & out$!doors)

These four functions are called in the following way:

100doors-tbl$& 100doors-var$& 100doors-list$& 100doors-obj$;

Burlesque

Version using square numbers:

blsq ) 10ro2?^{1 4 9 16 25 36 49 64 81 100}

BQN

First Solution

swch←≠´{100⥊1«𝕩⥊0}¨1+↕100¯1↓∾{𝕩∾@+10}¨•Fmt¨⟨swch,/swch⟩
"⟨ 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 1 ⟩⟨ 0 3 8 15 24 35 48 63 80 99 ⟩"
swch

uses an idea similar to the GNU APL solution to generate a boolean array of the correct switches.

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

Try it here!

Second Solution

this idea taken from Uiua solution and it's almost identical

F←{1+/2|+˝0=|⌜˜1+↕𝕩}F100# ⟨ 1 4 9 16 25 36 49 64 81 100 ⟩

Optimized

F←{ט1+↕⌊√𝕩}F100# ⟨ 1 4 9 16 25 36 49 64 81 100 ⟩

C

unoptimized

Uses:C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
#include<stdio.h>intmain(){charis_open[100]={0};intpass,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"));return0;}

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

Uses:C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
#include<stdio.h>#define NUM_DOORS 100intmain(intargc,char*argv[]){intis_open[NUM_DOORS]={0};int*doorptr,*doorlimit=is_open+NUM_DOORS;intpass;/* do the N passes, go backwards because the order is not important */for(pass=NUM_DOORS;(pass);--pass){for(doorptr=is_open+(pass-1);(doorptr<doorlimit);doorptr+=pass){(*doorptr)^=1;}}/* output results */for(doorptr=is_open;(doorptr!=doorlimit);++doorptr){printf("door #%lld is %s\n",(doorptr-is_open)+1,(*doorptr)?"open":"closed");}}

memory optimization

This uses bits to represent doors.

#include<stdio.h>#include<stdint.h>intmain(){uint32_tdoorBytes[4]={0};for(uint32_ti=1;i<=100;++i)for(uint32_tj=i-1;j<=99;j+=i)doorBytes[j%4]^=(uint32_t)1<<j/4;for(uint32_ti=0;i<=99;doorBytes[i++%4]>>=1)if(doorBytes[i%4]&1)printf("door %d is open\n",i+1);}

optimized

This optimized version makes use of the fact that finally only the doors with square index are open, as well as the fact thatn2=1+3+5+…+(2n−1){\displaystyle {\displaystyle n^{2}=1+3+5+\ldots +(2n-1)}}.

Uses:C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})
#include<stdio.h>intmain(){intsquare=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;}elseprintf(" is closed.\n");}return0;}

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

#include<stdio.h>intmain(){intdoor,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"));return0;}

Or really optimize it -- square of an integer is, well, computable:

#include<stdio.h>intmain(){inti;for(i=1;i*i<=100;i++)printf("door %d open\n",i*i);return0;}

C#

Unoptimized with Modulus % Operator

namespaceConsoleApplication1{usingSystem;classProgram{staticvoidMain(string[]args){// Arrays are initialized to their type default values; the default for bool is false// Use false to indicate closed doorbool[]doors=newbool[100];//For each pass...for(intp=0;p<100;p++)//number of passes{//For each door to toggle...for(intd=0;d<100;d++)//door number{if((d+1)%(p+1)==0){doors[d]=!doors[d];}}}//Output the results.Console.WriteLine("Passes Completed!!!  Here are the results:");for(intd=0;d<100;d++){if(doors[d]){Console.WriteLine(String.Format("Door #{0}: Open",d+1));}else{Console.WriteLine(String.Format("Door #{0}: Closed",d+1));}}Console.ReadKey(true);}}}

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

namespaceConsoleApplication1{usingSystem;classProgram{staticvoidMain(string[]args){//Perform the operation.bool[]doors=newbool[100];intn=0;intd;while((d=(++n*n))<=100)doors[d-1]=true;//Perform the presentation.for(d=0;d<doors.Length;d++)Console.WriteLine("Door #{0}: {1}",d+1,doors[d]?"Open":"Closed");Console.ReadKey(true);}}}

Unoptimized but Concise

namespaceConsoleApplication1{usingSystem;classProgram{staticvoidMain(){bool[]doors=newbool[100];//The number of passes can be 1-based, but the number of doors must be 0-based.for(intp=1;p<=100;p++)for(intd=p-1;d<100;d+=p)doors[d]=!doors[d];for(intd=0;d<100;d++)Console.WriteLine("Door #{0}: {1}",d+1,doors[d]?"Open":"Closed");Console.ReadKey(true);}}}

Optimized for brevity

namespaceConsoleApplication1{usingSystem;classProgram{staticvoidMain(){doublen;//If the current door number is the perfect square of an integer, say it is open, else say it is closed.for(intd=1;d<=100;d++)Console.WriteLine("Door #{0}: {1}",d,(n=Math.Sqrt(d))==(int)n?"Open":"Closed");Console.ReadKey(true);}}}

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.

usingSystem;usingSystem.IO;usingSystem.Collections.Generic;classProgram{staticvoidMain(){Console.Clear();Console.WriteLine("Input a number of doors to calculate, then press enter");StartCalculator();}staticvoidStartCalculator(){//The number to calculate is input herestringinput=Console.ReadLine();Console.Clear();try{//The program attempts to convert the string to an int//Exceptions will be caught on this lineintnumberOfDoors=Convert.ToInt32(input);//Will call method recursively if input number is less than 1if(numberOfDoors<=0){Console.WriteLine("Please use a number greater than 0");StartCalculator();}//The program then starts the calculation processCalculate(numberOfDoors);//After calculation process is finished, restart method is calledRestartCalculator();}catch(FormatException){//Code will be executed if the number has a decimal or has an unrecognizable symbolConsole.WriteLine("Unable to read. Please use a real number without a decimal");StartCalculator();}catch(OverflowException){//Code will be executed if number is too longConsole.WriteLine("You number is too long");StartCalculator();}}staticvoidCalculate(intnumberOfDoors){//Increases numberOfDoors by 1 since array starts at 0numberOfDoors++;//Dictionary key represents door number, value represents if the door is open//if value == true, the door is openDictionary<int,bool>doors=newDictionary<int,bool>();//Creates Dictionary size of numberOfDoors, all initialized at falsefor(inti=0;i<numberOfDoors;i++){doors.Add(i,false);}//Creates interval between doors, starting at 0, while less than numberOfDoorsfor(intdoorInterval=0;doorInterval<numberOfDoors;doorInterval++){//Will alter every cubby at doorInterval//1 needs to be added since doorInterval will start at 0 and end when equal to numberOfDoorsfor(inti=0;i<numberOfDoors;i+=doorInterval+1){//Changes a false value to true and vice versadoors[i]=doors[i]?false:true;}}//Writes each door and whether it is open or closedfor(inti=0;i<numberOfDoors;i++){//Skips over door 0if(i==0)continue;//Writes open if door value is true, writes closed if door value is falseConsole.WriteLine("Door "+(i)+" is "+(doors[i]?"open":"closed"));}}staticvoidRestartCalculator(){Console.WriteLine("Press any key to restart");Console.ReadKey(true);Main();}}

C++

Works with:GCC version 4.1.2 20061115 (prerelease) (SUSE Linux)

unoptimized

#include<iostream>intmain(){boolis_open[100]={false};// do the 100 passesfor(intpass=0;pass<100;++pass)for(intdoor=pass;door<100;door+=pass+1)is_open[door]=!is_open[door];// output the resultfor(intdoor=0;door<100;++door)std::cout<<"door #"<<door+1<<(is_open[door]?" is open.":" is closed.")<<std::endl;return0;}

optimizedThis optimized version makes use of the fact that finally only the doors with square index are open, as well as the fact that(n+1)2=1+3+5+…+(2n+1){\displaystyle {\displaystyle (n+1)^{2}=1+3+5+\ldots +(2n+1)}}.

#include<iostream>intmain(){intsquare=1,increment=3;for(intdoor=1;door<=100;++door){std::cout<<"door #"<<door;if(door==square){std::cout<<" is open."<<std::endl;square+=increment;increment+=2;}elsestd::cout<<" is closed."<<std::endl;}return0;}

The only calculation that's really needed:

#include<iostream> //compiled with "Dev-C++" , from RaptorOneintmain(){for(inti=1;i*i<=100;i++)std::cout<<"Door "<<i*i<<" is open!"<<std::endl;}

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

#include<iostream>    // compiled with clang (tags/RELEASE_600/final)#include<type_traits> // or g++ (GCC) 7.3.1 20180406 -- from hare1039namespacefunctional_list// basic building block for template meta programming{structNIL{usinghead=NIL;usingtail=NIL;friendstd::ostream&operator<<(std::ostream&os,NILconst){returnos;}};template<typenameH,typenameT=NIL>structlist{usinghead=H;usingtail=T;};template<inti>structinteger{staticconstexprintvalue=i;friendstd::ostream&operator<<(std::ostream&os,integer<i>const){os<<integer<i>::value;returnos;}};template<typenameL,intnTH>constexprautoat(){ifconstexpr(nTH==0)return(typenameL::head){};elseifconstexpr(notstd::is_same_v<typenameL::tail,NIL>)returnat<typenameL::tail,nTH-1>();elsereturnNIL{};}template<typenameL,intnTH>usingat_t=decltype(at<L,nTH>());template<typenameL,typenameelem>constexprautoprepend(){returnlist<elem,L>{};}template<typenameL,typenameelem>usingprepend_t=decltype(prepend<L,elem>());template<intSize,typenameDat=integer<0>>constexprautogen_list(){ifconstexpr(Size==0)returnNIL{};else{usingnext=decltype(gen_list<Size-1,Dat>());returnprepend<next,Dat>();}}template<intSize,typenameDat=integer<0>>usinggen_list_t=decltype(gen_list<Size,Dat>());}namespacefl=functional_list;constexprintdoor_amount=101;// index from 1 to 100template<typenameL,intcurrent,intmoder>constexprautoconstruct_loop(){usingval_t=fl::at_t<L,current>;ifconstexpr(std::is_same_v<val_t,fl::NIL>)returnfl::NIL{};else{constexprintval=val_t::value;usingval_add_t=fl::integer<val+1>;usingval_old_t=fl::integer<val>;ifconstexpr(current==door_amount){ifconstexpr(current%moder==0)returnfl::list<val_add_t>{};elsereturnfl::list<val_old_t>{};}else{usingsub_list=decltype(construct_loop<L,current+1,moder>());ifconstexpr(current%moder==0)returnfl::prepend<sub_list,val_add_t>();elsereturnfl::prepend<sub_list,val_old_t>();}}}template<intiteration>constexprautoconstruct(){ifconstexpr(iteration==1)// door index = 1{usingl=fl::gen_list_t<door_amount>;returnconstruct_loop<l,0,iteration>();}else{usingprev_iter_list=decltype(construct<iteration-1>());returnconstruct_loop<prev_iter_list,0,iteration>();}}template<typenameL,intpos>constexprvoidshow_ans(){ifconstexpr(std::is_same_v<typenameL::head,fl::NIL>)return;else{ifconstexpr(L::head::value%2==1)std::cout<<"Door "<<pos<<" is opened.\n";show_ans<typenameL::tail,pos+1>();}}intmain(){usingresult=decltype(construct<100>());show_ans<result,0>();}

C1R

100_doors

Caché ObjectScript

 for i=1:1:100 { set doors(i) = 0 } for i=1:1:100 { for door=i:i:100 {  Set doors(door)='doors(door) } } for i = 1:1:100 {if doors(i)=1 write i_": open",! }

Output:

1: open4: open9: open16: open25: open36: open49: open64: open81: open100: open

Ceylon

sharedvoidrun(){print("Open doors (naive):     ``naive()``           Open doors (optimized): ``optimized()``");}shared{Integer*}naive(Integercount=100){variablevaluedoors=[for(_in1..count)closed];for(stepin1..count){doors=[for(i->doorindoors.indexed)let(index=i+1)if(step==1||step.divides(index))thendoor.toggle()elsedoor];}returndoors.indexesWhere((door)=>door==opened).map(1.plusInteger);}shared{Integer*}optimized(Integercount=100)=>{for(iin1..count)i*i}.takeWhile(count.notSmallerThan);sharedabstractclassDoor(sharedactualStringstring)ofopened|closed{sharedformalDoortoggle();}objectopenedextendsDoor("opened"){toggle()=>closed;}objectclosedextendsDoor("closed"){toggle()=>opened;}

Output:

Open doors (naive):     { 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 }Open doors (optimized): { 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 }

Clarion

    program    map    endMAX_DOOR_NUMBER         equate(100)CRLF                    equate('<13,10>')Doors                   byte,dim(MAX_DOOR_NUMBER)Pass                    byteDoorNumber              byteDisplayString           cstring(2000)ResultWindow            window('Result'),at(,,133,291),center,double,auto                            prompt('Door states:'),at(8,4),use(?PromptTitle)                            text,at(8,16,116,266),use(DisplayString),boxed,vscroll,font('Courier New',,,,CHARSET:ANSI),readonly                        end    code    Doors :=: false    loop Pass = 1 to MAX_DOOR_NUMBER        loop DoorNumber = Pass to MAX_DOOR_NUMBER by Pass            Doors[DoorNumber] = choose(Doors[DoorNumber], false, true)        end    end    clear(DisplayString)    loop DoorNumber = 1 to MAX_DOOR_NUMBER        DisplayString = DisplayString & format(DoorNumber, @n3) & ' is ' & choose(Doors[DoorNumber], 'opened', 'closed') & CRLF    end    open(ResultWindow)    accept    end    close(ResultWindow)    return

Clio

Unoptimized

fn visit-doors doors step:  if step > 100: doors  else:    [1:100]      -> * fn index:            if index % step: doors[(index - 1)]            else: not doors[(index - 1)]      -> visit-doors (step + 1)[1:100] -> * n: false -> visit-doors 1 => doors[1:100] -> * (@eager) fn i:  doors[(i - 1)]    -> if = true: #open            else: #closed    -> print #Door i #is @

Optimized

[1:100] -> * (@eager) fn i:  i ^ 0.5    -> eq @ (transform i: floor)    -> if = true: #open            else: #closed    -> print #Door i #is @

CLIPS

Unoptimized

(deffacts initial-state  (door-count 100))(deffunction toggle  (?state)  (switch ?state    (case "open" then "closed")    (case "closed" then "open")  ))(defrule create-doors-and-visits  (door-count ?count)  =>  (loop-for-count (?num 1 ?count) do    (assert (door ?num "closed"))    (assert (visit-from ?num ?num))  )  (assert (doors initialized)))(defrule visit  (door-count ?max)  ?visit <- (visit-from ?num ?step)  ?door <- (door ?num ?state)  =>  (retract ?visit)  (retract ?door)  (assert (door ?num (toggle ?state)))  (if    (<= (+ ?num ?step) ?max)    then    (assert (visit-from (+ ?num ?step) ?step))  ))(defrule start-printing  (doors initialized)  (not (visit-from ? ?))  =>  (printout t "These doors are open:" crlf)  (assert (print-from 1)))(defrule print-door  (door-count ?max)  ?pf <- (print-from ?num)  (door ?num ?state)  =>  (retract ?pf)  (if    (= 0 (str-compare "open" ?state))    then    (printout t ?num " ")  )  (if    (< ?num ?max)    then    (assert (print-from (+ ?num 1)))    else    (printout t crlf "All other doors are closed." crlf)  ))

Optimized

(deffacts initial-state  (door-count 100))(deffunction is-square  (?num)  (= (sqrt ?num) (integer (sqrt ?num))))(defrule check-doors  (door-count ?count)  =>  (printout t "These doors are open:" crlf)  (loop-for-count (?num 1 ?count) do    (if (is-square ?num) then      (printout t ?num " ")    )  )  (printout t crlf "All other doors are closed." crlf))

Clojure

Unoptimized / mutable array

(defndoors[](let[doors(into-array(repeat100false))](doseq[pass(range1101)i(range(decpass)100pass)](asetdoorsi(not(agetdoorsi))))doors))(defnopen-doors[](for[[dn](map vector(doors)(iterate inc1)):whend]n))(defnprint-open-doors[](println"Open doors after 100 passes:"(apply str(interpose", "(open-doors)))))

Unoptimized / functional

(defndoors[](reduce(fn[doorstoggle-idx](update-indoors[toggle-idx]not))(into[](repeat100false))(for[pass(range1101)i(range(decpass)100pass)]i)))(defnopen-doors[](for[[dn](map vector(doors)(iterate inc1)):whend]n))(defnprint-open-doors[](println"Open doors after 100 passes:"(apply str(interpose", "(open-doors)))))

Alternative Unoptimized / functional

(defnopen-doors[](->>(for[step(range1101),occ(rangestep101step)]occ)frequencies(filter(compodd?val))keyssort))(defnprint-open-doors[](println"Open doors after 100 passes:"(apply str(interpose", "(open-doors)))))

Optimized / functional

(defndoors[](reduce(fn[doorsidx](assocdoorsidxtrue))(into[](repeat100false))(map#(dec(*%%))(range111))))(defnopen-doors[](for[[dn](map vector(doors)(iterate inc1)):whend]n))(defnprint-open-doors[](println"Open doors after 100 passes:"(apply str(interpose", "(open-doors)))))


Alternative Optimized / functional

(defnopen-doors[](->>(iterate inc1)(map#(*%%))(take-while#(<=%100))))(defnprint-open-doors[](println"Open doors after 100 passes:"(apply str(interpose", "(open-doors)))))

CLU

start_up = proc ()    max = 100    po: stream := stream$primary_output()    open: array[bool] := array[bool]$fill(1, max, false)    for pass: int in int$from_to(1, max) do        for door: int in int$from_to_by(pass, max, pass) do            open[door] := ~open[door]        end    end    for door: int in array[bool]$indexes(open) do        if open[door] then            stream$putl(po, "Door " || int$unparse(door) || " is open.")        end    endend start_up
Output:
Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

COBOL

IDENTIFICATIONDIVISION.PROGRAM-ID.100Doors.DATADIVISION.WORKING-STORAGESECTION.01Current-nPIC 9(3).01StepSizePIC 9(3).01DoorTable.02DoorsPIC 9(1)OCCURS100TIMES.88ClosedDoorVALUEZERO.01IdxPIC 9(3).PROCEDUREDIVISION.Begin.INITIALIZEDoorTablePERFORMVARYINGStepSizeFROM1BY1UNTILStepSize>100PERFORMVARYINGCurrent-nFROMStepSizeBYStepSizeUNTILCurrent-n>100SUBTRACTDoors(Current-n)FROM1GIVINGDoors(Current-n)END-PERFORMEND-PERFORMPERFORMVARYINGIdxFROM1BY1UNTILIdx>100IFClosedDoor(Idx)DISPLAYIdx" is closed."ELSEDISPLAYIdx" is open."END-IFEND-PERFORMSTOPRUN.

Coco

We use the naive algorithm.

doors = [false] * 100for pass til doors.length    for i from pass til doors.length by pass + 1        ! = doors[i]for i til doors.length    console.log 'Door %d is %s.', i + 1, if doors[i] then 'open' else 'closed'

CoffeeScript

unoptimized:

doors=[]forpassin[1..100]foriin[pass..100]bypassdoors[i]=!doors[i]console.log"Doors#{indexforindex,openofdoorswhenopen} are open"# matrix outputconsole.logdoors.map(open) ->+open

optimized:

isInteger=(i) ->Math.floor(i)==iconsole.logdoorfordoorin[1..100]whenisIntegerMath.sqrtdoor

ultra-optimized:

console.logMath.pow(i,2)foriin[1..10]

ColdFusion

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

doorCount = 1;doorList = "";// create all doors and set all doors to openwhile (doorCount LTE 100) {doorList = ListAppend(doorList,"1");doorCount = doorCount + 1;}loopCount = 2;doorListLen = ListLen(doorList);while (loopCount LTE 100) {loopDoorListCount = 1;while (loopDoorListCount LTE 100) {testDoor = loopDoorListCount / loopCount;if (testDoor EQ Int(testDoor)) {checkOpen = ListGetAt(doorList,loopDoorListCount);if (checkOpen EQ 1) {doorList = ListSetAt(doorList,loopDoorListCount,"0");} else {doorList = ListSetAt(doorList,loopDoorListCount,"1");}}loopDoorListCount = loopDoorListCount + 1;}loopCount = loopCount + 1;}

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

doorCount = 1;doorList = "";loopCount = 1;while (loopCount LTE 100) {if (Sqr(loopCount) NEQ Int(Sqr(loopCount))) {doorList = ListAppend(doorList,0);} else {doorList = ListAppend(doorList,1);}loopCount = loopCount + 1;}

Display only

// Display all doors<cfloopfrom="1"to="100"index="x">    Door #x# Open: #YesNoFormat(ListGetAt(doorList,x))#<br/></cfloop>// Output only open doors<cfloopfrom="1"to="100"index="x"><cfifListGetAt(doorList,x)EQ1>        #x#<br/></cfif></cfloop>

Another Route

<Cfparamname="doorlist"default=""><cfloopfrom="1"to="100"index="i"><Cfsetdoorlist=doorlist&'c,'></cfloop><cfloopfrom="1"to="100"index="i"><Cfloopfrom="1"to="100"index="door"step="#i#"><Cfiflistgetat(doorlist,door)eq'c'><Cfsetdoorlist=listsetat(doorlist,door,'O')><Cfelse><Cfsetdoorlist=listsetat(doorlist,door,'c')></Cfif></Cfloop></cfloop><Cfoutput>#doorlist#</Cfoutput>

Comal

0010DIMdoors#(100)0020FORpass#:=1TO100DO0030FORdoor#:=pass#TO100STEPpass#DOdoors#(door#):=NOTdoors#(door#)0040ENDFORpass#0050FORdoor#:=1TO100DO0060IFdoors#(door#)THENPRINT"Door ",door#," is open."0070ENDFORdoor#0080END
Output:
Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

Commodore BASIC

10D=100:DIMD(D):P=120PRINTCHR$(147);"PASS: ";P22FORI=PTODSTEPP:D(I)=NOTD(I):NEXT30IFP=100THEN4032P=P+1:GOTO2040PRINT:PRINT"THE FOLLOWING DOORS ARE OPEN: "42FORI=1TOD:IFD(I)=-1THENPRINTI;44NEXT

Common Lisp

Unoptimized / functionalThis is a very unoptimized version of the problem, using recursion and quite considerable list-copying. It emphasizes the functional way of solving this problem.

(defunvisit-door(doorsdoornumvalue1value2)"visits a door, swapping the value1 to value2 or vice-versa"(let((d(copy-listdoors))(n(-doornum1)))(if(eql(nthnd)value1)(setf(nthnd)value2)(setf(nthnd)value1))d))(defunvisit-every(doorsnumitervalue1value2)"visits every 'num' door in the list"(if(>(*iternum)(lengthdoors))doors(visit-every(visit-doordoors(*numiter)value1value2)num(+1iter)value1value2)))(defundo-all-visits(doorscntvalue1value2)"Visits all doors changing the values accordingly"(if(<cnt1)doors(do-all-visits(visit-everydoorscnt1value1value2)(-cnt1)value1value2)))(defunprint-doors(doors)"Pretty prints the doors list"(formatT"~{~A ~A ~A ~A ~A ~A ~A ~A ~A ~A~%~}~%"doors))(defunstart(&optional(size100))"Start the program"(let*((open"_")(shut"#")(doors(make-listsize:initial-elementshut)))(print-doors(do-all-visitsdoorssizeopenshut))))

Unoptimized, imperativeThis 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".

(define-modify-macrotoggle()not)(defun100-doors()(let((doors(make-array100)))(dotimes(i100)(loopforjfromibelow100by(1+i)do(toggle(svrefdoorsj))))(dotimes(i100)(formatt"door ~a: ~:[closed~;open~]~%"(1+i)(svrefdoorsi)))))

Unoptimized, n-doors.

(defundoors(z&optional(w(make-listz))(n1))(if(>nz)w(doorsz(togglewnz)(1+n))))(defuntoggle(wmz)(loopforainwfornfrom1tozcollect(if(zerop(modnm))(nota)a)))>(doors100)(TNILNILTNILNILNILNILTNILNILNILNILNILNILTNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILT)

Optimized, n-doors.

(defundoors(n)(loopforafrom1toncollect(zerop(mod(sqrta)1))))>(doors100)(TNILNILTNILNILNILNILTNILNILNILNILNILNILTNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILTNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILNILT)

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

(defun100-doors()(let((doors(make-array100)))(dotimes(i10)(setf(svrefdoors(*ii))t))(dotimes(i100)(formatt"door ~a: ~:[closed~;open~]~%"(1+i)(svrefdoorsi)))))

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

(defunperfect-square-list(n)"Generates a list of perfect squares from 0 up to n"(loopforifrom1to(isqrtn)collect(expti2)))(defunprint-doors(doors)"Pretty prints the doors list"(formatT"~{~A ~A ~A ~A ~A ~A ~A ~A ~A ~A~%~}~%"doors))(defunopen-door(doorsnumopen)"Sets door at num to open"(setf(nth(-num1)doors)open))(defunvisit-all(doorsvlistopen)"Visits and opens all the doors indicated in vlist"(dolist(dnvlistdoors)(open-doordoorsdnopen)))(defunstart2(&optional(size100))"Start the program"(print-doors(visit-all(make-listsize:initial-element'\#)(perfect-square-listsize)'_)))

Optimized (2)This version displays a much more functional solution through the use of MAPCAR.

(let((i0))(mapcar(lambda(x)(if(zerop(mod(sqrt(incfi))1))"_""#"))(make-list100)))

Component Pascal

BlackBox Component Builder

MODULE Doors100;IMPORT StdLog;PROCEDURE Do*;VAR       i,j: INTEGER;       closed:ARRAY 101OF BOOLEAN;BEGIN(* initialization of closed to true *)FOR i := 0TO LEN(closed) - 1DO closed[i] :=TRUEEND;(* process *)FOR i := 1TO LEN(closed)DO;               j := 1;WHILE j < LEN(closed)DOIF jMOD i = 0THEN closed[j] := ~closed[j]END;INC(j)ENDEND;(* print results *)       i := 1;WHILE  i < LEN(closed)DOIF (i - 1)MOD 10 = 0THEN StdLog.LnEND;IF closed[i]THEN StdLog.String("C ")ELSE StdLog.String("O ")END;               INC(i)END;END Do;END Doors100.

Execute: ^Q Doors100.Do

Output:
O C C O C C C C O C C C C C C O C C C C C C C C O C C C C C C C C C C O C C C C C C C C C C C C O C C C C C C C C C C C C C C O C C C C C C C C C C C C C C C C O C C C C C C C C C C C C C C C C C C O

Cowgol

include "cowgol.coh";var doors: uint8[101];  # one extra so we can start at 1var pass: @indexof doors;var door: @indexof doors;MemZero(&doors as [uint8], @bytesof doors);pass := 1;while pass <= 100 loop    door := pass;    while door <= 100 loop        doors[door] := 1-doors[door];        door := door + pass;    end loop;    pass := pass + 1;end loop;door := 1;while door <= 100 loop    if doors[door] == 1 then        print_i8(door);        print(" is open\n");    end if;    door := door + 1;end loop;
Output:
1 is open4 is open9 is open16 is open25 is open36 is open49 is open64 is open81 is open100 is open

Craft Basic

dolet i = i + 1print i * i, " ",loop i * i < 100
Output:
1 4 9 16 25 36 49 64 81 100

Crystal

doors = Array.new(100, false)1.upto(100) do |i|  i.step(by: i, to: 100) do |j|    doors[j - 1] = !doors[j - 1]  endenddoors.each_with_index do |open, i|  puts "Door #{i + 1} is #{open ? "open" : "closed"}"end

D

Unoptimized

import std.stdio;const N = 101; // #doors + 1void main() {  bool[N] doors = false;  for(auto door=1; door<N; door++ ) {    for(auto i=door; i<N; i+=door ) doors[i] = !doors[i];    if (doors[door]) write(door, " ");  }}
Output:
1 4 9 16 25 36 49 64 81 100

Optimized

The problem of the 100 doors is an algorithm to find the squares between 1 and 100.

This optimized version prints these squares using an alternative algorithm based on∑i=1n(2i−1)=n2{\displaystyle {\displaystyle \sum _{i=1}^{n}(2i-1)=n^{2}}}

import std.stdio;const N = 101; // #doors + 1void main() {  for( auto door=1,s=3; door<N; door+=s, s+=2 )    write(door, " ");}
Output:
1 4 9 16 25 36 49 64 81 100

Other proposals

import std.stdio, std.algorithm, std.range;enum DoorState : bool { closed, open }alias Doors = DoorState[];Doors flipUnoptimized(Doors doors) pure nothrow {    doors[] = DoorState.closed;    foreach (immutable i; 0 .. doors.length)        for (ulong j = i; j < doors.length; j += i + 1)            if (doors[j] == DoorState.open)                doors[j] = DoorState.closed;            else                doors[j] = DoorState.open;    return doors;}Doors flipOptimized(Doors doors) pure nothrow {    doors[] = DoorState.closed;    for (int i = 1; i ^^ 2 <= doors.length; i++)        doors[i ^^ 2 - 1] = DoorState.open;    return doors;}void main() {    auto doors = new Doors(100);    foreach (const open; [doors.dup.flipUnoptimized,                          doors.dup.flipOptimized])        iota(1, open.length + 1).filter!(i => open[i - 1]).writeln;}
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100][1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Unoptimized. Demonstrates very basic language syntax/features.Program output allows to see what the code is doing:

import std.stdio;void printAllDoors(bool[] doors){   // Prints the state of all the doors   foreach(i, door; doors)   {      writeln("#: ", i + 1, (door) ? " open" : " closed");      }}void main(){   bool[100] doors = false;   //Create 100 closed doors   for(int a = 0; a < 100; ++a) {      writefln("Pass #%s; visiting every %s door.", a + 1, a + 1);  // Optional for(int i = a; i < 100; i += (a + 1)) { writefln("Visited door %s", i + 1);  //Optional doors[i] = !doors[i]; }      writeln();  // Optional      }   printAllDoors(doors);   // Prints the state of each door}

Dafny

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

datatype Door = Closed | Openmethod InitializeDoors(n:int) returns (doors:array<Door>)  // Precondition: n must be a valid array size.  requires n >= 0  // Postcondition: doors is an array, which is not an alias for any other  // object, with a length of n, all of whose elements are Closed. The "fresh"  // (non-alias) condition is needed to allow doors to be modified by the  // remaining code.  ensures doors != null && fresh(doors) && doors.Length == n  ensures forall j :: 0 <= j < doors.Length ==> doors[j] == Closed;{  doors := new Door[n];  var i := 0;  // Invariant: i is always a valid index inside the loop, and all doors less  // than i are Closed. These invariants are needed to ensure the second  // postcondition.  while i < doors.Length    invariant i <= doors.Length    invariant forall j :: 0 <= j < i ==> doors[j] == Closed;  {    doors[i] := Closed;    i := i + 1;  }}method Main (){  var doors := InitializeDoors(100);  var pass := 1;  while pass <= doors.Length  {    var door := pass;    while door < doors.Length    {      doors[door] := if doors[door] == Closed then Open else Closed;      door := door + pass;    }    pass := pass + 1;  }  var i := 0;  while i < doors.Length  {    print i, " is ", if doors[i] == Closed then "closed\n" else "open\n";    i := i + 1;  }}

Dart

unoptimized

main() {    for (var k = 1, x = new List(101); k <= 100; k++) {        for (int i = k; i <= 100; i += k)            x[i] = !x[i];        if (x[k]) print("$k open");    }}
Works with:Dart version SDK 3.6.1
main() {    var x = List.filled(101,false);    for (var k = 1; k <= 100; k++) {        for (int i = k; i <= 100; i += k)            x[i] = !x[i];        if (x[k]) print("$k open");    }}

optimized version (including generating squares without multiplication)

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

import 'dart:io';final numDoors = 100;final List<bool> doorClosed = List(numDoors);String stateToString(String message) {  var res = '';  for (var i = 0; i < numDoors; i++) {    res += (doorClosed[i] ? 'X' : '\u2610');  }  return res + " " + message;}main() {  for (var i = 0; i < numDoors; i++) {    doorClosed[i] = true;  }  stdout.writeln(stateToString("after initialization"));  for (var step = 1; step <= numDoors; step++) {    final start = step - 1;    for (var i = start; i < numDoors; i += step) {      doorClosed[i] = !doorClosed[i];    }    stdout.writeln(stateToString("after toggling with step = $step"));  }}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX after initialization☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐ after toggling with step = 1☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X☐X after toggling with step = 2☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XXX after toggling with step = 3☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐XX☐X☐XX☐ after toggling with step = 4☐XX☐X☐☐☐X☐☐X☐X☐☐☐☐☐XXX☐XXXX☐☐X☐☐XXXX☐XXX☐☐☐☐☐X☐X☐☐X☐☐☐X☐XX☐☐☐XX☐X☐☐☐X☐☐X☐X☐☐☐☐☐XXX☐XXXX☐☐X☐☐XXXX☐XXX after toggling with step = 5☐XX☐XX☐☐X☐☐☐☐X☐☐☐X☐XXX☐☐XXX☐☐☐☐☐XXX☐☐XXX☐X☐☐☐X☐☐☐☐X☐☐XX☐XX☐X☐XX☐XX☐☐X☐☐☐☐X☐☐☐X☐XXX☐☐XXX☐☐☐☐☐XXX☐☐XXX after toggling with step = 6☐XX☐XXX☐X☐☐☐☐☐☐☐☐X☐X☐X☐☐XXXX☐☐☐☐XX☐☐☐XXX☐☐☐☐☐X☐☐X☐X☐☐XXXXX☐X☐X☐☐XX☐☐XX☐☐☐X☐☐XX☐XXX☐XXXX☐☐☐X☐XXX☐☐☐XX after toggling with step = 7☐XX☐XXXXX☐☐☐☐☐☐X☐X☐X☐X☐XXXXX☐☐☐XXX☐☐☐XX☐☐☐☐☐☐X☐XX☐X☐☐XX☐XX☐X☐X☐XXX☐☐XX☐X☐X☐☐XX☐☐XX☐XXXXX☐☐X☐XXXX☐☐XX after toggling with step = 8☐XX☐XXXX☐☐☐☐☐☐☐X☐☐☐X☐X☐XXX☐X☐☐☐XXX☐X☐XX☐☐☐☐☐XX☐XX☐X☐☐☐X☐XX☐X☐XXXXX☐☐XX☐☐☐X☐☐XX☐☐☐X☐XXXXX☐XX☐XXXX☐☐☐X after toggling with step = 9☐XX☐XXXX☐X☐☐☐☐☐X☐☐☐☐☐X☐XXX☐X☐X☐XXX☐X☐XXX☐☐☐☐XX☐XXXX☐☐☐X☐XX☐☐☐XXXXX☐☐X☐☐☐☐X☐☐XX☐X☐X☐XXXXX☐☐X☐XXXX☐☐☐☐ after toggling with step = 10☐XX☐XXXX☐XX☐☐☐☐X☐☐☐☐☐☐☐XXX☐X☐X☐X☐X☐X☐XXX☐☐☐XXX☐XXXX☐☐☐☐☐XX☐☐☐XXXX☐☐☐X☐☐☐☐X☐☐☐X☐X☐X☐XXXX☐☐☐X☐XXXX☐☐X☐ after toggling with step = 11☐XX☐XXXX☐XXX☐☐☐X☐☐☐☐☐☐☐☐XX☐X☐X☐X☐X☐☐☐XXX☐☐☐XXX☐☐XXX☐☐☐☐☐XX☐X☐XXXX☐☐☐X☐☐X☐X☐☐☐X☐X☐X☐☐XXX☐☐☐X☐XXX☐☐☐X☐ after toggling with step = 12☐XX☐XXXX☐XXXX☐☐X☐☐☐☐☐☐☐☐X☐☐X☐X☐X☐X☐☐☐X☐X☐☐☐XXX☐☐XXXX☐☐☐☐XX☐X☐XXX☐☐☐☐X☐☐X☐X☐☐☐☐☐X☐X☐☐XXX☐☐☐☐☐XXX☐☐☐X☐ after toggling with step = 13☐XX☐XXXX☐XXXXX☐X☐☐☐☐☐☐☐☐X☐☐☐☐X☐X☐X☐☐☐X☐X☐X☐XXX☐☐XXXX☐☐☐XXX☐X☐XXX☐☐☐☐XX☐X☐X☐☐☐☐☐X☐X☐XXXX☐☐☐☐☐XXX☐☐XX☐ after toggling with step = 14☐XX☐XXXX☐XXXXXXX☐☐☐☐☐☐☐☐X☐☐☐☐☐☐X☐X☐☐☐X☐X☐X☐X☐X☐☐XXXX☐☐☐XXX☐☐☐XXX☐☐☐☐XX☐X☐XX☐☐☐☐X☐X☐XXXX☐☐X☐☐XXX☐☐XX☐ after toggling with step = 15☐XX☐XXXX☐XXXXXX☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐X☐☐☐X☐X☐X☐X☐X☐XXXXX☐☐☐XXX☐☐☐XX☐☐☐☐☐XX☐X☐XX☐☐☐☐☐☐X☐XXXX☐☐X☐☐XXXX☐XX☐ after toggling with step = 16☐XX☐XXXX☐XXXXXX☐X☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐X☐X☐X☐X☐XXX☐X☐☐☐XXX☐☐☐XX☐☐☐☐XXX☐X☐XX☐☐☐☐☐☐X☐X☐XX☐☐X☐☐XXXX☐XX☐ after toggling with step = 17☐XX☐XXXX☐XXXXXX☐XX☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐XXX☐☐☐XX☐☐☐☐XXX☐☐☐XX☐☐☐☐☐☐X☐X☐XX☐☐☐☐☐XXXX☐XX☐ after toggling with step = 18☐XX☐XXXX☐XXXXXX☐XXX☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐☐☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐☐☐XX☐☐☐☐XXX☐☐☐XXX☐☐☐☐☐X☐X☐XX☐☐☐☐☐XX☐X☐XX☐ after toggling with step = 19☐XX☐XXXX☐XXXXXX☐XXXX☐☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐XX☐☐☐☐XXX☐☐☐XXX☐☐☐X☐X☐X☐XX☐☐☐☐☐XX☐X☐XXX after toggling with step = 20☐XX☐XXXX☐XXXXXX☐XXXXX☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐☐☐☐☐XXX☐☐☐XXX☐☐☐X☐X☐☐☐XX☐☐☐☐☐XX☐X☐XXX after toggling with step = 21☐XX☐XXXX☐XXXXXX☐XXXXXX☐☐X☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐X☐XXX☐X☐X☐X☐X☐X☐X☐☐☐X☐XXX☐☐☐XXX☐☐☐X☐X☐☐☐XXX☐☐☐☐XX☐X☐XXX after toggling with step = 22☐XX☐XXXX☐XXXXXX☐XXXXXXX☐X☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐XXX☐X☐X☐X☐X☐X☐X☐☐☐X☐X☐X☐☐☐XXX☐☐☐X☐X☐☐☐XXX☐☐☐XXX☐X☐XXX after toggling with step = 23☐XX☐XXXX☐XXXXXX☐XXXXXXXXX☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐XX☐X☐X☐X☐X☐X☐X☐☐☐X☐X☐X☐X☐XXX☐☐☐X☐X☐☐☐XXX☐☐☐XXX☐☐☐XXX after toggling with step = 24☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐X☐X☐X☐X☐X☐X☐☐☐X☐X☐X☐X☐X☐X☐☐☐X☐X☐☐☐XXX☐☐☐XXX☐☐☐XX☐ after toggling with step = 25☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐X☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐X☐X☐X☐X☐X☐☐☐X☐X☐X☐X☐X☐X☐X☐X☐X☐☐☐XXX☐☐☐XXX☐☐☐XX☐ after toggling with step = 26☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XX☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐X☐X☐X☐X☐☐☐X☐X☐X☐X☐X☐X☐X☐XXX☐☐☐XXX☐☐☐XXX☐☐☐XX☐ after toggling with step = 27☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXX☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐X☐X☐X☐☐☐X☐X☐X☐X☐X☐X☐X☐XXX☐X☐XXX☐☐☐XXX☐☐☐XX☐ after toggling with step = 28☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXX☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐X☐☐☐X☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐☐☐XXX☐☐☐XX☐ after toggling with step = 29☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXX☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐X☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐XXX☐☐☐XX☐ after toggling with step = 30☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXX☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐☐☐XX☐ after toggling with step = 31☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXX☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐X☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐XX☐ after toggling with step = 32☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXX☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐X☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 33☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐X☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 34☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐X☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 35☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐X☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 36☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐X☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 37☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XX☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐X☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 38☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXX☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐XXX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 39☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXX☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐XX☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 40☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXX☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐X☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 41☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXX☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐X☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 42☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXX☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐X☐X☐X☐X☐X☐X☐☐ after toggling with step = 43☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXX☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐X☐X☐X☐X☐X☐☐ after toggling with step = 44☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXX☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐X☐X☐X☐X☐☐ after toggling with step = 45☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXX☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐X☐X☐X☐☐ after toggling with step = 46☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐X☐☐ after toggling with step = 47☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐ after toggling with step = 48☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐ after toggling with step = 49☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 50☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XX☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 51☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXX☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 52☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXX☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 53☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXX☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 54☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXX☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 55☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXX☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 56☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXX☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 57☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXX☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 58☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXX☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 59☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXX☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 60☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXX☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 61☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 62☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 63☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 64☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 65☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XX☐☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 66☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXX☐☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 67☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXX☐☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 68☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXX☐☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 69☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXX☐☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 70☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXX☐☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 71☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXX☐☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 72☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXX☐☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 73☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXX☐☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 74☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXX☐☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 75☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXX☐☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 76☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXX☐☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 77☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXX☐☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 78☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 79☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 80☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 81☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐X☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 82☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 83☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 84☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXX☐☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 85☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXX☐☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 86☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXX☐☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 87☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXX☐☐☐☐☐☐☐☐☐☐☐X after toggling with step = 88☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXX☐☐☐☐☐☐☐☐☐☐X after toggling with step = 89☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXX☐☐☐☐☐☐☐☐☐X after toggling with step = 90☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXX☐☐☐☐☐☐☐☐X after toggling with step = 91☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXX☐☐☐☐☐☐☐X after toggling with step = 92☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXX☐☐☐☐☐☐X after toggling with step = 93☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXX☐☐☐☐☐X after toggling with step = 94☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXX☐☐☐☐X after toggling with step = 95☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXXX☐☐☐X after toggling with step = 96☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐☐X after toggling with step = 97☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXXX☐X after toggling with step = 98☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXXXXX after toggling with step = 99☐XX☐XXXX☐XXXXXX☐XXXXXXXX☐XXXXXXXXXX☐XXXXXXXXXXXX☐XXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXX☐XXXXXXXXXXXXXXXXXX☐ after toggling with step = 100

Dc

Unoptimized:

Works with:GNU dc version 1.3.95
## NB: This code uses the dc command "r" via register "r".##     You may comment out the unwanted version.[SxSyLxLy]sr    # this should work with every "dc"[r]sr           # GNU dc can exchange top 2 stack values by "r"## Now use "lrx" instead of "r" ...0k              # we work without decimal places[q]sq           # useful e.g. as loop termination## (x)(y)>R  ==  if (y)>(x) eval R## isle         x y --> (x <= y)[    [1q]S. [ !<. 0 ]x s.L.]sl## l: isle[    100 llx]sL## L: isle100## for  initcode condcode incrcode body##       [1]      [2]      [3]      [4][    [q]S. 4:. 3:. 2:. 1:.  1;.x [2;.x 0=. 4;.x 3;.x 0;.x]d0:.x Os.L.o]sf## f: for##----------------------------------------------------------------------------##      for( i=1 ; i<=100 ; ++i ) {##          door[i] = 0;##      }#[init ...]P []ps-[1si] [li lLx] [li1+si] [    li 0:d]lfx##      for( s=1 ; s<=100 ; ++s ) {##          for( i=s ; i<=100 ; i+=s ) {##              door[i] = 1 - door[i]##          }##      }[1ss] [ls lLx] [ls1+ss] [    #[step ]P lsn [ ...]ps-    [lssi] [li lLx] [lils+si] [        1 li;d - li:d    ]lfx]lfx##      long output:##          for( i=1 ; i<=100 ; ++i ) {##              print "door #", i, " is ", (door[i] ? "open" : "closed")), NL##          }[    [1si] [li lLx] [li1+si] [        [door #]P        li n        [ is ]P            [closed]            [open]        li;d 0=r lrx s- n        [.]ps-    ]lfx]##      terse output:##          for( i=1 ; i<=100 ; ++i ) {##              if( door[i] ) {##                  print i##              }##              print NL##          }[    [1si] [li lLx] [li1+si] [        [] [ [ ]n lin ]        li;d 0=r lrx s- x    ]lfx    []ps-]lrx             # comment out for the long output versions- x#[stack rest...]P []ps- f

Output:

 1 4 9 16 25 36 49 64 81 100

DCL

Adapted from optimized Batch example

$! doors.com$! Excecute by running @doors at prompt.$ square = 1$ incr = 3$ count2 = 0$ d = 1$ LOOP2:$       count2 = count2 + 1$       IF (d .NE. square)$               THEN WRITE SYS$OUTPUT "door ''d' is closed"$       ELSE WRITE SYS$OUTPUT "door ''d' is open"$               square = incr + square$               incr = incr + 2$       ENDIF$       d = d + 1$       IF (count2 .LT. 100) THEN GOTO LOOP2

Delphi

SeePascal

Draco

proc nonrec main() void:    byte DOORS = 100;    [DOORS+1] bool door_open;    unsigned DOORS i, j;    /* make sure all doors are closed */    for i from 1 upto DOORS do door_open[i] := false od;    /* pass through the doors */    for i from 1 upto DOORS do        for j from i by i upto DOORS do            door_open[j] := not door_open[j]        od    od;    /* show the open doors */    for i from 1 upto DOORS do        if door_open[i] then            writeln("Door ", i, " is open.")        fi    odcorp
Output:
Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

DuckDB

Works with:DuckDB version V1.1

This entry illustrates how a simulation can be performedusing a recursive Common Table Expression (CTE). This isostensibly expensive in terms of memory requirements but DuckDBis free to optimize.

# Show the state of n doors after n iterationscreate or replace function doors(n) as (  with recursive cte(ix,d) as (    select 0 as ix, list_transform(range(0, n), x -> false) as d    union all    select ix+1,           list_transform(d, (x,i) -> if (i % (ix + 1) = 0, NOT x, x))    from cte    where ix < n  )  select last(d order by ix)  from cte);# For brevity, we just show the indices of the doors that are open after all# have been visited:select ixfrom (select unnest(generate_series(1,100)) as ix, unnest(doors(100)) as d)where d = true;
Output:
┌───────┐│  ix   ││ int64 │├───────┤│     1 ││     4 ││     9 ││    16 ││    25 ││    36 ││    49 ││    64 ││    81 ││   100 │└───────┘

DUP

100[$][0^:1-]#                                                  {initialize doors}%[s;[$101<][$$;~\:s;+]#%]d:                                     {function d, switch door state function}1s:[s;101<][d;!s;1+s:]#                                        {increment step width from 1 to 100, execute function d each time}1[$101<][$$.' ,;['o,'p,'e,'n,10,]['c,'l,'o,'s,'e,'d,10,]?1+]#  {loop through doors, print door number and state}

Result:

1 open2 closed3 closed4 open5 closed6 closed7 closed8 closed9 open10 closed11 closed12 closed...94 closed95 closed96 closed97 closed98 closed99 closed100 open

Compare this solution to theFALSE solution of this problem.

DWScript

Unoptimized

var doors : array [1..100] of Boolean;var i, j : Integer;for i := 1 to 100 do   for j := i to 100 do      if (j mod i) = 0 then         doors[j] := not doors[j];Ffor i := 1 to 100 do   if doors[i] then      PrintLn('Door '+IntToStr(i)+' is open');

Dyalect

Outputs only open doors to save up space:

var doors = Array.Empty(100, false) for p in 0..99 {    for d in 0..99 {        if (d + 1) % (p + 1) == 0 {            doors[d] = !doors[d];        }    }} for d in doors.Indices() when doors[d] {    print("Door \(d+1): Open")}
Output:
Door 1: OpenDoor 4: OpenDoor 9: OpenDoor 16: OpenDoor 25: OpenDoor 36: OpenDoor 49: OpenDoor 64: OpenDoor 81: OpenDoor 100: Open

Dylan

Unoptimized

define function doors ()  let n = 100;  let doors = make(<vector>, size: n, fill: #f);  for (x from 0 below n)    for (y from x below n by x + 1)      doors[y] := ~doors[y]    end  end;  format-out("open: ");  for (x from 0 below n)     if (doors[x])       format-out("%d ", x + 1)    end  endend function;

Result:

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

Déjà Vu

local :open-doors [ rep 101 false ]for i range 1 100:local :j iwhile <= j 100:set-to open-doors j not open-doors! jset :j + j i!print\ "Open doors: "for i range 1 100:if open-doors! i:!print\( to-str i " " )
Output:
Open doors: 1 4 9 16 25 36 49 64 81 100

E

Graphical

Works with:E-on-Java

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

#!/usr/bin/env runevar toggles := []var gets := []# Set up GUI (and data model)def frame := <swing:makeJFrame>("100 doors")frame.getContentPane().setLayout(<awt:makeGridLayout>(10, 10))for i in 1..100 {  def component := <import:javax.swing.makeJCheckBox>(E.toString(i))  toggles with= fn { component.setSelected(!component.isSelected()) }  gets with= fn { component.isSelected() }  frame.getContentPane().add(component)}# Set up termination conditiondef doneframe.addWindowListener(def _ {  to windowClosing(event) {    bind done := true  }  match _ {}})# Open and close doorsdef loop(step, i) {  toggles[i] <- ()  def next := i + step  timer.whenPast(timer.now() + 10, fn {    if (next >= 100) {      if (step >= 100) {        # Done.      } else {        loop <- (step + 1, step)      }    } else {      loop <- (step, i + step)    }      })}loop(1, 0)frame.pack()frame.show()interp.waitAtTop(done)

EasyLang

len d[] 100for p = 1 to 100   i = p   while i <= 100      d[i] = 1 - d[i]      i += p   ..for i = 1 to 100   if d[i] = 1 : write i & " ".
Output:
1 4 9 16 25 36 49 64 81 100

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)); run pass 100 to 1(for*    ((pass (in-range 100 0 -1))    (door (in-range 0 101 pass)))     (when (and         (vector-set! doors door (not (vector-ref doors door)))         (= pass 1))         (writeln door "is open"))) 1     "is open"    4     "is open"    9     "is open"    16     "is open"    25     "is open"    36     "is open"    49     "is open"    64     "is open"    81     "is open"    100     "is open"

ECL

optimized version

Doors := RECORD UNSIGNED1 DoorNumber; STRING6   State;END;AllDoors := DATASET([{0,0}],Doors);Doors  OpenThem(AllDoors L,INTEGER Cnt) := TRANSFORM SELF.DoorNumber := Cnt; SELF.State      := IF((CNT * 10) % (SQRT(CNT)*10)<>0,'Closed','Opened');END;OpenDoors := NORMALIZE(AllDoors,100,OpenThem(LEFT,COUNTER)); OpenDoors;

unoptimized version - demonstrating LOOP

Doors := RECORD  UNSIGNED1 DoorNumber;  STRING6   State;END;AllDoors := DATASET([{0,'0'}],Doors);//first build the 100 doorsDoors  OpenThem(AllDoors L,INTEGER Cnt) := TRANSFORM  SELF.DoorNumber := Cnt;  SELF.State      := 'Closed';END;ClosedDoors := NORMALIZE(AllDoors,100,OpenThem(LEFT,COUNTER));//now iterate through them and use door logicloopBody(DATASET(Doors) ds, UNSIGNED4 c) :=            PROJECT(ds,    //ds=original input              TRANSFORM(Doors,                      SELF.State := CASE((COUNTER % c) * 100,                            0 => IF(LEFT.STATE = 'Opened','Closed','Opened')    ,LEFT.STATE);SELF.DoorNumber := COUNTER;     //PROJECT COUNTER                    ));   g1 := LOOP(ClosedDoors,100,loopBody(ROWS(LEFT),COUNTER));   OUTPUT(g1);

unoptimized version - using ITERATEThis is a bit more efficient than the LOOP version

DoorSet := DATASET(100,TRANSFORM({UNSIGNED1 DoorState},SELF.DoorState := 1));SetDoors := SET(DoorSet,DoorState);Doors := RECORD  UNSIGNED1 Pass;  SET OF UNSIGNED1 DoorSet;END;StartDoors := DATASET(100,TRANSFORM(Doors,SELF.Pass := COUNTER,SELF.DoorSet := SetDoors));Doors XF(Doors L, Doors R) := TRANSFORM  ds := DATASET(L.DoorSet,{UNSIGNED1 DoorState});  NextDoorSet := PROJECT(ds,                           TRANSFORM({UNSIGNED1 DoorState},                                 SELF.DoorState := CASE((COUNTER % R.Pass) * 100,                                                          0 => IF(LEFT.DoorState = 1,0,1),                                                          LEFT.DoorState)));  SELF.DoorSet := IF(L.Pass=0,R.DoorSet,SET(NextDoorSet,DoorState));  SELF.Pass := R.PassEND; Res := DATASET(ITERATE(StartDoors,XF(LEFT,RIGHT))[100].DoorSet,{UNSIGNED1 DoorState});PROJECT(Res,TRANSFORM({STRING20 txt},SELF.Txt := 'Door ' + COUNTER + ' is ' + IF(LEFT.DoorState=1,'Open','Closed')));

Ecstasy

module OneHundredDoors {    void run() {        Boolean[] doors = new Boolean[100];        for (Int pass : 0 ..< 100) {            for (Int door = pass; door < 100; door += 1+pass) {                doors[door] = !doors[door];            }        }        @Inject Console console;        console.print($|open doors: {doors.mapIndexed((d, i) -> d ? i+1 : 0)                       |                  .filter(i -> i > 0)}                     );    }}
Output:
open doors: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

EDSAC order code

Since there are only 100 doors, we'll keep things simple and usea whole EDSAC location for each door.A single bit would be enough, but that would make the code much longer.

The program works through the array of doors by modifying its ownorders (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][Library subroutine M3. Prints header and is then overwritten.Here, the last character sets the teleprinter to figures.]       PFGKIFAFRDLFUFOFE@A6FG@E8FEZPF       @&*THE!OPEN!DOORS!ARE@&#       ..PZ   [blank tape, needed to mark end of header text][Library subroutine P6. Prints strictly positive integer.32 locations; working locations 1, 4, 5]        T56K  [define load address for subroutine]        GKA3FT25@H29@VFT4DA3@TFH30@S6@T1F        V4DU4DAFG26@TFTFO5FA4DF4FS4F        L4FT4DA1FS3@G9@EFSFO31@E20@J995FJF!F        T88K   [define load address for main program]        GK     [set @ (theta) for relative addresses][The 100 doors are at locations 200..299.Doors are numbered 0..99 internally, and 1..100 for output.The base address and the number of doors can be varied.The value of a door is 0 if open, negative if closed.]                   [Constants. Program also uses order 'P 1 F'                    which is permanently at absolute address 2.]    [0] P200F  [address of door #0]    [1] P100F  [number of doors, as an address]    [2] UF     [makes S order from T, since 'S' = 'T' + 'U']    [3] MF     [makes A order from T, since 'A' = 'T' + 'M']    [4] V2047D [all 1's for "closed" (any negative value will do)]    [5] &F     [line feed]    [6] @F     [carriage return]    [7] K4096F [teleprinter null[                   [Variables]    [8] PF   [pass number; step when toggling doors]    [9] PF   [door number, as address, 0-based]   [10] PF   [order referring to door 0]                   [Enter with acc = 0]                   [Part 1 : close all the doors]   [11] T8@  [pass := 0 (used in part 2)]        T9@  [door number := 0]        A16@ [load 'T F' order]        A@   [add base address]        T10@ [store T order for door #0]   [16] TF   [clear acc; also serves as constant]        A9@  [load door number]        A10@ [make T order]        T21@ [plant in code]        A4@  [load value for "closed"]   [21] TF   [store in current door]        A9@  [load door number]        A2F  [add 1]        U9@  [update door number]        S1@  [done all doors yet?]        G16@ [if not, loop back]                   [Part 2 : 100 passes, toggling the doors]   [27] TF   [clear acc]        A8@  [load pass number]        A2F  [add 1]        T8@  [save updated pass number]        S2F  [make -1]        U9@  [door number := -1]        A8@  [add pass number to get first door toggled on this pass]        S1@  [gone beyond end?]        E50@ [if so, move on to part 3]   [36] A1@  [restore acc after test]        U9@  [store current door number]        A10@ [make T order to load status]        U44@ [plant T order for first door in pass]        A2@  [convert to S order]        T43@ [plant S order]        A4@  [load value for "closed"]   [43] SF   [subtract status; toggles status]   [44] TF   [update status]        A9@  [load door number just toggled]        A8@  [add pass number to get next door in pass]        S1@  [gone beyond end?]        G36@ [no, loop to do next door]        E27@ [yes, loop to do next pass]                   [Part 3 : Print list of open doors.                    Header has set teleprinter to figures.]   [50] TF   [clear acc]        T9@  [door nr := 0]        A10@ [T order for door 0]        A3@  [convert to A order]        T10@   [55] TF        A9@  [load door number]        A10@ [make A order to load value]        T59@ [plant in next order]   [59] AF   [acc := 0 if open, < 0 if closed]        G69@ [skip if closed]        A9@  [door number as address]        A2F  [add 1 for 1-based output]        RD   [shift 1 right, address --> integer]        TF   [store integer at 0 for printing]   [65] A65@ [for return from subroutine]        G56F [call subroutine to print door number]        O6@  [followed by CRLF]        O5@   [69] TF   [clear acc]        A9@  [load door number]        A2F  [add 1]        U9@  [update door number]        S1@  [done all doors yet?]        G55@  [if not, loop back]   [75] O7@  [output null to flush teleprinter buffer]        ZF   [stop]        E11Z [define relative start address]        PF
Output:
THE OPEN DOORS ARE    1    4    9   16   25   36   49   64   81  100

Eero

#import <Foundation/Foundation.h>int main()  square := 1, increment = 3  for int door in 1 .. 100    printf("door #%d", door)    if door == square      puts(" is open.")      square += increment      increment += 2    else      puts(" is closed.")  return 0

Egel

import "prelude.eg"using Systemusing Listdata open, closeddef toggle =    [ open N -> closed N | closed N -> open N ]def doors =    [ N -> map [ N -> closed N ] (fromto 1 N) ]def toggleK =    [ K nil              -> nil    | K (cons (D N) DD)  ->          let DOOR = if (N%K) == 0 then toggle (D N) else D N in             cons DOOR (toggleK K DD) ]def toggleEvery =    [ nil DOORS -> DOORS    | (cons K KK) DOORS -> toggleEvery KK (toggleK K DOORS) ]def run =    [ N -> toggleEvery (fromto 1 N) (doors N) ]def main = run 100

EGL

program OneHundredDoors   function main()      doors boolean[] = new boolean[100];      n int = 100;      for (i int from 1 to n)         for (j int from i to n by i)            doors[j] = !doors[j];         end      end                   for (i int from 1 to n)         if (doors[i])            SysLib.writeStdout( "Door " + i + " is open" );         end      end    endend

Eiffel

This is my first RosettaCode submission, as well as a foray into Eiffel for myself. I've tried to adhere to the description of the problem statement, as well as showcase a few Eiffelisms shown in the documentation.

The replacement code below took the original code and has made improvements in some ways, such as:

  1. Removal of "magic" many magic numbers and strings.
  2. Refactor of various code blocks to routines (commands and queries with good CQS).
  3. Utilization/Demonstration of full, secret, and selective feature exporting.
  4. Utilization/Demonstration of constants as expanded type constants and once-functions.
  5. Utilization/Demonstration of static-references (e.g. {APPLICATION}.min_door_count).
  6. Utilization/Demonstration of "like" keyword type anchoring (e.g. a_index_address: like {DOOR}.address).
  7. Utilization/Demonstration of semi-strict logical implication (e.g. consistency: is_open implies not Is_closed).
  8. Utilization/Demonstration of contracts, including require, ensure, and class invariant.
  9. Utilization/Demonstration of agent and `do_all' call on ITERABLE type.
  10. Utilization/Demonstration of various forms of across including "loop" and "all".

... as well as other Eiffel-ism's and some coding standards/best-practices.

file: application.e

notedescription: "100 Doors problem"date: "08-JUL-2015"revision: "1.1"classAPPLICATIONcreatemakefeature {NONE} -- Initializationmake-- Main application routine.doinitialize_closed_doorstoggle_doorsoutput_door_statesendfeature -- Accessdoors: ARRAYED_LIST [DOOR]-- A set of doors (self-initialized to capacity of `max_door_count').attributecreate Result.make (max_door_count)endfeature -- Basic Operationsinitialize_closed_doors-- Initialize all `doors'.doacross min_door_count |..| max_door_count as ic_address_list loopdoors.extend (create {DOOR}.make_closed (ic_address_list.item))endensurehas_all_closed_doors: across doors as ic_doors_list all not ic_doors_list.item.is_open endendtoggle_doors-- Toggle all `doors'.doacross min_door_count |..| max_door_count as ic_addresses_list loopacross doors as ic_doors_list loopif is_door_to_toggle (ic_doors_list.item.address, ic_addresses_list.item) thenic_doors_list.item.toggle_doorendendendendoutput_door_states-- Output the state of all `doors'.dodoors.do_all (agent door_state_out)endfeature -- Status Reportis_door_to_toggle (a_door_address, a_index_address: like {DOOR}.address): BOOLEAN-- Is the door at `a_door_address' needing to be toggled, when compared to `a_index_address'?doResult := a_door_address \\ a_index_address = 0ensureonly_modulus_zero: Result = (a_door_address \\ a_index_address = 0)endfeature -- Outputsdoor_state_out (a_door: DOOR)-- Output the state of `a_door'.doprint ("Door " + a_door.address.out + " is ")if a_door.is_open thenprint ("open.")elseprint ("closed.")endio.new_lineendfeature {DOOR} -- Constantsmin_door_count: INTEGER = 1-- Minimum number of doors.max_door_count: INTEGER = 100-- Maximum number of doors.end

file: door.e

notedescription: "A door with an address and an open or closed state."date: "08-JUL-2015"revision: "1.1"classDOORcreatemake_closed,makefeature {NONE} -- initializationmake_closed (a_address: INTEGER)-- Initialize Current {DOOR} at `a_address' and state of `Is_closed'.requirepositive: a_address >= {APPLICATION}.min_door_count and a_address >= Min_door_countdomake (a_address, Is_closed)ensureclosed: is_open = Is_closedendmake (a_address: INTEGER; a_status: BOOLEAN)-- Initialize Current {DOOR} with `a_address' and `a_status', denoting position and `is_open' or `Is_closed'.requirepositive: a_address >= {APPLICATION}.min_door_count and a_address >= Min_door_countdoaddress := a_addressis_open := a_statusensureaddress_set: address = a_addressstatus_set: is_open = a_statusendfeature -- accessaddress: INTEGER-- `address' of Current {DOOR}.is_open: BOOLEAN assign set_open-- `is_open' (or not) status of Current {DOOR}.feature -- Settersset_open (a_status: BOOLEAN)-- Set `status' with `a_status'dois_open := a_statusensureopen_updated: is_open = a_statusendfeature {APPLICATION} -- Basic Operationstoggle_door-- Toggle Current {DOOR} from `is_open' to not `is_open'.dois_open := not is_openensuretoggled: is_open /= old is_openendfeature {NONE} -- Implementation: ConstantsIs_closed: BOOLEAN = False-- State of being not `is_open'.Min_door_count: INTEGER = 1-- Minimum door count.invariantone_or_more: address >= 1consistency: is_open implies not Is_closedend

Ela

Standard Approach

open generictype Door = Open | Closed  deriving Showgate [] _ = []gate (x::xs) (y::ys)   | x == y = Open :: gate xs ys  | else = Closed :: gate xs ysrun n = gate [1..n] [& k*k \\ k <- [1..]]

Alternate Approach

open listrun n = takeWhile (<n) [& k*k \\ k <- [1..]]

Elena

ELENA 6.x :

import system'routines;import extensions;public program(){     var Doors := Array.allocate(100).populate::(n=>false);    for(int i := 0; i < 100; i++)    {        for(int j := i; j < 100; j := j + i + 1)        {            Doors[j] := Doors[j].Inverted        }    };     for(int i := 0; i < 100; i++)    {        Console.printLine("Door #",i + 1," :",Doors[i].iif("Open","Closed"))    };     Console.readChar()}

Elixir

defmodule HundredDoors do  def doors(n \\ 100) do    List.duplicate(false, n)  end    def toggle(doors, n) do    List.update_at(doors, n, &(!&1))  end    def toggle_every(doors, n) do    Enum.reduce( Enum.take_every((n-1)..99, n), doors, fn(n, acc) -> toggle(acc, n) end )  endend# unoptimizedfinal_state = Enum.reduce(1..100, HundredDoors.doors, fn(n, acc) -> HundredDoors.toggle_every(acc, n) end)open_doors = Enum.with_index(final_state)             |> Enum.filter_map(fn {door,_} -> door end, fn {_,index} -> index+1 end)IO.puts "All doors are closed except these: #{inspect open_doors}"# optimized final_state = Enum.reduce(1..10, HundredDoors.doors, fn(n, acc) -> HundredDoors.toggle(acc, n*n-1) end)open_doors = Enum.with_index(final_state)             |> Enum.filter_map(fn {door,_} -> door end, fn {_,index} -> index+1 end)IO.puts "All doors are closed except these: #{inspect open_doors}"
Output:
All doors are closed except these: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Elm

-- Unoptimizedimport List exposing (indexedMap, foldl, repeat, range)import Html exposing (text)import Debug exposing (toString)type Door = Open | Closedtoggle d = if d == Open then Closed else OpentoggleEvery : Int -> List Door -> List DoortoggleEvery k doors = indexedMap   (\i door -> if modBy k (i+1) == 0 then toggle door else door)  doorsn = 100main =   text (toString (foldl toggleEvery (repeat n Closed) (range 1 n)))

Emacs Lisp

Unoptimized

(defun create-doors ()  "Returns a list of closed doorsEach door only has two status: open or closed.If a door is closed it has the value 0, if it's open it has the value 1."  (let ((return_value '(0))         ;; There is already a door in the return_value, so k starts at 1         ;; otherwise we would need to compare k against 99 and not 100 in         ;; the while loop         (k 1))    (while (< k 100)      (setq return_value (cons 0 return_value))      (setq k (+ 1 k)))    return_value))(defun toggle-single-door (doors)  "Toggle the stat of the door at the `car' position of the DOORS listDOORS is a list of integers with either the value 0 or 1 and it representsa row of doors.Returns a list where the `car' of the list has it's value toggled (if openit becomes closed, if closed it becomes open)."  (if (= (car doors) 1)    (cons 0 (cdr doors))    (cons 1 (cdr doors))))(defun toggle-doors (doors step original-step)  "Step through all elements of the doors' list and toggle a door when step is 1DOORS is a list of integers with either the value 0 or 1 and it representsa row of doors.STEP is the number of doors we still need to transverse before we arriveat a door that has to be toggled.ORIGINAL-STEP is the value of the argument step when this function iscalled for the first time.Returns a list of doors"  (cond ((null doors)          '())    ((= step 1)      (cons (car (toggle-single-door doors))        (toggle-doors (cdr doors) original-step original-step)))    (t      (cons (car doors)        (toggle-doors (cdr doors) (- step 1) original-step)))))(defun main-program ()  "The main loop for the program"  (let ((doors_list (create-doors))         (k 1)         ;; We need to define max-specpdl-size and max-specpdl-size to big         ;; numbers otherwise the loop reaches the max recursion depth and         ;; throws an error.         ;; If you want more information about these variables, press Ctrl         ;; and h at the same time and then press v and then type the name         ;; of the variable that you want to read the documentation.         (max-specpdl-size 5000)         (max-lisp-eval-depth 2000))    (while (< k 101)      (setq doors_list (toggle-doors doors_list k k))      (setq k (+ 1 k)))    doors_list))(defun print-doors (doors)  "This function prints the values of the doors into the current buffer.DOORS is a list of integers with either the value 0 or 1 and it representsa row of doors."  ;; As in the main-program function, we need to set the variable  ;; max-lisp-eval-depth to a big number so it doesn't reach max recursion  ;; depth.  (let ((max-lisp-eval-depth 5000))    (unless (null doors)      (insert (int-to-string (car doors)))      (print-doors (cdr doors)))));; Returns a list with the final solution(main-program);; Print the final solution on the buffer(print-doors (main-program))

Using bit manipulation

(defun one-hundred-doors(initial-state)  "Turn doors in INITIAL-STATE according to 100 Doors problem."  (interactive "nEnter initial doors' state (as a number): ")  (cl-loop for x from 1 to 100           do (cl-loop for y from (1- x) to 99 by x                       do (setq initial-state (logxor initial-state (ash 1 y)))))  (let ((counter 1)        (open-doors nil))    (while (> initial-state 0)      (when (eq (mod initial-state 2) 1)        (push counter open-doors))      (cl-incf counter)      (setq initial-state (/ initial-state 2)))    (message "Open doors are %s" (reverse open-doors))))(one-hundred-doors 0)
Output:
"Open doors are (1 4 9 16 25 36 49 64 81 100)"

EMal

type Door:Stateenum do int CLOSED, OPEN endtype Doormodel  int id  Door:State state  new by int ←id, Door:State ←state do end  fun toggle ← <|me.state ← when(me.state æ Door:State.CLOSED, Door:State.OPEN, Door:State.CLOSED)  fun asText ← <|"Door #" + me.id + " is " + when(me.state æ Door:State.CLOSED, "closed", "open")endtype Main^|There are 100 doors in a row that are all initially closed.|^List doors ← Door[].with(100, <int i|Door(i + 1, Door:State.CLOSED))^|You make 100 passes by the doors.|^for int pass ← 0; pass < 100; ++pass  for int i ← pass; i < 100; i += pass + 1    doors[i].toggle()  endend^|Which are open, which are closed?|^for each Door door in doors  if door.state æ Door:State.CLOSED do continue end  writeLine(door)end
Output:
Door #1 is openDoor #4 is openDoor #9 is openDoor #16 is openDoor #25 is openDoor #36 is openDoor #49 is openDoor #64 is openDoor #81 is openDoor #100 is open

Erlang

non-optimized

-module(hundoors).-export([go/0]).toggle(closed) -> open;toggle(open) -> closed.go() -> go([closed || _ <- lists:seq(1, 100)],[], 1, 1).go([], L, N, _I) when N =:= 101 -> lists:reverse(L);go([], L, N, _I) -> go(lists:reverse(L), [], N + 1, 1);go([H|T], L, N, I) ->  H2 = case I rem N of    0 -> toggle(H);    _ -> H  end,  go(T, [H2|L], N, I + 1).

using an array is faster (around 2 time faster for 100 doors but already 25 faster for 10 000 doors)

array_go() -> go(array:new([101, fixed, {default, closed}]), 1, 1).go(Array, Big, Inc) when Big > 100, Inc =< 100 ->    go(Array, Inc + 1, Inc + 1);go(Array, Index, Inc) when Inc < 101 ->    go(array:set(Index, toggle(Array, Index), Array), Index + Inc, Inc);go(Array, _, _) -> array:sparse_to_orddict(Array).toggle(Array, Index) -> toggle(array:get(Index, Array)).

and, as an added benefit, the output is nicer :)

Output:
 task_100_doors:array_go().[{1,open}, {4,open}, {9,open}, {16,open}, {25,open}, {36,open}, {49,open}, {64,open}, {81,open}, {100,open}]

optimized

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)].

ERRE

! "100 Doors" program for ERRE LANGUAGE! Author: Claudio Larini! Date: 21-Nov-2014!! PC Unoptimized version translated from a QB versionPROGRAM 100DOORS!$INTEGERCONST N=100DIM DOOR[N]BEGINFOR STRIDE=1 TO N DO    FOR INDEX=STRIDE TO N STEP STRIDE DO        DOOR[INDEX]=NOT(DOOR[INDEX])    END FOREND FORPRINT("Open doors:";)FOR INDEX=1 TO N DO    IF DOOR[INDEX] THEN PRINT(INDEX;) END IFEND FORPRINTEND PROGRAM

Euler

In Euler, all variables have the valueundefined until assigned another value.isu x returnstrue if x is currently undefined and the and/or operators short-circuit.

beginnew doors;new i;label doorLoop;label outDoors;          doors <-list 100;          i     <- 0;doorLoop:if [ i <- i + 1 ] <=length doorsthenbeginnew j;label flipLoop;             j  <- 0;flipLoop:if [ j <- J + i ] <=length doorsthenbegin                doors[ j ] <-isu doors[ j ]ornot doors[ j ];goto flipLoopendelse 0;goto doorLoopendelse 0;          i <- 0;outDoors:if [ i <- i + 1 ] <=length doorsthenbeginif doors[ i ]thenout ielse 0;goto outDoorsendelse 0end $

Euler Math Toolbox

>function Doors () ...$  doors:=zeros(1,100);$  for i=1 to 100$    for j=i to 100 step i$      doors[j]=!doors[j];$    end;$  end;$  return doors$endfunction>nonzeros(Doors()) [ 1  4  9  16  25  36  49  64  81  100 ]

Euphoria

unoptimised

-- doors.exinclude std/console.esequence doorsdoors = repeat( 0, 100 ) -- 1 to 100, initialised to false for pass = 1 to 100 dofor door = pass to 100 by pass do--printf( 1, "%d", doors[door] )--printf( 1, "%d", not doors[door] )doors[door] = not doors[door]end forend forsequence ocfor i = 1 to 100 doif doors[i] thenoc = "open"elseoc = "closed"end if printf( 1, "door %d is %s\n", { i, oc } )end for

Excel

Multi-cell approaach

Note: The use of Auto Fill saves a lot of time when entering this code. One can refer to Excel help pages to learn about Auto Fill features.
Create a labelling column (A) and row (1) labelling the number of the door (column A, labelling starts in row 2 with a "1" and continues counting up to "100" in row 101) and the number of the pass (row 1, labelling starts in column B with a "0" and continues counting up to "100" in column CX). Additonally, you can label cell A1 as "Door/Pass" or so.
Closed doors are represented by zeroes ("0"), open doors are represented by ones ("1"). To represent the initial condition fill rows 2 to 101 in column B (pass "0") with zeroes.
Starting in column C, row 2, you enter code as shown in the examples below. The examples show the code to be entered in cells C2, C3, and D2. Continue to write code for the rest of the 4245 data cells, accordingly. Excel Auto Fill feature is best used for this.

Cell C2:

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

Cell C3:

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

Cell D2:

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

The last column (column CX, labelled "100") shows a "1" for each door (labelled by the rows in column A) that is open after the 100th pass. It shows a "1" for the following doors: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100.

Single cell approach (Optimized)

=LET(i, SEQUENCE(100), root, SQRT(i), "Door " & i &  ": " & IF(root = INT(root), "open", "close"))

F#

type doorState=Open|Closedlet flip=function Open->Closed |_->Openlet Doors=Array.create 100 Closedfor n in 1..100 do {n-1..n..99}|>Seq.iter(fun n->Doors[n]<-flip Doors[n])Doors|>Array.iteri(fun n g->if g=Open then printf "%d " (n+1)); printfn ""
Output:
1 4 9 16 25 36 49 64 81 100

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.

open Systemlet answer2 =    let PerfectSquare n =        let sqrt = int(Math.Sqrt(float n))        n = sqrt * sqrt    [| for i in 1..100 do yield PerfectSquare i |]

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

Factor

Unoptimized

USING: bit-arrays formatting fry kernel math math.rangessequences ;IN: rosetta.doorsCONSTANT: number-of-doors 100: multiples ( n -- range )    0 number-of-doors rot <range> ;: toggle-multiples ( n doors -- )    [ multiples ] dip '[ _ [ not ] change-nth ] each ;: toggle-all-multiples ( doors -- )    [ number-of-doors [1,b] ] dip '[ _ toggle-multiples ] each ;: print-doors ( doors -- )    [        swap "open" "closed" ? "Door %d is %s\n" printf    ] each-index ;: main ( -- )    number-of-doors 1 + <bit-array>    [ toggle-all-multiples ] [ print-doors ] bi ;main

Optimized

USING:    formatting    math math.primes.factors math.ranges    sequences ;IN: rosetta-doors2: main ( -- )    100 [1,b] [ divisors length odd? ] filter "Open %[%d, %]\n" printf ;

Falcon

Unoptimized code

doors = arrayBuffer( 101, false )for pass in [ 0 : doors.len() ]  for door in [ 0 : doors.len() : pass+1 ]    doors[ door ] = not doors[ door ]  endendfor door in [ 1 : doors.len() ]  // Show Output  >  "Door ", $door, " is: ", ( doors[ door ] ) ? "open" : "closed"end

Optimized code

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

FALSE

100[$][0 1ø:1-]#              {initialize doors}%[s;[$101\>][$$;~\:s;+]#%]d:   {function d, switch door state function}1s:[s;101\>][d;!s;1+s:]#      {increment step width from 1 to 100, execute function d each time}1[$101\>][$$." ";$["open"]?~["closed"]?1+]#                       {loop through doors, print door number and state}

Result:

1 open2 closed3 closed4 open5 closed6 closed7 closed8 closed9 open10 closed...98 closed99 closed100 open

Compare this solution to theDUP solution of this problem.

Fantom

Unoptimized

    states := (1..100).toList    100.times |i| {      states = states.map |state| { state % (i+1) == 0 ? -state : +state }    }    echo("Open doors are " + states.findAll { it < 0 }.map { -it })

Optimized

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

FBSL

Unoptimised

#AppType ConsoleDim doors[], n As Integer = 100For Dim i = 1 To nFor Dim j = i To n Step idoors[j] = Not doors[j]NextNextFor i = 1 To nIf doors[i] Then Print "Door ", i, " is open"NextPause

Optimised (by ML)

#APPTYPE CONSOLEDIM i = 0, j = 0, door = 1WHILE INCR(i) < 101 IF i = door THEN   PRINT "Door ", door, " open"   INCR(door, INCR((INCR(j) << 1))) END IFWENDPAUSE

Fe

; macro for finite loop(= repeat (mac (i n . body)  (list 'do    (list 'let i 0)    (list 'while (list '< i n)      (list '= i (list '+ i 1))      (cons 'do body))))); function to get n-th element of list(= nth (fn (i lst)  (while (< 0 i)    (= i (- i 1))    (= lst (cdr lst)))  lst)); make list of 100 nils(repeat i 100 (= doors (cons nil doors))); do algorithm iterations(repeat i 100  (let pos (nth (- i 1) doors))  (while pos    (setcar pos (not (car pos)))    (= pos (nth i pos))))(print doors)

Algorithm iterations can be simplified to:

; do algorithm iterations sqrt(100) = 10 times(repeat i 10 (setcar (nth (- (* i i) 1) doors) 't))

Fennel

(do ;;; find the first few squares via the unoptimised door flipping method    (local door-max 100)    ; repeatedly flip the doors and show the ones that are left open    (var door {})    (for [i 1 door-max]         (for [j i door-max i]              (tset door j (not (. door j)))         )         (when (. door i)               (io.write (.. " " i))         )    ))
Output:
 1 4 9 16 25 36 49 64 81 100

Fhidwfe

unoptomized

doors = malloc$ 100ufor uint [0u, sizeof$ doors) with l1 {  put_byte$ + doors l1 as false byte}function void pass(step:uint) {  location = step  while <= location sizeof$ doors {    ac = - + doors location 1u    put_byte$ ac ~ deref_byte$ ac// true is represented as 255 (0xff)    location = + location step  }}for uint (0u, sizeof$ doors] with l2 {//range exclusive of 0, inclusive of 100  pass$ l2}count = 1ufor ubyte as doors listubyte with isopen {// list for-each  if as isopen bool {// cast byte to bool    puts$ "door "    putui$ count    puts$ " is open\n"  } ;  count = + count 1u}free$ doors

Fish

Unoptimized

1001-p01.>0101-p02.>101-g001-g+:::aa*)?v101-p03.>02-g?v1}02-p02.    >05.      >0}02-p02.>~~~0101-p001-g:1+001-paa*)?v02.                            >07.>0101-p08.>101-g::02-g?v     >1+:101-paa*=?;             >n" "o^

FOCAL

1.1 F N=1,100;S D(N)=01.2 F M=1,100;F N=M,M,100;S D(N)=1-D(N)1.3 F N=1,100;D 2.01.4 Q2.1 I (D(N)),,2.2;R2.2 T "OPEN DOOR ",%3.0,N,!
Output:
OPEN DOOR =   1OPEN DOOR =   4OPEN DOOR =   9OPEN DOOR =  16OPEN DOOR =  25OPEN DOOR =  36OPEN DOOR =  49OPEN DOOR =  64OPEN DOOR =  81OPEN DOOR = 100

Forth

Unoptimized

: toggle ( c-addr -- )  \ toggle the byte at c-addr    dup c@ 1 xor swap c! ;100  1+ ( 1-based indexing ) constant ndoorscreate 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

Optimized

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

Fortran

Works with:Fortran 90

unoptimized

program doors    implicit none    integer, allocatable :: door(:)    character(6), parameter :: s(0:1) = [character(6) :: "closed", "open"]    integer :: i, n      print "(A)", "Number of doors?"    read *, n    allocate (door(n))    door = 1    do i = 1, n        door(i:n:i) = 1 - door(i:n:i)        print "(A,G0,2A)", "door ", i, " is ", s(door(i))    end doend program

optimized

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

Free Pascal

program OneHundredIsOpen;const  DoorCount = 100;var  IsOpen: array[1..DoorCount] of boolean;  Door, Jump: integer;begin  // Close all doors  for Door := 1 to DoorCount do    IsOpen[Door] := False;  // Iterations  for Jump := 1 to DoorCount do  begin    Door := Jump;    repeat      IsOpen[Door] := not IsOpen[Door];      Door := Door + Jump;    until Door > DoorCount;  end;  // Show final status  for Door := 1 to DoorCount do  begin    Write(Door, ' ');    if IsOpen[Door] then      WriteLn('open')    else      WriteLn('closed');  end;  // Wait for <enter>  Readln;end.

FreeBASIC

Toggle

' version 27-10-2016' compile with: fbc -s console#Define max_doors 100Dim As ULong c, n, n1, door(1 To max_doors)' toggle, at start all doors are closed (0)' 0 = door closed, 1 = door openFor n = 1 To max_doors    For n1 = n To max_doors Step n        door(n1) = 1 - door(n1)    NextNext' count the doors that are open (1)Print "doors that are open nr: ";For n = 1 To max_doors    If door(n) = 1 Then        Print n; " ";        c = c + 1    End IfNextPrint : PrintPrint "There are " + Str(c) + " doors open"' empty keyboard bufferWhile InKey <> "" : WendPrint : Print "hit any key to end program"SleepEnd
Output:
doors that are open nr: 1 4 9 16 25 36 49 64 81 100 There are 10 doors open

Count

' version 27-10-2016' compile with: fbc -s console#Define max_doors 100Dim As ULong c, n, n1, door(1 To max_doors)' at start all doors are closed' simple add 1 each time we open or close a door' doors with odd numbers are open' doors with even numbers are closedFor n = 1 To max_doors    For n1 = n To max_doors Step n        door(n1) += 1    NextNextPrint "doors that are open nr: ";For n = 1 To max_doors    If door(n) And 1 Then        Print n; " ";        c = c + 1    End IfNextPrint : PrintPrint "There are " + Str(c) + " doors open"' empty keyboard bufferWhile InKey <> "" : WendPrint : Print "hit any key to end program"SleepEnd

Output is the same as the first version.

Optimized

' version 27-10-2016' compile with: fbc -s console#Define max_doors 100Dim As ULong c, nPrint "doors that are open nr: ";For n = 1 To 10    Print n * n; " ";    c = c + 1NextPrint : PrintPrint "There are " + Str(c) + " doors open"' empty keyboard bufferWhile InKey <> "" : WendPrint : Print "hit any key to end program"SleepEnd

Output is the same as the first version.

Ultra optimizado

' version 16-06-2021' portado desde JuliaFor i As Integer = 1 To 10    If (i Mod i^2) < 11  Then Print "La puerta"; i^2; " esta abierta"   Next iSleep

friendly interactive shell

Unoptimized

# Set doors to empty listset doors# Initialize doors arraysfor i in (seq 100)    set doors[$i] 0endfor i in (seq 100)    set j $i    while test $j -le 100        # Logical not on doors        set doors[$j] (math !$doors[$j])        set j (math $j + $i)    endend# Print every doorfor i in (seq (count $doors))    echo -n "$i "    if test $doors[$i] -eq 0        echo closed    else        echo open    endend

Optimized

# Set doors to empty listset doorsfor i in (seq 100)    set doors[(math "$i * $i")] 1    echo -n "$i "    if test $doors[$i] -eq 1        echo open    else        echo closed    endend

Frink

doors = new array[[101], false]for pass=1 to 100   for door=pass to 100 step pass      doors@door = ! doors@doorprint["Open doors:  "]for door=1 to 100   if doors@door      print["$door "]

FTCBASIC

define i = 0, d = 0dolet i = i + 1let d = i * iprint dloop d < 100pauseend

FunL

Unoptimized

for i <- 1..100  r = foldl1( \a, b -> a xor b, [(a|i) | a <- 1..100] )  println( i + ' ' + (if r then 'open' else 'closed') )

Optimized

import math.sqrtfor i <- 1..100  println( i + ' ' + (if sqrt(i) is Integer then 'open' else 'closed') )

Futhark

let main(n: i32): [n]bool =  loop is_open = replicate n false for i < n do    let js = map (*i+1) (iota n)    let flips = map (\j ->                       if j < n                       then unsafe !is_open[j]                       else true -- Doesn't matter.                    ) js    in scatter is_open js flips

FutureBasic

include "NSLog.incl"NSInteger door, square = 1, increment = 3for door = 1 to 100  if ( door == square )    NSLog( @"Door %ld is open.", door )    square += increment : increment += 2  else    NSLog( @"Door %ld is closed.", door )  end ifnextHandleEvents
Output:
Door 1 is open.Door 2 is closed.Door 3 is closed.Door 4 is open.Door 5 is closed.Door 6 is closed.Door 7 is closed.Door 8 is closed.Door 9 is open.Door 10 is closed.Door 11 is closed.Door 12 is closed.Door 13 is closed.Door 14 is closed.Door 15 is closed.Door 16 is open.Door 17 is closed.Door 18 is closed.Door 19 is closed.Door 20 is closed.Door 21 is closed.Door 22 is closed.Door 23 is closed.Door 24 is closed.Door 25 is open.Door 26 is closed.Door 27 is closed.Door 28 is closed.Door 29 is closed.Door 30 is closed.Door 31 is closed.Door 32 is closed.Door 33 is closed.Door 34 is closed.Door 35 is closed.Door 36 is open.Door 37 is closed.Door 38 is closed.Door 39 is closed.Door 40 is closed.Door 41 is closed.Door 42 is closed.Door 43 is closed.Door 44 is closed.Door 45 is closed.Door 46 is closed.Door 47 is closed.Door 48 is closed.Door 49 is open.Door 50 is closed.Door 51 is closed.Door 52 is closed.Door 53 is closed.Door 54 is closed.Door 55 is closed.Door 56 is closed.Door 57 is closed.Door 58 is closed.Door 59 is closed.Door 60 is closed.Door 61 is closed.Door 62 is closed.Door 63 is closed.Door 64 is open.Door 65 is closed.Door 66 is closed.Door 67 is closed.Door 68 is closed.Door 69 is closed.Door 70 is closed.Door 71 is closed.Door 72 is closed.Door 73 is closed.Door 74 is closed.Door 75 is closed.Door 76 is closed.Door 77 is closed.Door 78 is closed.Door 79 is closed.Door 80 is closed.Door 81 is open.Door 82 is closed.Door 83 is closed.Door 84 is closed.Door 85 is closed.Door 86 is closed.Door 87 is closed.Door 88 is closed.Door 89 is closed.Door 90 is closed.Door 91 is closed.Door 92 is closed.Door 93 is closed.Door 94 is closed.Door 95 is closed.Door 96 is closed.Door 97 is closed.Door 98 is closed.Door 99 is closed.Door 100 is open.

FUZE BASIC

READ x,y,zPRINT "Open doors: ";x;" ";CYCLE    z=x+y    PRINT z;" ";    x=z    y=y+2REPEAT UNTIL z>=100DATA 1,3,0END

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in itswebsite.

Inthis page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

The solution consists in having a 100 element array, initialized with FALSE values. In each of the 100 rounds (controlled by a simple FOR-FROM-TO cycle), the values are flipped using a FOR-FROM-TO-STEP cycle. Finally the array is shown, using green colors for open doors, and red for closed ones. The resulting matrix is transposed in order to be shown horizontally.

The result of calling the function is:

Improvements. Graphic output, in order to show evolution in time, and an arbitrary number of doors

100 doors, each door is 3x3 pixel:

Gambas

Click this link to run this code

Public Sub Main()Dim bDoor As New Boolean[101]Dim siCount1, siCount2, siStart As ShortFor siCount1 = 1 To 100  Inc siStart  For siCount2 = siStart To 100 Step siCount1    bDoor[siCount2] = Not bDoor[siCount2]  NextNextFor siCount1 = 1 To 100  If bDoor[siCount1] Then Print siCount1;;NextEnd

Output:

1 4 9 16 25 36 49 64 81 100

GAP

doors := function(n)  local a,j,s;  a := [ ];  for j in [1 .. n] do    a[j] := 0;  od;  for s in [1 .. n] do    j := s;    while j <= n do      a[j] := 1 - a[j];      j := j + s;    od;  od;  return Filtered([1 .. n], j -> a[j] = 1);end;doors(100);# [ 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 ]

GDScript

func Doors(door_count:int) -> void :  var doors : Array  doors.resize(door_count)  # Note : Initialization is not necessarily mandatory (by default values are false)  # Intentionally left here  for i in door_count :    doors[i] = false  # do visits  for i in door_count :    for j in range(i,door_count,i+1) :      doors[j] = not doors[j]    # print results  var results : String = ""  for i in door_count :    results += str(i+1) + " " if doors[i] else ""  print("Doors open : %s" % [results] )# calling the function from the _ready functionfunc _ready() -> void :  Doors(100)

Output:

Doors open : 1 4 9 16 25 36 49 64 81 100

Genie

// 100 doors problem// Author: Sinuhe masan (2019)init// 100 elements array of boolean typedoors:bool[100]    for var i = 1 to 100doors[i] = false  // set all doors closed        for var i = 1 to 100j:int = iwhile j <= 100 dodoors[j] = not doors[j]j = j + i    print("Doors open: ")for var i = 1 to 100if doors[i]stdout.printf ("%d ", i)

Glee

100` *=0=>d                      $$ create vector 1..100, create bit pattern d, marking all equal to 0: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)d                                $$ output d

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

Result:10010000 10000001 00000000 10000000 00010000 00000000 10000000 00000001 00000000 00000000 10000000 00000000 0001

GML

var doors,a,i;//Sets up the array for all of the doors.for (i = 1; i<=100; i += 1)    {    doors[i]=0;    }//This first for loop goes through and passes the interval down to the next for loop.for (i = 1; i <= 100; i += 1;)    {    //This for loop opens or closes the doors and uses the interval(if interval is 2 it only uses every other etc..)    for (a = 0; a <= 100; a += i;)        {        //Opens or closes a door.        doors[a] = !doors[a];        }    }open_doors = '';//This for loop goes through the array and checks for open doors.//If the door is open it adds it to the string then displays the string.for (i = 1; i <= 100; i += 1;)    {    if (doors[i] == 1)        {        open_doors += "Door Number "+string(i)+" is open#";        }    }show_message(open_doors);game_end();

Go

unoptimized

package mainimport "fmt"func main() {    doors := [100]bool{}    // 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(" ")        }    }}

Output:

1 0 0 1 0 0 0 0 1 00 0 0 0 0 1 0 0 0 00 0 0 0 1 0 0 0 0 00 0 0 0 0 1 0 0 0 00 0 0 0 0 0 0 0 1 00 0 0 0 0 0 0 0 0 00 0 0 1 0 0 0 0 0 00 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 1

optimized

package mainimport "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")        }    }}

optimized 2

// 100 (optimized) doors in Gopackage mainimport (    "fmt"    "math")func main() {    for i := 1; i <= 100; i++ {        f := math.Sqrt(float64(i))        if math.Mod(f, 1) == 0 {            fmt.Print("O")        } else {            fmt.Print("-")        }    }    fmt.Println()}

Output:

O--O----O------O--------O----------O------------O--------------O----------------O------------------O

Goboscript

costumes "assets/blank.svg";list doors;proc do_100_doors {    delete doors;    repeat 100 {add false to doors;}    local pass_i = 1;    repeat 100 {        local i = 0;        repeat length doors / pass_i {            i += pass_i;            doors[i] = not doors[i];        }                pass_i++;    }}onflag{main;}proc main {    do_100_doors;    show doors;    local i = 1;    repeat length doors {        if doors[i] {            local state = "open";        } else {            local state = "closed";        }        log "Door " & i & " is " & state;        i++;    }}
Output:
Args: []Log: 'Door 1 is open'Log: 'Door 2 is closed'Log: 'Door 3 is closed'Log: 'Door 4 is open'Log: 'Door 5 is closed'Log: 'Door 6 is closed'Log: 'Door 7 is closed'Log: 'Door 8 is closed'Log: 'Door 9 is open'Log: 'Door 10 is closed'Log: 'Door 11 is closed'Log: 'Door 12 is closed'Log: 'Door 13 is closed'Log: 'Door 14 is closed'Log: 'Door 15 is closed'Log: 'Door 16 is open'Log: 'Door 17 is closed'Log: 'Door 18 is closed'Log: 'Door 19 is closed'Log: 'Door 20 is closed'Log: 'Door 21 is closed'Log: 'Door 22 is closed'Log: 'Door 23 is closed'Log: 'Door 24 is closed'Log: 'Door 25 is open'Log: 'Door 26 is closed'Log: 'Door 27 is closed'Log: 'Door 28 is closed'Log: 'Door 29 is closed'Log: 'Door 30 is closed'Log: 'Door 31 is closed'Log: 'Door 32 is closed'Log: 'Door 33 is closed'Log: 'Door 34 is closed'Log: 'Door 35 is closed'Log: 'Door 36 is open'Log: 'Door 37 is closed'Log: 'Door 38 is closed'Log: 'Door 39 is closed'Log: 'Door 40 is closed'Log: 'Door 41 is closed'Log: 'Door 42 is closed'Log: 'Door 43 is closed'Log: 'Door 44 is closed'Log: 'Door 45 is closed'Log: 'Door 46 is closed'Log: 'Door 47 is closed'Log: 'Door 48 is closed'Log: 'Door 49 is open'Log: 'Door 50 is closed'Log: 'Door 51 is closed'Log: 'Door 52 is closed'Log: 'Door 53 is closed'Log: 'Door 54 is closed'Log: 'Door 55 is closed'Log: 'Door 56 is closed'Log: 'Door 57 is closed'Log: 'Door 58 is closed'Log: 'Door 59 is closed'Log: 'Door 60 is closed'Log: 'Door 61 is closed'Log: 'Door 62 is closed'Log: 'Door 63 is closed'Log: 'Door 64 is open'Log: 'Door 65 is closed'Log: 'Door 66 is closed'Log: 'Door 67 is closed'Log: 'Door 68 is closed'Log: 'Door 69 is closed'Log: 'Door 70 is closed'Log: 'Door 71 is closed'Log: 'Door 72 is closed'Log: 'Door 73 is closed'Log: 'Door 74 is closed'Log: 'Door 75 is closed'Log: 'Door 76 is closed'Log: 'Door 77 is closed'Log: 'Door 78 is closed'Log: 'Door 79 is closed'Log: 'Door 80 is closed'Log: 'Door 81 is open'Log: 'Door 82 is closed'Log: 'Door 83 is closed'Log: 'Door 84 is closed'Log: 'Door 85 is closed'Log: 'Door 86 is closed'Log: 'Door 87 is closed'Log: 'Door 88 is closed'Log: 'Door 89 is closed'Log: 'Door 90 is closed'Log: 'Door 91 is closed'Log: 'Door 92 is closed'Log: 'Door 93 is closed'Log: 'Door 94 is closed'Log: 'Door 95 is closed'Log: 'Door 96 is closed'Log: 'Door 97 is closed'Log: 'Door 98 is closed'Log: 'Door 99 is closed'Log: 'Door 100 is open'Exited with code 0

Golfscript

100:c;[{0}c*]:d;c,{.c,>\)%{.d<\.d=1^\)d>++:d;}/}/[c,{)"door "\+" is"+}%d{{"open"}{"closed"}if}%]zip{" "*puts}/

optimized with sqrt(Original version of GolfScript has no sqrt operator, but it can beadded easily; the code was tested using a work-in-progress C interpreterfor a language compatible enough with Golfscript)

100,{)}%{:d.sqrt 2?={"open"}{"close"}if"door "d+" is "+\+puts}/

optimized without sqrt

[{"close"}100*]:d;10,{)2?(.d<\["open"]\)d>++:d;}/[100,{)"door "\+" is"+}%d]zip{" "*puts}/

Gosu

unoptimized

uses java.util.Arraysvar doors = new boolean[100]Arrays.fill( doors, false )for( pass in 1..100 ) {    var counter = pass-1    while( counter < 100 ) {        doors[counter] = !doors[counter]        counter += pass  }}for( door in doors index i ) {    print( "door ${i+1} is ${door ? 'open' : 'closed'}" )}

optimized

var door = 1var delta = 0for( i in 1..100 ) {    if( i == door ) {        print( "door ${i} is open" )        delta++        door += 2*delta + 1    } else {        print( "door ${i} is closed" )    }}

Groovy

unoptimized

doors = [false] * 100(0..99).each {   it.step(100, it + 1) {      doors[it] ^= true   }}(0..99).each {   println("Door #${it + 1} is ${doors[it] ? 'open' : 'closed'}.")}

optimized aUsing square roots

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

optimized bWithout using square roots

doors = ['closed'] * 100(1..10).each { doors[it**2 - 1] = 'open' }(0..99).each {   println("Door #${it + 1} is ${doors[it]}.")}

GW-BASIC

10 DIM A(100)20 FOR OFFSET = 1 TO 10030      FOR I = 0 TO 100 STEP OFFSET40              A(I) = A(I) + 150      NEXT I60 NEXT OFFSET70 ' Print "opened" doors80 FOR I = 1 TO 10090      IF A(I) MOD 2 = 1 THEN PRINT I100 NEXT I

Output:

149162536496481100

Harbour

Unoptimized code:

#define ARRAY_ELEMENTS 100PROCEDURE Main()   LOCAL aDoors := Array( ARRAY_ELEMENTS )   LOCAL i, j   AFill( aDoors, .F. )   FOR i := 1 TO ARRAY_ELEMENTS      FOR j := i TO ARRAY_ELEMENTS STEP i         aDoors[ j ] = ! aDoors[ j ]      NEXT   NEXT   AEval( aDoors, {|e, n| QQout( Padl(n,3) + " is " + Iif(aDoors[n], "*open*", "closed" ) + "|" ), Iif( n%5 == 0, Qout(), e:=NIL) } )   RETURN

Optimized code

#define ARRAY_ELEMENTS 100PROCEDURE Main()   LOCAL aDoors := Array( ARRAY_ELEMENTS )   AFill( aDoors, .F. )   AEval( aDoors, {|e, n| aDoors[n] := e := Iif( Int(Sqrt(n))==Sqrt(n), .T., .F. ) } )   AEval( aDoors, {|e, n| QQout( Padl(n,3) + " is " + Iif(aDoors[n], "*open*", "closed" ) + "|" ), Iif( n%5 == 0, Qout(), e:=NIL )} )   RETURN

Output:

 1 is *open*|  2 is closed|  3 is closed|  4 is *open*|  5 is closed|  6 is closed|  7 is closed|  8 is closed|  9 is *open*| 10 is closed| 11 is closed| 12 is closed| 13 is closed| 14 is closed| 15 is closed| 16 is *open*| 17 is closed| 18 is closed| 19 is closed| 20 is closed| 21 is closed| 22 is closed| 23 is closed| 24 is closed| 25 is *open*| 26 is closed| 27 is closed| 28 is closed| 29 is closed| 30 is closed| 31 is closed| 32 is closed| 33 is closed| 34 is closed| 35 is closed| 36 is *open*| 37 is closed| 38 is closed| 39 is closed| 40 is closed| 41 is closed| 42 is closed| 43 is closed| 44 is closed| 45 is closed| 46 is closed| 47 is closed| 48 is closed| 49 is *open*| 50 is closed| 51 is closed| 52 is closed| 53 is closed| 54 is closed| 55 is closed| 56 is closed| 57 is closed| 58 is closed| 59 is closed| 60 is closed| 61 is closed| 62 is closed| 63 is closed| 64 is *open*| 65 is closed| 66 is closed| 67 is closed| 68 is closed| 69 is closed| 70 is closed| 71 is closed| 72 is closed| 73 is closed| 74 is closed| 75 is closed| 76 is closed| 77 is closed| 78 is closed| 79 is closed| 80 is closed| 81 is *open*| 82 is closed| 83 is closed| 84 is closed| 85 is closed| 86 is closed| 87 is closed| 88 is closed| 89 is closed| 90 is closed| 91 is closed| 92 is closed| 93 is closed| 94 is closed| 95 is closed| 96 is closed| 97 is closed| 98 is closed| 99 is closed|100 is *open*|

Haskell

Unoptimized

data Door  = Open  | Closed  deriving (Eq, Show)toggle :: Door -> Doortoggle Open = Closedtoggle Closed = OpentoggleEvery :: Int -> [Door] -> [Door]toggleEvery k = zipWith toggleK [1 ..]  where    toggleK n door      | n `mod` k == 0 = toggle door      | otherwise = doorrun :: Int -> [Door]run n = foldr toggleEvery (replicate n Closed) [1 .. n]main :: IO ()main = print $ filter ((== Open) . snd) $ zip [1 ..] (run 100)
Output:
[(1,Open),(4,Open),(9,Open),(16,Open),(25,Open),(36,Open),(49,Open),(64,Open),(81,Open),(100,Open)]

One liner (unoptimized)

run n = findIndices odd $ foldr toggleEvery (replicate n 0) [0..n] where toggleEvery k =  zipWith (+) $ cycle $ 1 : replicate k 0

Without toggling doors

isDoorOpen :: Integral a => a -> Bool-- In Haskell, we are too lazy to open and close doors. Instead we-- count how many times we would have toggled them, and then check if-- that number is odd.isDoorOpen doorNumber = odd numToggles  where numToggles = length [ 1 | x <- [1..doorNumber], doorNumber `rem` x == 0]main = do  print $ "Open doors are " ++ show [x | x <- [0..100], isDoorOpen x]

Optimized

(without using square roots)

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

One liner (optimized)

Alternatively, returning a list of all open gates, it's a one-liner:

run n = takeWhile (< n) [k*k | k <- [1..]]

Haxe

Unoptimised

class Main{    static public function main()    {        findOpenDoors( 100 );    }    static function findOpenDoors( n : Int )    {        var door = [];        for( i in 0...n + 1 ){ door[ i ] = false; }        for( i in 1...n + 1 ){            var j = i;            while( j <= n ){                 door[ j ] = ! door[ j ];                j += i;            }        }        for( i in 1...n + 1 ){            if( door[ i ] ){ Sys.print( ' $i' ); }        }    }}
Output:
 1 4 9 16 25 36 49 64 81 100

Optimised

class RosettaDemo{    static public function main()    {        findOpenLockers(100);    }    static function findOpenLockers(n : Int)    {        var i = 1;        while((i*i) <= n)        {            Sys.println(i*i);            i++;        }    }}

HicEst

Unoptimized

REAL :: n=100, open=1, door(n)door = 1 - open ! = closedDO i = 1, n  DO j = i, n, i    door(j) = open - door(j)  ENDDOENDDODLG(Text=door, TItle=SUM(door)//" doors open")

Optimized

door = 1 - open ! = closedDO i = 1, n^0.5  door(i*i) = openENDDODLG(Text=door, TItle=SUM(door)//" doors open")

HolyC

Translation of:C
U8 is_open[100];U8 pass = 0, door = 0;/* 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)  if (is_open[door])    Print("Door #%d is open.\n", door + 1);  else    Print("Door #%d is closed.\n", door + 1);

Hoon

|^=/  doors=(list ?)  (reap 100 %.n)=/  passes=(list (list ?))  (turn (gulf 1 100) pass-n)|-?~  passes  doors$(doors (toggle doors i.passes), passes t.passes)++  pass-n  |=  n=@ud  (turn (gulf 1 100) |=(k=@ud =((mod k n) 0)))++  toggle  |=  [a=(list ?) b=(list ?)]  =|  c=(list ?)  |-  ?:  |(?=(~ a) ?=(~ b))  (flop c)  $(a t.a, b t.b, c [=((mix i.a i.b) 1) c])--

Huginn

#! /bin/shexec huginn --no-argv -E "${0}"#! huginnimport Algorithms as algo;main() {        doorCount = 100;        doors = [].resize( doorCount, false );        for ( pass : algo.range( doorCount ) ) {                i = 0;                step = pass + 1;                while ( i < doorCount ) {                        doors[i] = ! doors[i];                        i += step;                }        }        for ( i : algo.range( doorCount ) ) {                if ( doors[i] ) {                        print( "door {} is open\n".format( i ) );                }        }        return ( 0 );}

Hy

Translation of:Coco
(setv doors (* [False] 100))(for [pass (range (len doors))]  (for [i (range pass (len doors) (inc pass))]    (assoc doors i (not (get doors i)))))(for [i (range (len doors))]  (print (.format "Door {} is {}."    (inc i)    (if (get doors i) "open" "closed"))))

I

software {var doors = len(100)for pass over [1, 100]var door = pass - 1loop door < len(doors) {doors[door] = doors[door]/0door += pass}endfor door,isopen in doorsif isopenprint("Door ",door+1,": open")endendprint("All other doors are closed")}

Icon andUnicon

Icon and Unicon don't have a boolean type because most often, logic is expressed in terms of success or failure, which affects flow at run time.

Unoptimized solution.

procedure main()    door := table(0)    # default value of entries is 0    every pass := 1 to 100 do        every door[i := pass to 100 by pass] := 1 - door[i]    every write("Door ", i := 1 to 100, " is ", if door[i] = 1 then "open" else "closed")end

Optimized solution.

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

or

procedure main(args)    dMap := table("closed")    every dMap[(1 to sqrt(100))^2] := "open"    every write("Door ",i := 1 to 100," is ",dMap[i])end

Idris

import Data.Vect-- Creates list from 0 to n (not including n) upTo : (m : Nat) -> Vect m (Fin m)upTo Z = []upTo (S n) = 0 :: (map FS (upTo n))data DoorState = DoorOpen | DoorClosedtoggleDoor : DoorState -> DoorStatetoggleDoor DoorOpen = DoorClosedtoggleDoor DoorClosed = DoorOpenisOpen : DoorState -> BoolisOpen DoorOpen = TrueisOpen DoorClosed = FalseinitialDoors : Vect 100 DoorStateinitialDoors = fromList $ map (\_ => DoorClosed) [1..100]iterate : (n : Fin m) -> Vect m DoorState -> Vect m DoorStateiterate n doors {m} =   map (\(idx, doorState) =>           if ((S (finToNat idx)) `mod` (S (finToNat n))) == Z               then toggleDoor doorState               else doorState)        (zip (upTo m) doors)-- Returns all doors left open at the endsolveDoors : List (Fin 100)solveDoors =   findIndices isOpen $ foldl (\doors,val => iterate val doors) initialDoors (upTo 100)main : IO ()main = print $ map (\n => S (finToNat n)) solveDoors

Inform 7

Works with:Z-machine version 8
Works with:Glulx virtual machine
Hallway is a room.A toggle door is a kind of thing.A toggle door can be open or closed. It is usually closed.A toggle door has a number called the door number.Understand the door number property as referring to a toggle door.Rule for printing the name of a toggle door: say "door #[door number]".There are 100 toggle doors.When play begins (this is the initialize doors rule):let the next door number be 1;repeat with D running through toggle doors:now the door number of D is the next door number;increment the next door number.To toggle (D - open toggle door): now D is closed.To toggle (D - closed toggle door): now D is open.When play begins (this is the solve puzzle rule):let the door list be the list of toggle doors;let the door count be the number of entries in the door list;repeat with iteration running from 1 to 100:let N be the iteration;while N is less than the door count:toggle entry N in the door list;increase N by the iteration;say "Doors left open: [list of open toggle doors].";end the story.

Informix 4GL

MAIN    DEFINE        i, pass SMALLINT,        doors ARRAY[100] OF SMALLINT     FOR i = 1 TO 100        LET doors[i] = FALSE    END FOR     FOR pass = 1 TO 100        FOR i = pass TO 100 STEP pass            LET doors[i] = NOT doors[i]        END FOR    END FOR     FOR i = 1 TO 100        IF doors[i]          THEN DISPLAY i USING "Door <<& is open"          ELSE DISPLAY i USING "Door <<& is closed"        END IF    END FOREND MAIN

Insitux

(var doors (times 100 false))(for i  (range 1 101)     i2 (range (dec i) 100 i)  (var! doors (set-at [i2] (not (i2 doors))))  (continue))(-> (xmap vec doors)    (filter 1)    (map (comp 0 inc))    (join ", ")   @(str "open doors: "))
Output:
open doors: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

Io

simple boolean list solution:

doors := List clone100 repeat(doors append(false))for(i,1,100,    for(x,i,100, i, doors atPut(x - 1, doors at(x - 1) not)))doors foreach(i, x, if(x, "Door #{i + 1} is open" interpolate println))

Optimized solution:

(Range 1 to(10) asList) foreach(v, "Door #{v ** 2} is open." interpolate println)

Sample output:

Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

Ioke

Unoptimized Object Oriented solution.

NDoors = Origin mimicNDoors Toggle = Origin mimic do(  initialize = method(toggled?, @toggled? = toggled?)  toggle! = method(@toggled? = !toggled?. self))NDoors Doors = Origin mimic do(  initialize = method(n,    @n = n    @doors = {} addKeysAndValues(1..n, (1..n) map(_, NDoors Toggle mimic(false)))  )  numsToToggle = method(n, for(x <- (1..@n), (x % n) zero?, x))  toggleThese = method(nums, nums each(x, @doors[x] = @doors at(x) toggle))  show = method(@doors filter:dict(value toggled?) keys sort println)); Test codex = NDoors Doors mimic(100)(1..100) each(n, x toggleThese(x numsToToggle(n)))x show

Isabelle

theory Scratch  imports Mainbeginsection‹100 Doors›  datatype doorstate = Open | Closed    fun toggle :: "doorstate ⇒ doorstate" where    "toggle Open   = Closed"  | "toggle Closed = Open"    fun walk :: "('a ⇒ 'a) ⇒ nat ⇒ nat ⇒ 'a list ⇒ 'a list" where    "walk f _     _       []     = []"  | "walk f every 0       (x#xs) = (f x) # walk f every every xs"  | "walk f every (Suc n) (x#xs) = x # walk f every n xs"    text‹Example: \<^const>‹toggle› every second door. (second = 1, because of 0 indexing)›  lemma "walk toggle 1 1 [Open, Open, Open, Open, Open, Open] =                         [Open, Closed, Open, Closed, Open, Closed]" by code_simp    text‹Example: \<^const>‹toggle› every third door.›  lemma "walk toggle 2 2 [Open, Open, Open, Open, Open, Open] =                         [Open, Open, Closed, Open, Open, Closed]" by code_simp    text‹Walking each door is essentially the same as the common \<^const>‹map› function.›  lemma "walk f 0 0 xs = map f xs"    by(induction xs) (simp)+    lemma walk_beginning:    "walk f every n xs = (walk f every n (take (Suc n) xs)) @ (walk f every every (drop (Suc n) xs))"    by(induction f every n xs rule:walk.induct) (simp)+    text‹A convenience definition to take the off-by-one into account and setting the starting position.›  definition visit_every :: "('a ⇒ 'a) ⇒ nat ⇒ 'a list ⇒ 'a list" where    "visit_every f every xs ≡ walk f (every - 1) (every - 1) xs"      fun iterate :: "nat ⇒ (nat ⇒ 'a ⇒ 'a) ⇒ nat ⇒ 'a ⇒ 'a" where    "iterate 0       _ _ a = a"  | "iterate (Suc i) f n a = iterate i f (Suc n) (f n a)"    text‹The 100 doors problem.›  definition "onehundred_doors ≡ iterate 100 (visit_every toggle) 1 (replicate 100 Closed)"    lemma "onehundred_doors =    [Open, Closed, Closed, Open, Closed, Closed, Closed,     Closed, Open, Closed, Closed, Closed, Closed, Closed,     Closed, Open, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Open, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Open, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Open,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Open, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Open, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Closed, Closed, Closed, Closed, Closed, Closed,     Closed, Open]" by code_simp    text‹Filtering for the open doors, we get the same result as the Haskell implementation.›  lemma    "[(i, door) ← enumerate 1 onehundred_doors. door = Open] =     [(1,Open),(4,Open),(9,Open),(16,Open),(25,Open),(36,Open),(49,Open),(64,Open),(81,Open),(100,Open)]"    by code_simpsection‹Equivalence to Haskell Implementation›text‹We will now present an alternative implementation, which is similar to the Haskell implementationon 🌐‹https://rosettacode.org/wiki/100_doors#Haskell›. We will prove, that the two behave the same;in general, not just for a fixed set of 100 doors.›  definition map_every_start :: "('a ⇒ 'a) ⇒ nat ⇒ nat ⇒ 'a list ⇒ 'a list" where    "map_every_start f every start xs ≡      map (λ(i, x). if i mod every = 0 then f x else x) (enumerate start xs)"  definition visit_every_alt :: "('a ⇒ 'a) ⇒ nat ⇒ 'a list ⇒ 'a list" where    "visit_every_alt f every xs ≡ map_every_start f every 1 xs"    text‹Essentially, \<^term>‹start› and \<^term>‹start mod every› behave the same.›  lemma map_every_start_cycle:    "map_every_start f every (start + k*every) xs = map_every_start f every start xs"    proof(induction xs arbitrary: start)      case Nil      show "map_every_start f every (start + k * every) [] = map_every_start f every start []"        by(simp add: map_every_start_def)    next      case (Cons x xs)      from Cons.IH[of "Suc start"]        show "map_every_start f every (start + k * every) (x # xs) =              map_every_start f every start (x # xs)"        by(simp add: map_every_start_def)    qed  corollary map_every_start_cycle_zero:    "map_every_start f every every xs = map_every_start f every 0 xs"    using map_every_start_cycle[where k=1 and start=0, simplified] by blast    lemma map_every_start_fst_zero:    "map_every_start f every 0 (x # xs) = f x # map_every_start f every (Suc 0) xs"    by(simp add: map_every_start_def)    text‹  The first \<^term>‹n› elements are not processed by \<^term>‹f›,  as long as \<^term>‹n› is less than the \<^term>‹every› cycle.  ›  lemma map_every_start_skip_first: "Suc n < every ⟹         map_every_start f every (every - (Suc n)) (x # xs) =          x # map_every_start f every (every - n) xs"    by(simp add: map_every_start_def Suc_diff_Suc)  lemma map_every_start_append:    "map_every_start f n s (ds1 @ ds2) =     map_every_start f n s ds1 @ map_every_start f n (s + length ds1) ds2"    by(simp add: map_every_start_def enumerate_append_eq)  text‹  The \<^const>‹walk› function and \<^const>‹map_every_start› behave the same,  as long as the starting \<^term>‹n› is less than the \<^term>‹every› cycle,  because \<^const>‹walk› allows pushing the start arbitrarily far and  \<^const>‹map_every_start› only allows deferring the start within  the \<^term>‹every› cycle.  This generalization is needed to strengthen the induction hypothesis  for the proof.  ›  lemma walk_eq_map_every_start:    "n ≤ every ⟹ walk f every n xs = map_every_start f (Suc every) (Suc every - n) xs"    proof(induction xs arbitrary: n)      case Nil      show "walk f every n [] = map_every_start f (Suc every) (Suc every - n) []"        by(simp add: map_every_start_def)    next      case (Cons x xs)      then show "walk f every n (x # xs) = map_every_start f (Suc every) (Suc every - n) (x # xs)"      proof(cases n)        case 0        with Cons.IH show ?thesis           by(simp add: map_every_start_cycle_zero map_every_start_fst_zero)      next        case (Suc n2)        with Cons.prems map_every_start_skip_first[of n2 "Suc every"] have          "map_every_start f (Suc every) (Suc every - Suc n2) (x # xs) =           x # map_every_start f (Suc every) (Suc every - n2) xs"          by fastforce        with Suc Cons show ?thesis          by(simp)      qed    qed    corollary walk_eq_visit_every_alt:    "walk f every every xs = visit_every_alt f (Suc every) xs"    unfolding visit_every_alt_def    using walk_eq_map_every_start by fastforce  text‹  Despite their very different implementations, our alternative visit function behaves the same  as our original visit function.  Text the theorem includes \<^term>‹Suc every› to express that we exclude \<^term>‹every = 0›.  ›  theorem visit_every_eq_visit_every_alt:    "visit_every f (Suc every) xs = visit_every_alt f (Suc every) xs"    unfolding visit_every_def    using walk_eq_visit_every_alt by fastforce  text‹Also, the \<^const>‹iterate› function we implemented above can be implemented by a simple \<^const>‹fold›.›  lemma fold_upt_helper: assumes n_geq_1: "Suc 0 ≤ n"    shows "fold f [Suc s..<n + s] (f s xs) = fold f [s..<n + s] xs"  proof -    from n_geq_1 have "[s..<n + s] = s#[Suc s..<n + s]" by (simp add: Suc_le_lessD upt_rec)    from this have "fold f [s..<n + s] xs = fold f (s#[Suc s..<n + s]) xs" by simp    also have "fold f (s#[Suc s..<n + s]) xs = fold f [Suc s..<n + s] (f s xs)" by(simp)    ultimately show ?thesis by simp  qed    theorem iterate_eq_fold: "iterate n f s xs = fold f [s ..< n+s] xs"  proof(induction n arbitrary: s xs)    case 0    then show "iterate 0 f s xs = fold f [s..<0 + s] xs" by simp  next    case (Suc n)    from Suc show "iterate (Suc n) f s xs = fold f [s..<Suc n + s] xs"       by(simp add: fold_upt_helper not_less_eq_eq)  qedsection‹Efficient Implementation›text ‹As noted on this page, the only doors that remain open are those whose numbers are perfect squares.Yet, rosettacode does not want us to take this shortcut, since we want to compare implementationsacross programming languages. But we can prove that our code computes the same result as reportingall doors with a perfect square number as open:›  theorem "[(i, door) ← enumerate 1 onehundred_doors. door = Open] =           [(i*i, Open). i ← [1..<11]]"    by code_simpend

J

unoptimized

   ~:/ (100 $ - {. 1:)"0 >:i.1001 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. alternative1 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)2|>:_ q:>:i.100 NB. alternative

optimized

   (e. *:) 1+i.1001 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. alternative1 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 ...

with formatting

   'these doors are open: ',": I. (i.101) e. *: 1+i.10these doors are open: 1 4 9 16 25 36 49 64 81 100

Janet

(def doors (seq [_ :range [0 100]] false))(loop [pass :range [0 100]       door :range [pass 100 (inc pass)]]  (put doors door (not (doors door))))(print "open doors: " ;(seq [i :range [0 100] :when (doors i)] (string (inc i) " ")))

Output:

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

Java

With an array of boolean

class HundredDoors {    public static void main(String[] args) {        boolean[] doors = new boolean[101];        for (int i = 1; i < doors.length; i++) {            for (int j = i; j < doors.length; j += i) {                doors[j] = !doors[j];            }        }        for (int i = 1; i < doors.length; i++) {            if (doors[i]) {                System.out.printf("Door %d is open.%n", i);            }        }    }}

With a BitSet

import java.util.BitSet;public class HundredDoors {    public static void main(String[] args) {        final int n = 100;        var a = new BitSet(n);        for (int i = 1; i <= n; i++) {            for (int j = i - 1; j < n; j += i) {                a.flip(j);            }        }        a.stream().map(i -> i + 1).forEachOrdered(System.out::println);    }}

Only print the result

class HundredDoors {    public static void main(String[] args) {        for (int i = 1; i <= 10; i++)            System.out.printf("Door %d is open.%n", i * i);    }}

Output:

Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

If only printing the result is required, using streams.

import java.util.stream.Collectors;import java.util.stream.IntStream;class HundredDoors {    public static void main(String args[]) {        String openDoors = IntStream.rangeClosed(1, 100)                .filter(i -> Math.pow((int) Math.sqrt(i), 2) == i)                .mapToObj(Integer::toString)                .collect(Collectors.joining(", "));        System.out.printf("Open doors: %s%n", openDoors);    }}

Output:

Open doors: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

JavaScript

ES5

Iterative

var doors=[];for (var i=0;i<100;i++)    doors[i]=false;for (var i=1;i<=100;i++)    for (var i2=i-1;i2<100;i2+=i)        doors[i2]=!doors[i2];for (var i=1;i<=100;i++)    console.log("Door %d is %s",i,doors[i-1]?"open":"closed")

Functional Composition

Naive search

(function (n) {    "use strict";    function finalDoors(n) {        var lstRange = range(1, n);        return lstRange            .reduce(function (a, _, k) {                var m = k + 1;                return a.map(function (x, i) {                    var j = i + 1;                    return [j, j % m ? x[1] : !x[1]];                });            }, zip(                lstRange,                replicate(n, false)            ));    };    function zip(xs, ys) {        return xs.length === ys.length ? (            xs.map(function (x, i) {                return [x, ys[i]];            })        ) : undefined;    }    function replicate(n, a) {        var v = [a],            o = [];        if (n < 1) return o;        while (n > 1) {            if (n & 1) o = o.concat(v);            n >>= 1;            v = v.concat(v);        }        return o.concat(v);    }    function range(m, n, delta) {        var d = delta || 1,            blnUp = n > m,            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,            a = Array(lng),            i = lng;        if (blnUp)            while (i--) a[i] = (d * i) + m;        else            while (i--) a[i] = m - (d * i);        return a;    }    return finalDoors(n)        .filter(function (tuple) {            return tuple[1];        })        .map(function (tuple) {            return {                door: tuple[0],                open: tuple[1]            };        });})(100);

Optimized (iterative)

for (var door = 1; door <= 100; door++) {  var sqrt = Math.sqrt(door);  if (sqrt === (sqrt | 0)) {    console.log("Door %d is open", door);  }}

Simple for loop. Optimizing the optimized?

for(var door=1;i<10/*Math.sqrt(100)*/;i++){ console.log("Door %d is open",i*i);}

Optimized (functional)

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:

(function (n) {    "use strict";    return range(1, 100)        .filter(function (x) {            return integerFactors(x)                .length % 2;        });    function integerFactors(n) {        var rRoot = Math.sqrt(n),            intRoot = Math.floor(rRoot),            lows = range(1, intRoot)            .filter(function (x) {                return (n % x) === 0;            });        return lows.concat(lows.map(function (x) {                return n / x;            })            .reverse()            .slice((rRoot === intRoot) | 0));    }    function range(m, n, delta) {        var d = delta || 1,            blnUp = n > m,            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,            a = Array(lng),            i = lng;        if (blnUp)            while (i--) a[i] = (d * i) + m;        else            while (i--) a[i] = m - (d * i);        return a;    }})(100);

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.

(function (n) {    "use strict";    return perfectSquaresUpTo(100);    function perfectSquaresUpTo(n) {        return range(1, Math.floor(Math.sqrt(n)))            .map(function (x) {                return x * x;            });    }    function range(m, n, delta) {        var d = delta || 1,            blnUp = n > m,            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,            a = Array(lng),            i = lng;        if (blnUp)            while (i--) a[i] = (d * i) + m;        else            while (i--) a[i] = m - (d * i);        return a;    }})(100);

ES6

Array.apply(null, { length: 100 })  .map((v, i) => i + 1)    .forEach(door => {       var sqrt = Math.sqrt(door);       if (sqrt === (sqrt | 0)) {        console.log("Door %d is open", door);      }     });
Works with:SpiderMonkey

(Firefox) But not most (if any) other JavaScript engines. Array comprehension ([ for... ]) is non-standard.

// Array comprehension style[ for (i of Array.apply(null, { length: 100 })) i ].forEach((_, i) => {   var door = i + 1  var sqrt = Math.sqrt(door);   if (sqrt === (sqrt | 0)) {    console.log("Door " + door + " is open");  } });

The result is always:

Door 1 is openDoor 4 is openDoor 9 is openDoor 16 is openDoor 25 is openDoor 36 is openDoor 49 is openDoor 64 is openDoor 81 is openDoor 100 is open

Or using a more general function for listing perfect squares:

(function (n) {      // ONLY PERFECT SQUARES HAVE AN ODD NUMBER OF INTEGER FACTORS    // (Leaving the door open at the end of the process)      return perfectSquaresUpTo(n);      // perfectSquaresUpTo :: Int -> [Int]    function perfectSquaresUpTo(n) {        return range(1, Math.floor(Math.sqrt(n)))            .map(x => x * x);    }      // GENERIC     // range(intFrom, intTo, optional intStep)    // Int -> Int -> Maybe Int -> [Int]    function range(m, n, step) {        let d = (step || 1) * (n >= m ? 1 : -1);         return Array.from({            length: Math.floor((n - m) / d) + 1        }, (_, i) => m + (i * d));    } })(100);
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


School example

Works with:JavaScript version Node.js 16.13.0 (LTS)
"use strict";// Doors can be open or closed.const open = "O";const closed = "C";// There are 100 doors in a row that are all initially closed.const doorsCount = 100;const doors = [];for (let i = 0; i < doorsCount; doors[i] = closed, i++);// You make 100 passes by the doors, visiting every door and toggle the door (if// the door is closed, open it; if it is open, close it), according to the rules// of the task.for (let pass = 1; pass <= doorsCount; pass++)    for (let i = pass - 1; i < doorsCount; i += pass)        doors[i] = doors[i] == open ? closed : open;// Answer the question: what state are the doors in after the last pass?doors.forEach((v, i) =>    console.log(`Doors ${i + 1} are ${v == open ? 'opened' : 'closed'}.`));// Which are open, which are closed?let openKeyList = [];let closedKeyList = [];for (let door of doors.entries())    if (door[1] == open)        openKeyList.push(door[0] + 1);    else        closedKeyList.push(door[0] + 1);console.log("These are open doors: " + openKeyList.join(", ") + ".");console.log("These are closed doors: " + closedKeyList.join(", ") + ".");// Assert:const expected = [];for (let i = 1; i * i <= doorsCount; expected.push(i * i), i++);if (openKeyList.every((v, i) => v === expected[i]))    console.log("The task is solved.")else    throw "These aren't the doors you're looking for.";

jq

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


Solution by simulation

# Solution for n doors:def doors(n):  def print:    . as $doors    | range(1; length+1)    | if $doors[.] then "Door \(.) is open" else empty end;    [range(n+1)|null] as $doors  | reduce range(1; n+1) as $run      ( $doors; reduce range($run; n+1; $run ) as $door                  ( .; .[$door] = (.[$door] | not) ) )  | print ;

Analytical solution

# Solution for 100 doors:def solution:  range(1;11) | "Door \(. * .) is open";

Julia

Simple:

  • falses(100) creates a 100-element Bool array filled with false values,
  • 'b in a:a:100' translates to 'start:step:end',
  • string concatenation by '*'.


doors = falses(100)for a in 1:100, b in a:a:100    doors[b] = !doors[b]endfor a = 1:100    println("Door $a is " * (doors[a] ? "open." : "closed.")) end

Gimmicky-optimized:

for i in 1:10 println("Door $(i^2) is open.") end

K

K3

Works with:Kona

Converted fromQ:

   doors:{`closed`open![;2]@#:'1_=,/&:'0=t!\:/:t:!101}

Optimized 1-based indices:

   (1+!10)^21 4 9 16 25 36 49 64 81 100

Indices as a parameterized function:

   {(1+!_ x^%2)^2}1001 4 9 16 25 36 49 64 81 100

Klingphix

include ..\Utilitys.tlhy%n 100 !n0 $n repeat$n [dup sqrt int dup * over== ( [1 swap set] [drop] ) if] for$n [ ( "The door " over  " is " ) lprint get ( ["OPEN"] ["closed"] ) if print nl] for( "Time elapsed: " msec " seconds" ) lprint nlpstack" " input

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

Koka

Iterative version

type state  Open  Closedfun toggle(self: state): state  match self    Open   -> Closed    Closed -> Openinline extern unsafe-assign : forall<a> ( v : vector<a>, i : ssize_t, x : a ) -> total ()  c "kk_vector_unsafe_assign"fun main()  val doors = vector(100, Closed)  for(0,99) fn(pass)    var door := pass    while { door < 99 }      doors.unsafe-assign(door.ssize_t, doors[door].toggle)      door := door + (pass+1)  doors.foreach-indexed fn(idx, it)    match it      Open   -> println("door " ++ (idx + 1).show ++ " is open")      Closed -> println("door " ++ (idx + 1).show ++ " is closed")

Functional Version (Same definitions as above with different main)

fun main()  val doors = list(0,99,1,fn(i) Closed)  val transformed = list(1,99).foldl(doors) fn(drs, pass)    drs.map-indexed fn(i, door)      if ((i + 1) % pass) == 0 then door.toggle else door  transformed.foreach-indexed fn(idx, it)    match it      Open   -> println("door " ++ (idx + 1).show ++ " is open")      Closed -> println("door " ++ (idx + 1).show ++ " is closed")

Kotlin

fun oneHundredDoors(): List<Int> {    val doors = BooleanArray(100) { false }    repeat(doors.size) { i ->        for (j in i until doors.size step (i + 1)) {            doors[j] = !doors[j]        }    }    return doors        .foldIndexed(emptyList()) { i, acc, door ->            if (door) acc + (i + 1) else acc        }}

KQL

range InitialDoor from 1 to 100 step 1| extend DoorsVisited=range(InitialDoor, 100, InitialDoor)| mvexpand DoorVisited=DoorsVisited to typeof(int)| summarize VisitCount=count() by DoorVisited| project Door=DoorVisited, IsOpen=(VisitCount % 2) == 1

LabVIEW

This image is aVI Snippet, an executable image ofLabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Optimized

This image is aVI Snippet, an executable image ofLabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lambdatalk

Translation from Python

1) unoptimized version{def doors {A.new  {S.map {lambda {} false} {S.serie 1 100}}}}-> doors{def toggle {lambda {:i :a}  {let { {_ {A.set! :i {not {A.get :i :a}} :a} }}}}}-> toggle{S.map {lambda {:b}  {S.map {lambda {:i} {toggle :i {doors}}}   {S.serie :b 99 {+ :b 1}}}}   {S.serie 0 99}} ->{S.replace \s by space in  {S.map {lambda {:i} {if {A.get :i {doors}} then {+ :i 1} else}}   {S.serie 0 99}}}-> 1 4 9 16 25 36 49 64 81 1002.2) optimized version{S.replace \s by space in  {S.map {lambda {:i}         {let { {:root {sqrt :i}} }               {if {= :root {round :root}}                then {* :root :root}               else}}}        {S.serie 1 100}}}-> 1 4 9 16 25 36 49 64 81 100

Lang

&doors = fn.arrayGenerateFrom(fn.inc, 100)fp.mapper = ($i) -> {$n$open = 0repeat($[n], 100) {$open $= $i % +|$n?!$open:$open}return $open}fn.arrayMap(&doors, fp.mapper)fn.print(Open doors:)$irepeat($[i], @&doors) {if(&doors[$i]) {fn.printf(\s%03d, parser.op(+|$i))}}fn.println()
Output:
Open doors: 001 004 009 016 025 036 049 064 081 100

langur

not optimized

var doors = [false] * 100for i of doors {    for j = i; j <= len(doors); j += i {        doors[j] = not doors[j]    }}writeln for[=[]] i of doors { if doors[i]: _for = more(_for, i) }

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

writeln fold(doors, series(1..len(doors)), by=fn a, b, c: if(b: a~[c]; a), init=[])

optimized

writeln map(1..10, by=fn{^2})
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Lasso

Loop

loop(100) => {^local(root = math_sqrt(loop_count))local(state = (#root == math_ceil(#root) ? '<strong>open</strong>' | 'closed'))#state != 'closed' ? 'Door ' + loop_count + ': ' + #state + '<br>'^}
Output:
Door 1: openDoor 4: openDoor 9: openDoor 16: openDoor 25: openDoor 36: openDoor 49: openDoor 64: openDoor 81: openDoor 100: open

Latitude

use 'format importAllSigils.doors := Object clone.doors missing := { False. }.doors check := {  self slot ($1 ordinal).}.doors toggle := {  self slot ($1 ordinal) = self slot ($1 ordinal) not.}.1 upto 101 do {  takes '[i].  local 'j = i.  while { j <= 100. } do {    doors toggle (j).    j = j + i.  }.}.$stdout printf: ~fmt "The open doors are: ~A", 1 upto 101 filter { doors check. } to (Array).

Lhogho

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.

to doors;Problem 100 Doors ;Lhoghofor "p [1 100] [make :p "false]for "a [1 100 1][for "b [:a 100 :a][if :b < 101 [make :b not thing :b]]]for "c [1 100][if thing :c [ (print "door :c "is "open) ]] enddoors

Liberty BASIC

Works with:Just BASIC
Works with:Run BASIC
dim doors(100)for pass = 1 to 100    for door = pass to 100 step pass        doors(door) = not(doors(door))    next doornext passprint "open doors ";for door = 1 to 100    if doors(door) then print door;"  ";next door

Lily

var doors = List.fill(100, false)for i in 0...99:    for j in i...99 by i + 1:        doors[j] = !doors[j]# The type must be specified since the list starts off empty.var open_doors: List[Integer] = []doors.each_index{|i|    if doors[i]:        open_doors.push(i + 1)}print($"Open doors: ^(open_doors)")
Output:
Open doors: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

LiveCode

xTalk

Works with:HyperCard
Works with:LiveCode
on mouseUp      repeat with tStep = 1 to 100      repeat with tDoor = tStep to 100 step tStep         put not tDoors[tDoor] into tDoors[tDoor]      end repeat      if tDoors[tStep] then put "Door " & tStep & " is open" & cr after tList   end repeat   set the text of field "Doors" to tListend mouseUp

Logo

to doors;Problem 100 Doors ;FMSLogo;lrcvs 2010make "door (vector 100 1) for [p 1 100][setitem :p :door 0]   for [a 1 100 1][for [b :a 100 :a][make "x item :b :door                           ifelse :x  = 0 [setitem :b :door 1][setitem :b :door 0] ] ]   for [c 1 100][make "y item :c :door       ifelse :y = 0 [pr (list :c "Close)] [pr (list :c "Open)] ] end

LOLCODE

HAI 1.3I HAS A doors ITZ A BUKKITIM IN YR hallway UPPIN YR door TIL BOTH SAEM door AN 100    doors HAS A SRS door ITZ FAIL BTW, INISHULIZE ALL TEH DOORZ AS CLOZDIM OUTTA YR hallwayIM IN YR hallway UPPIN YR pass TIL BOTH SAEM pass AN 100    I HAS A door ITZ pass    IM IN YR passer        doors'Z SRS door R NOT doors'Z SRS door        door R SUM OF door AN SUM OF pass AN 1        DIFFRINT door AN SMALLR OF door AN 99, O RLY?            YA RLY, GTFO        OIC    IM OUTTA YR passerIM OUTTA YR hallwayIM IN YR printer UPPIN YR door TIL BOTH SAEM door AN 100    VISIBLE "Door #" SUM OF door AN 1 " is "!    doors'Z SRS door, O RLY?        YA RLY, VISIBLE "open."        NO WAI, VISIBLE "closed."    OICIM OUTTA YR printerKTHXBYE

Lua

local is_open = {}for pass = 1,100dofor door = pass,100,passdo        is_open[door] =not is_open[door]endendfor i,vin pairs(is_open)doif vthen io.write( string.format( " %d", i ) )endend

M2000 Interpreter

Second dim preserve values except explicit assign a value for each item using = or a different value using << and a lambda function as generator.

Here we use =false to make all items false (which is a double value of 0).

M2000 use True and False as -1 and 0 (type of double), but from comparisons return Boolean True and False, which used as -1 and 0 also. Using =1=1 we get Boolean True and =1=0 we get Boolean False. We can check type from a variable using Type$(), so x=1=1 : Print Type$(x)="Boolean". We can chack type of an expression using a function: Def ExpressionType$(x)=Type$(x)


Module Doors100 {      Dim Doors(1 to 100)      For i=1 to 100            For j=i to 100 step i                  Doors(j)~            Next j      Next i      DispAll()      ' optimization      Dim Doors(1 to 100)=False      For i=1 to 10            Doors(i**2)=True      Next i      Print      DispAll()      Sub DispAll()            Local i            For i=1 to 100                  if Doors(i) then print i,            Next i            Print      End Sub}Doors100

M4

define(`_set', `define(`$1[$2]', `$3')')dnldefine(`_get', `defn(`$1[$2]')')dnldefine(`for',`ifelse($#,0,``$0'',`ifelse(eval($2<=$3),1,`pushdef(`$1',$2)$5`'popdef(`$1')$0(`$1',eval($2+$4),$3,$4,`$5')')')')dnldefine(`opposite',`_set(`door',$1,ifelse(_get(`door',$1),`closed',`open',`closed'))')dnldefine(`upper',`100')dnlfor(`x',`1',upper,`1',`_set(`door',x,`closed')')dnlfor(`x',`1',upper,`1',`for(`y',x,upper,x,`opposite(y)')')dnlfor(`x',`1',upper,`1',`door x is _get(`door',x)')dnl

MACRO-11

        .TITLE  DOORS        .MCALL  .TTYOUT,.EXITNDOORS  =       ^D100DOORS::        ; CLOSE ALL DOORS        MOV     #DOORBF+1,R0CLOSE:  CLR     (R0)+        CMP     R0,#BUFTOP        BLT     CLOSE        ; VISIT DOORS        MOV     #1,R1                   ; R1 = PASSPASS:   MOV     R1,R2                   ; R2 = DOORDOOR:   COMB    DOORBF(R2)              ; VISIT DOOR        ADD     R1,R2        CMP     R2,#NDOORS              ; NEXT DOOR        BLE     DOOR        INC     R1        CMP     R1,R2                   ; NEXT PASS        BLE     PASS        ; DISPLAY DOORS AS ASCII 0 OR 1        MOV     #DOORBF+1,R1DISP:   MOVB    (R1)+,R0        BICB    #^C1,R0        BISB    #^D48,R0        .TTYOUT        CMP     R1,#BUFTOP        BLT     DISP        .EXITDOORBF: .BLKB   NDOORS+1BUFTOP  =       .        .END    DOORS
Output:
1001000010000001000000001000000000010000000000001000000000000001000000000000000010000000000000000001

MAD

            NORMAL MODE IS INTEGER            DIMENSION OPEN(100)            PRINT COMMENT $ $                     R MAKE SURE ALL DOORS ARE CLOSED AT BEGINNING            THROUGH CLOSE, FOR DOOR=1, 1, DOOR.G.100CLOSE       OPEN(DOOR) = 0          R MAKE 100 PASSES            THROUGH TOGGLE, FOR PASS=1, 1, PASS.G.100            THROUGH TOGGLE, FOR DOOR=PASS, PASS, DOOR.G.100TOGGLE      OPEN(DOOR) = 1 - OPEN(DOOR)           R PRINT THE DOORS THAT ARE OPEN            THROUGH SHOW, FOR DOOR=1, 1, DOOR.G.100SHOW        WHENEVER OPEN(DOOR).E.1, PRINT FORMAT ISOPEN, DOOR                       VECTOR VALUES ISOPEN = $5HDOOR ,I3,S1,8HIS OPEN.*$                 END OF PROGRAM
Output:
DOOR   1 IS OPEN.DOOR   4 IS OPEN.DOOR   9 IS OPEN.DOOR  16 IS OPEN.DOOR  25 IS OPEN.DOOR  36 IS OPEN.DOOR  49 IS OPEN.DOOR  64 IS OPEN.DOOR  81 IS OPEN.DOOR 100 IS OPEN.

make

Make does not have any built-in arithmetic. It does have easy access to the shell and plug-ins for other languages but using them would be 'cheating' because the real work would not be done by make. Instead of doing arithmetic with numbers, the number of passes is encoded as the number of X's in $(pass). The door to toggle is encoded as the number of X's in $(count) and toggling a door is achieved by adding a dependency to the door number. To prevent $(count) from containing a huge number of X's the 'if' in $(loop) short circuits the inner loop.

.DEFAULT_GOAL:=100digit=1 2 3 4 5 6 7 8 9doors:=$(digit) $(foreach i,$(digit),$(foreach j,0 $(digit),$i$j)) 100$(doors):;@: $(if $(filter %1 %3 %5 %7 %9,$(words $^)),$(info $@))$(foreach i,$(doors),$(eval $i: $(word $i,0 $(doors))))0 $(addprefix pass,$(doors)):pass:=Xdep=$(eval count+=$(pass))$(eval $(words $(count)):pass$(words $(pass)))loop=$(foreach inner,$(doors),$(if $(word 101,$(count)),,$(dep)))$(foreach outer,$(doors),$(eval pass+=X)$(eval count:=)$(loop))

Maple

NDoors := proc( N :: posint )        # Initialise, using 0 to represent "closed"        local pass, door, doors := Array( 1 .. N, 'datatype' = 'integer'[ 1 ] );        # Now do N passes        for pass from 1 to N do                for door from pass by pass while door <= N do                        doors[ door ] := 1 - doors[ door ]                end do        end do;        # Output        for door from 1 to N do                printf( "Door %d is %s.\n", door, `if`( doors[ door ] = 0, "closed", "open" ) )        end do;        # Since this is a printing routine, return nothing.        NULLend proc:

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

> NDoors( 100 );

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

Alternatively,

> [seq]( 1 .. 10 )^~2;                 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Mathematica /Wolfram Language

unoptimized 1

n=100;tmp=ConstantArray[-1,n];Do[tmp[[i;;;;i]]*=-1;,{i,n}];Do[Print["door ",i," is ",If[tmp[[i]]==-1,"closed","open"]],{i,1,Length[tmp]}]

unoptimized 2

f[n_] = "Closed"; 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}]

unoptimized 3

Mathematica also supports immutable data paradigms, like so:

Fold[ ReplacePart[#1, (i_ /; Mod[i, #2] == 0) :> (-#1[[i]])] &, ConstantArray[-1, {100}], Range[100]] /. {1 -> "Open", -1 -> "Closed"}


optimized 1

Do[Print["door ",i," is ",If[IntegerQ[Sqrt[i]],"open","closed"]],{i,100}]

optimized 2

n=100;a=Range[1,Sqrt[n]]^2Do[Print["door ",i," is ",If[MemberQ[a,i],"open","closed"]],{i,100}]

optimized 3

n=100nn=1a=0For[i=1,i<=n,i++, If[i==nn,  Print["door ",i," is open"];  a++;  nn+=2a+1; ,  Print["door ",i," is closed"]; ];]

These will only give the indices for the open doors:unoptimized 2

Pick[Range[100], Xor@@@Array[Divisible[#1,#2]&, {100,100}]]

optimized 4

Range[Sqrt[100]]^2

MATLAB /Octave

Iterative Method

Unoptimized

a = false(1,100);for b=1:100  for i = b:b:100    a(i) = ~a(i);  endenda

Optimized

for x=1:100;  if sqrt(x) == floor(sqrt(x))    a(i)=1;  endenda

Optimized - Alternative

doors   = zeros(1,100); // 0: closed 1: openfor i = 1:100    doors(i:i:100) = 1-doors(i:i:100)enddoors

More Optimized

a = zeros(100,1);for counter = 1:sqrt(100);  a(counter^2) = 1;enda

Vectorized Method

function [doors,opened,closed] = hundredDoors()    %Initialize the doors, make them booleans for easy vectorization    doors = logical( (1:1:100) );        %Go through the flipping process, ignore the 1 case because the doors    %array is already initialized to all open    for initialPosition = (2:100)        doors(initialPosition:initialPosition:100) = not( doors(initialPosition:initialPosition:100) );    end        opened = find(doors); %Stores the numbers of the open doors    closed = find( not(doors) ); %Stores the numbers of the closed doors    end

Known-Result Method

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

Maxima

doors(n) := block([v], local(v),  v: makelist(true, n),  for i: 2 thru n do  for j: i step i thru n do v[j]: not v[j],  sublist_indices(v, 'identity));

Usage:

doors(100);/* [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] */

MAXScript

unoptimized

doorsOpen = for i in 1 to 100 collect falsefor pass in 1 to 100 do(    for door in pass to 100 by pass do    (        doorsOpen[door] = not doorsOpen[door]    ))for i in 1 to doorsOpen.count do(    format ("Door % is open?: %\n") i doorsOpen[i])

optimized

for i in 1 to 100 do(    root = pow i 0.5    format ("Door % is open?: %\n") i (root == (root as integer)))

Mercury

:- module doors.:- interface.:- import_module io.:- pred main(io::di, io::uo) is det.:- implementation.:- import_module bitmap, bool, list, string, int.:- func doors = bitmap.doors = bitmap.init(100, no).:- pred walk(int, bitmap, bitmap).:- mode walk(in, bitmap_di, bitmap_uo) is det.walk(Pass, !Doors) :-    walk(Pass, Pass, !Doors).:- pred walk(int, int, bitmap, bitmap).:- mode walk(in, in, bitmap_di, bitmap_uo) is det.walk(At, By, !Doors) :-    ( if bitmap.in_range(!.Doors, At - 1) then        bitmap.unsafe_flip(At - 1, !Doors),        walk(At + By, By, !Doors)    else        true    ).:- pred report(bitmap, int, io, io).:- mode report(bitmap_di, in, di, uo) is det.report(Doors, N, !IO) :-    ( if is_set(Doors, N - 1) then        State = "open"    else        State = "closed"    ),    io.format("door #%d is %s\n",        [i(N), s(State)], !IO).main(!IO) :-    list.foldl(walk, 1 .. 100, doors, Doors),    list.foldl(report(Doors), 1 .. 100, !IO).

Metafont

boolean doors[];for i = 1 upto 100: doors[i] := false; endforfor i = 1 upto 100:  for j = 1 step i until 100:    doors[j] := not doors[j];  endforendforfor i = 1 upto 100:  message decimal(i) & " " & if doors[i]: "open" else: "close" fi;endforend

Microsoft Small Basic

Translation of:GW-BASIC
For offset = 1 To 100  For i = 0 To 100 Step offset    a[i] = a[i] + 1  EndForEndFor' Print "opened" doorsFor i = 1 To 100  If math.Remainder(a[i], 2) = 1 Then     TextWindow.WriteLine(i)  EndIf  EndFor

Output:

149162536496481100

MiniScript

Using a map to hold the set of open doors:

d = {}for p in range(1, 100)    for t in range(p, 100, p)        if d.hasIndex(t) then d.remove t else d.push t    end forend forprint d.indexes.sort
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

d = [false] * 101open = []for p in range(1, 100)    for t in range(p, 100, p)        d[t] = not d[t]    end for    if d[p] then open.push pend forprint open

(Output same as above.)

MIPS Assembly

.data  doors:     .space 100  num_str:   .asciiz "Number "  comma_gap: .asciiz " is "  newline:   .asciiz "\n".textmain:# Clear all the cells to zero  li $t1, 100  la $t2, doorsclear_loop:  sb $0, ($t2)  add $t2, $t2, 1  sub $t1, $t1, 1  bnez $t1, clear_loop# Now start the loops  li $t0, 1         # This will the the step size  li $t4, 1         # just an arbitrary 1loop1:  move $t1, $t0      # Counter  la $t2, doors      # Current pointer  add $t2, $t2, $t0  addi $t2, $t2, -1loop2:  lb $t3, ($t2)  sub $t3, $t4, $t3  sb $t3, ($t2)  add $t1, $t1, $t0  add $t2, $t2, $t0  ble $t1, 100, loop2  addi $t0, $t0, 1  ble $t0, 100, loop1  # Now display everything  la $t0, doors  li $t1, 1loop3:  li $v0, 4  la $a0, num_str  syscall    li $v0, 1  move $a0, $t1  syscall  li $v0, 4  la $a0, comma_gap  syscall  li $v0, 1  lb $a0, ($t0)  syscall  li $v0, 4,  la $a0, newline  syscall  addi $t0, $t0, 1  addi $t1, $t1, 1  bne $t1, 101 loop3

Mirah

import java.util.ArrayListclass Door:statedef initialize@state=falseend def closed?; !@state; enddef open?; @state; enddef close; @state=false; enddef open; @state=true; end def toggleif closed?openelsecloseendend def toString; Boolean.toString(@state); endend doors=ArrayList.new1.upto(100) do    doors.add(Door.new)end 1.upto(100) do |multiplier|    index = 0    doors.each do |door|        Door(door).toggle if (index+1)%multiplier == 0        index += 1    endendi = 0doors.each do |door|     puts "Door #{i+1} is #{door}."    i+=1end

Miranda

main :: [sys_message]main = [Stdout (show (openDoors 100)),         Stdout "\n"]    openDoors :: num->[num]openDoors doors =    map snd (filter fst (zip2 (doorStates doors) [1..]))doorStates :: num->[bool]doorStates doors =    take doors (foldr (zipWith (~=)) (repeat False) (map pass [1..doors]))pass :: num->[bool]pass n = tl (concat (repeat (take n (True:repeat False))))zipWith f x y = map f' (zip2 x y)                where f' (x,y) = f x y
Output:
[1,4,9,16,25,36,49,64,81,100]

mIRC Scripting Language

var %d = $str(0 $+ $chr(32),100), %m = 1while (%m <= 100) {  var %n = 1  while ($calc(%n * %m) <= 100) {    var %d = $puttok(%d,$iif($gettok(%d,$calc(%n * %m),32),0,1),$calc(%n * %m),32)    inc %n  }  inc %m}echo -ag All Doors (Boolean): %dvar %n = 1while (%n <= $findtok(%d,1,0,32)) {  var %t = %t $findtok(%d,1,%n,32)  inc %n}echo -ag Open Door Numbers: %t

ML/I

MCSKIP "WITH" NL"" 100 doorsMCINS %.MCSKIP MT,<>"" Doors represented by P1-P100, 0 is closedMCPVAR 100"" Set P variables to 0MCDEF ZEROPS WITHS NL AS <MCSET T1=1%L1.MCSET PT1=0MCSET T1=T1+1MCGO L1 UNLESS T1 EN 101>ZEROPS"" Generate door stateMCDEF STATE WITHS () AS <MCSET T1=%A1.MCGO L1 UNLESS T1 EN 0closed<>MCGO L0%L1.open>"" Main macro - no arguments"" T1 is pass number"" T2 is door numberMCDEF DOORS WITHS NLAS <MCSET T1=1"" pass loop%L1.MCGO L4 IF T1 GR 100"" door loopMCSET T2=T1%L2.MCGO L3 IF T2 GR 100MCSET PT2=1-PT2MCSET T2=T2+T1MCGO L2%L3.MCSET T1=T1+1MCGO L1%L4."" now output the resultMCSET T1=1%L5.door %T1. is STATE(%PT1.)MCSET T1=T1+1MCGO L5 UNLESS T1 GR 100>"" Do itDOORS

MMIX

See100 doors/MMIX

Modula-2

unoptimized

MODULE Doors;IMPORT InOut;TYPE State = (Closed, Open);TYPE List = ARRAY [1 .. 100] OF State;VAR  Doors: List;  I, J:  CARDINAL;BEGIN  FOR I := 1 TO 100 DO    FOR J := 1 TO 100 DO      IF J MOD I = 0 THEN        IF Doors[J] = Closed THEN          Doors[J] := Open        ELSE          Doors[J] := Closed        END      END    END  END;  FOR I := 1 TO 100 DO    InOut.WriteCard(I, 3);    InOut.WriteString(' is ');    IF Doors[I] = Closed THEN      InOut.WriteString('Closed.')    ELSE      InOut.WriteString('Open.')    END;    InOut.WriteLn  ENDEND Doors.

optimized

MODULE DoorsOpt;IMPORT InOut;TYPE State = (Closed, Open);TYPE List = ARRAY [1 .. 100] OF State;VAR  Doors: List;  I:  CARDINAL;BEGIN  FOR I := 1 TO 10 DO    Doors[I*I] := Open  END;  FOR I := 1 TO 100 DO    InOut.WriteCard(I, 3);    InOut.WriteString(' is ');    IF Doors[I] = Closed THEN      InOut.WriteString('Closed.')    ELSE      InOut.WriteString('Open.')    END;    InOut.WriteLn  ENDEND DoorsOpt.

Modula-3

unoptimized

MODULE Doors EXPORTS Main;IMPORT IO, Fmt;TYPE State = {Closed, Open};TYPE List = ARRAY [1..100] OF State;VAR doors := List{State.Closed, ..};BEGIN  FOR i := 1 TO 100 DO    FOR j := FIRST(doors) TO LAST(doors) DO      IF j MOD i = 0 THEN        IF doors[j] = State.Closed THEN          doors[j] := State.Open;        ELSE          doors[j] := State.Closed;        END;      END;    END;  END;  FOR i := FIRST(doors) TO LAST(doors) DO    IO.Put(Fmt.Int(i) & " is ");    IF doors[i] = State.Closed THEN      IO.Put("Closed.\n");    ELSE      IO.Put("Open.\n");    END;  END;END Doors.

optimized

MODULE DoorsOpt EXPORTS Main;IMPORT IO, Fmt;TYPE State = {Closed, Open};TYPE List = ARRAY [1..100] OF State;VAR doors := List{State.Closed, ..};BEGIN  FOR i := 1 TO 10 DO    doors[i * i] := State.Open;  END;  FOR i := FIRST(doors) TO LAST(doors) DO    IO.Put(Fmt.Int(i) & " is ");    IF doors[i] = State.Closed THEN      IO.Put("Closed.\n");    ELSE      IO.Put("Open.\n");    END;  END;END DoorsOpt.

MontiLang

101 var l .for l 0 endforarr0 var i .for l    i 1 + var i var j .    j l < var pass .    while pass        get j not insert j .        j i + var j        l < var pass .      endwhileendforprint /# show all doors #//# show only open doors #/|| print .0 var i .for l    get i    if : i out | | out . . endif .    i 1 + var i .endforinput . /# pause until ENTER key pressed #/

MOO

is_open = make(100);for pass in [1..100]  for door in [pass..100]    if (door % pass)      continue;    endif    is_open[door] = !is_open[door];  endforendfor"output the result";for door in [1..100]  player:tell("door #", door, " is ", (is_open[door] ? "open" : "closed"), ".");endfor

MoonScript

is_open = [false for door = 1,100] for pass = 1,100     for door = pass,100,pass        is_open[door] = not is_open[door]  for i,v in ipairs is_open    print "Door #{i}: " .. if v then 'open' else 'closed'

MUMPS

doorsnew door,passFor door=1:1:100 Set door(door)=0For pass=1:1:100 For door=pass:pass:100 Set door(door)='door(door)For door=1:1:100 If door(door) Write !,"Door",$j(door,4)," is open"Write !,"All other doors are closed."QuitDo doorsDoor   1 is openDoor   4 is openDoor   9 is openDoor  16 is openDoor  25 is openDoor  36 is openDoor  49 is openDoor  64 is openDoor  81 is openDoor 100 is openAll other doors are closed.

Myrddin

use stdconst main = {var isopen: bool[100]std.slfill(isopen[:], false)for var i = 0; i < isopen.len; i++for var j = i; j < isopen.len; j += i + 1isopen[j] = !isopen[j];;;;for var i = 0; i < isopen.len; i++if isopen[i]std.put("door {} is open\n", i + 1);;;;}
Output:
door 1 is opendoor 4 is opendoor 9 is opendoor 16 is opendoor 25 is opendoor 36 is opendoor 49 is opendoor 64 is opendoor 81 is opendoor 100 is open

MySQL

DROP PROCEDURE IF EXISTS one_hundred_doors;DELIMITER |CREATE PROCEDURE one_hundred_doors (n INT)BEGIN  DROP TEMPORARY TABLE IF EXISTS doors;   CREATE TEMPORARY TABLE doors (    id INTEGER NOT NULL,    open BOOLEAN DEFAULT FALSE,    PRIMARY KEY (id)  );  SET @i = 1;  create_doors: LOOP    INSERT INTO doors (id, open) values (@i, FALSE);    SET @i = @i + 1;    IF @i > n THEN      LEAVE create_doors;    END IF;  END LOOP create_doors;  SET @i = 1;  toggle_doors: LOOP    UPDATE doors SET open = NOT open WHERE MOD(id, @i) = 0;    SET @i = @i + 1;    IF @i > n THEN      LEAVE toggle_doors;    END IF;  END LOOP toggle_doors;  SELECT id FROM doors WHERE open;END|DELIMITER ;CALL one_hundred_doors(100);
Output:
+-----+| id  |+-----+|   1 ||   4 ||   9 ||  16 ||  25 ||  36 ||  49 ||  64 ||  81 || 100 |+-----+10 rows in set (0.02 sec)

Nanoquery

// allocate a boolean array with all closed doors (false)// we need 101 since there will technically be a door 0doors = {false} * 101 // loop through all the step lengths (1-100)for step in range(1, 100)// loop through all the doors, stepping by stepfor door in range(0, len(doors) - 1, step)// change the state of the current doordoors[door] = !doors[door]end forend for // loop through and print the doors that are open, skipping door 0for i in range(1, len(doors) - 1)// if the door is open, display itif doors[i]println "Door " + i + " is open."end ifend for

NetRexx

unoptimized

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

optimized (Based on the Java 'optimized' version)

Translation of:Java
/* NetRexx */options replace format comments java crossref symbols binaryTrue  = (1 == 1)False = \Truedoors = boolean[100]loop i_ = 0 to 9  doors[(i_ + 1) * (i_ + 1) - 1] = True;  end i_loop i_ = 0 to 99  if doors[i_] then  state = 'open'  else  state = 'closed'  say 'Door Nr.' Rexx(i_ + 1).right(4) 'is' state  end i_

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

Translation of:Java
/* NetRexx */options replace format comments java crossref savelog symbols binaryresultstring = ''loop i_ = 1 to 10  resultstring = resultstring || 'Door Nr.' Rexx(i_ * i_).right(4) 'is open\n'  end i_say resultstring

optimized 3

/* NetRexx */loop i = 1 to 10   say 'Door Nr.' i * i 'is open.'  end i

newLISP

(define (status door-num)    (let ((x (int (sqrt door-num))))     (if       (= (* x x) door-num) (string "Door " door-num " Open")       (string "Door " door-num " Closed"))))(dolist (n (map status (sequence 1 100)))  (println n))

Not optimized:

(set 'Doors (array 100))  ;; Default value: nil (Closed)(for (x 0 99)    (for (y x 99 (+ 1 x))        (setf (Doors y) (not (Doors y)))))(for (x 0 99)  ;; Display open doors    (if (Doors x)        (println (+ x 1) " : Open")))

Output:

1 : Open4 : Open9 : Open16 : Open25 : Open36 : Open49 : Open64 : Open81 : Open100 : Open

Nial

unoptimized solution (works with Q'Nial7):

Output of the boolean array showing the status of the doors. Truth values in Nial arrays are shown asl(true) ando(false):

     n:=100;reduce xor (count n eachright mod count n eachall<1)looloooolooooooloooooooolooooooooooloooooooooooolooooooooooooooloooooooooooooooolooooooooooooooooool

Indices of the open doors:

     true findall (n:=100;reduce xor (count n eachright mod count n eachall<1))+11 4 9 16 25 36 49 64 81 100

optimized solution:

     count 10 power 21 4 9 16 25 36 49 64 81 100

Nim

unoptimized:

from strutils import `%`const numDoors = 100var doors: array[1..numDoors, bool]for pass in 1..numDoors:  for door in countup(pass, numDoors, pass):    doors[door] = not doors[door]for door in 1..numDoors:  echo "Door $1 is $2." % [$door, if doors[door]: "open" else: "closed"]

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

from strutils import `%`const numDoors = 100var doors {.compileTime.}: array[1..numDoors, bool]proc calcDoors(): string =  for pass in 1..numDoors:    for door in countup(pass, numDoors, pass):      doors[door] = not doors[door]   for door in 1..numDoors:    result.add("Door $1 is $2.\n" % [$door, if doors[door]: "open" else: "closed"])const outputString: string = calcDoors()echo outputString

Oberon-07

Oberon-07, byNiklaus Wirth.

MODULE Doors;IMPORT Out;PROCEDURE Do*;(* In Oberon an asterisk after an identifier is an export mark *)CONST N = 100; len = N + 1;VAR i, j: INTEGER;      closed:ARRAY lenOF BOOLEAN;(* Arrays in Oberon always start with index 0; closed[0] is not used *)BEGINFOR i := 1TO NDO closed[i] :=TRUEEND;FOR i := 1TO NDO      j := 1;WHILE j < lenDOIF jMOD i = 0THEN closed[j] := ~closed[j]END; INC(j)(* ~ = NOT *)ENDEND;(* Print a state diagram of all doors *)FOR i := 1TO NDOIF (i - 1)MOD 10 = 0THEN Out.LnEND;IF closed[i]THEN Out.String("- ")ELSE Out.String("+ ")ENDEND;  Out.Ln;(* Print the numbers of the open doors *)FOR i := 1TO NDOIF ~closed[i]THEN Out.Int(i, 0); Out.Char(" ")ENDEND;  Out.LnEND Do;END Doors.

Execute: Doors.Do

Output:
+ – – + – – – – + – – – – – – + – – – – – – – – + – – – – – – – – – – + – – – – – – – – – – – – + – – – – – – – – – – – – – – + – – – – – – – – – – – – – – – – + – – – – – – – – – – – – – – – – – – + 1 4 9 16 25 36 49 64 81 100

Objeck

optimized

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

Objective-C

A basic implementation in Objective-C:

This is a very basic Objective-C sample that shows the usage of standard types and classes such as NSInteger and NSMutableArray.

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

@import Foundation;int main(int argc, const char * argv[]) {    @autoreleasepool {                // Create a mutable array        NSMutableArray *doorArray = [@[] mutableCopy];                // Fill the doorArray with 100 closed doors        for (NSInteger i = 0; i < 100; ++i) {            doorArray[i] = @NO;        }                // Do the 100 passes        for (NSInteger pass = 0; pass < 100; ++pass) {            for (NSInteger door = pass; door < 100; door += pass+1) {                doorArray[door] = [doorArray[door]  isEqual: @YES] ? @NO : @YES;            }        }                // Print the results        [doorArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {            if ([obj isEqual: @YES]) {                NSLog(@"Door number %lu is open", idx + 1);            }        }];    }}

A more typical implementation in Objective-C:

This example is more along the lines of what typical Objective-C program would look like.

Language features used include:

  • MVC design pattern with separate classes for the data model, user interface, and controller (Here, main steps in to represent the controller class.)
  • Class category to extend the standard NSMutableArray class to add doors without a subclass
  • Class inheritance in the DoorViewClass when subclassing NSObject
  • Pragma mark statements for IDE navigation in Xcode

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

@import Foundation;#pragma mark - Classes////////////////////////////////////////////////////// Model class header - A we are using a category to add a method to MSMutableArray@interface NSMutableArray (DoorModelExtension)- (void)setNumberOfDoors:(NSUInteger)doors;@end// Model class implementation@implementation NSMutableArray (DoorModelExtension)- (void)setNumberOfDoors:(NSUInteger)doors {    // Fill the doorArray with 100 closed doors    for (NSInteger i = 0; i < doors; ++i) {        self[i] = @NO;    }}@end////////////////////////////////////////////////////// View class header - A simple class to handle printing our values@interface DoorViewClass : NSObject- (void)printResultsOfDoorTask:(NSMutableArray *)doors;@end// View class implementation@implementation DoorViewClass- (void)printResultsOfDoorTask:(NSMutableArray *)doors {    // Print the results, using an enumeration block for easy index tracking    [doors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {        if ([obj isEqual: @YES]) {            NSLog(@"Door number %lu is open", idx + 1);        }    }];}@end////////////////////////////////////////////////////#pragma mark - main// With our classes set we can use them from our controller, in this case mainint main(int argc, const char * argv[]) {        // Init our classes    NSMutableArray *doorArray = [NSMutableArray array];    DoorViewClass *doorView = [DoorViewClass new];        // Use our class category to add the doors    [doorArray setNumberOfDoors:100];        // Do the 100 passes    for (NSUInteger pass = 0; pass < 100; ++pass) {        for (NSUInteger door = pass; door < 100; door += pass+1) {            doorArray[door] = [doorArray[door]  isEqual: @YES] ? @NO : @YES;        }    }        // Print the results    [doorView printResultsOfDoorTask:doorArray];   }

OCaml

unoptimized

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

optimized

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

This variant is morefunctional 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.

type door = Open | Closed    (* human readable code *)let flipdoor = function Open -> Closed | Closed -> Openlet string_of_door =         function Open -> "is open." | Closed -> "is closed."let printdoors ls =  let f i d = Printf.printf "Door %i %s\n" (i + 1) (string_of_door d)  in List.iteri f lslet outerlim = 100let innerlim = 100let rec outer cnt accu =  let rec inner i door = match i > innerlim with (* define inner loop *)    | true  -> door                             | false -> inner (i + 1) (if (cnt mod i) = 0 then flipdoor door else door)  in (* define and do outer loop *)  match cnt > outerlim with  | true  -> List.rev accu  | false -> outer  (cnt + 1)  (inner 1 Closed :: accu) (* generate new entries with inner *)let () = printdoors (outer 1 [])

Octave

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

See also the solutions in Matlab. They will work in Octave, too.

Odin

Both versions are essentially adapted from theGo version, except for the output which is more inspired by theAda example.

unoptimized

package mainimport "core:fmt"main :: proc() { using fmt    Door_State :: enum {Closed, Open}    doors := [?]Door_State { 0..<100 = .Closed }    for i in  1..=100 {    for j := i-1; j < 100; j += i {      if doors[j] == .Closed {        doors[j] = .Open      } else {        doors[j] = .Closed      }    }  }  for state, i in doors {    println("Door: ",int(i+1)," -> ",state)  }}

optimized

package mainimport "core:fmt"import "core:math"main :: proc() { using fmt    Door_State :: enum {Closed, Open}    doors := [?]Door_State { 0..<100 = .Closed }    for i in  1..=100 {     res := math.sqrt_f64( f64(i) )     if math.mod_f64( res, 1) == 0 {        doors[i-1] = .Open     } else {        doors[i-1] = .Closed     }     println("Door: ", i, " -> ", doors[i-1])  }}

Oforth

: doors| i j l |   100 false Array newWith dup ->l   100 loop: i [       i 100 i step: j [ l put ( j , j l at not ) ]       ] ;

Ol

(define (flip doors every)   (map (lambda (door num)            (mod (+ door (if (eq? (mod num every) 0) 1 0)) 2))      doors      (iota (length doors) 1)))(define doors   (let loop ((doors (repeat 0 100)) (n 1))      (if (eq? n 100)         doors         (loop (flip doors n) (+ n 1)))))(print "100th doors: " doors)

Output:

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)

OmniMark

process  local switch doors size 100 ; all initialised ('1st pass' to false)  repeat over doors    repeat for integer door from #item to 100 by #item      do when doors[door] = false        activate doors[door] ; illustrating alternative to set ... to      else        set doors[door] to false      done    again  again  repeat over doors    do when doors = true      put #error '%d(#item)%n'    done  again
Output:
149162536496481100

Optimised version.

process  local integer door initial {1}  local integer step initial {3}  repeat    output "Door %d(door) is open%n"    increment door by step    increment step by 2    exit when door > 100  again
Output:
Door 1 is openDoor 4 is openDoor 9 is openDoor 16 is openDoor 25 is openDoor 36 is openDoor 49 is openDoor 64 is openDoor 81 is openDoor 100 is open

Onyx

$Door dict def1 1 100 {Door exch false put} for$Toggle {dup Door exch get not Door up put} def$EveryNthDoor {dup 100 {Toggle} for} def$Run {1 1 100 {EveryNthDoor} for} def$ShowDoor {dup `Door no. ' exch cvs cat ` is ' cat  exch Door exch get {`open.\n'}{`shut.\n'} ifelse cat  print flush} defRun 1 1 100 {ShowDoor} for
Output:
Door no. 1 is open.Door no. 2 is shut.Door no. 3 is shut.Door no. 4 is open.Door no. 5 is shut.Door no. 6 is shut.Door no. 7 is shut.Door no. 8 is shut.Door no. 9 is open.Door no. 10 is shut.Door no. 11 is shut.Door no. 12 is shut.Door no. 13 is shut.Door no. 14 is shut.Door no. 15 is shut.Door no. 16 is open.Door no. 17 is shut.Door no. 18 is shut.Door no. 19 is shut.Door no. 20 is shut.Door no. 21 is shut.Door no. 22 is shut.Door no. 23 is shut.Door no. 24 is shut.Door no. 25 is open.Door no. 26 is shut.Door no. 27 is shut.Door no. 28 is shut.Door no. 29 is shut.Door no. 30 is shut.Door no. 31 is shut.Door no. 32 is shut.Door no. 33 is shut.Door no. 34 is shut.Door no. 35 is shut.Door no. 36 is open.Door no. 37 is shut.Door no. 38 is shut.Door no. 39 is shut.Door no. 40 is shut.Door no. 41 is shut.Door no. 42 is shut.Door no. 43 is shut.Door no. 44 is shut.Door no. 45 is shut.Door no. 46 is shut.Door no. 47 is shut.Door no. 48 is shut.Door no. 49 is open.Door no. 50 is shut.Door no. 51 is shut.Door no. 52 is shut.Door no. 53 is shut.Door no. 54 is shut.Door no. 55 is shut.Door no. 56 is shut.Door no. 57 is shut.Door no. 58 is shut.Door no. 59 is shut.Door no. 60 is shut.Door no. 61 is shut.Door no. 62 is shut.Door no. 63 is shut.Door no. 64 is open.Door no. 65 is shut.Door no. 66 is shut.Door no. 67 is shut.Door no. 68 is shut.Door no. 69 is shut.Door no. 70 is shut.Door no. 71 is shut.Door no. 72 is shut.Door no. 73 is shut.Door no. 74 is shut.Door no. 75 is shut.Door no. 76 is shut.Door no. 77 is shut.Door no. 78 is shut.Door no. 79 is shut.Door no. 80 is shut.Door no. 81 is open.Door no. 82 is shut.Door no. 83 is shut.Door no. 84 is shut.Door no. 85 is shut.Door no. 86 is shut.Door no. 87 is shut.Door no. 88 is shut.Door no. 89 is shut.Door no. 90 is shut.Door no. 91 is shut.Door no. 92 is shut.Door no. 93 is shut.Door no. 94 is shut.Door no. 95 is shut.Door no. 96 is shut.Door no. 97 is shut.Door no. 98 is shut.Door no. 99 is shut.Door no. 100 is open.

ooRexx

doors = .array~new(100)    -- array containing all of the doorsdo i = 1 to doors~size     -- initialize with a collection of closed doors   doors[i] = .door~new(i)enddo inc = 1 to doors~size  do d = inc to doors~size by inc    doors[d]~toggle  endendsay "The open doors after 100 passes:"do door over doors  if door~isopen then say doorend::class door           -- simple class to represent a door::method init          -- initialize an instance of a door  expose id state      -- instance variables of a door  use strict arg id    -- set the id  state = .false       -- initial state is closed::method toggle        -- toggle the state of the door  expose state  state = \state::method isopen        -- test if the door is open  expose state  return state::method string        -- return a string value for a door  expose state id  if state then return "Door" id "is open"  else return "Door" id "is closed"::method state         -- return door state as a descriptive string  expose state  if state then return "open"  else return "closed"

The two programs in the Rexx section run under ooRexx when '#' is replaced by, e.g., 'dd'.
'#' is not supported by ooRexx as part of or as a symbol.Neither are @ and $.

OpenEdge/Progress

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

OPL

Tested with Psion Series 3a & Series 5.

REM https://github.com/Eva-Broccoli/OPL-Rosetta-Code/blob/main/A100door.oplPROC main:  LOCAL door%(100),i%,j%  i%=1  j%=1  WHILE j%<101    WHILE i%<101      IF door%(i%)=0        door%(i%)=1      ELSE        door%(i%)=0      ENDIF      i%=i%+j%    ENDWH    j%=j%+1    i%=0+j%  ENDWH  PRINT "Open doors:",  i%=1  WHILE i%<101    IF door%(i%)=1      PRINT i%,    ENDIF    i%=i%+1  ENDWH  GETENDP

OxygenBasic

def    doors 100int    door[doors],i ,j, cstring cr,tab,pr'for i=1 to doors  for j=i to doors step i    door[j]=1-door[j]    if door[j] then c++ else c--  nextnext'cr=chr(13) chr(10)pr="Doors Open: " c cr cr 'for i=1 to doors   if door[i] then pr+=i crnextprint pr

Oz

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

Output:

Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

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]));for(i=1,d,if(v[i],print("Door ",i," is open.")))

Optimized version.

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

Unoptimized version.

doors =vector(100);print("open doors are : ");for(i=1,100,for(j=i,100,doors[j]=!doors[j];j +=i-1))for(k=1,100,if(doors[k]==1,print1(" ",k)))

Output:

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

Pascal

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

Optimized version.

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

PascalABC.NET

Translation of:F#
// 100 doors. Nigel Galloway: January 11th., 2023
type doorState=(Open,Closed);
function flip(n:doorState):doorState:=if n=Open then Closed else Open;
var Doors:Array of doorState:=ArrFill(100,Closed);
begin
  for var n:=1 to 100 do for var g:=n-1 to 99 step n do Doors[g]:=flip(Doors[g]);
  for var n:=0 to 99 do if Doors[n]=Open then write(n+1,' '); writeLn
end.

Output:
1 4 9 16 25 36 49 64 81 100

Pebble

;100 doors example program for x86 DOS;Compiles with Pebble to 95 bytes com executableprogram examples\100doorsdataint i[0]int d[0]beginlabel loop+1 [i][d] = [i] * [i]echo [d]crlfif [d] < 100 then looppausekillend

Perl

unoptimized

Works with:Perl version 5.x
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;

semi-optimized

Works with:Perl version 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/perluse strict;use warnings;my @doors = (1) x 100;for my $N (1 .. 100) {   $doors[$_]=1-$doors[$_] for map { $_*$N - 1 } 1 .. int(100/$N);}print join("\n", map { "Door $_ is Open" } grep { ! $doors[$_-1] } 1 .. 100), "\n";print "The rest are closed\n";

optimized

Works with:Perl version 5.x
print "Door $_ is open\n" for map $_**2, 1 .. 10;
print "Door $_ is ", qw"closed open"[int sqrt == sqrt], "\n" for 1..100;
while( ++$i <= 100 ){    $root = sqrt($i);    if ( int( $root ) == $root )    {        print "Door $i is open\n";    }    else    {        print "Door $i is closed\n";    }}

Perl5i

use perl5i::2;package doors {  use perl5i::2;  use Const::Fast;  const my $OPEN   => 1;  const my $CLOSED => 0;  # ----------------------------------------  # Constructor: door->new( @args );  # input: N - how many doors?  # returns: door object  #  method new($class: @args ) {    my $self = bless {}, $class;    $self->_init( @args );    return $self;  }  # ----------------------------------------  # class initializer.  # input: how many doors?  # sets N, creates N+1 doors ( door zero is not used ).  #  method _init( $N ) {    $self->{N} = $N;    $self->{doors} = [ ($CLOSED) x ($N+1) ];  }  # ----------------------------------------  # $self->toggle( $door_number );  # input: number of door to toggle.  # OPEN a CLOSED door; CLOSE an OPEN  door.  #  method toggle( $which ) {    $self->{doors}[$which] = ( $self->{doors}[$which] == $OPEN                               ? $CLOSED                               : $OPEN             );  }  # ----------------------------------------  # $self->toggle_n( $cycle );  # input: number.  # Toggle doors 0, $cycle, 2 * $cycle, 3 * $cycle, .. $self->{N}  #  method toggle_n( $n ) {    $self->toggle($_)      for map { $n * $_ }          ( 1 .. int( $self->{N} / $n) );  }  # ----------------------------------------  # $self->toggle_all();  # Toggle every door, then every other door, every third door, ...  #  method toggle_all() {    $self->toggle_n( $_ ) for ( 1 .. $self->{N} );  }  # ----------------------------------------  # $self->print_open();  # Print list of which doors are open.  #  method print_open() {    say join ', ', grep { $self->{doors}[$_] == $OPEN } ( 1 ... $self->{N} );  }}# ----------------------------------------------------------------------# Main Thread#my $doors = doors->new(100);$doors->toggle_all();$doors->print_open();

Phix

unoptimised

sequencedoors=repeat(false,100)fori=1to100doforj=ito100byidodoors[j]=notdoors[j]endforendforfori=1to100doifdoors[i]==truethenprintf(1,"Door #%d is open.\n",i)endifendfor
Output:
Door #1 is open.Door #4 is open.Door #9 is open.Door #16 is open.Door #25 is open.Door #36 is open.Door #49 is open.Door #64 is open.Door #81 is open.Door #100 is open.

optimised

functiondoors(integern)-- returns the perfect squares<=nintegerdoor=1,step=1sequenceres={}whiledoor<=ndores&=doorstep+=2door+=stependwhilereturnresendfunction?doors(100)
Output:
{1,4,9,16,25,36,49,64,81,100}

Phixmonti

101 var l                           0 l repeat                      l for    var s    s l s 3 tolist    for        var i        i get not i set    endforendforl for    var i    i get    if        i print " " print    endifendfor

Another way

100 var n   /# Number of doors #/0 n repeat  /# Make the doors #/n for    dup    sqrt int    dup * over == if 1 swap set else drop endifendforn for    "The door " print dup print " is " print    get if "OPEN." else "closed." endif print nlendfor

Optimized

100 sqrt for dup * print " " print endfor

PHL

unoptimized

module doors;extern printf;@Integer main [@Array<@Boolean> doors = new @Array<@Boolean>.init(100);var i = 1;while (i <= 100) {var j = i-1;while (j < 100) {doors.set(j, doors.get(j)::not);j = j + i;}i = i::inc;}i = 0;while (i < 100) {printf("%i %s\n", i+1, iif(doors.get(i), "open", "closed"));i = i::inc;}return 0;]

optimized

Translation of:C#
module var;extern printf;@Integer main [var door = 1;var incrementer = 0;var current = 1;        while (current <= 100)        {printf("Door %i ", current);if (current == door){printf("open\n");incrementer = incrementer::inc;door = door + 2 * incrementer + 1;}elseprintf("closed\n");current = current + 1;                    }return 0;]

PHP

See:Demooptimized

<?phpfor ($i = 1; $i <= 100; $i++) {$root = sqrt($i);$state = ($root == ceil($root)) ? 'open' : 'closed';echo "Door {$i}: {$state}\n";}?>

unoptimized

<?php$doors = array_fill(1, 100, false);for ($pass = 1; $pass <= 100; ++$pass) {for ($nr = 1; $nr <= 100; ++$nr) {if ($nr % $pass == 0) {$doors[$nr] = !$doors[$nr];}}}for ($nr = 1; $nr <= 100; ++$nr)printf("Door %d: %s\n", $nr, ($doors[$nr])?'open':'closed');?>

Picat

Non-optimized:

doors(N) =>    Doors = new_array(N),   foreach(I in 1..N) Doors[I] := 0 end,   foreach(I in 1..N)     foreach(J in I..I..N)        Doors[J] := 1^Doors[J]     end,     if N <= 10 then        print_open(Doors)     end   end,   println(Doors),   print_open(Doors),   nl.print_open(Doors) => println([I : I in 1..Doors.length, Doors[I] == 1]).

optimized version 1:

doors_opt(N) =>  foreach(I in 1..N)     Root = sqrt(I),     println([I, cond(Root == 1.0*round(Root), open, closed)])  end,  nl.

optimized version 2:

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

PicoLisp

unoptimized

(let Doors (need 100)   (for I 100      (for (D (nth Doors I)  D  (cdr (nth D I)))         (set D (not (car D))) ) )   (println Doors) )

optimized

(let Doors (need 100)   (for I (sqrt 100)      (set (nth Doors (* I I)) T) )   (println Doors) )

Output in both cases:

(T NIL NIL T NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL T)

With formatting:

(let Doors (need 100)   (for I (sqrt 100)      (set (nth Doors (* I I)) T) )   (make      (for (N . D) Doors         (when D (link N)) ) ) )

Output:

(1 4 9 16 25 36 49 64 81 100)

Piet

image

Pike

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

optimized version:

array doors = map(enumerate(100,1,1), lambda(int x)                                      {                                            return sqrt((float)x)%1 == 0.0;                                       });
write("%{%d %d %d %d %d %d %d %d %d %d\n%}\n", doors/10)

output:

1 0 0 1 0 0 0 0 1 00 0 0 0 0 1 0 0 0 00 0 0 0 1 0 0 0 0 00 0 0 0 0 1 0 0 0 00 0 0 0 0 0 0 0 1 00 0 0 0 0 0 0 0 0 00 0 0 1 0 0 0 0 0 00 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 1

PL/I

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

See also#Polyglot:PL/I and PL/M

PL/I-80

/* Solution to the 100 doors problem in PLI-80 */hundred_doors:  procedure options (main);    %replace      open_door by '1'b,      closed_door by '0'b,      numdoors by 100;    dcl      doors(1:numdoors) bit(1),      (i, j) fixed bin(15);    /* all doors are initially closed */    do i = 1 to numdoors;      doors(i) = closed_door;    end;    /* cycle through at increasing intervals and flip doors */    do i = 1 to numdoors;      j = i;      do while (j <= numdoors);        doors(j) = ^doors(j);        j = j + i;      end;    end;    /* show results - open doors should all be perfect squares */    put skip list ('The open doors are:');    do i = 1 to numdoors;      if doors(i) = open_door then        put edit (i) (F(4));    end;end hundred_doors;
Output:
The open doors are:   1   4   9  16  25  36  49  64  81 100

See also#Polyglot:PL/I and PL/M

PL/M

Translation of:ALGOL W
100H:/* FIND THE FIRST FEW SQUARES VIA THE UNOPTIMISED DOOR FLIPPING METHOD *//* BDOS SYSTEM CALL */    BDOS:PROCEDURE( FN, ARG );DECLARE FNBYTE, ARGADDRESS;GOTO 5;END BDOS;/* PRINTS A BYTE AS A CHARACTER */    PRINT$CHAR:PROCEDURE( CH );DECLARE CHBYTE;CALL BDOS( 2, CH );END PRINT$CHAR;/* PRINTS A BYTE AS A NUMBER */    PRINT$BYTE:PROCEDURE( N );DECLARE NBYTE;DECLARE ( V, D3, D2 )BYTE;        V  = N;        D3 = VMOD 10;IF ( V := V / 10 ) <> 0THENDO;            D2 = VMOD 10;IF ( V := V / 10 ) <> 0THENCALL PRINT$CHAR( '0' + V );CALL PRINT$CHAR( '0' + D2 );END;CALL PRINT$CHAR( '0' + D3 );END PRINT$BYTE;DECLARE DOOR$DCLLITERALLY '101';DECLARE FALSELITERALLY '0';DECLARE CRLITERALLY '0DH';DECLARE LFLITERALLY '0AH';/* ARRAY OF DOORS - DOOR( I ) IS TRUE IF OPEN, FALSE IF CLOSED */DECLARE DOOR( DOOR$DCL )BYTE;DECLARE ( I, J )BYTE;/* SET ALL DOORS TO CLOSED */DO I = 0TO LAST( DOOR ); DOOR( I ) = FALSE;END;/* REPEATEDLY FLIP THE DOORS */DO I = 1TO LAST( DOOR );DO J = ITO LAST( DOOR )BY I;          DOOR( J ) =NOT DOOR( J );END;END;/* DISPLAY THE RESULTS */DO I = 1TO LAST( DOOR );IF DOOR( I )THENDO;CALL PRINT$CHAR( ' ' );CALL PRINT$BYTE( I );END;END;CALL PRINT$CHAR( CR );CALL PRINT$CHAR( LF );EOF
Output:
 1 4 9 16 25 36 49 64 81 100

See Also#Polyglot:PL/I and PL/M

PL/SQL

Unoptimized

DECLARE  TYPE doorsarray IS VARRAY(100) OF BOOLEAN;  doors doorsarray := doorsarray();BEGINdoors.EXTEND(100);  --ACCOMMODATE 100 DOORSFOR i IN 1 .. doors.COUNT  --MAKE ALL 100 DOORS FALSE TO INITIALISE  LOOP     doors(i) := FALSE;                      END LOOP;FOR j IN 1 .. 100 --ITERATE THRU USING MOD LOGIC AND FLIP THE DOOR RIGHT OPEN OR CLOSE LOOP      FOR k IN 1 .. 100        LOOP                  IF MOD(k,j)=0 THEN                      doors(k) := NOT doors(k);                   END IF;        END LOOP; END LOOP; FOR l IN 1 .. doors.COUNT  --PRINT THE STATUS IF ALL 100 DOORS AFTER ALL ITERATION  LOOP       DBMS_OUTPUT.PUT_LINE('DOOR '||l||' IS -->> '||CASE WHEN SYS.DBMS_SQLTCB_INTERNAL.I_CONVERT_FROM_BOOLEAN(doors(l)) = 'TRUE'                                                                 THEN 'OPEN'                                                               ELSE 'CLOSED'                                                         END);  END LOOP;END;

Plain English

Library:Plain English-output
A flag list is a doubly linked list with a flag.A door is a flag list.A pass is a number.To run:  Start up.  Pass doors given 1000 and 1000 passes.    Shut down.To pass doors given a count and some passes:  Create some doors given the count.  Loop.    Add 1 to a counter.    If the counter is greater than the passes, break.    Go through the doors given the counter and the passes.  Repeat.  Output the states of the doors.  Destroy the doors.To create some doors given a count:  Loop.    Add 1 to a counter.    If the counter is greater than the count, exit.    Allocate memory for a door.    Clear the door's flag.    Append the door to the doors.  Repeat.To go through some doors given a number and some passes:  Put 0 into a counter.  Loop.    Add the number to the counter.    If the counter is greater than the passes, exit.    Pick a door from the doors given the number.    Invert the door's flag.  Repeat.To pick a door from some doors given a number:  Loop.    Add 1 to a counter.    If the counter is greater than the number, exit.    Get the door from the doors.    If the door is nil, exit.  Repeat.To output the states of some doors:  Loop.    Bump a counter.    Get a door from the doors.    If the door is nil, exit.    If the door's flag is set,       Write "Door " then the counter then " is open"         then the CRLF string to StdOut;       Repeat.    \Write "Door " then the counter then " is closed"       \then the CRLF string to StdOut.  Repeat.
Output:
Door 1 is openDoor 2 is closedDoor 3 is closedDoor 4 is openDoor 5 is closedDoor 6 is closedDoor 7 is closedDoor 8 is closedDoor 9 is openDoor 10 is closedDoor 11 is closedDoor 12 is closedDoor 13 is closedDoor 14 is closedDoor 15 is closedDoor 16 is openDoor 17 is closedDoor 18 is closedDoor 19 is closedDoor 20 is closedDoor 21 is closedDoor 22 is closedDoor 23 is closedDoor 24 is closedDoor 25 is openDoor 26 is closedDoor 27 is closedDoor 28 is closedDoor 29 is closedDoor 30 is closedDoor 31 is closedDoor 32 is closedDoor 33 is closedDoor 34 is closedDoor 35 is closedDoor 36 is openDoor 37 is closedDoor 38 is closedDoor 39 is closedDoor 40 is closedDoor 41 is closedDoor 42 is closedDoor 43 is closedDoor 44 is closedDoor 45 is closedDoor 46 is closedDoor 47 is closedDoor 48 is closedDoor 49 is openDoor 50 is closedDoor 51 is closedDoor 52 is closedDoor 53 is closedDoor 54 is closedDoor 55 is closedDoor 56 is closedDoor 57 is closedDoor 58 is closedDoor 59 is closedDoor 60 is closedDoor 61 is closedDoor 62 is closedDoor 63 is closedDoor 64 is openDoor 65 is closedDoor 66 is closedDoor 67 is closedDoor 68 is closedDoor 69 is closedDoor 70 is closedDoor 71 is closedDoor 72 is closedDoor 73 is closedDoor 74 is closedDoor 75 is closedDoor 76 is closedDoor 77 is closedDoor 78 is closedDoor 79 is closedDoor 80 is closedDoor 81 is openDoor 82 is closedDoor 83 is closedDoor 84 is closedDoor 85 is closedDoor 86 is closedDoor 87 is closedDoor 88 is closedDoor 89 is closedDoor 90 is closedDoor 91 is closedDoor 92 is closedDoor 93 is closedDoor 94 is closedDoor 95 is closedDoor 96 is closedDoor 97 is closedDoor 98 is closedDoor 99 is closedDoor 100 is open

Pluto

TheLua sample will run unchanged in Pluto, the following uses a Pluto specific for loop that iterates through is_open.

local is_open = {}for pass = 1,100dofor door = pass,100,passdo        is_open[door] =not is_open[door]endendfor i,vin is_opendo-- would be: "for i,v in pairs(is_open) do" in Luaif vthen io.write( string.format( " %d", i ) )endend
Output:
 1 4 9 16 25 36 49 64 81 100

Pointless

output =  range(1, 100)  |> map(visit(100))  |> println----------------------------------------------------------toggle(state) =  if state == Closed then Open else Closed------------------------------------------------------------ Door state on iteration i is recursively-- defined in terms of previous door statevisit(i, index) = cond {  case (i == 0) Closed  case (index % i == 0) toggle(lastState)  else lastState} where lastState = visit(i - 1, index)
Output:
[Open, Closed, Closed, Open, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Closed, Open]

Polyglot:PL/I and PL/M

Works with:8080 PL/M Compiler

... under CP/M (or an emulator)

Should work with many PL/I implementations.
The PL/I include file "pg.inc" can be found on thePolyglot: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.

/* FIND THE FIRST FEW SQUARES VIA THE UNOPTIMISED DOOR FLIPPING METHOD */doors_100H: procedure options                                                   (main);/* PROGRAM-SPECIFIC %REPLACE STATEMENTS MUST APPEAR BEFORE THE %INCLUDE AS *//* E.G. THE CP/M PL/I COMPILER DOESN'T LIKE THEM TO FOLLOW PROCEDURES      */   /* PL/I                                                                      */      %replace dcldoors by         100;   /* PL/M */                                                                   /*      DECLARE  DCLDOORS LITERALLY '101';   /* *//* PL/I DEFINITIONS                                                             */%include 'pg.inc';/* PL/M DEFINITIONS: CP/M BDOS SYSTEM CALL AND CONSOLE I/O ROUTINES, ETC. */    /*   DECLARE BINARY LITERALLY 'ADDRESS', CHARACTER LITERALLY 'BYTE';   DECLARE FIXED  LITERALLY ' ',       BIT       LITERALLY 'BYTE';   DECLARE STATIC LITERALLY ' ',       RETURNS   LITERALLY ' ';   DECLARE FALSE  LITERALLY '0',       TRUE LITERALLY '1';   DECLARE HBOUND LITERALLY 'LAST',    SADDR  LITERALLY '.';   BDOSF: PROCEDURE( FN, ARG )BYTE;                               DECLARE FN BYTE, ARG ADDRESS; GOTO 5;   END;    BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5;   END;   PRCHAR:   PROCEDURE( C );   DECLARE C BYTE;      CALL BDOS( 2, C ); END;   PRSTRING: PROCEDURE( S );   DECLARE S ADDRESS;   CALL BDOS( 9, S ); END;   PRNL:     PROCEDURE;        CALL PRCHAR( 0DH ); CALL PRCHAR( 0AH ); END;   PRNUMBER: PROCEDURE( N );      DECLARE N ADDRESS;      DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;      N$STR( W := LAST( N$STR ) ) = '$';      N$STR( W := W - 1 ) = '0' + ( ( V := N ) MOD 10 );      DO WHILE( ( V := V / 10 ) > 0 );         N$STR( W := W - 1 ) = '0' + ( V MOD 10 );      END;       CALL BDOS( 9, .N$STR( W ) );   END PRNUMBER;   MODF:     PROCEDURE( A, B )ADDRESS;      DECLARE ( A, B ) ADDRESS;      RETURN A MOD B;   END MODF;/* END LANGUAGE DEFINITIONS */   /* TASK */   /* ARRAY OF DOORS - DOOR( I ) IS TRUE IF OPEN, FALSE IF CLOSED */   DECLARE DOOR( DCLDOORS )  BIT;   DECLARE ( I, J, MAXDOOR ) FIXED BINARY;   MAXDOOR = HBOUND( DOOR                                                       ,1                   );   /* SET ALL DOORS TO CLOSED */   DO I = 0 TO MAXDOOR; DOOR( I ) = FALSE; END;   /* REPEATEDLY FLIP THE DOORS */   DO I = 1 TO MAXDOOR;      DO J = I TO MAXDOOR BY I;         DOOR( J ) = NOT( DOOR( J ) );      END;   END;   /* DISPLAY THE RESULTS */   DO I = 1 TO MAXDOOR;      IF DOOR( I ) THEN DO;         CALL PRCHAR( ' ' );         CALL PRNUMBER( I );      END;   END;   CALL PRNL;EOF: end doors_100H;
Output:
 1 4 9 16 25 36 49 64 81 100

Pony

Combined Optimized and Unoptimized

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

actor Toggler    let doors:Array[Bool]    let env: Env    new create(count:USize,_env:Env) =>        var i:USize=0        doors=Array[Bool](count)        env=_env        while doors.size() < count do            doors.push(false)        end    be togglin(interval : USize)=>        var i:USize=0        try            while i < doors.size() do                doors.update(i,not doors(i)?)?                i=i+interval            end        else            env.out.print("Errored while togglin'!")        end    be printn(onlyOpen:Bool)=>        try            for i in doors.keys() do                if onlyOpen and not doors(i)? then                    continue                end                env.out.print("Door " + i.string() + " is " +                    if doors(i)? then                        "Open"                    else                        "closed"                    end)            end        else            env.out.print("Error!")        end        trueactor OptimizedToggler    let doors:Array[Bool]    let env:Env    new create(count:USize,_env:Env)=>        env=_env        doors=Array[Bool](count)        while doors.size()<count do            doors.push(false)        end    be togglin()=>        var i:USize=0        if alreadydone then            return        end        try            doors.update(0,true)?            doors.update(1,true)?            while i < doors.size() do                i=i+1                let z=i*i                let x=z*z                if z > doors.size() then                    break                else                    doors.update(z,true)?                end                if x < doors.size() then                    doors.update(x,true)?                end            end        end    be printn(onlyOpen:Bool)=>        try            for i in doors.keys() do                if onlyOpen and not doors(i)? then                    continue                end                env.out.print("Door " + i.string() + " is " +                    if doors(i)? then                        "Open"                    else                        "closed"                    end)            end        else            env.out.print("Error!")        end        trueactor Main    new create(env:Env)=>        var count: USize =100        try            let index=env.args.find("-n",0,0,{(l,r)=>l==r})?            try            match env.args(index+1)?.read_int[USize]()?                | (let x:USize, _)=>count=x                end            else                env.out.print("You either neglected to provide an argument after -n or that argument was not an integer greater than zero.")                return            end        end        if env.args.contains("optimized",{(l,r)=>r==l}) then            let toggler=OptimizedToggler(count,env)            var i:USize = 1            toggler.togglin()            toggler.printn(env.args.contains("onlyopen", {(l,r)=>l==r}))        else            let toggler=Toggler(count,env)            var i:USize = 1            while i < count do                toggler.togglin(i)                i=i+1            end            toggler.printn(env.args.contains("onlyopen", {(l,r)=>l==r}))        end

Pop11

unoptimized

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

optimized

for i to 100 do    lvars root = sqrt(i);    i; if root = round(root) then ' open' ><; else ' closed' ><; endif; =>endfor;

PostScript

Bruteforce:

/doors [ 100 { false } repeat ] def1 1 100 { dup 1 sub exch 99 {        dup doors exch get not doors 3 1 roll put} for } fordoors pstack

Shows:

[true false false true false false false false true false ...<90 doors later>... true]

Potion

square=1, i=31 to 100(door):  if (door == square):    ("door", door, "is open") say    square += i    i += 2..

PowerShell

unoptimized

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

Alternative Method

function Get-DoorState($NumberOfDoors){   begin    {      $Doors = @()      $Multiple = 1   }   process   {      for ($i = 1; $i -le $NumberOfDoors; $i++)      {         $Door = [pscustomobject]@{                    Name = $i                    Open = $false                 }         $Doors += $Door         }      While ($Multiple -le $NumberOfDoors)      { Foreach ($Door in $Doors) {    if ($Door.name % $Multiple -eq 0)               {          If ($Door.open -eq $False){$Door.open = $True}          Else {$Door.open = $False}       } }         $Multiple++      }    }    end {$Doors}}

unoptimized Pipeline

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

unoptimized Pipeline 2

$doors = 1..100 | ForEach-Object {0}$visited = 1..1001..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" } }

unoptimized Pipeline 3 (dynamically build pipeline)

1..100|foreach-object {$pipe += "toggle $_ |"} -begin {$pipe=""}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 {    Foreach –parallel ($number in 1..100) {        "Door " + $number.ToString("0000") + ": " + @{$true="Closed";$false="Open"}[([Math]::pow($number, 0.5)%1) -ne 0]    }}Calc-Doors | sort

optimized

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

Processing

Unoptimized:

boolean[] doors = new boolean[100];void setup() {  for (int i = 0; i < 100; i++) {    doors[i] = false;  }  for (int i = 1; i < 100; i++) {    for (int j = 0; j < 100; j += i) {      doors[j] = !doors[j];    }  }  println("Open:");  for (int i = 1; i < 100; i++) {    if (doors[i]) {      println(i);    }  }  exit();}
Output:
Open:149162536496481

Processing.R

Unoptimized:

setup <- function() {  for(door in doors(100, 100)) {    stdout$print(paste(door, ""))  }}doors <- 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))}
Output:
1 4 9 16 25 36 49 64 81 100

ProDOS

Uses math module.

enableextensions enabledelayedexpansioneditvar /newvar /value=0 /title=closededitvar /newvar /value=1 /title=openeditvar /newvar /range=1-100 /increment=1 /from=2editvar /newvar /value=2 /title=next:doorsfor /alloccurrences (!next!-!102!) do editvar /modify /value=-open-editvar /modify /value=-next-=+1if -next- /hasvalue=100 goto :cont else goto :doors:contprintline !1!-!102!stoptask

Prolog

unoptimized

Declarative:

main :-    forall(between(1,100,Door), ignore(display(Door))).% show output if door is open after the 100th passdisplay(Door) :-    status(Door, 100, open),    format("Door ~d is open~n", [Door]).% true if Door has Status after Pass is donestatus(Door, Pass, Status) :-    Pass > 0,    Remainder is Door mod Pass,    toggle(Remainder, OldStatus, Status),    OldPass is Pass - 1,    status(Door, OldPass, OldStatus).status(_Door, 0, closed).toggle(Remainder, Status, Status) :-    Remainder > 0.toggle(0, open, closed).toggle(0, closed, open).

Doors as a list:

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

Using dynamic-rules. Tried to be ISO:

doors(Num, Passes) :-    forall(( everyNth(1,Passes,1,Pass)           , forall((everyNth(Pass,Num,Pass,Door), toggle(Door)))           ))  , show(Num)  .toggle(Door) :-    Opened = opened(Door)  , ( clause(Opened,_) -> retract(Opened)                        ; asserta(Opened)    ).show(Num) :-    forall(( between(1,Num,Door)           , (opened(Door) -> State = opened ; State = closed)           , write(Door), write(' '), write(State), nl           )).% utilsforall(X) :- findall(_, X, _).everyNth(From,To,Step,X) :-    From =< To  , ( X = From ; From1 is From + Step, everyNth(From1,To,Step,X) )  .main :- doors(100,100), halt.

optimized

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

PROMAL

;;; find the first few squares via the unoptimised door flipping methodPROGRAM hundredDoorsINCLUDE LIBRARYCON INT doorMax = 100BYTE door [ doorMax + 1 ] ; door( i ) is true if open, false if closedWORD iBYTE jBEGINFOR i = 0 TO doorMax            ; set all doors to closed  door[ i ] = falseFOR i = 1 TO doorMax            ; repeatedly flip the doors  j = i:<  WHILE j <= doorMax    door[ j ] = not door[ j ]    j = j + i:<FOR i = 1 TO doorMax            ; display the results  IF door[ i ]    OUTPUT " #W", iOUTPUT "#C"END

Pure

using system;// initialize doors as pairs: number, status where 0 means openlet doors = zip (1..100) (repeat 1);toogle (x,y) = x,~y;toogleEvery n d = map (tooglep n) d with                    tooglep n d@((x,_)) = toogle d if ~(x mod n);                                        = d otherwise; end;// show description of given doorsstatus (n,x) = (str n) + (case x of                            1 = " close";                            0 = " open"; end);let result = foldl (\a n -> toogleEvery n a) doors (1..100);// pretty print the result (only open doors)showResult = do (puts.status) final when               final = filter open result with                         open (_,x) = ~x;                       end; end;
Output:
 > showResult;1 open4 open9 open16 open25 open...

Pure Data

100Doors.pd#N canvas 241 375 414 447 10;#X obj 63 256 expr doors[$f1] = doors[$f1] ^ 1;#X msg 83 118 \; doors const 0;#X msg 44 66 bang;#X obj 44 92 t b b b;#X obj 43 28 table doors 101;#X obj 44 360 sel 0;#X obj 44 336 expr if (doors[$f1] == 1 \, $f1 \, 0);#X obj 63 204 t b f f;#X text 81 66 run;#X obj 71 384 print -n;#X text 132 310 print results (open doors);#X obj 63 179 loop 1 100 1;#X obj 63 231 loop 1 100 1;#X obj 44 310 loop 1 100 1;#X text 148 28 create array;#X text 151 180 100 passes;#X text 179 123 set values to 0;#X connect 2 0 3 0;#X connect 3 0 13 0;#X connect 3 1 11 0;#X connect 3 2 1 0;#X connect 5 1 9 0;#X connect 6 0 5 0;#X connect 7 0 12 0;#X connect 7 1 12 1;#X connect 7 2 12 3;#X connect 11 0 7 0;#X connect 12 0 0 0;#X connect 13 0 6 0;loop.pd#N canvas 656 375 427 447 10;#X obj 62 179 until;#X obj 102 200 f;#X obj 62 89 inlet;#X obj 303 158 f \$3;#X obj 270 339 outlet;#X obj 223 89 inlet;#X obj 138 89 inlet;#X obj 324 89 inlet;#X obj 117 158 f \$1;#X text 323 68 step;#X obj 202 158 f \$2;#X obj 62 118 t b b b b;#X obj 270 315 spigot;#X obj 89 314 sel 0;#X obj 137 206 +;#X obj 102 237 expr $f1 \; if ($f3 > 0 \, if ($f1 > $f2 \, 0 \, 1)\, if ($f3 < 0 \, if ($f1 < $f2 \, 0 \, 1) \, 0)), f 34;#X text 63 68 run;#X text 136 68 start;#X text 227 68 end;#X text 58 31 loop (abstraction);#X connect 0 0 1 0;#X connect 1 0 14 0;#X connect 1 0 15 0;#X connect 2 0 11 0;#X connect 3 0 14 1;#X connect 3 0 15 2;#X connect 5 0 10 1;#X connect 6 0 8 1;#X connect 7 0 3 1;#X connect 8 0 1 1;#X connect 10 0 15 1;#X connect 11 0 0 0;#X connect 11 1 8 0;#X connect 11 2 10 0;#X connect 11 3 3 0;#X connect 12 0 4 0;#X connect 13 0 0 1;#X connect 14 0 1 1;#X connect 15 0 12 0;#X connect 15 1 12 1;#X connect 15 1 13 0;

PureBasic

unoptimized

Dim doors.i(100) For x = 1 To 100  y = x  While y <= 100    doors(y) = 1 - doors(y)    y + x  WendNext OpenConsole()PrintN("Following Doors are open:")For x = 1 To 100  If doors(x)    Print(Str(x) + ", ")  EndIfNextInput()

optimized

OpenConsole()PrintN("Following Doors are open:")For i = 1 To 100    root.f = Sqr(i)    If root = Int(root)    Print (Str(i) + ", ")    EndIfNext     Input()


Output:

Following Doors are open:1, 4, 9, 16, 25, 36, 49, 64, 81, 100,

Pyret

data Door:  | open  | closedend fun flip-door(d :: Door) -> Door:  cases(Door) d:    | open => closed    | closed => open  endend fun flip-doors(doors :: List<Door>) -> List<Door>:  doc:```Given a list of door positions, repeatedly switch the positions of      every nth door for every nth pass, and return the final list of door      positions```  for fold(flipped-doors from doors, n from range(1, doors.length() + 1)):    for map_n(m from 1, d from flipped-doors):      if num-modulo(m, n) == 0:        flip-door(d)      else:        d      end    end  endwhere:    flip-doors([list: closed, closed, closed]) is  [list: open, closed, closed]  flip-doors([list: closed, closed, closed, closed]) is  [list: open, closed, closed, open]  flip-doors([list: closed, closed, closed, closed, closed, closed]) is  [list: open, closed, closed, open, closed, closed]  closed-100 = for map(_ from range(1, 101)): closed end  answer-100 = for map(n from range(1, 101)):    if num-is-integer(num-sqrt(n)): open    else: closed    end  end  flip-doors(closed-100) is answer-100endfun find-indices<A>(pred :: (A -> Boolean), xs :: List<A>) -> List<Number>:    doc:```Given a list and a predicate function, produce a list of index      positions where there's a match on the predicate```  ps = map_n(lam(n,e): if pred(e): n else: -1 end end, 1, xs)  ps.filter(lam(x): x >= 0 end)where:  find-indices((lam(i): i == true end), [list: true,false,true]) is [list:1,3]endfun run(n):  doc:```Given a list of doors that are closed, make repeated passes       over the list, switching the positions of every nth door for       each nth pass. Return a list of positions in the list where the      door is Open.```  doors = repeat(n, closed)  ys = flip-doors(doors)  find-indices((lam(y): y == open end), ys)where:  run(4) is [list: 1,4]end run(100)

Python

Works with:Python version 2.5-2.7

unoptimized

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

optimized

A version that only visits each door once:

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

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

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

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

print '\n'.join('Door %s is %s' % (i, 'closed' if i**0.5 % 1 else 'open') for i in range(1, 101))
Works with:Python version 3.12+
for i in range(1, 101):    print(f"Door {i}:{"closed" if i**0.5 % 1 else "open"}")

ultra-optimized: ported from Julia version

for i in range(1,11): print(f"Door {i**2} is open")

Q

unoptimized

`closed`open(100#0b){@[x;where y;not]}/100#'(til[100]#'0b),'1b

Binary function{@[x;where y;not]} is applied usingOver. The initial state is100#0b and the right argument is a list of 100 boolean masks. The boolean vector result is used to index the pair of states.

Following expressions simply flag perfect squares.

optimized

`closed`open (1+til 100) in {x*x} 1+til 10

alternative

@[100#`closed; -1+{x*x}1+til 10; :; `open]


QB64

Const Opened = -1, Closed = 0Dim Doors(1 To 100) As Integer, Passes As Integer, Index As IntegerRem Normal implementationPrint "100doors Normal method"For Passes = 1 To 100 Step 1    Doors(Passes) = ClosedNext PassesFor Passes = 1 To 100 Step 1    For Index = 0 To 100 Step Passes        If Index > 100 Then Exit For        If Index > 0 Then If Doors(Index) = Opened Then Doors(Index) = Closed Else Doors(Index) = Opened    Next IndexNext PassesPrint "OPEN DOORS after 100th passes"For Passes = 1 To 100 Step 1    If Doors(Passes) = Opened Then Print Passes; " ";NextRem Alternative solution of perfect squaresPrint "Alternative method"Passes = 0For Passes = 1 To 100 Step 1    Doors(Passes) = ClosedNext PassesFor Passes = 1 To 100 Step 1    If Sqr(Passes) = Int(Sqr(Passes)) Then Doors(Passes) = OpenedNextPrint "Opened doors found by SQR method"For Passes = 1 To 100 Step 1    If Doors(Passes) = Opened Then Print Passes; " ";Next PassesEnd

Quackery

unoptimized

  [ bit ^ ]                       is toggle      ( f n --> f )     [ 0    100 times      [ i^ 1+ swap        101 times          [ i^ toggle over step ]      nip ] ]                     is toggledoors (     --> f )      [ 100 times       [ 1 >> dup 1 &         if [ i^ 1+ echo sp ] ]         drop ]                   is echodoors   (   f -->   )    toggledoors  say " These doors are open: " echodoors cr  say " The rest are closed." cr
Output:
 These doors are open: 1 4 9 16 25 36 49 64 81 100  The rest are closed.

optimized

  10 times [ i^ 1+ 2 ** echo sp ]
Output:
1 4 9 16 25 36 49 64 81 100

R

Using a loop

doors_puzzle <- function(ndoors, passes = ndoors) {    doors <- logical(ndoors)    for (ii in seq(passes)) {        mask <- seq(ii, ndoors, ii)        doors[mask] <- !doors[mask]    }    which(doors)}doors_puzzle(100)


optimized

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

Using a **ply function

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


Using Reduce

H=100f=rep(F,H)which(Reduce(function(d,n) xor(replace(f,seq(n,H,n),T),d), 1:H, f))
Output:
1   4   9  16  25  36  49  64  81 100

Racket

#lang racket;; Applies fun to every step-th element of seq, leaving the others unchanged.(define (map-step fun step seq)  (for/list ([elt seq] [i (in-naturals)])    ((if (zero? (modulo i step)) fun values) elt)))(define (toggle-nth n seq)  (map-step not n seq))(define (solve seq)  (for/fold ([result seq]) ([_ seq] [pass (in-naturals 1)])    (toggle-nth pass result)))(for ([door (solve (make-vector 101 #f))] [index (in-naturals)]      #:when (and door (> index 0)))  (printf "~a is open~%" index))

Optimized:

#lang racket(for ([x (in-range 1 101)] #:when (exact-integer? (sqrt x)))  (printf "~a is open\n" x))

Unoptimized imperative, with graphic rendering:

#lang slideshow(define-syntax-rule (vector-neg! vec pos)  (vector-set! vec pos (not (vector-ref vec pos))))(define (make-doors)  (define doors (make-vector 100 #f))  (for* ([i 100] [j (in-range i 100 (add1 i))]) (vector-neg! 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)))

Output:

Raku

(formerly Perl 6)

unoptimized

Works with:Rakudo version 2015.09"
my @doors = False xx 101; (.=not for @doors[0, $_ ... 100]) for 1..100; say "Door $_ is ", <closed open>[ @doors[$_] ] for 1..100;

optimized

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

probably the most compact idiom

say 'Door $_ is open' for (1..10)»²;

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

 say "Door $_ is open" for 1..10 X** 2;

This one prints both opened and closed doors:

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

verbose version, but uses ordinary components

Works with:Rakudo version 2016.07 Tom Legrady
sub  output( @arr, $max ) {    my $output = 1;    for 1..^$max -> $index {if @arr[$index] {    printf "%4d", $index;    say '' if $output++ %%  10;}    }    say '';}sub MAIN ( Int :$doors = 100 ) {    my $doorcount = $doors + 1;    my @door[$doorcount] = 0 xx ($doorcount);        INDEX:    for 1...^$doorcount -> $index {        # flip door $index & its multiples, up to last door.        #for ($index, * + $index ... *)[^$doors] -> $multiple {    next INDEX if $multiple > $doors;    @door[$multiple] =  @door[$multiple] ?? 0 !! 1;}    }    output @door, $doors+1;}
Output:
$ ./100_doors.pl6 -doors=100   1   4   9  16  25  36  49  64  81


RapidQ

dim x as integer, y as integerdim door(1 to 100) as byte'initialize arrayfor x = 1 to 100 : door(x) = 0 : next'set door valuesfor y = 1 to 100    for x = y to 100 step y        door(x) = not door(x)    next xnext y'print resultfor x = 1 to 100    if door(x) then print "Door " + str$(x) + " = open"next while inkey$="":wendend

Output

Door 1 = openDoor 4 = openDoor 9 = openDoor 16 = openDoor 25 = openDoor 36 = openDoor 49 = openDoor 64 = openDoor 81 = openDoor 100 = open

Rebol

Unoptimized

doors: array/initial 100 'closedrepeat i 100 [    door: at doors i    forskip door i [change door either 'open = first door ['closed] ['open]]]

Using bitset in Rebol 3

;; Create a bitset with capacity for 100 bits (representing 100 doors);; Each bit represents a door state: 0 = closed, 1 = opendoors: make bitset! 100;; Outer loop: Make 100 passes (i = 1 to 100)repeat i 100 [    ;; Inner loop: Check each door position (j = 1 to 100)    repeat j 100 [        ;; If door j index is divisible by pass number i (no remainder)        if zero? (j // i) [            ;; Toggle the door's bit:            ;; doors/:j accesses door j in the bitset            ;; 'not' flips the bit value (0 -> 1, 1 -> 0)            doors/:j: not doors/:j        ]    ]];; Final loop: Check which doors are open, print their numbersrepeat i 100 [    ;; If door i's bit is set (open)    if doors/:i [        ;; Print the door's number and that it is open        print ["door" i "is open"]    ]]


Optimized

Mathematical Approach

;; Loop variable i from 1 to 10 (since 10^2 = 100, covers doors 1 to 100)repeat i 10 [    ;; Print that door number (i squared) is open    ;; These are exactly the doors with perfect square numbers: 1, 4, 9, ..., 100    print ["door" (i * i) "is open"]]
Output:
door 1 is opendoor 4 is opendoor 9 is opendoor 16 is opendoor 25 is opendoor 36 is opendoor 49 is opendoor 64 is opendoor 81 is opendoor 100 is open

Red

Unoptimized

Red [  Purpose: "100 Doors Problem (Perfect Squares)"  Author: "Barry Arthur"  Date: "07-Oct-2016"]doors: make vector! [char! 8 100]repeat i 100 [change at doors i #"."]repeat i 100 [    j: i    while [j <= 100] [      door: at doors j      change door either #"O" = first door [#"."] [#"O"]      j: j + i    ]]repeat i 10 [  print copy/part at doors (i - 1 * 10 + 1) 10]

Using bitset! type

Red ["Doors"]doors: make bitset! len: 100repeat step len [repeat n to-integer len / step [m: step * n doors/:m: not doors/:m]]repeat n len [if doors/:n [print n]]

Refal

$ENTRY Go {    = <Show 1 <Walk 1 <Doors>>>;};NDoors { = 100; };Doors  { = <Repeat <NDoors> Closed>; };Repeat {    0   s.val = ;    s.N s.val = s.val <Repeat <- s.N 1> s.val> ;};    Toggle {    1   Closed e.rest = Open   e.rest;    1   Open   e.rest = Closed e.rest;    s.N s.door e.rest = s.door <Toggle <- s.N 1> e.rest>;};    Pass {    s.pass s.door e.doors, <Compare s.door <NDoors>>: '+'        = e.doors;    s.pass s.door e.doors        = <Pass s.pass <+ s.pass s.door> <Toggle s.door e.doors>>;};Walk {    s.pass e.doors, <Compare s.pass <NDoors>>: '+'         = e.doors;    s.pass e.doors        = <Walk <+ s.pass 1> <Pass s.pass s.pass e.doors>>;};Show {    s.N Open   e.rest = <Prout Door s.N is open>                         <Show <+ s.N 1> e.rest>;    s.N Closed e.rest = <Show <+ s.N 1> e.rest>;    s.N = ;};
Output:
Door 1 is openDoor 4 is openDoor 9 is openDoor 16 is openDoor 25 is openDoor 36 is openDoor 49 is openDoor 64 is openDoor 81 is openDoor 100 is open

Relation

relation door, stateset i = 1while i <= 100insert i, 1set i = i+1end whileset i = 2while i <= 100update state = 1-state where not (door mod i)set i = i+1end whileupdate state = "open" where stateupdate state = "closed" where state !== "open"print
doorstate
1open
2closed
3closed
4open
5closed
6closed
7closed
8closed
9open...

Retro

:doors (n-) [ #1 repeat dup-pair n:square gt? 0; drop dup n:square n:put sp n:inc again ] do drop-pair ;#100 doors

REXX

the idiomatic way

/*REXX pgm solves the  100 doors puzzle, doing it the hard way by opening/closing doors.*/parse arg doors .                                /*obtain the optional argument from CL.*/if doors=='' | doors==","  then doors=100        /*not specified?  Then assume 100 doors*/                                                 /*        0 =  the door is  closed.    */                                                 /*        1 =   "    "   "  open.      */door.=0                                          /*assume all doors are closed at start.*/                do #=1  for doors                /*process a pass─through for all doors.*/                    do j=#  by #  to doors       /*  ··· every Jth door from this point.*/                    door.j= \door.j              /*toggle the  "openness"  of the door. */                    end   /*j*/                end       /*#*/say 'After '                doors          " passes, the following doors are open:"say                do k=1  for doors                if door.k  then say right(k, 20) /*add some indentation for the output. */                end    /*k*/                     /*stick a fork in it,  we're all done. */
output  when using the default input:
After  100  passes, the following doors are open:                   1                   4                   9                  16                  25                  36                  49                  64                  81                 100

the shortcut way

/*REXX pgm solves the  100 doors  puzzle,  doing it the easy way by calculating squares.*/parse arg doors .                                /*obtain the optional argument from CL.*/if doors=='' | doors==","  then doors=100        /*not specified?  Then assume 100 doors*/say 'After '          doors          " passes, the following doors are open:"say          do #=1  while  #**2 <= doors           /*process easy pass─through  (squares).*/          say right(#**2, 20)                    /*add some indentation for the output. */          end   /*#*/                            /*stick a fork in it,  we're all done. */
output  is identical to the 1st REXX version.



Ring

Unoptimized

doors = list(100)for i = 1 to 100doors[i] = falsenextFor pass = 1 To 100         For door = pass To 100             if doors[door] doors[door] = false else doors[door] = true ok         door += pass-1         NextNextFor door = 1 To 100     see "Door (" + door + ") is "     If doors[door] see "Open" else see "Closed" ok     see nlNext

Optimized

doors = list(100)for i = 1 to 100doors[i] = falsenextFor p = 1 To 10        doors[pow(p,2)] = TrueNextFor door = 1 To 100     see "Door (" + door + ") is "     If doors[door] see "Open" else see "Closed" ok     see nlNext

Rocq

Basic solution:

Require Import List.Fixpoint rep {A} (a : A) n :=  match n with    | O => nil    | S n' => a::(rep a n')  end.Fixpoint flip (l : list bool) (n k : nat) : list bool :=  match l with    | nil => nil    | cons h t => match k with                | O => (negb h) :: (flip t n n)                | S k' => h :: (flip t n k')              end  end.Definition flipeach l n := flip l n n.Fixpoint flipwhile l n :=  match n with    | O => flipeach l 0    | S n' => flipwhile (flipeach l (S n')) n'  end.Definition prison cells := flipwhile (rep false cells) cells.

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

Require Import List.Fixpoint prisoo' nd n k accu :=  match nd with    | O => rev accu    | S nd' => let ra := match k with                 | O => (true, S n, (n + n))                 | S k' => (false, n, k')               end in               prisoo' nd' (snd (fst ra)) (snd ra) ((fst (fst ra))::accu)  end.Definition prisoo cells := prisoo' cells 1 0 nil.

Unit test:

Goal prison 100 = prisoo 100. compute. reflexivity. Qed.

Full proof atgithub:

Goal forall n, prison n = prisoo n. Abort.

RPL

Translation of:Python
Works with:Halcyon Calc version 4.2.7
RPL codeComment
 ≪ { }   { 100 } 0 CON    1 100FOR ii      ii 100FOR j         DUP j GET NOT j SWAP PUT iiSTEPIF DUP ii GETTHEN SWAP ii + SWAPENDNEXT DROP≫ 'DOORS' STO
DOORS( -- { open_doors } )  doors = [False] * 100for i in range(100):  for j in range(i, 100, i+1):      doors[j] = not doors[j]  if doors[i} then print(i)// clean stack
Output:
1: { 1 4 9 16 25 36 49 64 81 100 }

Optimized

≪ { } 1 100FOR iiIF ii √ FP NOTTHEN ii +END NEXT ≫

Run time on standard HP-28S:

  • unoptimized: 45 seconds
  • optimized: 3 seconds

Ruby

doors = Array.new(101,0)print "Open doors "(1..100).step(){ |i|(i..100).step(i) { |d|    doors[d] = doors[d]^= 1    if i == d and doors[d] == 1 then      print "#{i} "    end  }}

Output:

Open doors 1 4 9 16 25 36 49 64 81 100

unoptimized; Ruby-way

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? then open else close end  end    def to_s    @state.to_s  endenddoors = Array.new(100) { Door.new }1.upto(100) do |multiplier|  doors.each_with_index do |door, i|    door.toggle if (i + 1) % multiplier == 0  endenddoors.each_with_index { |door, i| puts "Door #{i+1} is #{door}." }

unoptimized

n = 100Open = "open"Closed = "closed"def Open.toggle  Closedenddef Closed.toggle  Openenddoors = [Closed] * (n + 1)for mul in 1..n  for x in (mul..n).step(mul)    doors[x] = doors[x].toggle  endenddoors.each_with_index do |b, i|  puts "Door #{i} is #{b}" if i > 0end

optimized

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

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

doors = [false] * 100100.times do |i|  (i ... doors.length).step(i + 1) do |j|    doors[j] = !doors[j]  endendputs doors.map.with_index(1){|d,i| "Door #{i} is #{d ? 'open' : 'closed'}."}
Output:
Door 1 is openDoor 2 is closedDoor 3 is closedDoor 4 is openDoor 5 is closedDoor 6 is closedDoor 7 is closedDoor 8 is closedDoor 9 is openDoor 10 is closedDoor 11 is closedDoor 12 is closedDoor 13 is closedDoor 14 is closedDoor 15 is closedDoor 16 is openDoor 17 is closedDoor 18 is closedDoor 19 is closedDoor 20 is closedDoor 21 is closedDoor 22 is closedDoor 23 is closedDoor 24 is closedDoor 25 is openDoor 26 is closedDoor 27 is closedDoor 28 is closedDoor 29 is closedDoor 30 is closedDoor 31 is closedDoor 32 is closedDoor 33 is closedDoor 34 is closedDoor 35 is closedDoor 36 is openDoor 37 is closedDoor 38 is closedDoor 39 is closedDoor 40 is closedDoor 41 is closedDoor 42 is closedDoor 43 is closedDoor 44 is closedDoor 45 is closedDoor 46 is closedDoor 47 is closedDoor 48 is closedDoor 49 is openDoor 50 is closedDoor 51 is closedDoor 52 is closedDoor 53 is closedDoor 54 is closedDoor 55 is closedDoor 56 is closedDoor 57 is closedDoor 58 is closedDoor 59 is closedDoor 60 is closedDoor 61 is closedDoor 62 is closedDoor 63 is closedDoor 64 is openDoor 65 is closedDoor 66 is closedDoor 67 is closedDoor 68 is closedDoor 69 is closedDoor 70 is closedDoor 71 is closedDoor 72 is closedDoor 73 is closedDoor 74 is closedDoor 75 is closedDoor 76 is closedDoor 77 is closedDoor 78 is closedDoor 79 is closedDoor 80 is closedDoor 81 is openDoor 82 is closedDoor 83 is closedDoor 84 is closedDoor 85 is closedDoor 86 is closedDoor 87 is closedDoor 88 is closedDoor 89 is closedDoor 90 is closedDoor 91 is closedDoor 92 is closedDoor 93 is closedDoor 94 is closedDoor 95 is closedDoor 96 is closedDoor 97 is closedDoor 98 is closedDoor 99 is closedDoor 100 is open

Run BASIC

Works with:Just BASIC
Works with:Liberty BASIC
dim doors(100)print "Open doors ";for i = 1 to 100     for door = i to 100 step i        doors(door) = (doors(door) <> 1)        if i = door and doors(door) = 1 then   print i;" ";    next doornext i

Output:

Open doors 1 4 9 16 25 36 49 64 81 100

Rust

fn main() {    let mut door_open = [false; 100];    for pass in 1..101 {        let mut door = pass;        while door <= 100 {            door_open[door - 1] = !door_open[door - 1];            door += pass;        }    }    for (i, &is_open) in door_open.iter().enumerate() {        println!(            "Door {} is {}.",            i + 1,            if is_open { "open" } else { "closed" }        );    }}

Declarative version of above:

fn main() {    let doors = vec![false; 100]        .iter_mut()        .enumerate()        .map(|(door, door_state)| {            (1..100)                .into_iter()                .filter(|pass| (door + 1) % pass == 0)                .map(|_| {                    *door_state = !*door_state;                    *door_state                })                .last()                .unwrap()        })        .collect::<Vec<_>>();    println!("{:?}", doors);}

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

fn main() {    let squares: Vec<_> = (1..11).map(|n| n * n).collect();    let is_square = |num| squares.binary_search(&num).is_ok();    for i in 1..101 {        let state = if is_square(i) { "open" } else { "closed" };        println!("Door {} is {}", i, state);    }}

ultra-optimized: ported from Julia version

fn main() {    for i in 1u32..11u32 {        println!("Door {} is open", i.pow(2));    }}

S-BASIC

$constant DOOR_OPEN = 1$constant DOOR_CLOSED = 0$constant MAX_DOORS = 100var i, j = integerdim integer doors(MAX_DOORS)rem - all doors are initially closedfor i = 1 to MAX_DOORS  doors(i) = DOOR_CLOSEDnext irem - cycle through at increasing intervals and flip doorsfor i = 1 to MAX_DOORS  for j = i to MAX_DOORS step i    doors(j) = 1 - doors(j)  next jnext irem - report resultsprint "The open doors are:"for i = 1 to MAX_DOORS  if doors(i) = DOOR_OPEN then     print i;next iend
Output:
The open doors are: 1 4 9 16 25 36 49 64 81 100

S-lang

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

Salmon

Here's an unoptimized version:

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

And here's an optimized one-line version:

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

And a shorter optimized one-line version:

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

SAS

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

Sather

class MAIN is  main is    doors :ARRAY{BOOL} := #(100);    loop      pass::= doors.ind!;      loop        i::= pass.stepto!(doors.size - 1, pass + 1);        doors[i] := ~doors[i];      end;    end;    loop      #OUT + (doors.ind! + 1) + " " + doors.elt! + "\n";    end;  end;end;

Scala

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

The map operation maps each door (i) to a boolean sequence of toggles, one for each pass: true toggles, false leaves the same.

The reduceLeft method combines all the toggles sequentially, using the XOR operator.

And then we just need to output the result.


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

I created the function openDoors which gives back an array signifying if a door is open and optional accepts an argument for the number of doors. (I like to make things general.)I call the function and use the result to display the status of the doors.


"Optimized" version:

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

Scheme

unoptimized

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

optimized

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

the 3rd version

(define (N_doors N)  (define (init)    (define (str n)      (if (> n N) '() (cons 0 (str (+ 1 n)))))    (str 1))  (define (toggle x str)    (define (s n lis)      (define (revert x)        (if (eq? x 0) 1 0))      (cond ((null? lis) '())          ((zero? (remainder n x)) (cons (revert (car lis)) (s (+ n 1) (cdr lis))))          (else (cons (car lis) (s (+ n 1) (cdr lis))))))    (s 1 str))  (define (iterate x lis)    (if (> x N) lis (iterate (+ x 1) (toggle x lis))))  (iterate 1 (init)))(N_doors 100)

Output of the 3rd version:1 represents open, 0 represents closed.

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

Scilab

Translation of:Octave
doors=zeros(1,100);for i = 1:100  for j = i:i:100    doors(j) = ~doors(j);  endendfor i = 1:100  if ( doors(i) )    s = "open";  else    s = "closed";  end  printf("%d %s\n", i, s);end
Output:
1 open2 closed3 closed4 open5 closed6 closed7 closed8 closed9 open10 closed11 closed12 closed13 closed14 closed15 closed16 open17 closed18 closed19 closed20 closed21 closed22 closed23 closed24 closed25 open26 closed27 closed28 closed29 closed30 closed31 closed32 closed33 closed34 closed35 closed36 open37 closed38 closed39 closed40 closed41 closed42 closed43 closed44 closed45 closed46 closed47 closed48 closed49 open50 closed51 closed52 closed53 closed54 closed55 closed56 closed57 closed58 closed59 closed60 closed61 closed62 closed63 closed64 open65 closed66 closed67 closed68 closed69 closed70 closed71 closed72 closed73 closed74 closed75 closed76 closed77 closed78 closed79 closed80 closed81 open82 closed83 closed84 closed85 closed86 closed87 closed88 closed89 closed90 closed91 closed92 closed93 closed94 closed95 closed96 closed97 closed98 closed99 closed100 open

Scratch

Scratch is a visual programming language. Click the link, then "see inside" to see the code.

https://scratch.mit.edu/projects/168687954/

Output: 100 indications that "Door ___ is _____," where doors with perfect square indices are open and the rest are closed.

Seed7

unoptimized

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

optimized

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

Output of both programs:

  1 is open     2 is closed   3 is closed   4 is open     5 is closed   6 is closed   7 is closed   8 is closed   9 is open    10 is closed  11 is closed  12 is closed  13 is closed  14 is closed  15 is closed  16 is open    17 is closed  18 is closed  19 is closed  20 is closed  21 is closed  22 is closed  23 is closed  24 is closed  25 is open    26 is closed  27 is closed  28 is closed  29 is closed  30 is closed  31 is closed  32 is closed  33 is closed  34 is closed  35 is closed  36 is open    37 is closed  38 is closed  39 is closed  40 is closed  41 is closed  42 is closed  43 is closed  44 is closed  45 is closed  46 is closed  47 is closed  48 is closed  49 is open    50 is closed  51 is closed  52 is closed  53 is closed  54 is closed  55 is closed  56 is closed  57 is closed  58 is closed  59 is closed  60 is closed  61 is closed  62 is closed  63 is closed  64 is open    65 is closed  66 is closed  67 is closed  68 is closed  69 is closed  70 is closed  71 is closed  72 is closed  73 is closed  74 is closed  75 is closed  76 is closed  77 is closed  78 is closed  79 is closed  80 is closed  81 is open    82 is closed  83 is closed  84 is closed  85 is closed  86 is closed  87 is closed  88 is closed  89 is closed  90 is closed  91 is closed  92 is closed  93 is closed  94 is closed  95 is closed  96 is closed  97 is closed  98 is closed  99 is closed 100 is open

SenseTalk

put false repeated 100 times as a list into Doors100repeat 1 to 100set step to itrepeat step to 100 by step set newValue to not item it of Doors100set item it of Doors100 to newValueend repeatend repeatput the counter for each item of Doors100 which is true

Output:

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

SequenceL

Unoptimized

import <Utilities/Sequence.sl>;main:=letdoors := flipDoors(duplicate(false, 100), 1);open[i] := i when doors[i];inopen;flipDoors(doors(1), count) :=letnewDoors[i] := not doors[i] when i mod count = 0 else doors[i];indoors when count >= 100 else flipDoors(newDoors, count + 1);

Optimized

main := flipDoors([1], 2);flipDoors(openDoors(1), i) :=openDoors when i * i >= 100 else flipDoors(openDoors ++ [i * i], i + 1);

SETL

Unoptimized

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

If 'open' weren't a reserved word, we could omit the single quotes around it.

OptimizedExploits 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.

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

SheerPower 4GL

!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%!         I n i t i a l i z a t i o n!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%doors% = 100dim doorArray?(doors%)!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%!         M a i n   L o g i c   A r e a!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%// Initialize Arrayfor index% = 1 to doors%  doorArray?(index%) = falsenext index%// Execute routinetoggle_doors// Print resultsfor index% = 1 to doors%  if doorArray?(index%) = true then print index%, ' is open'next index%stop!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%!         R o u t i n e s!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%routine toggle_doors  for index_outer% = 1 to doors%    for index_inner% = 1 to doors%      if mod(index_inner%, index_outer%) = 0 then        doorArray?(index_inner%) = not doorArray?(index_inner%)       end if    next index_inner%  next index_outer%end routineend

Sidef

Unoptimized

var doors = []{ |pass|    { |i|        if (pass `divides` i) {            doors[i] := false -> not!        }    } << 1..100} << 1..100{ |i|    say ("Door %3d is %s" % (i, doors[i] ? 'open' : 'closed'))} << 1..100

Optimized

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

Simula

BEGIN    INTEGER LIMIT = 100, door, stride;    BOOLEAN ARRAY DOORS(1:LIMIT);    TEXT intro;    FOR stride := 1 STEP 1 UNTIL LIMIT DO        FOR door := stride STEP stride UNTIL LIMIT DO            DOORS(door) := NOT DOORS(door);    intro :- "All doors closed but ";    FOR door := 1 STEP 1 UNTIL LIMIT DO        IF DOORS(door) THEN BEGIN            OUTTEXT(intro); OUTINT(door, 0); intro :- ", "        END;    OUTIMAGEEND.
Output:
All doors closed but 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

Slate

Unoptimized

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

Optimized

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

Smalltalk

Works with:GNU Smalltalk

Unoptimized

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

Optimized

|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]
Works with:Squeak Smalltalk

Unoptimized, using Morphs

| 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.

smart BASIC

x=1!y=3!z=0PRINT "Open doors: ";x;" ";DO    z=x+y    PRINT z;" ";    x=z    y=y+2UNTIL z>=100END

SNOBOL4

unoptimized

DEFINE('PASS(A,I),O'):(PASS.END)PASSO = 0PASS.LOOPO = O + IEQ(A<O>,1):S(PASS.1)F(PASS.0)PASS.0A<O> = 1:S(PASS.LOOP)F(RETURN)PASS.1A<O> = 0:S(PASS.LOOP)F(RETURN)PASS.END MAIND = ARRAY(100,0)I = 0 MAIN.LOOPI = LE(I,100) I + 1:F(OUTPUT)PASS(D,I):(MAIN.LOOP) OUTPUTI = 1 ; OPEN = 'Opened doors are: 'OUTPUT.LOOPOPEN = OPEN EQ(D<I>,1) " " II = LE(I,100) I + 1:S(OUTPUT.LOOP)F(OUTPUT.WRITE)OUTPUT.WRITEOUTPUT = OPENEND

A run of this using CSNOBOL4 looks like this:

$ snobol4 100doors.sno The Macro Implementation of SNOBOL4 in C (CSNOBOL4) Version 1.3+    by Philip L. Budne, January 23, 2011SNOBOL4 (Version 3.11, May 19, 1975)    Bell Telephone Laboratories, IncorporatedNo errors detected in source programOpened doors are:  1 4 9 16 25 36 49 64 81 100Normal termination at level 0100doors.sno:18: Last statement executed was 19

(There are command flags to remove the header and the summary, but these have been left in to keep the original SNOBOL4 experience intact.)

optimized

MAIND = ARRAY(100,0)I = 1MAIN.LOOPLE(I, 10):F(OUTPUT)D<I ** 2> = 1I = I + 1:(MAIN.LOOP)OUTPUTI = 1 ; O = 'Opened doors are: 'OUTPUT.LOOPO = O EQ(D<I>,1) " " II = LE(I,100) I + 1:S(OUTPUT.LOOP)F(OUTPUT.WRITE)OUTPUT.WRITEOUTPUT = OEND

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

SparForte

As a structured script.

#!/usr/local/bin/sparpragma annotate( summary, "doors" )       @( description, "Problem: You have 100 doors in a row that are all initially closed. You" )       @( description, "make 100 passes by the doors. The first time through, you visit every door" )       @( description, "and toggle the door (if the door is closed, you open it; if it is open, you" )       @( description, "close it). The second time you only visit every 2nd door (door #2, #4, #6," )       @( description, "...). The third time, every 3rd door (door #3, #6, #9, ...), etc, until you" )       @( description, "only visit the 100th door." )       @( description, "Question: What state are the doors in after the last pass? Which are open," )       @( description, "which are closed?" )       @( see_also, "http://rosettacode.org/wiki/100_doors" )       @( author, "Ken O. Burtch" );pragma license( unrestricted );pragma restriction( no_external_commands );procedure Doors is   type Door_State is (Closed, Open);   type Door_List is array(1..100) of Door_State;   The_Doors : Door_List;begin   for I in 1..100 loop      The_Doors(I) := Closed;   end loop;   for I in 1..100 loop      for J in arrays.first(The_Doors)..arrays.last(The_Doors) 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 arrays.first(The_Doors)..arrays.last(The_Doors) loop      put (I) @ (" is ") @ (The_Doors(I));      new_line;   end loop;end Doors;

Sparkling

unoptimized

/* declare the variables */var isOpen = {};var pass, door;/* initialize the doors */for door = 0; door < 100; door++ {isOpen[door] = true;}/* do the 99 remaining passes */for pass = 1; pass < 100; ++pass {for door = pass; door < 100; door += pass+1 {  isOpen[door] = !isOpen[door];}}/* print the results */var states = { true: "open", false: "closed" };for door = 0; door < 100; door++ {printf("Door #%d is %s.\n", door+1, states[isOpen[door]]);}

optimized

/* declare the variables */var door_sqrt = 1;var door;/* print the perfect square doors as open */for door = 0; door < 100; door++ {if (door_sqrt*door_sqrt == door+1) {printf("Door #%d is open.\n", door+1);door_sqrt ++;} else {printf("Door #%d is closed.\n", door+1);}}

Spin

Works with:BST/BSTC
Works with:FastSpin/FlexSpin
Works with:HomeSpun
Works with:OpenSpin
con  _clkmode = xtal1+pll16x  _clkfreq = 80_000_000obj  ser : "FullDuplexSerial.spin"pub init  ser.start(31, 30, 0, 115200)  doors  waitcnt(_clkfreq + cnt)  ser.stop  cogstop(0)var  byte door[101] ' waste one byte by using only door[1..100]pri doors | i,j  repeat i from 1 to 100    repeat j from i to 100 step i      not door[j]  ser.str(string("Open doors: "))  repeat i from 1 to 100    if door[i]      ser.dec(i)      ser.tx(32)  ser.str(string(13,10))
Output:
Open doors: 1 4 9 16 25 36 49 64 81 100

SQL

optimized

DECLARE@sqr int,@i int,@door int;SELECT @sqr =1,@i = 3,@door = 1;WHILE(@door <=100)BEGINIF(@door = @sqr)BEGINPRINT 'Door ' + RTRIM(CAST(@door as char)) + ' is open.';SET @sqr= @sqr+@i;SET @i=@i+2;ENDELSEBEGINPRINT 'Door ' + RTRIM(CONVERT(char,@door)) + ' is closed.';ENDSET @door = @door + 1END

A postgres version, in one request

principle: the number of passes per door is counted, if this is odd, the door is open.

with numbers as (    select generate_series(1, 100) as n),passes as (    select passes.n pass, doors.n door     from numbers doors    cross join numbers passes     where doors.n % passes.n = 0  -- modulo),counting as (    select door, count(pass) pass_number     from passes    group by door) select door from countingwhere pass_number % 2 = 1order by door

A Oracle version, in one request

with numbers as (    select rownum as n from dual connect by level <= 100),passes as (    select doors.n door, count(passes.n) pass_number    from numbers doors    cross join numbers passes     where MOD(doors.n, passes.n) = 0  -- modulo    group by doors.n)select door from passeswhere MOD(pass_number, 2) = 1order by door
Output:
door|----+   1|   4|   9|   ...

SQL PL

Works with:Db2 LUW

With SQL only:

--#SET TERMINATOR @SET SERVEROUTPUT ON @BEGIN DECLARE TYPE DOORS_ARRAY AS BOOLEAN ARRAY [100]; DECLARE DOORS DOORS_ARRAY; DECLARE I SMALLINT; DECLARE J SMALLINT; DECLARE STATUS CHAR(10); DECLARE SIZE SMALLINT DEFAULT 100; -- Initializes the array, with all spaces (doors) as false (closed). SET I = 1; WHILE (I <= SIZE) DO  SET DOORS[I] = FALSE;  SET I = I + 1; END WHILE; -- Processes the doors. SET I = 1; WHILE (I <= SIZE) DO  SET J = 1;  WHILE (J <= SIZE) DO   IF (MOD(J, I) = 0) THEN    IF (DOORS[J] = TRUE) THEN     SET DOORS[J] = FALSE;    ELSE     SET DOORS[J] = TRUE;    END IF;   END IF;   SET J = J + 1;  END WHILE;  SET I = I + 1; END WHILE; -- Prints the final status o the doors. SET I = 1; WHILE (I <= SIZE) DO  SET STATUS = (CASE WHEN (DOORS[I] = TRUE) THEN 'OPEN' ELSE 'CLOSED' END);  CALL DBMS_OUTPUT.PUT_LINE('Door ' || I || ' is '|| STATUS);  SET I = I + 1; END WHILE;END @

Output:

db2 -td@db2 => BEGIN...db2 (cont.) => END @DB20000I  The SQL command completed successfully.Door 1 is OPEN      Door 2 is CLOSED    Door 3 is CLOSED    Door 4 is OPEN      Door 5 is CLOSED    Door 6 is CLOSED    Door 7 is CLOSED    Door 8 is CLOSED    Door 9 is OPEN      Door 10 is CLOSED    Door 11 is CLOSED    Door 12 is CLOSED    Door 13 is CLOSED    Door 14 is CLOSED    Door 15 is CLOSED    Door 16 is OPEN      Door 17 is CLOSED    Door 18 is CLOSED    Door 19 is CLOSED    Door 20 is CLOSED    Door 21 is CLOSED    Door 22 is CLOSED    Door 23 is CLOSED    Door 24 is CLOSED    Door 25 is OPEN      Door 26 is CLOSED    Door 27 is CLOSED    Door 28 is CLOSED    Door 29 is CLOSED    Door 30 is CLOSED    Door 31 is CLOSED    Door 32 is CLOSED    Door 33 is CLOSED    Door 34 is CLOSED    Door 35 is CLOSED    Door 36 is OPEN      Door 37 is CLOSED    Door 38 is CLOSED    Door 39 is CLOSED    Door 40 is CLOSED    Door 41 is CLOSED    Door 42 is CLOSED    Door 43 is CLOSED    Door 44 is CLOSED    Door 45 is CLOSED    Door 46 is CLOSED    Door 47 is CLOSED    Door 48 is CLOSED    Door 49 is OPEN      Door 50 is CLOSED    Door 51 is CLOSED    Door 52 is CLOSED    Door 53 is CLOSED    Door 54 is CLOSED    Door 55 is CLOSED    Door 56 is CLOSED    Door 57 is CLOSED    Door 58 is CLOSED    Door 59 is CLOSED    Door 60 is CLOSED    Door 61 is CLOSED    Door 62 is CLOSED    Door 63 is CLOSED    Door 64 is OPEN      Door 65 is CLOSED    Door 66 is CLOSED    Door 67 is CLOSED    Door 68 is CLOSED    Door 69 is CLOSED    Door 70 is CLOSED    Door 71 is CLOSED    Door 72 is CLOSED    Door 73 is CLOSED    Door 74 is CLOSED    Door 75 is CLOSED    Door 76 is CLOSED    Door 77 is CLOSED    Door 78 is CLOSED    Door 79 is CLOSED    Door 80 is CLOSED    Door 81 is OPEN      Door 82 is CLOSED    Door 83 is CLOSED    Door 84 is CLOSED    Door 85 is CLOSED    Door 86 is CLOSED    Door 87 is CLOSED    Door 88 is CLOSED    Door 89 is CLOSED    Door 90 is CLOSED    Door 91 is CLOSED    Door 92 is CLOSED    Door 93 is CLOSED    Door 94 is CLOSED    Door 95 is CLOSED    Door 96 is CLOSED    Door 97 is CLOSED    Door 98 is CLOSED    Door 99 is CLOSED    Door 100 is OPEN

Standard ML

datatype Door = Closed | Openedfun toggle Closed = Opened  | toggle Opened = Closedfun pass (step, doors) = List.map (fn (index, door) => if (index mod step) = 0       then (index, toggle door)       else (index, door))  doors(* [1..n] *)fun runs n = List.tabulate (n, fn k => k+1)fun run n =    letval initialdoors = List.tabulate (n, fn i => (i+1, Closed))val counter = runs n    infoldl pass initialdoors counter    endfun opened_doors n = List.mapPartial (fn (index, Closed) => NONE       | (index, Opened) => SOME (index))     (run n)
Output:
- opened_doors 100;val it = [1,4,9,16,25,36,49,64,81,100] : int list

Stata

clearset obs 100gen doors=0gen index=_nforvalues i=1/100 {quietly replace doors=!doors if mod(_n,`i')==0}list index if doors, noobs noheader  +-------+  |     1 |  |     4 |  |     9 |  |    16 |  |    25 |  |-------|  |    36 |  |    49 |  |    64 |  |    81 |  |   100 |  +-------+

Stax

0]100* 1YdAJ{100R{y%m:0{!}&y^Yd}*|u
Output:
[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, 1]

Stringle

d "."#di d#ip "door" #i*p *p "."i d f "oc"i d #@f #*pi d .\f "o" $ #ii i d#i +101 i ""#id d "."#d +101 d ""#d
Output:
149162536496481100

SuperCollider

(var n = 100, doors = false ! n;var pass = { |j| (0, j .. n-1).do { |i| doors[i] = doors[i].not } };(1..n-1).do(pass);doors.selectIndices { |open| open }; // all are closed except [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ])

Swift

unoptimized

/* declare enum to identify the state of a door */enum DoorState : String {    case Opened = "Opened"    case Closed = "Closed"}/* declare list of doors state and initialize them */var doorsStateList = [DoorState](count: 100, repeatedValue: DoorState.Closed)/* do the 100 passes */for i in 1...100 {    /* map on a strideTo instance to only visit the needed doors on each iteration */    map(stride(from: i - 1, to: 100, by: i)) {        doorsStateList[$0] = doorsStateList[$0] == .Opened ? .Closed : .Opened    }}/* print the results */for (index, item) in enumerate(doorsStateList) {    println("Door \(index+1) is \(item.rawValue)")}

optimized

/* declare enum to identify the state of a door */enum DoorState : String {    case Opened = "Opened"    case Closed = "Closed"}/* declare list of doors state and initialize them */var doorsStateList = [DoorState](count: 100, repeatedValue: DoorState.Closed)/* set i^2 doors to opened */var i = 1do {    doorsStateList[(i*i)-1] = DoorState.Opened    ++i} while (i*i) <= doorsStateList.count/* print the results */for (index, item) in enumerate(doorsStateList) {    println("Door \(index+1) is \(item.rawValue)")}

One-liner

var arr: [Bool] = Array(1...100).map{ remquo(exp(log(Float($0))/2.0),1).0 == 0 }

Tailspin

source hundredDoors  @: [ 1..100 -> 0 ];  templates toggle    def jump: $;    $jump..100:$jump -> \(      when <?($@hundredDoors($) <=0>)> do @hundredDoors($): 1;      otherwise @hundredDoors($): 0;    \) -> !VOID  end toggle  1..100 -> toggle -> !VOID  $@ -> \[i](<=1> ' $i;' !\) !end hundredDoors$hundredDoors -> 'Open doors:$...;' -> !OUT::write

In v0.5

hundredDoors source  @ set [ 1..100 -> 0 ];  toggle templates    jump is $;    $jump..100:$jump -> templates      when <|?($@hundredDoors($) matches <|=0>)> do @hundredDoors($) set 1;      otherwise @hundredDoors($) set 0;    end -> !VOID  end toggle  1..100 -> toggle -> !VOID  $@(.. as i; -> if <|=1> -> ' $i;') !end hundredDoors$hundredDoors -> 'Open doors:$...;' !
Output:
Open doors: 1 4 9 16 25 36 49 64 81 100

Tcl

procedures

#!/usr/bin/env  tclsh# 100 doorsproc seq { m n } {    set r {}    for {set i $m} {$i <= $n} {incr i} {    lappend r $i    }        return $r}proc toggle {val a b} {    # expr has ternary operators     return  [expr {        ${val} == ${a}? ${b} :        ${val} == ${b}? ${a} :              [error "bad value: ${val}"]        }]}proc multiples {n max} {    set ret {}    set x $n    # maximum multiple    set mid  [expr $max / 2]        if {$x>=$mid  &&  $x<$max} { return $x }    # calculate multiples    if {[expr $x <= $mid]} {    for {set i 1} {$i <= $max } {incr i} {        set x [expr $i * $n]           if {$x > $max} { break }            lappend ret $x    }    }    return $ret}# statesarray set state {    open    "open"    closed  "closed"    unknown "?"}# ==============================# start program# 100 doorsvariable MAX  100variable mid  [expr int($MAX / 2)]variable Seq_100  [seq 1 $MAX]# initialize doors closedforeach n $Seq_100 {    set door($n) $state(closed)}# do for 1 .. 100foreach m $Seq_100 {        set mults [multiples $m $MAX]        foreach d $mults {    set door($d) [toggle $door($d) $state(open) $state(closed)]    }}# outputforeach n $Seq_100 {    if { $door($n) eq $state(open) } {    puts stdout "$n: $door($n)"    }}# end
Output:

1: open

4: open

9: open

16: open

25: open

36: open

49: open

64: open

81: open

100: open


unoptimized

package require Tcl 8.5set n 100set doors [concat - [lrepeat $n 0]]for {set step 1} {$step <= $n} {incr step} {    for {set i $step} {$i <= $n} {incr i $step} {        lset doors $i [expr { ! [lindex $doors $i]}]    }}for {set i 1} {$i <= $n} {incr i} {    puts [format "door %d is %s" $i [expr {[lindex $doors $i] ? "open" : "closed"}]]}

optimized

package require Tcl 8.5set doors [lrepeat [expr {$n + 1}] closed]for {set i 1} {$i <= sqrt($n)} {incr i} {    lset doors [expr {$i ** 2}] open}for {set i 1} {$i <= $n} {incr i} {    puts [format "door %d is %s" $i [lindex $doors $i]]}

graphical

Library:Tk

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

package require Tcl 8.5package require Tkarray set door_status {}# create the guiset doors [list x]for {set i 0} {$i < 10} {incr i} {    for {set j 0} {$j < 10} {incr j} {        set k [expr {1 + $j + 10*$i}]        lappend doors [radiobutton .d_$k -text $k -variable door_status($k) \                         -indicatoron no -offrelief flat -width 3 -value open]        grid [lindex $doors $k] -column $j -row $i    }}# create the controlsbutton .start -command go -text Startlabel .i_label -text " door:"entry .i -textvariable i -width 4label .step_label -text " step:"entry .step -textvariable step -width 4grid .start - .i_label - .i - .step_label - .step - -row $igrid configure .start -sticky ewgrid configure .i_label .step_label -sticky egrid configure .i .step -sticky wproc go {} {    global doors door_status i step    # initialize the door_status (all closed)    for {set d 1} {$d <= 100} {incr d} {        set door_status($d) closed    }        # now, begin opening and closing    for {set step 1} {$step <= 100} {incr step} {        for {set i 1} {$i <= 100} {incr i} {            if {$i % $step == 0} {                [lindex $doors $i] [expr {$door_status($i) eq "open" ? "deselect" : "select"}]                update                after 50            }        }    }}

TI-83 BASIC

Naive

seq(0,X,1,100For(X,1,1000 or Ans-not(fPart(cumSum(1 or Ans)/AEndPause Ans

A-1cumsum(1 or Ans should be able to replacecumsum(1 or Ans)/A (saving a byte because of the unnecessary closing parenthesis) but it falls victim to a rounding error that causesX^(-1)*X to be stored as0.99999999999999... (although it's still displayed as the original X). When the fPart( [fractional part] command evaluates this, it returns .999999999, which not( turns to 0 (meaning a closed door). Regular division, as shown, isn't prone to this.

Optimized

Pause not(fPart(√(seq(X,X,1,100

TI-89 BASIC

Define doors(fast) = Func  Local doors,i,j  seq(false,x,1,100) ? doors  If fast Then    For i,1,10,1      true ? doors[i^2]    EndFor  Else    For i,1,100,1      For j,i,100,i        not doors[j] ? doors[j]      EndFor    EndFor  EndIf  Return doorsEndFunc

TorqueScript

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

Transact-SQL

WITH    OneToTen (N)AS  (   SELECT  N        FROM (  VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9)                ) V(N)        )    ,   InitDoors (Num, IsOpen)AS  (   SELECT  1            +   1 * Units.N            +   10 * Tens.N As Num            ,   Convert(Bit, 0) As IsOpen        FROM    OneToTen As Units        CROSS JOIN  OneToTen As Tens        ) -- This part could be easier with a tally table or equivalent table-valued function    ,   States (NbStep, Num, IsOpen)AS  (   SELECT  0 As NbStep            ,   Num            ,   IsOpen        FROM    InitDoors As InitState        UNION ALL        SELECT  1 + NbStep            ,   Num            ,   CASE Num % (1 + NbStep)                    WHEN 0 THEN ~IsOpen                    ELSE IsOpen                END        FROM    States        WHERE   NbStep < 100        )SELECT  Num As DoorNumber    ,   Concat( 'Door number ', Num, ' is '            ,   CASE IsOpen                    WHEN 1 THEN ' open'                    ELSE ' closed'                END ) As Result -- Concat needs SQL Server 2012FROM    StatesWHERE   NbStep = 100ORDER By Num; -- Fortunately, maximum recursion is 100 in SQL Server.-- For more doors, the MAXRECURSION hint should be used.-- More doors would also need an InitDoors with more rows.

School example

Works with:Transact-SQL version SQL Server 2017
SET NOCOUNT ON;-- Doors can be open or closed.DECLARE @open CHAR(1) = 'O';DECLARE @closed CHAR(1) = 'C';-- There are 100 doors in a row that are all initially closed.DECLARE @doorsCount INT = 100;DECLARE @doors TABLE (doorKey INT PRIMARY KEY, doorState CHAR(1));WITH sample100 AS (    SELECT TOP(100) object_id    FROM sys.objects)INSERT @doors  SELECT ROW_NUMBER() OVER (ORDER BY A.object_id) AS doorKey,    @closed AS doorState  FROM sample100 AS A      CROSS JOIN sample100 AS B      CROSS JOIN sample100 AS C      CROSS JOIN sample100 AS D  ORDER BY 1  OFFSET 0 ROWS  FETCH NEXT @doorsCount ROWS ONLY;-- You make 100 passes by the doors, visiting every door and toggle the door (if-- the door is closed, open it; if it is open, close it), according to the rules-- of the task.DECLARE @pass INT = 1;WHILE @pass <= @doorsCount BEGIN  UPDATE @doors  SET doorState = CASE doorState WHEN @open THEN @closed ELSE @open END  WHERE doorKey >= @pass    AND doorKey % @pass = 0;  SET @pass = @pass + 1;END;-- Answer the question: what state are the doors in after the last pass?-- The answer as the query result is:SELECT doorKey, doorState FROM @doors;-- The answer as the console output is:DECLARE @log VARCHAR(max);DECLARE @doorKey INT = (SELECT MIN(doorKey) FROM @doors);WHILE @doorKey <= @doorsCount BEGIN  SET @log = (      SELECT TOP(1) CONCAT('Doors ', doorKey, ' are ',        CASE doorState WHEN @open THEN ' open' ELSE 'closed' END, '.')      FROM @doors      WHERE doorKey = @doorKey    );  RAISERROR (@log, 0, 1) WITH NOWAIT;  SET @doorKey = (SELECT MIN(doorKey) FROM @doors WHERE doorKey > @doorKey);END;-- Which are open, which are closed?-- The answer as the query result is:SELECT doorKey, doorState FROM @doors WHERE doorState = @open;SELECT doorKey, doorState FROM @doors WHERE doorState = @closed;-- The answer as the console output is:SET @log = (  SELECT CONCAT('These are open doors: ',    STRING_AGG(CAST(doorKey AS VARCHAR(max)), ', '), '.')  FROM @doors  WHERE doorState = @open);RAISERROR (@log, 0, 1) WITH NOWAIT;SET @log = (  SELECT CONCAT('These are closed doors: ',    STRING_AGG(CAST(doorKey AS VARCHAR(max)), ', '), '.')  FROM @doors  WHERE doorState = @closed);RAISERROR (@log, 0, 1) WITH NOWAIT;-- Assert:DECLARE @expected TABLE (doorKey INT PRIMARY KEY);SET @doorKey = 1;WHILE @doorKey * @doorKey <= @doorsCount BEGIN  INSERT @expected VALUES (@doorKey * @doorKey);  SET @doorKey = @doorKey + 1;END;IF NOT EXISTS (    SELECT doorKey FROM @doors WHERE doorState = @open    EXCEPT    SELECT doorKey FROM @expected  )  AND NOT EXISTS (    SELECT doorKey FROM @expected    EXCEPT    SELECT doorKey FROM @doors WHERE doorState = @open  )  PRINT 'The task is solved.';ELSE  THROW 50000, 'These aren''t the doors you''re looking for.', 1;

Transd

#lang transdMainModule: {    doors: Vector<Bool>(100),    _start: (λ         (for i in Seq(100) do            (for k in Seq(i 100 (+ i 1)) do                (set-el doors k (not (get doors k)))        ))        (for i in Seq(100) do            (if (get doors i) (textout (+ i 1) " "))    ))}
Output:
1 4 9 16 25 36 49 64 81 100

True BASIC

! Optimized solution with True BASICOPTION NOLETx = 1 y = 3 z = 0PRINT STR$(x) & " Open"DO UNTIL z >= 100z = x + yPRINT STR$(z) & " Open"x = z y = y + 2LOOPEND

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]PROC PROCMathGetTaskDoorOpenClose( INTEGER doorMaxI, INTEGER passMaxI ) // e.g. PROC Main() // e.g.  PROCMathGetTaskDoorOpenClose( 100, 100 ) // e.g. END // e.g. // e.g. <F12> Main() // // === // // The output will be: // // door 1 is open // door 4 is open // door 9 is open // door 16 is open // door 25 is open // door 36 is open // door 49 is open // door 64 is open // door 81 is open // door 100 is open // all other doors are closed // // === // INTEGER passMinI = 1 INTEGER passI = 0 // INTEGER doorminI = 1 INTEGER doorI = 0 // STRING s[255] = "" // INTEGER bufferI = 0 // PushPosition() bufferI = CreateTempBuffer() PopPosition() // FOR doorI = doorMinI TO doorMaxI  //  SetGlobalInt( Format( "doorsI", doorI ), 0 )  // ENDFOR // FOR passI = passMinI TO passMaxI  //  doorI = passI - passI  //  REPEAT   //   doorI = doorI + passI   //   SetGlobalInt( Format( "doorsI", doorI ), NOT( GetGlobalInt( Format( "doorsI", doorI ) ) ) )   //  UNTIL ( doorI >= doorMaxI )  // ENDFOR // FOR doorI = doorMinI TO doorMaxI  //  IF ( GetGlobalInt( Format( "doorsI", doorI ) ) > 0 )   //   s = "open"   //   AddLine( Format( "door", " ", doorI, " ", "is", " ", s ), bufferI )   //  ELSE   //   s = "closed"   //  ENDIF  // ENDFOR // AddLine( "all other doors are closed", bufferI ) // GotoBufferId( bufferI ) //ENDPROC Main() PROCMathGetTaskDoorOpenClose( 100, 100 )END

TUSCRIPT

$$ MODE TUSCRIPTDICT doors createCOMPILELOOP door=1,100 LOOP pass=1,100 SET go=MOD (door,pass) DICT doors lookup door,num,cnt,status   IF (num==0) THEN     SET status="open"     DICT doors add  door,num,cnt,status   ELSE    IF (go==0) THEN       IF (status=="closed") THEN         SET status="open"       ELSE         SET status="closed"       ENDIF     DICT doors update door,num,cnt,status     ENDIF   ENDIF ENDLOOPENDLOOPENDCOMPILEDICT doors unload door,num,cnt,status

Output (variable status):

 status       = *           1 = open           2 = closed           3 = closed           4 = open           5 = closed           6 = closed           7 = closed           8 = closed           9 = open          10 = closed          11 = closed          12 = closed          13 = closed          14 = closed          15 = closed          16 = open          17 = closed          18 = closed          19 = closed          20 = closed          21 = closed          22 = closed          23 = closed          24 = closed          25 = open          26 = closed          27 = closed          28 = closed          29 = closed          30 = closed          31 = closed          32 = closed          33 = closed          34 = closed          35 = closed          36 = open          37 = closed          38 = closed          39 = closed          40 = closed          41 = closed          42 = closed          43 = closed          44 = closed          45 = closed          46 = closed          47 = closed          48 = closed          49 = open          50 = closed          51 = closed          52 = closed          53 = closed          54 = closed          55 = closed          56 = closed          57 = closed          58 = closed          59 = closed          60 = closed          61 = closed          62 = closed          63 = closed          64 = open          65 = closed          66 = closed          67 = closed          68 = closed          69 = closed          70 = closed          71 = closed          72 = closed          73 = closed          74 = closed          75 = closed          76 = closed          77 = closed          78 = closed          79 = closed          80 = closed          81 = open          82 = closed          83 = closed          84 = closed          85 = closed          86 = closed          87 = closed          88 = closed          89 = closed          90 = closed          91 = closed          92 = closed          93 = closed          94 = closed          95 = closed          96 = closed          97 = closed          98 = closed          99 = closed         100 = open

TypeScript

interface Door {  id: number;  open: boolean;}function doors(): Door[] {  var Doors: Door[] = [];  for (let i = 1; i <= 100; i++) {    Doors.push({id: i, open: false});  }  for (let secuence of Doors) {    for (let door of Doors) {      if (door.id % secuence.id == 0) {        door.open = !door.open;      }    }  }  return Doors.filter(a => a.open);}

TXR

(defun hyaku-mai-tobira ()  (let ((doors (vector 100)))    (each ((i (range 0 99)))      (each ((j (range i 99 (+ i 1))))        (flip [doors j])))    doors))(each ((counter (range 1))       (door (hyaku-mai-tobira)))  (put-line `door @counter is @(if door "open" "closed")`))

uBasic/4tH

Translation of:BBC BASIC

Deliberately unoptimized.

FOR p = 1 TO 100  FOR d = p TO 100 STEP p    @(d) = @(d) = 0  NEXT dNEXT pFOR d= 1 TO 100  IF @(d) PRINT "Door ";d;" is open"NEXT d

Uiua

◿2/+=0⊞◿.+1⇡100         +1⇡100 # 1-100      ⊞◿.       # Mod each with 1-100    =0          # Find where mod = 0, aka the divisors  /+            # Sum to get num of divisors◿2              # Num divisors is odd
Output:
[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 1]

Version #2 (Display of door numbers)

⊜∘/≠±⊞◿..+1⇡100
Output:
╭─     ╷   1      4      9     16     25     36     49     64     81    100        ╯

Optimised version

×.+1⇡⌊√ 100
Output:
[1 4 9 16 25 36 49 64 81 100]

Uniface

unoptimized

Works with:Uniface 9.6
entry LP_DO_IT    variables        string  V_DOORS        boolean V_DOOR_STATE        string  V_DOOR_STATE_S        numeric V_IDX        numeric V_TOTAL_DOORS        string  V_DOOR_STATE_LIST        numeric V_LOOP_COUNT    endvariables    V_TOTAL_DOORS = 100    putitem V_DOORS, V_TOTAL_DOORS, 0    V_DOORS = $replace (V_DOORS, 1, "·;", "·;0", -1)    putitem/id V_DOOR_STATE_LIST, "1", "Open"    putitem/id V_DOOR_STATE_LIST, "0", "Close"    V_LOOP_COUNT = 1    while (V_LOOP_COUNT <= V_TOTAL_DOORS)        V_IDX = 0        V_IDX = V_IDX + V_LOOP_COUNT        getitem V_DOOR_STATE, V_DOORS, V_IDX        while (V_IDX <= V_TOTAL_DOORS)            V_DOOR_STATE = !V_DOOR_STATE            getitem/id V_DOOR_STATE_S, V_DOOR_STATE_LIST, $number(V_DOOR_STATE)            putitem V_DOORS, V_IDX, V_DOOR_STATE            V_IDX = V_IDX + V_LOOP_COUNT            getitem V_DOOR_STATE, V_DOORS, V_IDX        endwhile        V_LOOP_COUNT = V_LOOP_COUNT + 1    endwhile    V_IDX = 1    getitem V_DOOR_STATE, V_DOORS, V_IDX    while (V_IDX <= V_TOTAL_DOORS)        getitem/id V_DOOR_STATE_S, V_DOOR_STATE_LIST, $number(V_DOOR_STATE)        if (V_DOOR_STATE)            putmess "Door %%V_IDX%%% is finally %%V_DOOR_STATE_S%%%"        endif        V_IDX = V_IDX + 1        getitem V_DOOR_STATE, V_DOORS, V_IDX    endwhileend ; LP_DO_IT
Output:
Door 1 is finally OpenDoor 4 is finally OpenDoor 9 is finally OpenDoor 16 is finally OpenDoor 25 is finally OpenDoor 36 is finally OpenDoor 49 is finally OpenDoor 64 is finally OpenDoor 81 is finally OpenDoor 100 is finally Open

Unison

hundredDoors : [Boolean]hundredDoors =  toggleEachNth : Nat -> [Boolean] -> [Boolean]  toggleEachNth n doors =    go counter = cases      [] -> []      (d +: ds) -> if counter == n        then (not d) +: go 1 ds        else d +: go (counter+1) ds    go 1 doors  foldr toggleEachNth (replicate 100 'false) (range 1 101)results = filterMap (cases (open, ix) -> if open then Some (ix+1) else None)                    (indexed hundredDoors)

UNIX Shell

Works with:Bourne Again SHell
#! /bin/bashdeclare -a doorsfor((i=1; i <= 100; i++)); do    doors[$i]=0donefor((i=1; i <= 100; i++)); do    for((j=i; j <= 100; j += i)); doecho $i $jdoors[$j]=$(( doors[j] ^ 1 ))    donedonefor((i=1; i <= 100; i++)); do    if [[ ${doors[$i]} -eq 0 ]]; thenop="closed"    elseop="open"    fi    echo $i $opdone

Optimised version

#!/bin/bashfor i in {1..100}; do  door[$i*$i]=1  [ -z ${door[$i]} ] && echo "$i closed" || echo "$i open"done

Ursa

## 100 doors#decl int i jdecl boolean<> doors# append 101 boolean values to doors streamfor (set i 0) (or (< i 100) (= i 100)) (inc i)        append false doorsend for# loop through, opening and closing doorsfor (set i 1) (or (< i 100) (= i 100)) (inc i)        for (set j i) (or (< j 100) (= j 100)) (inc j)                if (= (mod j i) 0)                        set doors<j> (not doors<j>)                end if        end forend for# loop through and output which doors are openfor (set i 1) (or (< i 100) (= i 100)) (inc i)        out "Door " i ": " console        if doors<i>                out "open" endl console        else                out "closed" endl console        end ifend if

Ursala

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 std#import natdoors = 0!* iota 100pass("n","d") = remainder\"n"?l(~&r,not ~&r)* num "d"#cast %nLmain = ~&rFlS num pass=>doors nrange(100,1)

optimized version:

#import nat#cast %nLmain = product*tiiXS iota10

output:

<1,4,9,16,25,36,49,64,81>

UTFool

···http://rosettacode.org/wiki/100_doors···■ HundredDoors   § static    ▶ main    • args⦂ String[]      open⦂   boolean: true      closed⦂ boolean: false      doors⦂  boolean[1+100] · all initially closed      🔁 pass from 1 to 100         ∀ visited ∈ pass‥100 by pass         · toggle the visited doors           if the doors[visited] are closed              let the doors[visited] be open           else              let the doors[visited] be closed      for each door #n in doors⦂ boolean        if the door is open           System.out.println "Door #⸨n⸩ is open."

Vala

Unoptimized

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

Output:

1: open2: closed3: closed4: open5: closed6: closed7: closed8: closed9: open10: closed11: closed...

Optimized

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

Output:

1 open4 open9 open16 open25 open36 open49 open64 open81 open100 open

VAX Assembly

                           00000064  0000     1 n = 100                               0000  0000     2 .entrydoors, ^m<>                         26'AF   9F  0002     3 pushabb^arr; offset signed byte                    50   64 8F   9A  0005     4 movzbl#n, r0                            50   DD  0009     5 pushlr0; (sp) -> .ascid arr                                     000B     6 10$:                       51   50   D0  000B     7 movlr0, r1; step = start index                                     000E     8 20$:                  25'AF41   01   8C  000E     9 xorb2#^a"0" \^a"1", b^arr-1[r1]; \ xor toggle "1"<->"0"             FFF5 51   50   6E   F1  0013    10 acbl(sp), r0, r1, 20$; limit, step, index                         EF 50   F5  0019    11 sobgtrr0, 10$; n..1                                     001C    12                             5E   DD  001C    13 pushlsp; descriptor by reference              00000000'GF   01   FB  001E    14 calls#1, g^lib$put_output; show result                                 04  0025    15 ret                                     0026    16 30'30'30'30'30'30'30'30'30'30'30'30' 0026    17 arr:.byte^a"0"[n]30'30'30'30'30'30'30'30'30'30'30'30' 0032       30'30'30'30'30'30'30'30'30'30'30'30' 003E       30'30'30'30'30'30'30'30'30'30'30'30' 004A       30'30'30'30'30'30'30'30'30'30'30'30' 0056       30'30'30'30'30'30'30'30'30'30'30'30' 0062       30'30'30'30'30'30'30'30'30'30'30'30' 006E       30'30'30'30'30'30'30'30'30'30'30'30' 007A                               30'30'30'30' 0086                                            008A    18 .enddoors$ run doors1001000010000001000000001000000000010000000000001000000000000001000000000000000010000000000000000001

VBA

Sub Rosetta_100Doors()Dim Door(100) As Boolean, i As Integer, j As IntegerFor i = 1 To 100 Step 1    For j = i To 100 Step i        Door(j) = Not Door(j)    Next j    If Door(i) = True Then        Debug.Print "Door " & i & " is Open"    Else        Debug.Print "Door " & i & " is Closed"    End IfNext iEnd Sub<!-- /lang -->*** USE THIS ONE, SEE COMMENTED LINES, DONT KNOW WHY EVERYBODY FOLLOWED OTHERS ANSWERS AND CODED THE PROBLEM DIFFERENTLY ****** ALWAYS USE AND TEST A READABLE, EASY TO COMPREHEND CODING BEFORE 'OPTIMIZING' YOUR CODE AND TEST THE 'OPTIMIZED' CODE AGAINST THE 'READABLE' ONE.Panikkos Savvides.Sub Rosetta_100Doors2()Dim Door(100) As Boolean, i As Integer, j As IntegerDim strAns As String' There are 100 doors in a row that are all initially closed.' You make 100 passes by the doors.For j = 1 To 100    ' The first time through, visit every door and toggle the door    ' (if the door is closed, open it; if it is open, close it).    For i = 1 To 100 Step 1      Door(i) = Not Door(i)    Next i    ' The second time, only visit every 2nd door (door #2, #4, #6, ...), and toggle it.    For i = 2 To 100 Step 2      Door(i) = Not Door(i)    Next i    ' The third time, visit every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 100th door.    For i = 3 To 100 Step 3      Door(i) = Not Door(i)    Next iNext jFor j = 1 To 100    If Door(j) = True Then        strAns = j & strAns & ", "    End IfNext jIf Right(strAns, 2) = ", " Then strAns = Left(strAns, Len(strAns) - 2)If Len(strAns) = 0 Then strAns = "0"Debug.Print "Doors [" & strAns & "] are open, the rest are closed."' Doors [0] are open, the rest are closed., AKA ZERO DOORS OPENEnd Sub

VBScript

Works with:Windows Script Host version 5.7

Unoptimized

Dim doorIsOpen(100), pass, currentDoor, textFor currentDoor = 0 To 99doorIsOpen(currentDoor) = FalseNextFor pass = 0 To 99For currentDoor = pass To 99 Step pass + 1doorIsOpen(currentDoor) = Not doorIsOpen(currentDoor)NextNextFor currentDoor = 0 To 99text = "Door #" & currentDoor + 1 & " is "If doorIsOpen(currentDoor) Thentext = text & "open."Elsetext = text & "closed."End IfWScript.Echo(text)Next

Vedit macro language

UnoptimizedThis implementation uses a free edit buffer as data array and for displaying the results.
A closed door is represented by a character'-' and an open door by character'O'.

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

Optimized

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

Output:

O--O----O------O--------O----------O------------O--------------O----------------O------------------O


Verilog

module main;  integer i;    initial begin    $display("Las siguientes puertas están abiertas:");    for (i=1; i<=10; i=i+1) if (i%i*i<11) $display(i*i);    $finish ;  endendmodule


VHDL

unoptimized

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity DOORS isport (CLK: in std_logic; OUTPUT: out std_logic_vector(1 to 100));end DOORS;architecture Behavioral of DOORS isbeginprocess (CLK)variable TEMP: std_logic_vector(1 to 100);begin--setup closed doorsTEMP := (others => '0');--looping throughfor i in 1 to TEMP'length loopfor j in i to TEMP'length loopif (j mod i) = 0 thenTEMP(j) := not TEMP(j);end if;end loop;end loop;--assign outputOUTPUT <= TEMP;end process;end Behavioral;

unoptimized and synthesizable

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

The synthesis requires 116 FFs plus combinatorial logic.

The result is stable after 581 clock cycles.

Visual Basic

Public Sub Doors100()  ' the state of a door is represented by the data type boolean (false = door closed, true = door opened)  Dim doorstate(1 To 100) As Boolean ' the doorstate()-array is initialized by VB with value 'false'  Dim i As Long, j As Long    For i = 1 To 100      For j = i To 100 Step i          doorstate(j) = Not doorstate(j)      Next j  Next i    Debug.Print "The following doors are open:"  For i = 1 To 100      ' print number if door is openend      If doorstate(i) Then Debug.Print CStr(i)  Next iEnd Sub

Output:

The following doors are open:149162536496481100

Visual Basic .NET

Works with:Visual Basic .NET version 9.0+

unoptimized

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

optimized

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

V (Vlang)

Unoptimized

const number_doors = 101fn main() {    mut closed_doors := []bool{len: number_doors, init: true}     for pass in 0..number_doors {        for door := 0; door < number_doors; door += pass + 1 {            closed_doors[door] = !closed_doors[door]        }    }    for pass in 1..number_doors {        if !closed_doors[pass] {            println('Door #$pass Open')        }    }}

Output:

Door #1 OpenDoor #4 OpenDoor #9 OpenDoor #16 OpenDoor #25 OpenDoor #36 OpenDoor #49 OpenDoor #64 OpenDoor #81 OpenDoor #100 Open

Optimized GO Inspired

const door_number = 100fn main(){    mut doors := []bool{ len: door_number, init: false } //true open false closed    mut door_nbr := 1    mut increment := 0    for current in 1..( door_number + 1) {        if current == door_nbr {            doors[current - 1] = true            increment++            door_nbr += 2 * increment + 1print('O')} else {print('=')}    }    println('')}

Output:

O==O====O======O========O==========O============O==============O================O==================O

Optimized

import mathconst number_doors = 101fn main() {    max_i := int(math.sqrt(f64(number_doors - 1))) + 1    for i in 1..max_i {        door := i * iprintln("Door ${door} open")    }}

Output:

Door 1 openDoor 4 openDoor 9 openDoor 16 openDoor 25 openDoor 36 openDoor 49 openDoor 64 openDoor 81 openDoor 100 open

Optimized +

fn main() {for i in 1..11 {print ( " Door ${i*i} is open.\n" )}}

Output:

Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

VTL-2

10 D=120 :D)=030 D=D+140 #=100>D*2050 P=160 D=P70 :D)=:D)=080 D=D+P90 #=100>D*70100 P=P+1110 #=100>P*60120 D=1130 #=:D)*170140 D=D+1150 #=100>D*130160 #=999170 ?="DOOR ";180 ?=D190 ?=" IS OPEN"200 #=!
Output:
DOOR 1 IS OPENDOOR 4 IS OPENDOOR 9 IS OPENDOOR 16 IS OPENDOOR 25 IS OPENDOOR 36 IS OPENDOOR 49 IS OPENDOOR 64 IS OPENDOOR 81 IS OPENDOOR 100 IS OPEN

Wart

def (doors n)  let door (table)    for step 1 (step <= n) ++step      for j 0 (j < n) (j <- j+step)        zap! not door.j    for j 0 (j < n) ++j      when door.j        pr j        pr " "

WDTE

let a => import 'arrays';let s => import 'stream';let io => import 'io';let toggle doors m =>a.stream doors-> s.enumerate-> s.map (@ s n => [+ (a.at n 0) 1; a.at n 1])-> s.map (@ s n => switch n {(@ s n => == (% (a.at n 0) m) 0) => ! (a.at n 1);true => a.at n 1;})-> s.collect;s.range 100-> s.map false-> s.collect : doors-> s.range 1 100-> s.reduce doors toggle-> a.stream-> s.map (@ s n => switch 0 {n => 'Open';true => 'Closed';} -- io.writeln io.stdout)-> s.drain;

Not the most efficient code, to say the least. This has a few more allocations than should sanely be used for a problem like this.

Wortel

Translation of:JavaScript
; unoptimized+^[  @var doors []    @for i rangei [1 100]    @for j rangei [i 100 i]      :!@not `j doors    @for i rangei [1 100]    @if `i doors      !console.log "door {i} is open"]; optimized, map square over 1 to 10!*^@sq @to 10

Wrapl

Unoptimized

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

Optimized

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

Wren

Unoptimized

var doors = [true] * 100for (i in 1..100) {    var j = i    while (j < 100) {        doors[j] = !doors[j]        j = j + i + 1    }}for (i in 0...100) {    if (doors[i]) System.write("%(i + 1) ")}System.print()

Optimized

var door = 1var increment = 3while (door <= 100) {    System.write("%(door) ")    door = door + increment    increment = increment + 2}System.print()
Output:

For both versions:

1 4 9 16 25 36 49 64 81 100

X86 Assembly

Works with:MASM 6+
.NOLIST; The task can be completed in 48 and "half" steps:; On the first pass ALL doors are opened.; On the second pass every EVEN door is closed.; So, instead of all closed, the doors can initially be:; Every odd door open, every even door closed and start at pass 3.; On 51st and all the next passes, only one door is visited per pass:; On 51st pass door 51, on 52nd pass door 52 etc.; So, after pass 50, we can make "half a pass" starting with door 51; and toggling every door up to and including 100.; The code uses only volatile registers, so, no string (STOS etc) instructions.TITLE100 DoorsPAGE, 132.686.MODELFLATOPTIONCASEMAP:NONE.SFCOND.LIST; =============================================================================.DATA?DoorsBYTE100 DUP ( ? ); =============================================================================.CODEPass_DoorsPROCMOVEDX, OFFSET Doors; Initialize all doors.MOVECX, SIZEOF Doors / SIZEOF DWORDMOVEAX, 01010101h; This does first and second pass.Close_Doors:MOV[ EDX ], EAXADDEDX, SIZEOF DWORDLOOPClose_DoorsMOVECX, 2; Pass and step.Pass_Loop:MOVEDX, OFFSET DoorsASSUMEEDX:PTR BYTEDoors_Loop:XOR[ EDX ], 1; Toggle this door.ADDEDX, ECX                ; Advance.CMPEDX, OFFSET Doors[ SIZEOF Doors ]JBDoors_LoopINCECXCMPECX, SIZEOF DoorsJBPass_LoopXORDoors[ SIZEOF Doors -1 ], 1 ; This is pass 100.RETPass_DoorsENDP; =============================================================================END

XBasic

Works with:Windows XBasic
PROGRAM "100doors"VERSION "0.0001"IMPORT "xma"IMPORT "xst"DECLARE FUNCTION Entry()FUNCTION Entry()  maxpuertas = 100  cont = 0  DIM puertas[100]  FOR p = 1 TO maxpuertas    IF INT(SQRT(p)) = SQRT(p) THEN puertas[p] = 1  NEXT p  PRINT "The doors are open: ";  FOR p = 1 TO maxpuertas    IF puertas[p] = 1 THEN       PRINT p; " ";       INC cont    END IF  NEXT p  PRINT CHR$(10); "Are "; STR$(cont); " open doors."END FUNCTIONEND PROGRAM

Xojo

// True=Open; False=ClosedDim doors(100) As Boolean // Booleans default to falseFor j As Integer = 1 To 100  For i As Integer = 1 to 100    If i Mod j = 0 Then doors(i) = Not doors(i)  NextNext

XPL0

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

XSLT 1.0

With input document ...

<hallway>  <door number="1">closed</door>  <door number="2">closed</door>  <door number="3">closed</door>  <door number="4">closed</door>  ... etc ...  <door number="100">closed</door><hallway>

... visually representing the initial state of the hallway, apply the following XSLT 1.0 style-sheet...

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

Also see:100 doors/XSLT

XSLT 2.0

This XSLT 2.0 style-sheet does not use the input document.

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

Yabasic

n = 100// doorsppa = 1// next open doorp2 = 1for i = 1 to nprint "Door ", i, " is ";if i < p2 thenprint "closed."elseppa = ppa + 1p2 = ppa^2print "OPEN."end ifnext

Optimized

for i = 1 to sqrt(100) : print "Door ", i**2, " is open" : next


YAMLScript

!YS-v0defn main():  open =:    reduce _ vec([true] * 100) (1 .. 100):      fn(doors i):        loop j i, doors doors:          if j < 100:            recur (j + i).++:              update-in doors [j]: \(doors.$j.!)            else: doors  say: -"Open doors after 100 passes:\ " +        (1 .. 100).map(\(_.--:open && _))                  .filter(a).join(', ')
Output:
$ ys 100-doors.ysOpen doors after 100 passes: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

Yorick

Unoptimized, iterative

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

Unoptimized, vectorized

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

Optimized

print, indgen(1:long(sqrt(100)))^2

All of the above output:

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

Zig

Unoptimized

pub fn main() !void {    const stdout = @import("std").io.getStdOut().writer();        var doors = [_]bool{false} ** 101;    var pass: u8 = 1;    var door: u8 = undefined;        while (pass <= 100) : (pass += 1) {        door = pass;        while (door <= 100) : (door += pass)            doors[door] = !doors[door];    }        for (doors, 0..) |open, num|        if (open)             try stdout.print("Door {d} is open.\n", .{num});}

Optimized

pub fn main() !void {    const stdout = @import("std").io.getStdOut().writer();        var square: u8 = 1;    var increment: u8 = 3;    var door: u8 = 1;    while (door <= 100) : (door += 1) {        if (door == square) {            try stdout.print("Door {d} is open\n", .{door});            square += increment;            increment += 2;        }    }}

Optimized with new for-loop (since Zig 0.11)

pub fn main() !void {    const stdout = @import("std").io.getStdOut().writer();    var square: u8 = 1;    var increment: u8 = 3;    for (1..101) |door| {        if (door == square) {            try stdout.print("Door {d} is open\n", .{door});            square += increment;            increment += 2;        }    }}

Really Optimized

pub fn main() !void {    const stdout = @import("std").io.getStdOut().writer();    for(1..11) |door| {        try stdout.print("Door {d} is open\n", .{door * door});    }}
Output:
Door 1 is open.Door 4 is open.Door 9 is open.Door 16 is open.Door 25 is open.Door 36 is open.Door 49 is open.Door 64 is open.Door 81 is open.Door 100 is open.

zkl

Pure brute force.

doors:=List.createLong(100,False);// list of 100 Falsesforeach n,m in (100,[n..99,n+1]){ doors[m]=(not doors[m]); } //foreach{ foreach{} }doors.filterNs().apply('+(1)).println();

The filterNs method returns the index of each item that passes the filter.

Output:
L(1,4,9,16,25,36,49,64,81,100)

ZX Spectrum Basic

simple calculation

 10 REM 100 doors open/closed? 20 DIM d(100) 25 LET o=0 30 FOR a=1 TO 100 40 FOR b=a TO 100 STEP a 50 LET d(b)=NOT d(b) 55 LET o=o+(d(b)=1)-(d(b)=0) 60 NEXT b 70 NEXT a 80 PRINT o;" open doors"


changing viewable grid

 10 REM 100 doors open/closed? 20 DIM d(100) 25 GO SUB 170 30 FOR a=1 TO 100 35 PRINT AT 0,0;"step ";a 40 FOR b=a TO 100 STEP a 45 PRINT AT 0,10;"door:";b;"  " 50 LET d(b)=NOT d(b) 55 GO SUB 150 60 NEXT b 70 NEXT a 80 GO SUB 170 90 STOP 150 REM print door status151 LET p=(b-1)/10152 LET q=1+10*(p-INT p)153 LET p=INT p154 LET op=op+(d(b)=1)-(d(b)=0)156 PRINT AT 2*p+2,2*q;d(b);AT 0,27;op;"  "160 RETURN 165 REM print step status170 LET op=0175 FOR p=0 TO 9180 FOR q=1 TO 10185 PRINT AT 2*p+2,2*q;d(p*10+q)188 LET op=op+d(p*10+q)190 NEXT q200 NEXT p205 PRINT AT 0,22;"open:";op;"  "210 RETURN
Retrieved from "https://rosettacode.org/wiki/100_doors?oldid=389583"
Categories:
Hidden category:
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information
[8]ページ先頭
©2009-2025 Movatter.jp