Introducción

Dada esta visualización de un campo de juego:

(0,0)
+----------------------+(map_width, 0)
|           A          |
|-----+-----------+----|
|  D  |     W     | B  |
|-----+-----------+----|
|           C          |
+----------------------+(map_width, map_height)
(0, map_height)

El mapa completo en el que se juega es el rectángulo con las coordenadas de las esquinas (0,0) y (map_width, map_height). Los puntos elegibles para generar enemigos es la Unión

El reto

Escriba el código que devuelve un punto aleatorio (x, y) que se garantiza que está dentro de S. Su código no puede introducir ningún sesgo adicional, lo que significa que la probabilidad de cada coordenada se distribuye uniformemente dado el supuesto de que su elección de generar aleatoriedad (por ejemplo, función | biblioteca | dev / urandom) es imparcial.

¡Las soluciones más cortas en bytes ganan!

Entrada

Se le dará un total de 6 variables de entrada de enteros positivos en orden: map_width, map_height, W_top_left_x, W_top_left_y, W_width, W_height . Puede suponer que el área de superficie (calculada) de todas las regiones (A, B, C, D, W) es cada una> 10, por lo que no hay espacios / regiones vacíos.

Entrada de ejemplo: 1000, 1000, 100, 100, 600, 400

La entrada tiene que contener los 6 valores descritos anteriormente, pero se puede pasar como un menor número de argumentos y en cualquier orden. Por ejemplo, pasar (map_width, map_height)como python tuple está permitido. Lo que no está permitido, por supuesto, son parámetros calculados como el punto inferior derecho de la W.

Salida

2 enteros generados aleatoriamente (x, y) donde

O

lo que significa que al menos una de las expresiones lógicas anteriores tiene que ser verdadera.

Ejemplos

Input                                    Output(valid random samples)

1000 1000 100 100 600 400                10 10
1000 1000 100 100 600 400                800 550
1000 1000 100 100 600 400                800 10
1000 1000 100 100 600 400                10 550

Para obtener detalles y limitaciones para la entrada / salida, consulte las reglas predeterminadas de entrada / salida

Python 2 , 114 106 102 101 bytes

lambda w,h,X,Y,W,H:choice([(i%w,i/w)for i in range(w*h)if(W>i%w-X>-1<i/w-Y<H)<1])
from random import*

Pruébalo en línea!

R , 89 73 bytes

function(w,h,K,D,`*`=sample){while(all((o<-c(0:w*1,0:h*1))<=K+D&o>K))0
o}

Pruébalo en línea!

Toma entrada como width,height,c(X,Y),c(W,H).

Muestras de $[0,w]\times[0,h]$ uniformemente hasta que encuentre un punto fuera del rectángulo interno.

05AB1E , 23 21 20 18 17 bytes

L`â<ʒ²³+‹y²@«P≠}Ω

La entrada está en el formato [map_width, map_height], [W_top_left_x, W_top_left_y], [W_width, W_height].

Gracias a @Grimy por -1 byte, y también por darme cuenta de que introduje un error después de mi última edición.

Pruébelo en línea , envíe 10 salidas posibles al mismo tiempo o verifique todas las coordenadas posibles . (Nota menor: he disminuido la entrada de ejemplo en un factor 10, porque el filtro y la selección aleatoria incorporada son bastante lentos para las listas grandes).

Explicación:

Las entradas map_width, map_height, [W_top_left_x, W_top_left_y], [W_width, W_height]se denominan a [Wm, Hm], [x, y], [w, h]continuación:

L          # Convert the values of the first (implicit) input to an inner list in
           # the range [1, n]: [[1,2,3,...,Wm],[1,2,3,....,Hm]]
 `         # Push both inner lists separated to the stack
  â        # Get the cartesian product of both lists, creating each possible pair
   <       # Decrease each pair by 1 to make it 0-based
           # (We now have: [[0,0],[0,1],[0,2],...,[Wm,Hm-2],[Wm,Hm-1],[Wm,Hm]])
    ʒ      # Filter this list of coordinates [Xr, Yr] by:
     ²³+   #  Add the next two inputs together: [x+w, y+h]
        ‹  #  Check for both that they're lower than the coordinate: [Xr<x+w, Yr<y+h]
     y     #  Push the coordinate again: [Xr, Yr]
      ²    #  Push the second input again: [x, y]
       @   #  Check for both that the coordinate is larger than or equal to this given 
           #  input: [Xr>=x, Yr>=y] (the w,h in the input are ignored)
     «     #  Merge it with the checks we did earlier: [Xr<x+w, Yr<y+h, Xr>=x, Yr>=y]
      P≠   #  And check if any of the four is falsey (by taking the product and !=1,
           #  or alternatively `ß_`: minimum == 0)
    }Ω     # After the filter: pick a random coordinate
           # (which is output implicitly as result)

C # (compilador interactivo de Visual C #) , 110 bytes

(a,b,c,d,e,f)=>{int g=c,h=d;for(var z=new Random();g>=c&g<e+c|h>=d&h<f+d;h=z.Next(b))g=z.Next(a);return(g,h);}

Pruébalo en línea!

PowerShell , 85 73 bytes

^{-12 bytes gracias a mazzy}

param($a,$b,$x,$y,$w,$h)$a,$b|%{0..--$x+($x+$w+2)..$_|random
$x,$w=$y,$h}

Pruébalo en línea!

Buena respuesta simple que improvisa una matriz hecha del rango de valores para cada dimensión y luego elige uno al azar para xy y. Se las arregla para reutilizar la mayor parte del código por primera transformación x, a continuación, sobrescribir $xcon $yy funcionando de nuevo.

Julia , 76 71 67 bytes

f(w,h,a,b,c,d)=rand(setdiff((0:w-1)'.=>0:h-1,(a:a+c-1)'.=>b:b+d-1))

Pruébalo en línea!

Jalea , 11 bytes

p/’$€+2¦ḟ/X

Pruébalo en línea!

Un enlace diádico que toma dos argumentos, [map_width, map_height], [W_width, W_height] y W_left, W_topy devuelve un punto seleccionado al azar el cumplimiento de los requisitos.

Explicación

   $€       | For each of member of the left argument, do the following as a monad:
p/          | - Reduce using Cartesian product (will generate [1,1],[1,2],... up to the width and height of each of the rectangles)
  ’         | - Decrease by 1 (because we want zero-indexing)
     +2¦    | Add the right argument to the second element of the resulting list
        ḟ/  | Reduce by filtering members of the second list from the first
          X | Select a random element

Python 2 , 100 bytes

La entrada debe estar en forma de ((map_width, W_top_left_x, W_width),(map_height, W_top_left_y, W_height))

La salida se da en la forma: [[x],[y]]

lambda C:[c(s(r(i[0]))-s(r(i[1],i[1]+i[2])),1)for i in C]
from random import*;c=sample;r=range;s=set

Pruébalo en línea!

Salidas aleatorias obtenidas de la entrada de ejemplo:

[[72], [940]]
[[45], [591]]
[[59], [795]]
[[860], [856]]
[[830], [770]]
[[829], [790]]
[[995], [922]]
[[23], [943]]
[[761], [874]]
[[816], [923]]

Java (OpenJDK 8) , 100 bytes

W->H->r->{int x=0,y=0;for(;r.contains(x+=W*Math.random(),y+=H*Math.random());x=y=0);return x+","+y;}

Pruébalo en línea!

Usos java.awt.Rectanglecomo titular de algunos de los parámetros. Naturalmente, esos usan intcampos, y no floato double.

Wolfram Language (Mathematica) , 84 68 60 bytes

RandomChoice[g=Join@@List~Array~##&;#~g~0~Complement~g@##2]&

Pruébalo en línea!

Tomar entradas como {map_width, map_height}, {W_width, W_height}, {W_top_left_x, W_top_left_y}.

Carbón , 55 43 bytes

ＮθＮηＦＥ²Ｎ⊞υ⟦ιＮ⟧Ｉ‽ΦＥ×θη⟦﹪ιθ÷ιθ⟧⊙υ∨‹§ιμ§λ⁰¬‹§ιμΣλ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＮθＮη

Ingrese el tamaño del mapa. (Si fueran los últimos, podría ingresar la altura en línea para un ahorro de 1 byte).

ＦＥ²Ｎ⊞υ⟦ιＮ⟧

Ingrese el rectángulo interno. (Si pudiera ingresar en el orden left, width, top, height, podría usarlo Ｆ²⊞υＥ²Ｎpara un ahorro de 3 bytes).

Ｅ×θη⟦﹪ιθ÷ιθ⟧

Genere una lista de todas las coordenadas en el campo.

Φ...⊙υ∨‹§ιμ§λ⁰¬‹§ιμΣλ

Filtre las entradas donde ambas coordenadas se encuentran dentro del rectángulo.

Ｉ‽...

Imprima un elemento aleatorio de los que quedan.

Perl 5 -ap , 84 bytes

sub c{($c=0|rand((pop)+($l=pop)-"@_"))<$l?$c:$c+"@_"-$l}say c@F[4,2,0];$_=c@F[5,3,1]

Pruébalo en línea!

Scala , 172 bytes

Aleatoriedad? Gotcha

(a:Int,b:Int,c:Int,d:Int,e:Int,f:Int)=>{var r=new scala.util.Random
var z=(0,0)
do{z=(r.nextInt(a),r.nextInt(b))}while((c to e+c contains z._1)|(d to e+d contains z._2))
z}

Una implementación divertida que se me ocurre.
Cómo funciona : genera un par aleatorio en el mapa. Si está en el rectángulo interno, intente nuevamente.
Pruébalo en línea!

J , ^{54 47 45} 39 bytes

(0?@{[)^:((-1&{)~(<*/@,0<:[)2{[)^:_{~&1

Pruébalo en línea!

Tome la entrada como una cuadrícula de 3 x 2 como:

grid_height  grid_width
inner_top    inner_left
inner_height inner_width

• Elija un punto aleatorio en toda la cuadrícula: 0?@{[
• Desplácese hacia la izquierda y hacia abajo por el punto superior izquierdo del rectángulo interior: (-1&{)~
• Regrese al paso 1 si el lugar elegido está dentro (<*/@,0<:[)del rectángulo interior desplazado de manera similar2{[ . De lo contrario, devuelva el punto aleatorio original no desplazado.
• Siembre todo el proceso con un punto que sabemos que no es válido, es decir, el punto superior izquierdo del rectángulo interior, definido por los elementos 2 y 3 de la lista de entrada: {~&1

Otro enfoque, 45 bytes

{.#:i.@{.(?@#{])@-.&,([:<@;&i./{:){1&{|.i.@{.

Pruébalo en línea!

Este es conceptualmente más simple y no se molesta con el bucle. En su lugar, construimos una matriz de todos los números 0 a (wxh), la desplazamos por el punto de inicio interno, tomamos solo los puntos en la subcuadrícula (0, 0) a (interior w, innner h), los eliminamos del total cuadrícula después de aplanar ambos, elija uno al azar del resto y convierta el entero de nuevo en un punto usando divmod<.@% , |~