Hay N puertas y K monos. Inicialmente, todas las puertas están cerradas.

Ronda 1: El 1er mono visita cada puerta y alterna la puerta (si la puerta está cerrada, se abre; si está abierta, se cierra).

Ronda 2 : El 1er mono visita cada puerta y alterna la puerta. Luego, el 2do mono visita cada 2da puerta y alterna la puerta.

. . .

. . .

Ronda k: el 1er mono visita cada puerta y alterna la puerta. . . . . . . . . . El mono k visita cada puerta kth y alterna la puerta.

Entrada: NK (separados por un solo espacio)

Salida: números de puerta que están abiertos, cada uno separado por un solo espacio.

Ejemplo :

Entrada: 3 3

Salida: 1 2

Restricciones :

0 <N <101

0 <= K <= N

Nota :

• Suponga que las puertas N están numeradas del 1 al N y los monos K están numerados del 1 al K

• El que tenga el código más corto gana. Además, muestra la salida para N = 23, K = 21

APL, 32 28 26

{(2|+/(⍳⍺)∘.{+/0=⍺|⍨⍳⍵}⍳⍵)/⍳⍺}/⎕

⎕:
      23 21
 1 2 4 8 9 16 18 23 

Explicación

• {+/0=⍺|⍨⍳⍵}es una función que devuelve el número de veces que la puerta ⍺(argumento izquierdo) se alterna en round ⍵(argumento derecho), que es igual al número de factores ⍺que es ≤ ⍵:

  • ⍳⍵ Generar matriz numérica de 1 a ⍵

  • ⍺|⍨Calcular el ⍺módulo de cada elemento de esa matriz

  • 0= Cambie a 1 donde había un 0, y un 0 para todo lo demás.

  • +/ Suma la matriz resultante

• La función externa:

  • (⍳⍺), ⍳⍵Generar matrices de 1 a N y 1 a K

  • ∘.{...}Para cada par de elementos de las dos matrices, aplique la función. Esto proporciona una matriz de número de veces activadas, cada fila representa una puerta y cada columna representa una ronda.

  • +/Suma las columnas. Esto proporciona un conjunto de la cantidad de veces que cada puerta se alterna en todas las rondas.

  • 2|Módulo 2, así que si una puerta está abierta, es un 1; si está cerrado, es un 0.

  • (...)/⍳⍺ Finalmente, genere una matriz de 1 a N y seleccione solo aquellas en las que haya un 1 en la matriz en el paso anterior.

• /⎕ Finalmente, inserte la función entre los números de entrada.

EDITAR

{(2|+⌿0=(,↑⍳¨⍳⍵)∘.|⍳⍺)/⍳⍺}/⎕

• ,↑⍳¨⍳⍵Genere todos los "monos" (si K = 4, entonces esto es 1 0 0 0 1 2 0 0 1 2 3 0 1 2 3 4)

  • ⍳⍵Matriz de 1 a ⍵(K)

  • ⍳¨ Para cada uno de ellos, genere una matriz de 1 a ese número

  • ,↑Convierta la matriz anidada en una matriz ( ↑) y luego desentrañe en una matriz simple ( ,)

• (,↑⍳¨⍳⍵)∘.|⍳⍺ Para cada número del 1 al ⍺ (N), modifíquelo con cada mono.

• 0=Cambie a 1 donde había un 0, y un 0 para todo lo demás. Esto proporciona una matriz de conmutadores: las filas son cada mono en cada ronda, las columnas son puertas; 1 significa alternar, 0 significa no alternar.

• +⌿ Suma las filas para obtener una serie de veces que se activa cada puerta

Otras partes no cambian

EDITAR

{(≠⌿0=(,↑⍳¨⍳⍵)∘.|⍳⍺)/⍳⍺}/⎕

Use XOR reduce ( ≠⌿) en lugar de suma y mod 2 ( 2|+⌿)

GolfScript, 33 caracteres

~:k;),1>{0\{1$)%!k@-&^}+k,/}," "*

Si las puertas estuvieran numeradas comenzando con cero, ahorrarían 3 caracteres.

Ejemplos (en línea ):

> 3 3
1 2

> 23 21
1 2 4 8 9 16 18 23

Mathematica, 104 caracteres

{n,k}=FromDigits/@StringSplit@InputString[];Select[Range@n,OddQ@DivisorSum[#,If[#>k,0,k+1-#]&]&]~Row~" "

Ejemplo:

En [1]: = {n, k} = FromDigits / @ StringSplit @ InputString []; Seleccione [Range @ n, OddQ @ DivisorSum [#, If [#> k, 0, k + 1 - #] &] & ] ~ Fila ~ ""

? 23 21

Fuera [1] = 1 2 4 8 9 16 18 23

Ruby, 88

Basado en la respuesta de @ manatwork.

gets;~/ /
$><<(1..$`.to_i).select{|d|(1..k=$'.to_i).count{|m|d%m<1&&(k-m+1)%2>0}%2>0}*$&

¡Esos glotones poco fiables siempre rompen el resaltado de sintaxis!

Python 3, 97 84

Si un mono aparece en un número par de rondas, eso no cambia en absoluto. Si un mono aparece en un número par de veces, es lo mismo que en una ronda exactamente.

Por lo tanto, algunos monos pueden quedar fuera, y los otros solo tienen que cambiar de puerta una vez.

N,K=map(int,input().split())
r=set()
while K>0:r^=set(range(K,N+1,K));K-=2
print(*r)

Salida para 23 21:

1 2 4 8 9 16 18 23

R - 74

x=scan(n=2);cat(which(colSums((!sapply(1:x[1],`%%`,1:x[2]))*x[2]:1)%%2>0))

Simulación:

> x=scan(n=2);cat(which(colSums((!sapply(1:x[1],`%%`,1:x[2]))*x[2]:1)%%2>0))
1: 23 21
Read 2 items
1 2 4 8 9 16 18 23

javascript 148 127

function e(n,k){b=array(n);d=[];function a(c){for(i=0;i<n;i+=c)b[i]=!b[i];c<k&&a(c+1)}a(1);for(i in b)b[i]&&d.push(i);return d}

Aquí hay una versión legible (muy pequeña):

function e(n, k) {     //define N and K
     b = array(n); //declare all doors as closed
     d = [];     //create array later used to print results

     function a(c) {   //(recursive) function that does all the work
         for (i = 0; i < n; i += c)  //increment by c until you reach N and...
              b[i] = !b[i];  //toggle said doors
         c < k && a(c + 1)  //until you reach k, repeat with a new C (next monkey)
     }
     a(1); //start up A

     for (i in b) b[i] && d.push(i); //convert doors to a list of numbers
     return d //NO, i refuse to explain this....
}   //closes function to avoid annoying errors

Violín DEMO

Debo tener en cuenta que comienza a contar desde 0 (técnicamente un error off-by-one)

JavaScript, 153

(function(g){o=[],f=g[0];for(;i<g[1];i++)for(n=0;n<=i;n++)for(_=n;_<f;_+=n+1)o[_]=!o[_];for(;f--;)o[f]&&(l=f+1+s+l);alert(l)})(prompt().split(i=l=s=' '))

Salida para N = 23, K = 21:

1 2 4 8 9 16 18 23  

Probado en Chrome, pero no utiliza ninguna característica nueva de ECMAScript, por lo que debería funcionar en cualquier navegador.

Sé que nunca ganaré contra las otras entradas y que @tryingToGetProgrammingStrainght ya envió una entrada en JavaScript, pero no estaba obteniendo los mismos resultados para N = 23, K = 21 como todos los demás obtenían eso, así que pensé que probaría mi propia versión.

Editar : fuente anotada (al revisar esto nuevamente, vi lugares para guardar otros 3 caracteres, por lo que probablemente aún se pueda mejorar ...)

(function(g) {
    // initialise variables, set f to N
    o = [], f = g[0];

    // round counter
    // since ++' ' == 1 we can use the same variable set in args
    for (; i < g[1]; i++)
        // monkey counter, needs to be reset each round
        for (n = 0 ; n <= i; n++)
            // iterate to N and flip each Kth door
            for (_ = n; _ < f; _ += n + 1)
                // flip the bits (as undef is falsy, we don't need to initialise)
                // o[_] = !~~o[_]|0; // flips undef to 1
                o[_] = !o[_]; // but booleans are fine
    // decrement f to 0, so we don't need an additional counter
    for (;f--;)
        // build string in reverse order
        o[f] && (l = f + 1 + s + l); // l = (f + 1) + ' ' + l
    alert(l)
    // return l // use with test
// get input from user and store ' ' in variable for use later
})(prompt().split(i = l = s = ' '))
// })('23 21'.split(i = l = s = ' ')) // lazy...

// == '1 2 4 8 9 16 18 23  '; // test

Ruby - 65 caracteres

(1..n).each{|d|
t=0
(1..k).each{|m|t+=n-m+1 if d%m==0}
p d if t%2>0}

n = 23, k = 21 # => 1 2 4 8 9 16 18 23 

Aquí está el cálculo, en pseudocódigo:

• Sea s (d) el número de veces que se toca la puerta d después de k rondas.
• s (d) = suma (m = 1..m = k) (d% m == 0? (n-m + 1): 0)
• la puerta d está abierta después de k rondas si s (d)% 2 = 1 (o> 0)

Si no está convencido de que la expresión para s (d) es correcta, mírela de esta manera:

• Sea s (d, r) el número de veces que se toca la puerta d después de r rondas.
• s (d, k) - s (d, k-1) = suma (m = 1, .., m = k) (d% m == 0? 1: 0)
• s (d, k-1) - s (d, k-2) = suma (m = 1, .., m = (k-1)) (d% m == 0? 1: 0)
• ...
• s (d, 2) - s (d, 1) = d% 2 == 0? 1: 0
• s (d, 1) = 1
• suma ambos lados para obtener la expresión anterior para s (d), que es igual a s (d, k)

PowerShell: 132

Código de golf:

$n,$k=(read-host)-split' ';0|sv($d=1..$n);1..$k|%{1..$_|%{$m=$_;$d|?{!($_%$m)}|%{sv $_ (!(gv $_ -Va))}}};($d|?{(gv $_ -Va)})-join' '

Código no comentado y comentado:

# Get number of doors and monkeys from user as space-delimited string.
# Store number of doors as $n, number of monkeys as $k.
$n,$k=(read-host)-split' ';

# Store a list of doors in $d.
# Create each door as a variable set to zero.
0|sv($d=1..$n);

# Begin a loop for each round.
1..$k|%{

    # Begin a loop for each monkey in the current round.
    1..$_|%{

        # Store the current monkey's ID in $m.
        $m=$_;

        # Select only the doors which are evenly divisible by $m.
        # Pass the doors to a loop.
        $d|?{!($_%$m)}|%{

            # Toggle the selected doors.
            sv $_ (!(gv $_ -Va))
        }
    }
};

# Select the currently open doors.
# Output them as a space-delimited string.
($d|?{(gv $_ -Va)})-join' '

# Variables cleanup - don't include in golfed code.
$d|%{rv $_};rv n;rv d;rv k;rv m;

# NOTE TO SELF - Output for N=23 K=21 should be:
# 1 2 4 8 9 16 18 23

Powershell, 66 bytes

Basado en la respuesta de Cary Swoveland .

param($n,$k)1..$n|?{$d=$_
(1..$k|?{($n-$_+1)*!($d%$_)%2}).Count%2}

Script de prueba:

$f = {

param($n,$k)1..$n|?{$d=$_
(1..$k|?{($n-$_+1)*!($d%$_)%2}).Count%2}

}

@(
    ,(3, 3   , 1,2)
    ,(23, 21 , 1, 2, 4, 8, 9, 16, 18, 23)
) | % {
    $n,$k,$expected = $_
    $result = &$f $n $k
    "$("$result"-eq"$expected"): $result"
}

Salida:

True: 1 2
True: 1 2 4 8 9 16 18 23