Constrained random points on a circle: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Perl}}: added version with plain-text output)
 
(40 intermediate revisions by 24 users not shown)
Line 11: Line 11:
2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.
2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.
<br><br>
<br><br>

=={{header|11l}}==
{{trans|Julia}}
<syntaxhighlight lang="11l">F print_circle(lo, hi, ndots)
V canvas = [[0B] * (2*hi+1)] * (2*hi+1)
V i = 0
L i < ndots
V x = random:(-hi..hi)
V y = random:(-hi..hi)
I x^2 + y^2 C lo^2 .. hi^2
canvas[x + hi][y + hi] = 1B
i++

L(i) 0 .. 2*hi
print(canvas[i].map(j -> I j {‘♦ ’} E ‘ ’).join(‘’))
print_circle(10, 15, 100)</syntaxhighlight>

=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC DrawCircle(BYTE rmin,rmax,max,x0,y0)
BYTE count,limit
INT x,y,r2,rmin2,rmax2

limit=rmax*2+1
rmin2=rmin*rmin
rmax2=rmax*rmax
count=0
WHILE count<max
DO
x=Rand(limit) y=Rand(limit)
x==-rmax y==-rmax
r2=x*x+y*y
IF r2>=rmin2 AND r2<=rmax2 THEN
Plot(x+x0,y+y0)
count==+1
FI
OD
RETURN

PROC Main()
BYTE CH=$02FC,COLOR0=$02C4

Graphics(5+16)
Color=1
COLOR0=$0C

DrawCircle(10,15,100,40,24)

DO UNTIL CH#$FF OD
CH=$FF
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Constrained_random_points_on_a_circle.png Screenshot from Atari 8-bit computer]


=={{header|Ada}}==
=={{header|Ada}}==


<lang Ada>with Ada.Text_IO;
<syntaxhighlight lang="ada">with Ada.Text_IO;
with Ada.Numerics.Discrete_Random;
with Ada.Numerics.Discrete_Random;
procedure Circle is
procedure Circle is
Line 107: Line 160:
Ada.Text_IO.Put_Line ("Chosen from precalculated:");
Ada.Text_IO.Put_Line ("Chosen from precalculated:");
Print_Points (My_Circle_Precalculated);
Print_Points (My_Circle_Precalculated);
end Circle;</lang>
end Circle;</syntaxhighlight>


Output:
Output:
Line 182: Line 235:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to use of '''format'''[ted] ''transput''}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to use of '''format'''[ted] ''transput''}}
<lang algol68>PROC clrscr = VOID:
<syntaxhighlight lang="algol68">PROC clrscr = VOID:
printf(($g"[2J"$,REPR 27)); # ansi.sys #
printf(($g"[2J"$,REPR 27)); # ansi.sys #


Line 253: Line 306:
gotoxy(2*radius+1, 2*radius+1);
gotoxy(2*radius+1, 2*radius+1);
newline(stand in)
newline(stand in)
)</lang>
)</syntaxhighlight>
Sample output:
Sample output:
<pre>
<pre>
Line 290: Line 343:
=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==
Requires the GDI+ standard library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238<br /> Works with individual pixels.
Requires the GDI+ standard library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238<br /> Works with individual pixels.
[[File:Ahk_fuzzycircle.png|thumb|right]]<lang AHK>z=100 ; x = x-coord; y = y-coord; z = count; pBitmap = a pointer to the image; f = filename
[[File:Ahk_fuzzycircle.png|thumb|right]]<syntaxhighlight lang="ahk">z=100 ; x = x-coord; y = y-coord; z = count; pBitmap = a pointer to the image; f = filename


pToken := Gdip_Startup()
pToken := Gdip_Startup()
Line 307: Line 360:


Gdip_DisposeImage(pBitmap)
Gdip_DisposeImage(pBitmap)
Gdip_Shutdown(pToken)</lang>
Gdip_Shutdown(pToken)</syntaxhighlight>

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

==={{header|BASIC256}}===
{{trans|PureBasic}}
<syntaxhighlight lang="freebasic">graphsize 31, 31

for i = 1 to 100
do
x = int(rand * 30) - 15
y = int(rand * 30) - 15
r = sqr(x*x + y*y)
until 10 <= r and r <= 15
color rgb(255, 0, 0)
plot(x+15, y+15)
next i
end</syntaxhighlight>


==={{header|BBC BASIC}}===
==={{header|BBC BASIC}}===
<lang bbcbasic> MODE 8
<syntaxhighlight lang="bbcbasic"> MODE 8
ORIGIN 640, 512
ORIGIN 640, 512
FOR i% = 1 TO 1000
FOR i% = 1 TO 1000
Line 318: Line 387:
r = SQR(x%^2 + y%^2)
r = SQR(x%^2 + y%^2)
IF r >= 10 IF r <= 15 PLOT x%*2, y%*2
IF r >= 10 IF r <= 15 PLOT x%*2, y%*2
NEXT</lang>
NEXT</syntaxhighlight>


==={{header|FreeBASIC}}===
==={{header|FreeBASIC}}===
Pre calculate and plot 100 points to the console
Pre calculate and plot 100 points to the console
<lang FreeBASIC>'Free Basic version .9
<syntaxhighlight lang="freebasic">'Free Basic version .9


#define Intrange(f,l) int(Rnd*(((l)+1)-(f))+(f))
#define Intrange(f,l) int(Rnd*(((l)+1)-(f))+(f))
Line 382: Line 451:
print "done"
print "done"
Sleep
Sleep
</syntaxhighlight>
</lang>
Console output:
Console output:
<pre>
<pre>
Line 409: Line 478:


</pre>
</pre>

==={{header|Yabasic}}===
{{trans|PureBasic}}
<syntaxhighlight lang="yabasic">open window 100, 100
clear window

for i = 1 to 100
repeat
x = ran(30)-15
y = ran(30)-15
r = sqr(x*x + y*y)
until 10 <= r and r <= 15
color 255, 0, 0
dot x+15, y+15
next i
end</syntaxhighlight>


=={{header|C}}==
=={{header|C}}==
<lang C>#include <stdio.h>
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>


Line 445: Line 530:


return 0;
return 0;
}</lang>Output<lang> . . . .
}</syntaxhighlight>Output<syntaxhighlight lang="text"> . . . .
. . .
. . .
. . . .
. . . .
Line 474: Line 559:
. . . .
. . . .
.
.
. </lang>
. </syntaxhighlight>

=={{header|C sharp|C#}}==

<syntaxhighlight lang="csharp">using System;
using System.Diagnostics;
using System.Drawing;

namespace RosettaConstrainedRandomCircle
{
class Program
{
static void Main(string[] args)
{
var points = new Point[404];
int i = 0;
for (int y = -15; y <= 15; y++)
for (int x = -15; x <= 15 && i < 404; x++)
{
var c = Math.Sqrt(x * x + y * y);
if (10 <= c && c <= 15)
{
points[i++] = new Point(x, y);
}
}

var bm = new Bitmap(600, 600);
var g = Graphics.FromImage(bm);
var brush = new SolidBrush(Color.Magenta);

var r = new System.Random();
for (int count = 0; count < 100; count++)
{
var p = points[r.Next(404)];
g.FillEllipse(brush, new Rectangle(290 + 19 * p.X, 290 + 19 * p.Y, 10, 10));
}
const string filename = "Constrained Random Circle.png";
bm.Save(filename);
Process.Start(filename);
}
}
}</syntaxhighlight>


=={{header|C++}}==
=={{header|C++}}==
[[File:constrained_rnd_pts_on_circle.png]]
[[File:constrained_rnd_pts_on_circle.png]]
<lang cpp>
<syntaxhighlight lang="cpp">
#include <windows.h>
#include <windows.h>
#include <list>
#include <list>
Line 544: Line 670:
}
}
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
</syntaxhighlight>
</lang>

=={{header|C sharp|C#}}==

<lang csharp>using System;
using System.Diagnostics;
using System.Drawing;

namespace RosettaConstrainedRandomCircle
{
class Program
{
static void Main(string[] args)
{
var points = new Point[404];
int i = 0;
for (int y = -15; y <= 15; y++)
for (int x = -15; x <= 15 && i < 404; x++)
{
var c = Math.Sqrt(x * x + y * y);
if (10 <= c && c <= 15)
{
points[i++] = new Point(x, y);
}
}

var bm = new Bitmap(600, 600);
var g = Graphics.FromImage(bm);
var brush = new SolidBrush(Color.Magenta);

var r = new System.Random();
for (int count = 0; count < 100; count++)
{
var p = points[r.Next(403)];
g.FillEllipse(brush, new Rectangle(290 + 19 * p.X, 290 + 19 * p.Y, 10, 10));
}
const string filename = "Constrained Random Circle.png";
bm.Save(filename);
Process.Start(filename);
}
}
}</lang>


=={{header|Clojure}}==
=={{header|Clojure}}==
<lang Clojure>(ns rosettacode.circle-random-points
<syntaxhighlight lang="clojure">(ns rosettacode.circle-random-points
(:import [java.awt Color Graphics Dimension]
(:import [java.awt Color Graphics Dimension]
[javax.swing JFrame JPanel]))
[javax.swing JFrame JPanel]))
Line 606: Line 691:
(.setDefaultCloseOperation JFrame/DISPOSE_ON_CLOSE)
(.setDefaultCloseOperation JFrame/DISPOSE_ON_CLOSE)
.pack
.pack
.show))</lang>
.show))</syntaxhighlight>


=={{header|COBOL}}==
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
<lang COBOL>
identification division.
identification division.
program-id. circle.
program-id. circle.
Line 723: Line 808:


end program circle.
end program circle.
</syntaxhighlight>
</lang>
<pre>
<pre>


Line 759: Line 844:


=={{header|CoffeeScript}}==
=={{header|CoffeeScript}}==
<lang coffeescript>
<syntaxhighlight lang="coffeescript">
NUM_POINTS = 100
NUM_POINTS = 100
MIN_R = 10
MIN_R = 10
Line 787: Line 872:
plot random_circle_points()
plot random_circle_points()
</syntaxhighlight>
</lang>


The output may be a bit distorted, since even monospace fonts take more vertical space per character than horizontal space.
The output may be a bit distorted, since even monospace fonts take more vertical space per character than horizontal space.
<lang>
<syntaxhighlight lang="text">
> coffee foo.coffee
> coffee foo.coffee
Line 821: Line 906:
* * * * *
* * * * *
* * *
* * *
</syntaxhighlight>
</lang>


=={{header|Common Lisp}}==
=={{header|Common Lisp}}==
<lang lisp>(flet ((good-p (x y) (<= 100 (+ (* x x) (* y y)) 255)))
<syntaxhighlight lang="lisp">(flet ((good-p (x y) (<= 100 (+ (* x x) (* y y)) 255)))
(loop with x with y with cnt = 0
(loop with x with y with cnt = 0
with scr = (loop repeat 31 collect (loop repeat 31 collect " "))
with scr = (loop repeat 31 collect (loop repeat 31 collect " "))
Line 832: Line 917:
(setf (elt (elt scr y) x) "@ ")
(setf (elt (elt scr y) x) "@ ")
(incf cnt))
(incf cnt))
finally (mapc #'(lambda (row) (format t "~{~a~^~}~%" row)) scr)))</lang>
finally (mapc #'(lambda (row) (format t "~{~a~^~}~%" row)) scr)))</syntaxhighlight>


=={{header|D}}==
=={{header|D}}==
This uses std.complex because D built-in complex numbers will be deprecated.
This uses std.complex because D built-in complex numbers will be deprecated.
<lang d>import std.stdio, std.random, std.math, std.complex;
<syntaxhighlight lang="d">import std.stdio, std.random, std.math, std.complex;


void main() {
void main() {
Line 851: Line 936:


writefln("%-(%s\n%)", table);
writefln("%-(%s\n%)", table);
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 883: Line 968:
* * * *
* * * *
** </pre>
** </pre>
=={{header|Delphi}}==
{{libheader| Winapi.Windows}}
{{libheader| System.SysUtils}}
{{libheader| Vcl.Graphics}}
{{libheader| Vcl.Controls}}
{{libheader| Vcl.Forms}}
{{libheader| Vcl.ExtCtrls}}
{{Trans|C#}}
<syntaxhighlight lang="delphi">
unit Main;


interface

uses
Winapi.Windows, System.SysUtils, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.ExtCtrls;

type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
procedure FormPaint(Sender: TObject);
end;

var
Form1: TForm1;
Points: TArray<TPoint>;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
ClientHeight := 600;
ClientWidth := 600;
end;

procedure TForm1.FormPaint(Sender: TObject);
var
i: integer;
p: TPoint;
index: integer;
begin
SetLength(Points, 404);
i := 0;
for var y := -15 to 15 do
for var x := -15 to 15 do
begin
if i >= 404 then
Break;
var c := Sqrt(x * x + y * y);
if (10 <= c) and (c <= 15) then
begin
inc(i);
points[i] := TPoint.Create(x, y);
end;
end;
var bm := TBitmap.create;
bm.SetSize(600, 600);
with bm.Canvas do
begin
Pen.Color := clRed;
Brush.Color := clRed;
Brush.Style := bsSolid;
Randomize;

for var count := 0 to 99 do
begin
repeat
index := Random(404);
p := points[index];
until (not p.IsZero);
points[index] := TPoint.Zero;

var cx := 290 + 19 * p.X;
var cy := 290 + 19 * p.Y;
Ellipse(cx - 5, cy - 5, cx + 5, cy + 5);
end;
end;
Canvas.Draw(0, 0, bm);
bm.Free;
end;
end.</syntaxhighlight>

=={{header|EasyLang}}==
[https://easylang.dev/show/#cod=bY0xDsIwFEP3nOKN0Igqv6hMzWGqtohIJYhPBMntUShsbLafZb8uYV2YYmJAnDNAxqNjnENMHIUDcqpx+R8rnsddE7tMQ8ZSaCj7ysIZcQweZYwzWqX0lcDn03rka6+350LvsNSdbpN1qvv1g07rsvVb05o3 Run it]

<syntaxhighlight>
while cnt < 100
x = randint 31 - 16
y = randint 31 - 16
r = sqrt (x * x + y * y)
if 10 <= r and r <= 15
cnt += 1
move 50 + x * 2 50 + y * 2
circle 1
.
.
</syntaxhighlight>


=={{header|EchoLisp}}==
=={{header|EchoLisp}}==
Using the '''plot''' library. For a greater visual appeal, points are plotted as circles of random radius and color. The resulting image is at [http://www.echolalie.org/echolisp/images/circle.png].
Using the '''plot''' library. For a greater visual appeal, points are plotted as circles of random radius and color. The resulting image is at [http://www.echolalie.org/echolisp/images/circle.png].
<lang scheme>
<syntaxhighlight lang="scheme">
(lib 'math)
(lib 'math)
(lib 'plot)
(lib 'plot)
Line 904: Line 1,086:
(plot-circle x y (random radius)))
(plot-circle x y (random radius)))
(plot-edit))
(plot-edit))
</syntaxhighlight>
</lang>


=={{header|Elixir}}==
=={{header|Elixir}}==
===Algorithm 1: Generate random pairs===
===Algorithm 1: Generate random pairs===
{{works with|Elixir|1.1}}
{{works with|Elixir|1.1}}
<lang elixir>defmodule Random do
<syntaxhighlight lang="elixir">defmodule Random do
defp generate_point(0, _, _, set), do: set
defp generate_point(0, _, _, set), do: set
defp generate_point(n, f, condition, set) do
defp generate_point(n, f, condition, set) do
Line 931: Line 1,113:
end
end


Random.circle</lang>
Random.circle</syntaxhighlight>


'''Example output:'''
'''Example output:'''
Line 969: Line 1,151:
{{trans|Ruby}}
{{trans|Ruby}}
{{works with|Elixir|1.2}}
{{works with|Elixir|1.2}}
<lang elixir>defmodule Constrain do
<syntaxhighlight lang="elixir">defmodule Constrain do
def circle do
def circle do
range = -15..15
range = -15..15
Line 982: Line 1,164:
end
end


Constrain.circle</lang>
Constrain.circle</syntaxhighlight>


{{out|Example}}
{{out|Example}}
Line 1,023: Line 1,205:
{{works with|Euphoria|4.0.3, 4.0.0 or later}}
{{works with|Euphoria|4.0.3, 4.0.0 or later}}
This program generates the set of 404 possible points in the ring. It randomly chooses 100 pairs from the set. The 100 pairs are a subset of that set because duplicates are discarded.
This program generates the set of 404 possible points in the ring. It randomly chooses 100 pairs from the set. The 100 pairs are a subset of that set because duplicates are discarded.
<lang euphoria>include std/console.e
<syntaxhighlight lang="euphoria">include std/console.e


sequence validpoints = {}
sequence validpoints = {}
Line 1,087: Line 1,269:
printf(1, "\nNumber of discarded coordinate pairs : %d", length(discardedpoints) )
printf(1, "\nNumber of discarded coordinate pairs : %d", length(discardedpoints) )
printf(1, "\nNumber of randomly picked coordinate pairs : %d\n", length(rand100points) )
printf(1, "\nNumber of randomly picked coordinate pairs : %d\n", length(rand100points) )
any_key()</lang>
any_key()</syntaxhighlight>
Output:
Output:
<pre>
<pre>
Line 1,125: Line 1,307:
Number of discarded coordinate pairs : 557
Number of discarded coordinate pairs : 557
Number of randomly picked coordinate pairs : 100
Number of randomly picked coordinate pairs : 100
Press Any Key to continue...</pre>Extra EuSDL code : <lang euphoria>
Press Any Key to continue...</pre>Extra EuSDL code : <syntaxhighlight lang="euphoria">
for i = 1 to length(validpoints) do --simple each pixel output to screen surface
for i = 1 to length(validpoints) do --simple each pixel output to screen surface
dummy=pixelColor(surface,validpoints[i][1]+18,validpoints[i][2]+18,#AA0202FF) --i is index number of each subsequence 'chunk'.
dummy=pixelColor(surface,validpoints[i][1]+18,validpoints[i][2]+18,#AA0202FF) --i is index number of each subsequence 'chunk'.
Line 1,144: Line 1,326:
dummy=stringColor(surface,0,83,sprintf("Number of discarded coordinate pairs : %d", length(discardedpoints) ),#0202AAFF)
dummy=stringColor(surface,0,83,sprintf("Number of discarded coordinate pairs : %d", length(discardedpoints) ),#0202AAFF)


dummy=stringColor(surface,0,93,sprintf("Number of randomly picked coordinate pairs : %d", length(rand100points) ),#02AA02FF)</lang>SDL Output :
dummy=stringColor(surface,0,93,sprintf("Number of randomly picked coordinate pairs : %d", length(rand100points) ),#02AA02FF)</syntaxhighlight>SDL Output :
[[File:Fuzzy_circle_Euphoria.png]] That particular program used a -16 to +16 square area, so more was discarded.
[[File:Fuzzy_circle_Euphoria.png]] That particular program used a -16 to +16 square area, so more was discarded.


Line 1,150: Line 1,332:
This version uses method 1 from the task description and just calculates 100 suitable points to plot.
This version uses method 1 from the task description and just calculates 100 suitable points to plot.
The INTERACTIVE bit just permits this code in a .fsx file to be run with the interactive interpreter or compiled to an exe.
The INTERACTIVE bit just permits this code in a .fsx file to be run with the interactive interpreter or compiled to an exe.
<lang fsharp>module CirclePoints =
<syntaxhighlight lang="fsharp">module CirclePoints =
let main args =
let main args =
let rnd = new System.Random()
let rnd = new System.Random()
Line 1,173: Line 1,355:
[<EntryPoint>]
[<EntryPoint>]
let main args = CirclePoints.main args
let main args = CirclePoints.main args
#endif</lang>
#endif</syntaxhighlight>
An example of the output:
An example of the output:
<pre>
<pre>
Line 1,206: Line 1,388:
o o</pre>
o o</pre>


=={{header|Factor}}==
{{works with|Factor|0.99 2020-01-23}}
<syntaxhighlight lang="factor">USING: io kernel math.matrices math.order math.ranges
math.statistics math.vectors random sequences strings ;

CHAR: X -15 15 [a,b] dup cartesian-product concat
[ sum-of-squares 100 225 between? ] filter 100 sample
[ 15 v+n ] map 31 31 32 <matrix> [ matrix-set-nths ] keep
[ >string print ] each</syntaxhighlight>
{{out}}
<pre>
XX X X
XX XXX X X X
X XXX
XX X X
X X XX X X X
X X X
X X X XXXX
X X X XXX
XXX
X
XXX XX
X XX
X
X X
X
X X
X
XXX X
X X
XX X
XX X
XX X X
X X
XXX X X
X X XX XX
X X XX X XX
X X
</pre>


=={{header|Falcon}}==
=={{header|Falcon}}==
<lang falcon>
<syntaxhighlight lang="falcon">
// Generate points in [min,max]^2 with constraint
// Generate points in [min,max]^2 with constraint
function random_point (min, max, constraint)
function random_point (min, max, constraint)
Line 1,226: Line 1,449:
>
>
end
end
</syntaxhighlight>
</lang>
Example output:
Example output:
<pre>
<pre>
Line 1,257: Line 1,480:
x x
x x
x x x x
x x x x
</pre>

=={{header|Forth}}==
{{works with|gforth|0.7.3}}
<br>
<syntaxhighlight lang=forth>#! /usr/bin/gforth
\ Constrained random points on a circle

require random.fs

\ initialize the random number generator with a time-dependent seed
utime drop seed !

\ generates a random integer in [-15,15]
: random-coord ( -- n )
31 random 15 -
;

\ generates a random point on the constrained circle
: random-point ( -- x y )
0 0
BEGIN
2drop
random-coord random-coord
2dup dup * swap dup * +
dup 100 >= swap 225 <= and
UNTIL
;

31 31 * CONSTANT SIZE
CREATE GRID SIZE cells allot GRID SIZE cells erase

\ get the address of point (x,y)
: point-addr ( x y -- addr )
15 + 31 * + 15 + cells GRID +
;

\ generate 100 random points and mark them in the grid
: gen-points ( -- )
100 0 ?DO
true random-point point-addr !
LOOP
;

\ prints the grid
: print-grid ( -- )
16 -15 ?DO
16 -15 ?DO
i j point-addr @
IF
42
ELSE
32
THEN
emit
LOOP
cr
LOOP
;

gen-points print-grid
bye</syntaxhighlight>

{{out}}
<pre>
*
*****
* ** **
* * * *
* **
***
* ** *
* *
* * **
*
*
* *
* * *
*
**
* *
* * * *
*
* **
* ** * **
* * *
* * ** *
** * * * * *
*
*** * *
** **
* *
</pre>
</pre>


=={{header|Fortran}}==
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
{{works with|Fortran|90 and later}}
<lang fortran>program Constrained_Points
<syntaxhighlight lang="fortran">program Constrained_Points
implicit none
implicit none
Line 1,336: Line 1,654:
end do
end do
end program</lang>
end program</syntaxhighlight>
Output
Output
<pre>
<pre>
Line 1,368: Line 1,686:
* * ** *
* * ** *
*</pre>
*</pre>

=={{header|Frink}}==
<syntaxhighlight lang="frink">g = new graphics

count = 0
do
{
x = random[-15,15]
y = random[-15,15]
r = sqrt[x^2 + y^2]
if 10 <= r and r <= 15
{
count = count + 1
g.fillEllipseCenter[x,y,.3, .3]
}
} while count < 100

g.show[]</syntaxhighlight>

=={{header|gnuplot}}==
=={{header|gnuplot}}==
{{Works with|gnuplot|5.0 (patchlevel 3) and above}}
{{Works with|gnuplot|5.0 (patchlevel 3) and above}}
[[File:RingRandPntsGnu.png|right|thumb|Output RingRandPntsGnu.png]]
[[File:RingRandPntsGnu.png|right|thumb|Output RingRandPntsGnu.png]]


<lang gnuplot>
<syntaxhighlight lang="gnuplot">
## Ring of random points 2/18/17 aev
## Ring of random points 2/18/17 aev
reset
reset
Line 1,400: Line 1,737:
set output
set output
unset print
unset print
</syntaxhighlight>
</lang>
{{Output}}
{{Output}}
<pre>
<pre>
Line 1,408: Line 1,745:
=={{header|Go}}==
=={{header|Go}}==
'''Algorithm 1:'''
'''Algorithm 1:'''
<lang go>package main
<syntaxhighlight lang="go">package main


import (
import (
Line 1,453: Line 1,790:
}
}
fmt.Println(u, "unique points")
fmt.Println(u, "unique points")
}</lang>
}</syntaxhighlight>
'''Algorithm 2:'''
'''Algorithm 2:'''
<lang go>package main
<syntaxhighlight lang="go">package main


import (
import (
Line 1,502: Line 1,839:
}
}
fmt.Println(u, "unique points")
fmt.Println(u, "unique points")
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 1,542: Line 1,879:
=={{header|Haskell}}==
=={{header|Haskell}}==
Using [[Knuth shuffle#Haskell|Knuth Shuffle]]
Using [[Knuth shuffle#Haskell|Knuth Shuffle]]
<lang haskell>import Data.List
<syntaxhighlight lang="haskell">import Data.List
import Control.Monad
import Control.Monad
import Control.Arrow
import Control.Arrow
Line 1,556: Line 1,893:
let canvas = foldl (\cs [x,y] -> replaceAt (31*(x+15)+y+15) "/ " cs ) blanco (take 100 pts)
let canvas = foldl (\cs [x,y] -> replaceAt (31*(x+15)+y+15) "/ " cs ) blanco (take 100 pts)
-- show canvas
-- show canvas
mapM_ (putStrLn.concat). takeWhile(not.null). unfoldr (Just . splitAt 31) $ canvas</lang>
mapM_ (putStrLn.concat). takeWhile(not.null). unfoldr (Just . splitAt 31) $ canvas</syntaxhighlight>
Output (added a trailing space per 'pixel'
Output (added a trailing space per 'pixel'
<pre>*Main> task
<pre>*Main> task
Line 1,591: Line 1,928:


=={{header|Hy}}==
=={{header|Hy}}==
<lang lisp>(import
<syntaxhighlight lang="lisp">(import
[math [sqrt]]
math [sqrt]
[random [choice]]
random [choice]
[matplotlib.pyplot :as plt])
matplotlib.pyplot :as plt)
(setv possible-points (list-comp (, x y)
(setv possible-points
(lfor
[x (range -15 16) y (range -15 16)]
(<= 10 (sqrt (+ (** x 2) (** y 2))) 15)))
x (range -15 16)
y (range -15 16)
(setv [xs ys] (apply zip (list-comp (choice possible-points) [_ (range 100)])))
:if (<= 10 (sqrt (+ (** x 2) (** y 2))) 15)
[x y]))

(setv [xs ys] (zip #* (map (fn [_] (choice possible-points)) (range 100))))
; We can't use random.sample because that samples without replacement.
; We can't use random.sample because that samples without replacement.
; #* is also known as unpack-iterable
(plt.plot xs ys "bo")
(plt.plot xs ys "bo")
(plt.show)</lang>
(plt.show)</syntaxhighlight>


=={{header|Icon}} and {{header|Unicon}}==
=={{header|Icon}} and {{header|Unicon}}==
Generate random points in the bounded by the outside edge. Reject any found out of the prescribed bounds and stop when the required numbers of points have been generated. [[File:Fuzzycircle-unicon.PNG|thumb|plot of 2000, 100, 120]]
Generate random points in the bounded by the outside edge. Reject any found out of the prescribed bounds and stop when the required numbers of points have been generated. [[File:Fuzzycircle-unicon.PNG|thumb|plot of 2000, 100, 120]]
<lang Icon>link graphics
<syntaxhighlight lang="icon">link graphics


procedure main(A) # points, inside r, outside r in pixels - default to task values
procedure main(A) # points, inside r, outside r in pixels - default to task values
Line 1,631: Line 1,972:
WDone()
WDone()


end</lang>
end</syntaxhighlight>


=={{header|J}}==
=={{header|J}}==
Line 1,637: Line 1,978:
This version deals 100 distinct coordinates from the set of acceptable coordinates (much like dealing cards from a shuffled deck):
This version deals 100 distinct coordinates from the set of acceptable coordinates (much like dealing cards from a shuffled deck):


<lang j>gen=: ({~ 100?#)bind((#~ 1=99 225 I.+/"1@:*:),/,"0/~i:15)</lang>
<syntaxhighlight lang="j">gen=: ({~ 100?#)bind((#~ 1=99 225 I.+/"1@:*:),/,"0/~i:15)</syntaxhighlight>


Example use (<code><nowiki>gen''</nowiki></code> generates the points, the rest of the example code deals with rendering them as a text array):
Example use (<code><nowiki>gen''</nowiki></code> generates the points, the rest of the example code deals with rendering them as a text array):
<lang j> '*' (<"1]15+gen '')} 31 31$' '
<syntaxhighlight lang="j"> '*' (<"1]15+gen '')} 31 31$' '
*
*
Line 1,670: Line 2,011:
**
**
* * *
* * *
** * </lang>
** * </syntaxhighlight>

=={{header|Java}}==
=={{header|Java}}==
<lang java>import java.util.Random;
<syntaxhighlight lang="java">import java.util.Random;


public class FuzzyCircle {
public class FuzzyCircle {
Line 1,700: Line 2,042:
}
}
}
}
}</lang>
}</syntaxhighlight>
Output:
Output:
<pre>
<pre>
Line 1,736: Line 2,078:
=={{header|JavaScript}}==
=={{header|JavaScript}}==
JavaScript embedded in HTML, using canvas:
JavaScript embedded in HTML, using canvas:
<lang javascript><html><head><title>Circle</title></head>
<syntaxhighlight lang="javascript"><html><head><title>Circle</title></head>
<body>
<body>
<canvas id="cv" width="320" height="320"></canvas>
<canvas id="cv" width="320" height="320"></canvas>
Line 1,781: Line 2,123:
}
}


</script></body></html></lang>
</script></body></html></syntaxhighlight>

=={{header|jq}}==
{{works with|jq}}
This solution uses a "generate and test" approach to find exactly 100 points within the specified annulus.

Since jq does not have a built-in PRNG, /dev/random is used instead. gnuplot and a bash or bash-like environment are also assumed.

<syntaxhighlight lang="bash">
#!/bin/bash

< /dev/random tr -cd '0-9' | fold -w 1 | jq -Mcnr '

# Output: a PRN in range(0;$n) where $n is .
def prn:
if . == 1 then 0
else . as $n
| (($n-1)|tostring|length) as $w
| [limit($w; inputs)] | join("") | tonumber
| if . < $n then . else ($n | prn) end
end;

def ss: map(.*.) | add;

# Input: [x,y]
# Emit . iff ss lies within the given bounds
def annulus($min; $max) : ss as $sum | select($min <= $sum and $sum <= $max);

limit(100;
repeat([((30 | prn) - 15), ((30 | prn) - 15)]
| select( annulus(100; 225)) ))
| "\(.[0]) \(.[1])"
' > rc-annulus.dat
</syntaxhighlight>

The plot can now be generated as a .png file using these gnuplot commands:
<syntaxhighlight lang="bash">
reset
set terminal pngcairo
set output 'rc-annulus.png'
set xrange [-20:20]
set yrange [-20:20]
plot "rc-annulus.dat" with points pt 1
</syntaxhighlight>


=={{header|Julia}}==
=={{header|Julia}}==
{{works with|Julia|0.6}}
{{works with|Julia|0.6}}
This solution uses the "pick random x, y and cull" rather than the "calculate valid and choose randomly" approach.
This solution uses the "pick random x, y and cull" rather than the "calculate valid and choose randomly" approach.
<lang julia>function printcircle(lo::Integer, hi::Integer, ndots::Integer; pad::Integer = 2)
<syntaxhighlight lang="julia">function printcircle(lo::Integer, hi::Integer, ndots::Integer; pad::Integer = 2)
canvas = falses(2hi + 1, 2hi + 1)
canvas = falses(2hi + 1, 2hi + 1)
i = 0
i = 0
Line 1,804: Line 2,189:
end
end


printcircle(10, 15, 100)</lang>
printcircle(10, 15, 100)</syntaxhighlight>


{{out}}
{{out}}
Line 1,842: Line 2,227:


=={{header|Kotlin}}==
=={{header|Kotlin}}==
<lang scala>// version 1.1.3
<syntaxhighlight lang="scala">// version 1.1.3


fun main(args: Array<String>) {
fun main(args: Array<String>) {
Line 1,858: Line 2,243:
}
}
for (i in 0..30) println(points[i].joinToString(""))
for (i in 0..30) println(points[i].joinToString(""))
}</lang>
}</syntaxhighlight>


Sample output:
Sample output:
Line 1,892: Line 2,277:
o o
o o
</pre>
</pre>

=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def circ
{lambda {:cx :cy :r}
{div {@ style="position:absolute;
top: {- :cy :r}px; left: {- :cx :r}px;
width: {* 2 :r}px; height: {* 2 :r}px;
border: 1px solid #000; border-radius: :rpx;"}} }}
-> circ

{def fuzzy_circle
{lambda {:cx :cy :rmin :rmax :n}
{circ :cx :cy :rmax}
{circ :cx :cy :rmin}
{S.map {{lambda {:cx :cy :rmin :rmax :i}
{let { {:cx :cx} {:cy :cy}
{:rmin :rmin} {:rmax :rmax}
{:x {- {round {* {random} {* 2 :rmax}}} :rmax}}
{:y {- {round {* {random} {* 2 :rmax}}} :rmax}}
} {let { {:x {+ :cx :x }}
{:y {+ :cy :y }}
{:rr {+ {* :x :x} {* :y :y}}}
{:r2min {* :rmin :rmin}}
{:r2max {* :rmax :rmax}}
} {if {or {< :rr :r2min} {> :rr :r2max}}
then else {circ :x :y 2}}
}}} :cx :cy :rmin :rmax}
{S.serie 1 :n}} }}
-> fuzzy_circle

{fuzzy_circle 200 700 80 120 1000}
-> plots 1000 dots between the circles r=80 and r=120 centered at [200,700]
directly in the wiki page (out of any canvas or svg contexts) as it
can be seen in http://lambdaway.free.fr/lambdawalks/?view=fuzzy_circle

</syntaxhighlight>


=={{header|Liberty BASIC}}==
=={{header|Liberty BASIC}}==
<lang lb>' RC Constrained Random Points on a Circle
<syntaxhighlight lang="lb">' RC Constrained Random Points on a Circle


nomainwin
nomainwin
Line 1,923: Line 2,345:
[quit]
[quit]
close #w
close #w
end</lang>
end</syntaxhighlight>


=={{header|Locomotive Basic}}==
=={{header|Locomotive Basic}}==


<lang locobasic>10 MODE 1:RANDOMIZE TIME
<syntaxhighlight lang="locobasic">10 MODE 1:RANDOMIZE TIME
20 FOR J=1 TO 100
20 FOR J=1 TO 100
30 X=INT(RND*30-15)
30 X=INT(RND*30-15)
Line 1,935: Line 2,357:
70 PLOT 320+10*X,200+10*Y:LOCATE 1,1:PRINT J
70 PLOT 320+10*X,200+10*Y:LOCATE 1,1:PRINT J
80 NEXT
80 NEXT
90 CALL &BB06 ' wait for key press</lang>
90 CALL &BB06 ' wait for key press</syntaxhighlight>


[[File:Points on a circle locomotive basic.png]]
[[File:Points on a circle locomotive basic.png]]
=={{header|Lua}}==
Method 1, modified so that the 100 points must be unique..
<syntaxhighlight lang="lua">t, n = {}, 0
for y=1,31 do t[y]={} for x=1,31 do t[y][x]=" " end end
repeat
x, y = math.random(-15,15), math.random(-15,15)
rsq = x*x + y*y
if rsq>=100 and rsq<=225 and t[y+16][x+16]==" " then
t[y+16][x+16], n = "██", n+1
end
until n==100
for y=1,31 do print(table.concat(t[y])) end</syntaxhighlight>
{{out}}
<pre style="font-size:50%"> ██ ██
██ ████ ██ ██
████ ████ ██
██ ██ ████ ██ ██
██ ████ ██ ██
██ ██ ██ ██
██ ██ ██ ██ ██ ████
██ ████
██ ██
████ ██
██████
██
██ ██ ██
██ ██ ██
██ ██ ██
██
██
██ ██ ██
██
██████
██ ██ ██
████
██ ██
████ ██
████ ██████ ████ ██
██ ████ ██ ██ ██ ██ ██
████ ██ ████
██ ██
██ ████</pre>


=={{header|Maple}}==
=={{header|Maple}}==
<lang maple> a := table():
<syntaxhighlight lang="maple"> a := table():
i := 1:
i := 1:
while i < 100 do
while i < 100 do
Line 1,951: Line 2,415:
end if:
end if:
end do:
end do:
plots:-pointplot(convert(a,list));</lang>
plots:-pointplot(convert(a,list));</syntaxhighlight>


=={{header|Mathematica}} / {{header|Wolfram Language}}==
=={{header|Mathematica}} / {{header|Wolfram Language}}==
This algorithm generates 500 pairs of random integers between +/- 15, picks out the ones that satisfy the inequality, and then takes the first 100 of those. It oversamples to reduce the chance of having less than 100 "candidates", which is not impossible, though extremely unlikely.
This algorithm generates 500 pairs of random integers between +/- 15, picks out the ones that satisfy the inequality, and then takes the first 100 of those. It oversamples to reduce the chance of having less than 100 "candidates", which is not impossible, though extremely unlikely.
<lang Mathematica>sample = Take[Cases[RandomInteger[{-15, 15}, {500, 2}], {x_, y_} /; 10 <= Sqrt[x^2 + y^2] <= 15], 100];
<syntaxhighlight lang="mathematica">sample = Take[Cases[RandomInteger[{-15, 15}, {500, 2}], {x_, y_} /; 10 <= Sqrt[x^2 + y^2] <= 15], 100];


Show[{RegionPlot[10 <= Sqrt[x^2 + y^2] <= 15, {x, -16, 16}, {y, -16, 16}, Axes -> True], ListPlot[sample]}]</lang>
Show[{RegionPlot[10 <= Sqrt[x^2 + y^2] <= 15, {x, -16, 16}, {y, -16, 16}, Axes -> True], ListPlot[sample]}]</syntaxhighlight>


=={{header|MATLAB}}==
=={{header|MATLAB}}==
Uses the Monte-Carlo method described above.
Uses the Monte-Carlo method described above.


<lang MATLAB>function [xCoordinates,yCoordinates] = randomDisc(numPoints)
<syntaxhighlight lang="matlab">function [xCoordinates,yCoordinates] = randomDisc(numPoints)


xCoordinates = [];
xCoordinates = [];
Line 1,992: Line 2,456:
yCoordinates(numPoints+1:end) = [];
yCoordinates(numPoints+1:end) = [];
end</lang>
end</syntaxhighlight>


Output:
Output:
<lang MATLAB>>> [x,y] = randomDisc(100);
<syntaxhighlight lang="matlab">>> [x,y] = randomDisc(100);
>> plot(x,y,'.')</lang>
>> plot(x,y,'.')</syntaxhighlight>
[[File:Matlab-randomDisc-output.png]]
[[File:Matlab-randomDisc-output.png]]


=={{header|Maxima}}==
=={{header|Maxima}}==
<lang Maxima>randomDisc(numPoints):= block([p: []],
<syntaxhighlight lang="maxima">randomDisc(numPoints):= block([p: []],
local(goodp, random_int),
local(goodp, random_int),
goodp(x, y):=block([r: sqrt(x^2+y^2)],
goodp(x, y):=block([r: sqrt(x^2+y^2)],
Line 2,015: Line 2,479:
p: randomDisc(100)$
p: randomDisc(100)$
plot2d(['discrete, p], ['style, 'points]);</lang>
plot2d(['discrete, p], ['style, 'points]);</syntaxhighlight>


=={{header|Nim}}==
=={{header|Nim}}==
{{trans|Python}}
{{trans|Python}}
<lang nim>import tables, math, strutils, complex, random
<syntaxhighlight lang="nim">import tables, math, complex, random

proc random[T](a: openarray[T]): T =
result = a[rand(low(a)..len(a))]


type Point = tuple[x, y: int]
type Point = tuple[x, y: int]
Line 2,031: Line 2,492:
for x in -15..15:
for x in -15..15:
for y in -15..15:
for y in -15..15:
if abs((x.float, y.float)) in 10.0..15.0:
if abs(complex(x.float, y.float)) in 10.0..15.0:
possiblePoints.add((x,y))
possiblePoints.add((x,y))


randomize()
randomize()
for i in 0..100: world.inc possiblePoints.random
for i in 0..100: world.inc possiblePoints.sample


for x in -15..15:
for x in -15..15:
Line 2,041: Line 2,502:
let key = (x, y)
let key = (x, y)
if key in world and world[key] > 0:
if key in world and world[key] > 0:
stdout.write min(9, world[key])
stdout.write ' ' & $min(9, world[key])
else:
else:
stdout.write ' '
stdout.write " "
echo ""</lang>
echo ""</syntaxhighlight>

Output:
{{out}}
<pre> 1
1211 1
<pre> 1
1 1 1
1 1 3 1 1
3
3 11
1 1 1 1
1 11 1 1 1
1 2 1 1 1 1 1
122 21 1
2
1 1 1 1 1 1
1 1 2
1
1
1 1 1 1
1 1
1 2 1
11 11
1 1
1 1 1
1 1
1
1 1 1
11 1
1 1
1 1 11
1
2 1
1 1 1 1 1 1
1
1
1 1
1 1
1 1
2
11
1 1 2
11
1 1
1 1 111
1 1 1 1 1
1 1 1 1
1
1 11
1 2 2 1 1
1 1 1
1 1 1 1
12 2 11 1 1
1 1 1
1 1 1 1 1
1 1 1
11 1
1 1
1 </pre>
1 1 2 1 1 2
1 1 1 1
1 </pre>


=={{header|OCaml}}==
=={{header|OCaml}}==


<lang ocaml>let p x y =
<syntaxhighlight lang="ocaml">let p x y =
let d = sqrt(x ** 2.0 +. y ** 2.0) in
let d = sqrt(x ** 2.0 +. y ** 2.0) in
10.0 <= d && d <= 15.0
10.0 <= d && d <= 15.0
Line 2,100: Line 2,563:
g.(y).[x] <- 'o'
g.(y).[x] <- 'o'
) points;
) points;
Array.iter print_endline g</lang>
Array.iter print_endline g</syntaxhighlight>


Line 2,130: Line 2,593:
o
o
oo o
oo o


=={{header|PARI/GP}}==
=={{header|PARI/GP}}==
<lang parigp>crpc()={
<syntaxhighlight lang="parigp">crpc()={
my(v=vector(404),t=0,i=0,vx=vy=vector(100));
my(v=vector(404),t=0,i=0,vx=vy=vector(100));
for(x=1,14,for(y=1,14,
for(x=1,14,for(y=1,14,
Line 2,156: Line 2,618:
);
);
plothraw(vx,vy)
plothraw(vx,vy)
};</lang>
};</syntaxhighlight>


=={{header|Perl}}==
=={{header|Perl}}==
===Graphical output===
===Graphical output===
<lang perl>my @points;
<syntaxhighlight lang="perl">my @points;
while (@points < 100) {
while (@points < 100) {
my ($x, $y) = (int(rand(31))-15, int(rand(31)) - 15);
my ($x, $y) = (int(rand(31))-15, int(rand(31)) - 15);
Line 2,181: Line 2,643:


print "@$_ pt\n" for @points;
print "@$_ pt\n" for @points;
print "%%EOF";</lang>
print "%%EOF";</syntaxhighlight>


Randomly generates points and reject ones not in the ring. Writes an EPS file.
Randomly generates points and reject ones not in the ring. Writes an EPS file.


===Plain-text output===
===Plain-text output===
<lang perl>@range = -15..16;
<syntaxhighlight lang="perl">@range = -15..16;


for $x (@range) {
for $x (@range) {
Line 2,198: Line 2,660:
push @matrix, ' ' x @range for 1..@range;
push @matrix, ' ' x @range for 1..@range;
substr $matrix[15+$$_[1]], 15+$$_[0], 1, '*' for @sample;
substr $matrix[15+$$_[1]], 15+$$_[0], 1, '*' for @sample;
print join(' ', split '', $_) . "\n" for @matrix;</lang>
print join(' ', split '', $_) . "\n" for @matrix;</syntaxhighlight>
{{out}}
{{out}}
<pre> * * *
<pre> * * *
Line 2,229: Line 2,691:
* *
* *
*</pre>
*</pre>

=={{header|Perl 6}}==
{{works with|rakudo|2015.09}}
<lang perl6>my @range = -15..16;

my @points = gather for @range X @range -> ($x, $y) {
take [$x,$y] if 10 <= sqrt($x*$x+$y*$y) <= 15
}
my @samples = @points.roll(100); # or .pick(100) to get distinct points

# format and print
my %matrix;
for @range X @range -> ($x, $y) { %matrix{$y}{$x} = ' ' }
%matrix{.[1]}{.[0]} = '*' for @samples;
%matrix{$_}{@range}.join(' ').say for @range;</lang>
{{out}}
<pre> *
* *
* * * * *
* * * *
* * * * *
* *
* * *
* * * *
*
* * * *
* * *
* * * *
*
* *
* * *
* * * *
* * *
*
* *
* *
* * *
* * *
* *
* * *
* * * * * * *
* * * * * *
* * * *
* *
* * *</pre>
Turning that program completely inside-out and reducing to a single statement with a single non-parameter variable, we get another version that also works.

This uses, among other things, a 0-based matrix rather than a hash, a <tt>given</tt> on the first line that allows us to print the final value of the matrix straight from its initial declaration, a <tt>for</tt> statement feeding a <tt>for</tt> statement modifier, a lambda that unpacks a single x-y argument into two variables, the functional form of pick rather than the method form, a quasi-list comprehension in the middle loop that filters each <tt>given</tt> with a <tt>when</tt>, precalculated squared limits so we don't have to take the square root, use of X- and X** to subtract and exponentiate both <tt>$x</tt> and <tt>$y</tt> in parallel.

After the <tt>given do</tt> has loaded up <tt>@matrix</tt> with our circle, the <tt>map</tt> on the first line substitutes a space for any undefined matrix element, and the extra space between elements is supplied by the stringification of the list value, performed by the prefix <tt>~</tt> operator, the unary equivalent of concatenation in Perl&nbsp;6.

At this point you would be justified in concluding that we are completely mad. <tt>:-)</tt>

<lang perl6>(say ~.map: { $_ // ' ' } for my @matrix) given do
-> [$x, $y] { @matrix[$x][$y] = '*' } for pick 100, do
for ^32 X ^32 -> ($x, $y) {
[$x,$y] when 100..225 given [+] ($x,$y X- 15) X** 2;
}
</lang>
{{out}}
<pre> * * *
* * *
* * * * * *
* * * * * *
* * * * * *
* * *
* * * * *
* * * *
* *
* *
*
* * *

* *
* * * * * *
* *

* * * *
* * *
* * * *
* *
* *
* * *
* * * * * *
* * * *
* * * * * *
* * * *
* * * * *
* * *</pre>


=={{header|Phix}}==
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>sequence screen = repeat(repeat(' ',31),31)
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
integer x, y, count = 0
<span style="color: #004080;">sequence</span> <span style="color: #000000;">screen</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #000000;">31</span><span style="color: #0000FF;">),</span><span style="color: #000000;">31</span><span style="color: #0000FF;">)</span>
atom r
<span style="color: #004080;">integer</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
while 1 do
<span style="color: #004080;">atom</span> <span style="color: #000000;">r</span>
x = rand(31)
<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
y = rand(31)
<span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">31</span><span style="color: #0000FF;">)</span>
r = sqrt(power(x-16,2)+power(y-16,2))
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">31</span><span style="color: #0000FF;">)</span>
if r>=10 and r<=15 then
<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">-</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)+</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">-</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
screen[x][y] = 'x'
<span style="color: #008080;">if</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">10</span> <span style="color: #008080;">and</span> <span style="color: #000000;">r</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">15</span> <span style="color: #008080;">then</span>
count += 1
<span style="color: #000000;">screen</span><span style="color: #0000FF;">[</span><span style="color: #000000;">x</span><span style="color: #0000FF;">][</span><span style="color: #000000;">y</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'x'</span>
if count>=100 then exit end if
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
end if
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">100</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end while
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
puts(1,join(screen,"\n"))</lang>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">screen</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{out}}
{{out}}
<pre>
<pre>
Line 2,368: Line 2,744:


=={{header|PicoLisp}}==
=={{header|PicoLisp}}==
<lang PicoLisp>(let Area (make (do 31 (link (need 31 " "))))
<syntaxhighlight lang="picolisp">(let Area (make (do 31 (link (need 31 " "))))
(use (X Y)
(use (X Y)
(do 100
(do 100
Line 2,380: Line 2,756:
10 ) )
10 ) )
(set (nth Area (+ 16 X) (+ 16 Y)) "#") ) )
(set (nth Area (+ 16 X) (+ 16 Y)) "#") ) )
(mapc prinl Area) )</lang>
(mapc prinl Area) )</syntaxhighlight>
Output:
Output:
<pre> #
<pre> #
Line 2,415: Line 2,791:
=={{header|PL/I}}==
=={{header|PL/I}}==
===version 1===
===version 1===
<syntaxhighlight lang="pl/i">
<lang PL/I>
constrain: procedure options (main);
constrain: procedure options (main);
declare 1 point (100),
declare 1 point (100),
Line 2,443: Line 2,819:
end;
end;
end constrain;
end constrain;
</syntaxhighlight>
</lang>
Output:
Output:
<pre>
<pre>
Line 2,475: Line 2,851:
</pre>
</pre>
===version 2===
===version 2===
<lang PL/I>*process source attributed xref or(!);
<syntaxhighlight lang="pl/i">*process source attributed xref or(!);
annulus: procedure options (main);
annulus: procedure options (main);
/* version 1 does not handle (0/15) etc. this does. */
/* version 1 does not handle (0/15) etc. this does. */
Line 2,517: Line 2,893:
Return(d);
Return(d);
End;
End;
End annulus;</lang>
End annulus;</syntaxhighlight>
'''output'''
'''output'''
<pre> *
<pre> *
Line 2,553: Line 2,929:
=={{header|PowerShell}}==
=={{header|PowerShell}}==
{{works with|PowerShell|3}}
{{works with|PowerShell|3}}
<lang PowerShell>$MinR2 = 10 * 10
<syntaxhighlight lang="powershell">$MinR2 = 10 * 10
$MaxR2 = 15 * 15
$MaxR2 = 15 * 15
Line 2,570: Line 2,946:
}
}
ForEach ( $Y in -16..16 ) { ( -16..16 | ForEach { ( " ", "*" )[[int]$Points["$_,$Y"]] } ) -join '' }</lang>
ForEach ( $Y in -16..16 ) { ( -16..16 | ForEach { ( " ", "*" )[[int]$Points["$_,$Y"]] } ) -join '' }</syntaxhighlight>
{{out}}
{{out}}
<pre> ***
<pre> ***
Line 2,604: Line 2,980:
=={{header|Prolog}}==
=={{header|Prolog}}==
Works with SWI-Prolog
Works with SWI-Prolog
<lang Prolog>:- use_module(library(clpfd)).
<syntaxhighlight lang="prolog">:- use_module(library(clpfd)).


circle :-
circle :-
Line 2,640: Line 3,016:
send(D, display, C))),
send(D, display, C))),
send(D, open).
send(D, open).
</syntaxhighlight>
</lang>
[[FILE:Prolog-Circle.jpg‎ ]]
[[FILE:Prolog-Circle.jpg‎ ]]


=={{header|PureBasic}}==
=={{header|PureBasic}}==
<lang PureBasic>CreateImage(0,31,31)
<syntaxhighlight lang="purebasic">CreateImage(0,31,31)
StartDrawing(ImageOutput(0))
StartDrawing(ImageOutput(0))
For i=1 To 100
For i=1 To 100
Line 2,660: Line 3,036:
OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags)
OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags)
ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0))
ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0))
Repeat: Until WaitWindowEvent()=#PB_Event_CloseWindow</lang>
Repeat: Until WaitWindowEvent()=#PB_Event_CloseWindow</syntaxhighlight>
[[File:PureBasic_Circle_plot.png‎|155px]]
[[File:PureBasic_Circle_plot.png‎|155px]]


=={{header|Python}}==
=={{header|Python}}==
Note that the diagram shows the number of points at any given position (up to a maximum of 9 points).
Note that the diagram shows the number of points at any given position (up to a maximum of 9 points).
<lang python>>>> from collections import defaultdict
<syntaxhighlight lang="python">>>> from collections import defaultdict
>>> from random import choice
>>> from random import choice
>>> world = defaultdict(int)
>>> world = defaultdict(int)
Line 2,708: Line 3,084:
1 1 1
1 1 1
2 2 1
2 2 1
1 </lang>
1 </syntaxhighlight>
If the number of samples is increased to 1100:
If the number of samples is increased to 1100:
<lang python>>>> for i in range(1000): world[choice(possiblepoints)] += 1
<syntaxhighlight lang="python">>>> for i in range(1000): world[choice(possiblepoints)] += 1


>>> for x in range(-15,16):
>>> for x in range(-15,16):
Line 2,747: Line 3,123:
2131181233 424
2131181233 424
47414232164
47414232164
4 </lang>
4 </syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang="Quackery"> [ 0 31 of ] is grid ( --> [ )

[ dup * ] is squared ( n --> n )

[ squared swap squared +
10 squared 15 squared 1+
within ] is inrange ( n n --> b )

[ 32 random 16 -
32 random 16 -
2dup inrange not while
2drop again ] is randxy ( --> n n )

[ 15 + swap 15 +
dip [ 2dup peek ]
bit | unrot poke ] is plot ( [ n n --> [ )

[ witheach
[ 31 times
[ dup
i^ bit & iff
[ $ "[]" ]
else
[ $ " " ]
echo$ ]
drop
cr ] ] is draw ( [ --> )

[ grid
swap times
[ randxy plot ]
draw ] is circle ( n --> )

100 circle</syntaxhighlight>

{{out}}

<pre>
[] [] []
[] [] []
[] [][] []
[] [] [] [][]
[] [] [][][][] [] []
[]
[] []
[] [][]
[]
[][] []
[] [] [] []
[] []
[]
[] []
[][] []
[][] []
[] [][][]
[] []
[] [] [] []
[]
[] []
[] []
[][][] []
[] [] [][] [] []
[] [][][] [] [] []
[] [] []
[] [][]
[] []
</pre>

Code check as per task discussion, as a dialogue in the Quackery shell.

<pre>/O> 10000 circle
...
[]
[][][][][][][][][][][]
[][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][][][][][][][][]
[][][][][][][][] [][][][][][][][]
[][][][][][][] [][][][][][][]
[][][][][][] [][][][][][]
[][][][][][] [][][][][][]
[][][][][][] [][][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][][] [][][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][] [][][][][]
[][][][][][] [][][][][][]
[][][][][][] [][][][][][]
[][][][][][] [][][][][][]
[][][][][][][] [][][][][][][]
[][][][][][][][] [][][][][][][][]
[][][][][][][][][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][]
[][][][][][][][][][][]
[]

Stack empty.
</pre>


=={{header|R}}==
=={{header|R}}==
<syntaxhighlight lang="r">
<lang R>
RMin <- 10
RMin <- 10
RMax <- 15
RMax <- 15
Line 2,769: Line 3,256:
plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue",
plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue",
xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )
xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )
</syntaxhighlight>
</lang>


Example of solution
Example of solution


[[File:FuzzyCircle.jpg]]
[[File:FuzzyCircle.jpg]]

=={{header|Racket}}==
=={{header|Racket}}==
<lang racket>#lang racket
<syntaxhighlight lang="racket">#lang racket


(require plot plot/utils)
(require plot plot/utils)
Line 2,785: Line 3,273:
#(15 15)))]
#(15 15)))]
#:when (<= 10 (vmag xy) 15))
#:when (<= 10 (vmag xy) 15))
xy)))</lang>
xy)))</syntaxhighlight>


=={{header|REXX}}==
=={{header|Raku}}==
(formerly Perl 6)
===version 0, without aspect adjustment===
{{works with|rakudo|2015.09}}
No aspect adjustment is done in version of the REXX program.
<syntaxhighlight lang="raku" line>my @range = -15..16;


my @points = gather for @range X @range -> ($x, $y) {
Both version '''0''' and version '''1''' suppress the displaying of blank lines at the top and bottom of the plot.
take [$x,$y] if 10 <= sqrt($x*$x+$y*$y) <= 15
<lang rexx>/*REXX program generates 100 random points in an annulus: 10 ≤ √(x²≤y²) ≤ 15 */
}
parse arg points low high . /*obtain optional args from the C.L. */
my @samples = @points.roll(100); # or .pick(100) to get distinct points
if points=='' then points=100
if low=='' then low=10; low2= low**2 /*define a shortcut for squaring LOW. */
if high=='' then high=15; high2=high**2 /* " " " " " HIGH.*/
$=
do x=-high; x2=x*x /*generate all possible annulus points.*/
if x<0 & x2>high2 then iterate
if x>0 & x2>high2 then leave
do y=-high; s=x2+y*y
if (y<0 & s>high2) | s<low2 then iterate
if y>0 & s>high2 then leave
$=$ x','y /*add a point─set to the $ list. */
end /*y*/
end /*x*/


# format and print
plotChar='Θ'; minY=high2; maxY=-minY; ap=words($); @.=
my %matrix;
for @range X @range -> ($x, $y) { %matrix{$y}{$x} = ' ' }
%matrix{.[1]}{.[0]} = '*' for @samples;
%matrix{$_}{@range}.join(' ').say for @range;</syntaxhighlight>
{{out}}
<pre> *
* *
* * * * *
* * * *
* * * * *
* *
* * *
* * * *
*
* * * *
* * *
* * * *
*
* *
* * *
* * * *
* * *
*
* *
* *
* * *
* * *
* *
* * *
* * * * * * *
* * * * * *
* * * *
* *
* * *</pre>
Turning that program completely inside-out and reducing to a single statement with a single non-parameter variable, we get another version that also works.


This uses, among other things, a 0-based matrix rather than a hash, a <tt>given</tt> on the first line that allows us to print the final value of the matrix straight from its initial declaration, a <tt>for</tt> statement feeding a <tt>for</tt> statement modifier, a lambda that unpacks a single x-y argument into two variables, the functional form of pick rather than the method form, a quasi-list comprehension in the middle loop that filters each <tt>given</tt> with a <tt>when</tt>, precalculated squared limits so we don't have to take the square root, use of X- and X** to subtract and exponentiate both <tt>$x</tt> and <tt>$y</tt> in parallel.
do j=1 for points /*define the x,y points [character O].*/
parse value word($,random(1,ap)) with x ',' y /*pick a random point in the annulus.*/
@.y=overlay(plotChar, @.y, x+high+1) /*define: the data point. */
minY=min(minY,y); maxY=max(maxY,y) /*perform the plot point restricting. */
end /*j*/
/* [↓] only show displayable section. */
do y=minY to maxY; say @.y; end /*display the annulus to the terminal. */
/*stick a fork in it, we're all done. */</lang>
'''output''' &nbsp; (without aspect adjustment) &nbsp; when using the default input:
<pre>
Θ
ΘΘ ΘΘ
ΘΘ Θ Θ Θ
Θ Θ Θ
ΘΘ Θ Θ Θ
Θ Θ Θ


After the <tt>given do</tt> has loaded up <tt>@matrix</tt> with our circle, the <tt>map</tt> on the first line substitutes a space for any undefined matrix element, and the extra space between elements is supplied by the stringification of the list value, performed by the prefix <tt>~</tt> operator, the unary equivalent of concatenation in Raku.
ΘΘ Θ Θ Θ
Θ Θ Θ
Θ Θ ΘΘ
Θ Θ Θ
Θ
Θ Θ
Θ Θ Θ
Θ ΘΘ
Θ
Θ
ΘΘ
Θ Θ Θ
Θ
Θ Θ Θ
Θ Θ Θ Θ
Θ Θ Θ
Θ ΘΘ Θ Θ
ΘΘΘΘ Θ Θ Θ
Θ Θ Θ Θ ΘΘ
Θ Θ Θ Θ
Θ Θ
</pre>


At this point you would be justified in concluding that we are completely mad. <tt>:-)</tt>
===version 1, with aspect adjustment===
Aspect adjustment is done in this version of the REXX program.
<lang rexx>/*REXX program generates 100 random points in an annulus: 10 ≤ √(x²≤y²) ≤ 15 */
parse arg points low high . /*obtain optional args from the C.L. */
if points=='' then points=100
if low=='' then low=10; low2= low**2 /*define a shortcut for squaring LOW. */
if high=='' then high=15; high2=high**2 /* " " " " " HIGH.*/
$=
do x=-high; x2=x*x /*generate all possible annulus points.*/
if x<0 & x2>high2 then iterate
if x>0 & x2>high2 then leave
do y=-high; s=x2+y*y
if (y<0 & s>high2) | s<low2 then iterate
if y>0 & s>high2 then leave
$=$ x','y /*add a point─set to the $ list. */
end /*y*/
end /*x*/


<syntaxhighlight lang="raku" line>(say ~.map: { $_ // ' ' } for my @matrix) given do
plotChar='Θ'; minY=high2; maxY=-minY; ap=words($); @.=
-> [$x, $y] { @matrix[$x][$y] = '*' } for pick 100, do
for ^32 X ^32 -> ($x, $y) {
[$x,$y] when 100..225 given [+] ($x,$y X- 15) X** 2;
}
</syntaxhighlight>
{{out}}
<pre> * * *
* * *
* * * * * *
* * * * * *
* * * * * *
* * *
* * * * *
* * * *
* *
* *
*
* * *


do j=1 for points /*define the x,y points [character O].*/
* *
* * * * * *
parse value word($,random(1,ap)) with x ',' y /*pick a random point in the annulus.*/
* *
@.y=overlay(plotChar, @.y, 2*x+2*high+1) /*define: the data point. */
minY=min(minY,y); maxY=max(maxY,y) /*perform the plot point restricting. */
end /*j*/
/* [↓] only show displayable section. */
do y=minY to maxY; say @.y; end /*display the annulus to the terminal. */
/*stick a fork in it, we're all done. */</lang>
'''output''' &nbsp; (with aspect adjustment) &nbsp; when using the default input:
<pre>
Θ
Θ Θ Θ
Θ Θ Θ Θ Θ Θ
Θ Θ Θ Θ Θ Θ Θ
Θ Θ Θ Θ Θ Θ
Θ
Θ Θ Θ
Θ Θ Θ Θ Θ
Θ
Θ Θ Θ Θ Θ Θ
Θ Θ
Θ Θ


Θ Θ Θ
* * * *
Θ Θ
* * *
* * * *
Θ
* *
Θ
* *
Θ Θ Θ
Θ Θ Θ Θ
* * *
Θ Θ Θ
* * * * * *
Θ Θ Θ
* * * *
Θ Θ Θ
* * * * * *
* * * *
* * * * *
* * *</pre>

=={{header|REXX}}==
===version 1===
This REXX version uses aspect adjustment for the plot of the (sparse) annulus.
<syntaxhighlight lang="rexx">/*REXX program generates 100 random points in an annulus: 10 ≤ √(x²≤y²) ≤ 15 */
parse arg pts LO HI . /*obtain optional args from the C.L. */
if pts=='' then pts= 100 /*Not specified? Then use the default.*/
if LO=='' then LO= 10; LO2= LO**2 /*define a shortcut for squaring LO. */
if HI=='' then HI= 15; HI2= HI**2 /* " " " " " HI. */
$=
do x=-HI; xx= x*x /*generate all possible annulus points.*/
if x>0 & xx>HI2 then leave /*end of annulus points generation ? */
do y=-HI; s= xx + y*y
if (y<0 & s>HI2) | s<LO2 then iterate
if y>0 & s>HI2 then leave
$= $ x','y /*add a point─set to the $ list. */
end /*y*/
end /*x*/
#= words($); @.= /*def: plotchr; #pts; lines*/
do pts; parse value word($, random(1,#)) with x ',' y /*get rand point in annulus*/
@.y= overlay('☼', @.y, x+x + HI+HI + 1) /*put a plot char on a line*/
end /*pts*/ /* [↑] maintain aspect ratio on X axis*/
/*stick a fork in it, we're all done. */
do y=-HI to HI; say @.y; end /*display the annulus to the terminal. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>


Θ Θ Θ Θ
☼ ☼
Θ Θ Θ Θ Θ
☼ ☼ ☼
Θ Θ
☼ ☼ ☼ ☼ ☼
Θ Θ Θ Θ
☼ ☼ ☼
Θ Θ Θ Θ
☼ ☼ ☼ ☼
☼ ☼ ☼
☼ ☼
☼ ☼ ☼
☼ ☼ ☼
☼ ☼ ☼ ☼
☼ ☼ ☼
☼ ☼
☼ ☼


Θ
☼ ☼ ☼
☼
☼ ☼ ☼ ☼
☼ ☼
☼ ☼ ☼
☼ ☼ ☼ ☼
☼ ☼ ☼ ☼ ☼
☼ ☼ ☼ ☼
☼ ☼ ☼
☼ ☼ ☼
☼
☼ ☼ ☼ ☼ ☼
☼ ☼ ☼ ☼
☼ ☼ ☼ ☼ ☼
☼ ☼
☼
</pre>
</pre>


===version 2===
===version 2===
{{trans|REXX version 1}}
<lang rexx>/* REXX ---------------------------------------------------------------
<syntaxhighlight lang="rexx">/* REXX ---------------------------------------------------------------
* show 100 random points of an annulus with radius 10 to 15
* show 100 random points of an annulus with radius 10 to 15
* 18.06.2014 Walter Pachl 'derived/simplified' from REXX version 1
* 18.06.2014 Walter Pachl 'derived/simplified' from REXX version 1
Line 2,952: Line 3,464:
Do y=-high To high
Do y=-high To high
Say line.y
Say line.y
End</lang>
End</syntaxhighlight>
'''output''' using default parameters
'''output''' using default parameters
<pre>
<pre>
Line 2,996: Line 3,508:
O O O O O
O O O O O
O </pre>
O </pre>

===version 3===
===version 3===
<lang rexx>/* REXX ---------------------------------------------------------------
<syntaxhighlight lang="rexx">/* REXX ---------------------------------------------------------------
* 19.06.2014 Walter Pachl alternate algorithm
* 19.06.2014 Walter Pachl alternate algorithm
* the idea: yl is a list of y coordinates which may have unused points
* the idea: yl is a list of y coordinates which may have unused points
Line 3,074: Line 3,587:
p.0=z
p.0=z
End
End
Return</lang>
Return</syntaxhighlight>
'''output''' using rexx fcaa 100 3 5 2
'''output''' using rexx fcaa 100 3 5 2
<pre>all points filled
<pre>all points filled
Line 3,091: Line 3,604:


=={{header|Ring}}==
=={{header|Ring}}==
<lang ring>
<syntaxhighlight lang="ring">
load "guilib.ring"
load "guilib.ring"


Line 3,136: Line 3,649:
}
}
label1 { setpicture(p1) show() }
label1 { setpicture(p1) show() }
</syntaxhighlight>
</lang>


Output:
Output:


[[File:CalmoSoftDrawCircle.jpg]]
[[File:CalmoSoftDrawCircle.jpg]]

=={{header|RPL}}==
{{works with|HP|48G}}
« ERASE -15 15 DUP2 XRNG YRNG <span style="color:grey">@ set graphics boundaries</span>
DEG -19 SF 0 <span style="color:grey">@ set degrees mode, polar vector mode, count = 0</span>
'''DO''' RAND 5 * 10 + RAND 360 * →V2 <span style="color:grey">@ z = rand(10..15).exp(i.rand(360))</span>
C→R IP SWAP IP R→C <span style="color:grey">@ make z a complex with integer coordinates</span>
'''IF''' DUP ABS DUP 10 ≥ SWAP 15 ≤ AND <span style="color:grey">@ if 10 ≤ | z | ≤ 15</span>
'''THEN''' PIXON 1 + <span style="color:grey">@ then set pixel and increment count</span>
'''ELSE''' DROP '''END'''
'''UNTIL''' DUP 100 ≥ '''END'''
DROP { } PVIEW
-19 CF
» '<span style="color:blue">TASK</span>' STO
[[File:Constrained.png|alt=Screenshot of a HP-48G emulator, displaying constrained random points on a circle|HP-48G emulator screenshot]]

The circle is actually an ellipse because RPL display screens are not squared.


=={{header|Ruby}}==
=={{header|Ruby}}==
Create the image with [[Raster graphics operations/Ruby]]
Create the image with [[Raster graphics operations/Ruby]]
<lang Ruby>points = (1..100).map do
<syntaxhighlight lang="ruby">points = (1..100).map do
# choose a random radius and angle
# choose a random radius and angle
angle = rand * 2.0 * Math::PI
angle = rand * 2.0 * Math::PI
Line 3,164: Line 3,694:
pngfile = __FILE__
pngfile = __FILE__
pngfile[/\.rb/] = ".png"
pngfile[/\.rb/] = ".png"
pixmap.save_as_png(pngfile)</lang>
pixmap.save_as_png(pngfile)</syntaxhighlight>


{{out}}
{{out}}
Line 3,199: Line 3,729:


===algorithm 2:===
===algorithm 2:===
<lang ruby>r2 = 10*10..15*15
<syntaxhighlight lang="ruby">r2 = 10*10..15*15
range = (-15..15).to_a
range = (-15..15).to_a
points = range.product(range).select {|i,j| r2.cover?(i*i + j*j)}
points = range.product(range).select {|i,j| r2.cover?(i*i + j*j)}
Line 3,206: Line 3,736:
pt = Hash.new(" ")
pt = Hash.new(" ")
points.sample(100).each{|ij| pt[ij] = " o"}
points.sample(100).each{|ij| pt[ij] = " o"}
puts range.map{|i| range.map{|j| pt[[i,j]]}.join}</lang>
puts range.map{|i| range.map{|j| pt[[i,j]]}.join}</syntaxhighlight>


{{out}}
{{out}}
Line 3,245: Line 3,775:


=={{header|Run BASIC}}==
=={{header|Run BASIC}}==
<lang runbasic>w = 320
<syntaxhighlight lang="runbasic">w = 320
h = 320
h = 320
dim canvas(w,h)
dim canvas(w,h)
Line 3,269: Line 3,799:
next x
next x
render #g
render #g
#g "flush"</lang>
#g "flush"</syntaxhighlight>


=={{header|Rust}}==
=={{header|Rust}}==
<syntaxhighlight lang="rust">extern crate rand;
<lang Rust>#![feature(inclusive_range_syntax)]

extern crate rand;


use rand::Rng;
use rand::Rng;
Line 3,344: Line 3,872:


precalculating_method(&mut rng);
precalculating_method(&mut rng);
}</lang>
}</syntaxhighlight>


=={{header|Scala}}==
=={{header|Scala}}==
{{libheader|Scala}}<lang Scala>import java.awt.{ Color, geom,Graphics2D ,Rectangle}
{{libheader|Scala}}<syntaxhighlight lang="scala">import java.awt.{ Color, geom,Graphics2D ,Rectangle}
import scala.math.hypot
import scala.math.hypot
import scala.swing.{MainFrame,Panel,SimpleSwingApplication}
import scala.swing.{MainFrame,Panel,SimpleSwingApplication}
Line 3,426: Line 3,954:
contents = ui
contents = ui
}
}
}</lang>
}</syntaxhighlight>


=={{header|Sidef}}==
=={{header|Sidef}}==
{{trans|Perl}}
{{trans|Perl}}
Generates an EPS file.
Generates an EPS file.
<lang ruby>var points = [];
<syntaxhighlight lang="ruby">var points = []
while (points.len < 100) {
while (points.len < 100) {
var (x, y) = 2.of{31.rand.int - 15}...;
var (x, y) = 2.of{ 30.irand - 15 }...
var r2 = (x**2 + y**2);
var r2 = (x**2 + y**2)
if ((r2 >= 100) && (r2 <= 225)) {
if ((r2 >= 100) && (r2 <= 225)) {
points.append([x, y]);
points.append([x, y])
}
}
}
}


print <<'HEAD';
print <<'HEAD'
%!PS-Adobe-3.0 EPSF-3.0
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox 0 0 400 400
%%BoundingBox 0 0 400 400
Line 3,452: Line 3,980:
HEAD
HEAD


points.each { |pt| say "#{pt.join(' ')} pt" };
points.each { |pt| say "#{pt.join(' ')} pt" }
print '%%EOF';</lang>
print '%%EOF'</syntaxhighlight>

=={{header|Standard ML}}==
Works with PolyML. Plotting function from 'Draw a pixel' task. Uniform random generator: copy from [[Random_numbers#Standard_ML]]. x,y plotted scaled x 10 px
<syntaxhighlight lang="standard ml">open XWindows ;
open Motif ;

val plotWindow = fn coords => (* input list of int*int within 'dim' *)
let
val dim = {tw=325,th=325} ;
val shell = XtAppInitialise "" "demo" "top" [] [ XmNwidth (#tw dim), XmNheight (#th dim) ] ; (* single call only *)
val main = XmCreateMainWindow shell "main" [ XmNmappedWhenManaged true ] ;
val canvas = XmCreateDrawingArea main "drawarea" [ XmNwidth (#tw dim), XmNheight (#th dim) ] ;
val usegc = DefaultGC (XtDisplay canvas) ;
val put = fn (w,s,t)=> (
XSetForeground usegc 0xfffffff ;
XFillRectangle (XtWindow canvas) usegc (Area{x=0,y=0,w = #tw dim, h= #th dim}) ;
XSetForeground usegc 0 ;
XDrawPoints (XtWindow canvas) usegc ( List.map (fn (x,y)=>XPoint {x=x,y=y}) coords ) CoordModeOrigin ;
t )
in
(
XtSetCallbacks canvas [ (XmNexposeCallback , put) ] XmNarmCallback ;
XtManageChild canvas ;
XtManageChild main ;
XtRealizeWidget shell
)
end;

val urandomlist = fn seed => fn n =>
(* put code from (www.rosettacode.org) wiki/Random_numbers#Standard_ML 'urandomlist' here
input : seed and number of drawings *)
end;

val normalizedPts = fn () => (* select ([0,1]*[0,1]) points in normalized bandwidth *)
let
val realseeds = ( 972.1 , 10009.3 ) ;
val usum = fn (u,v) => u*(u-1.0) + v*(v-1.0) ;
val lim = ( ~350.0/900.0, ~225.0/900.0 ) ; (* limits to usum *)
val select = fn i => usum i <= #2 lim andalso usum i >= #1 lim ; (* select according to inequalities *)
val uv = ListPair.zip ( urandomlist (#1 realseeds) 2500 , urandomlist (#2 realseeds) 2500 ) (* take 2500 couples *)
in
List.take ( List.filter select uv , 1000 )
end ;</syntaxhighlight>
call
> val scaledXY = map (fn (x,y)=>
( Real.toInt IEEEReal.TO_NEAREST (10.0+300.0*x), Real.toInt IEEEReal.TO_NEAREST (10.0+300.0*y) )) (normalizedPts ()) ;
> plotWindow scaledXY ;

=={{header|Swift}}==

{{trans|Rust}}

<syntaxhighlight lang="swift">let nPoints = 100

func generatePoint() -> (Int, Int) {
while true {
let x = Int.random(in: -15...16)
let y = Int.random(in: -15...16)
let r2 = x * x + y * y

if r2 >= 100 && r2 <= 225 {
return (x, y)
}
}
}

func filteringMethod() {
var rows = [[String]](repeating: Array(repeating: " ", count: 62), count: 31)

for _ in 0..<nPoints {
let (x, y) = generatePoint()

rows[y + 15][x + 15 * 2] = "*"
}

for row in rows {
print(row.joined())
}
}

func precalculatingMethod() {
var possiblePoints = [(Int, Int)]()

for y in -15...15 {
for x in -15...15 {
let r2 = x * x + y * y

if r2 >= 100 && r2 <= 225 {
possiblePoints.append((x, y))
}
}
}

possiblePoints.shuffle()

var rows = [[String]](repeating: Array(repeating: " ", count: 62), count: 31)

for (x, y) in possiblePoints {
rows[y + 15][x + 15 * 2] = "*"
}

for row in rows {
print(row.joined())
}
}

print("Filtering method:")
filteringMethod()

print("Precalculating method:")
precalculatingMethod()</syntaxhighlight>

{{out}}

<pre>Filtering method:
*
** *
** ** *
* ** * *
** * *
* ** **
* *
*
* ** *
* *
* * * ***
*
* * *
**
* *
* *
*
* * *
*
* **
*
* * *
* *
*
** **
* **
*** * *
* ** * *
* *
* * *
*
Precalculating method:
*
***********
***************
*******************
*********************
***********************
******** ********
******* *******
****** ******
****** ******
****** ******
***** *****
***** *****
***** *****
***** *****
****** ******
***** *****
***** *****
***** *****
***** *****
****** ******
****** ******
****** ******
******* *******
******** ********
***********************
*********************
*******************
***************
***********
*
</pre>


=={{header|SystemVerilog}}==
=={{header|SystemVerilog}}==
<lang SystemVerilog>program main;
<syntaxhighlight lang="systemverilog">program main;


bit [39:0] bitmap [40];
bit [39:0] bitmap [40];
Line 3,481: Line 4,190:
end
end


endprogram</lang>
endprogram</syntaxhighlight>


Piping the output through sed to improve the contrast of the output:
Piping the output through sed to improve the contrast of the output:
Line 3,523: Line 4,232:


=={{header|Tcl}}==
=={{header|Tcl}}==
<lang tcl>package require Tcl 8.5
<syntaxhighlight lang="tcl">package require Tcl 8.5


# Generate random point at specified distance from the centre
# Generate random point at specified distance from the centre
Line 3,556: Line 4,265:
}
}
puts ""
puts ""
}</lang>
}</syntaxhighlight>
Example output:
Example output:
<pre>
<pre>
Line 3,591: Line 4,300:
1
1
</pre>
</pre>

=={{header|Wren}}==
{{libheader|DOME}}
<syntaxhighlight lang="wren">import "graphics" for Canvas, Color
import "dome" for Window
import "random" for Random

class Game {
static init() {
Window.title = "Constrained random points on a circle"
var width = 800
var height = 800
Window.resize(width, height)
Canvas.resize(width, height)
var rand = Random.new()
var count = 0
var max = 100 // set to 1000 to produce a much more pronounced annulus
while (true) {
var x = rand.int(-15, 16)
var y = rand.int(-15, 16)
var dist = (x*x + y*y).sqrt
if (10 <= dist && dist <= 15) {
// translate coordinates to fit in the window
Canvas.circlefill((x + 16) * 25, (y + 16) * 25, 2, Color.white)
count = count + 1
if (count == max) break
}
}
}

static update() {}

static draw(alpha) {}
}</syntaxhighlight>


=={{header|XPL0}}==
=={{header|XPL0}}==
[[File:DonutXPL0.gif|right]]
[[File:DonutXPL0.gif|right]]
<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
int X, Y, C, R2;
int X, Y, C, R2;
[SetVid($13); \set 320x200x8 graphics mode
[SetVid($13); \set 320x200x8 graphics mode
Line 3,606: Line 4,349:
C:= ChIn(1); \wait for keystroke
C:= ChIn(1); \wait for keystroke
SetVid(3); \restore normal text mode
SetVid(3); \restore normal text mode
]</lang>
]</syntaxhighlight>


=={{header|zkl}}==
=={{header|zkl}}==
<lang zkl>xy:=(0).walker(*).tweak(fcn{ // generate infinite random pairs (lazy)
<syntaxhighlight lang="zkl">xy:=(0).walker(*).tweak(fcn{ // generate infinite random pairs (lazy)
x:=(-15).random(16); y:=(-15).random(16);
x:=(-15).random(16); y:=(-15).random(16);
if(not (100<=(x*x + y*y)<=225)) Void.Skip else T(x,y)
if(not (100<=(x*x + y*y)<=225)) Void.Skip else T(x,y)
Line 3,618: Line 4,361:


xy.walk(100).apply2(fcn([(x,y)],array){array[x+15 + N*(y+15)]="*"},array);
xy.walk(100).apply2(fcn([(x,y)],array){array[x+15 + N*(y+15)]="*"},array);
foreach n in ([0..30]){ array[n*N,30].concat().println(); }</lang>
foreach n in ([0..30]){ array[n*N,30].concat().println(); }</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 3,655: Line 4,398:
=={{header|ZX Spectrum Basic}}==
=={{header|ZX Spectrum Basic}}==
{{trans|BBC_BASIC}}
{{trans|BBC_BASIC}}
<lang zxbasic>10 FOR i=1 TO 1000
<syntaxhighlight lang="zxbasic">10 FOR i=1 TO 1000
20 LET x=RND*31-16
20 LET x=RND*31-16
30 LET y=RND*31-16
30 LET y=RND*31-16
40 LET r=SQR (x*x+y*y)
40 LET r=SQR (x*x+y*y)
50 IF (r>=10) AND (r<=15) THEN PLOT 127+x*2,88+y*2
50 IF (r>=10) AND (r<=15) THEN PLOT 127+x*2,88+y*2
60 NEXT i</lang>
60 NEXT i</syntaxhighlight>

Latest revision as of 22:25, 13 February 2024

Task
Constrained random points on a circle
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that
.
Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once.

There are several possible approaches to accomplish this. Here are two possible algorithms.

1) Generate random pairs of integers and filter out those that don't satisfy this condition:

.

2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

11l

Translation of: Julia
F print_circle(lo, hi, ndots)
   V canvas = [[0B] * (2*hi+1)] * (2*hi+1)
   V i = 0
   L i < ndots
      V x = random:(-hi..hi)
      V y = random:(-hi..hi)
      I x^2 + y^2 C lo^2 .. hi^2
         canvas[x + hi][y + hi] = 1B
         i++

   L(i) 0 .. 2*hi
      print(canvas[i].map(j -> I j {‘♦ ’} E ‘  ’).join(‘’))
 
print_circle(10, 15, 100)

Action!

PROC DrawCircle(BYTE rmin,rmax,max,x0,y0)
  BYTE count,limit
  INT x,y,r2,rmin2,rmax2

  limit=rmax*2+1
  rmin2=rmin*rmin
  rmax2=rmax*rmax
  count=0
  WHILE count<max
  DO
    x=Rand(limit) y=Rand(limit)
    x==-rmax y==-rmax
    r2=x*x+y*y
    IF r2>=rmin2 AND r2<=rmax2 THEN
      Plot(x+x0,y+y0)
      count==+1
    FI
  OD
RETURN

PROC Main()
  BYTE CH=$02FC,COLOR0=$02C4

  Graphics(5+16)
  Color=1
  COLOR0=$0C

  DrawCircle(10,15,100,40,24)

  DO UNTIL CH#$FF OD
  CH=$FF
RETURN
Output:

Screenshot from Atari 8-bit computer

Ada

with Ada.Text_IO;
with Ada.Numerics.Discrete_Random;
procedure Circle is
   -- extreme coordinate values are -15:0, 15:0, 0:-15, 0:15
   subtype Coordinate is Integer range -15 .. 15;
   type Point is record
      X, Y : Coordinate;
   end record;
   type Point_List is array (Positive range <>) of Point;

   function Acceptable (Position : Point) return Boolean is
      Squared_Sum : Natural := Position.X ** 2 + Position.Y ** 2;
   begin
      return 10 ** 2 <= Squared_Sum and Squared_Sum <= 15 ** 2;
   end Acceptable;

   -- first algorithm
   function Generate_Random_Points
     (Count : Positive := 100)
      return  Point_List
   is
      package RNG is new Ada.Numerics.Discrete_Random (Coordinate);
      Generator  : RNG.Generator;
      Next_Point : Point;
      Result     : Point_List (1 .. Count);
   begin
      RNG.Reset (Generator);
      for N in Result'Range loop
         loop
            Next_Point.X := RNG.Random (Generator);
            Next_Point.Y := RNG.Random (Generator);
            exit when Acceptable (Next_Point);
         end loop;
         Result (N) := Next_Point;
      end loop;
      return Result;
   end Generate_Random_Points;

   -- second algorithm
   function Choose_Precalculated
     (Count : Positive := 100)
      return  Point_List
   is
      subtype Possible_Points is Positive range 1 .. 404;
      package RNG is new Ada.Numerics.Discrete_Random (Possible_Points);
      Generator  : RNG.Generator;
      Point_Pool : Point_List (Possible_Points);
      Next_Point : Point;
      Next_Index : Possible_Points := 1;
      Result     : Point_List (1 .. Count);
   begin
      -- precalculate
      Precalculate : for X in Coordinate'Range loop
         Next_Point.X := X;
         for Y in Coordinate'Range loop
            Next_Point.Y := Y;
            if Acceptable (Next_Point) then
               Point_Pool (Next_Index) := Next_Point;
               exit Precalculate when Next_Index = Possible_Points'Last;
               Next_Index := Next_Index + 1;
            end if;
         end loop;
      end loop Precalculate;
      -- choose
      RNG.Reset (Generator);
      for N in Result'Range loop
         Result (N) := Point_Pool (RNG.Random (Generator));
      end loop;
      return Result;
   end Choose_Precalculated;

   procedure Print_Points (Points : Point_List) is
      Output_String : array (Coordinate, Coordinate) of Character :=
        (others => (others => ' '));
   begin
      for N in Points'Range loop
         Output_String (Points (N).X, Points (N).Y) := '*';
      end loop;
      for Line in Output_String'Range (2) loop
         for Column in Output_String'Range (1) loop
            Ada.Text_IO.Put (Output_String (Column, Line));
         end loop;
         Ada.Text_IO.New_Line;
      end loop;
   end Print_Points;

   My_Circle_Randomly      : Point_List := Generate_Random_Points;
   My_Circle_Precalculated : Point_List := Choose_Precalculated;
begin
   Ada.Text_IO.Put_Line ("Randomly generated:");
   Print_Points (My_Circle_Randomly);
   Ada.Text_IO.Put_Line ("Chosen from precalculated:");
   Print_Points (My_Circle_Precalculated);
end Circle;

Output: 

Randomly generated:

              **
          *  *    * *
               * * *  **
     *     * *      *
    **  *              * *
   *     *           *  *
      *              *   * *
   *                   **
  *    *               *
    *
    *                       *
   *                      * *
  * *                        *
                             *

   * *                       *
  *
     *                       *
  ***                      *
     *                  *    *
                            *
   *                       *
                     **    *
         **
     *        *   **     *
         * *        * *
      ***  * *         **
        * *   * ***
               *  *

Chosen from precalculated:

            *
            *    *   *
           * **   ** ** *
           * *  * *
                      *
   *  ** *              *
    *    *               * *
  *    *                ***
  *  ***                 *
                        *  * *
                            *

  *                       * *
    *                      **

   *
 *  **                     ***
                           *
                         *   *
  * **
   *                     *
     *
    *   *
         **           *
    *  *     *  *       * *
       **  *       *  * *
      *   **
        *
           *    * ***

ALGOL 68

Translation of: C

- note: This specimen retains the original C coding style.

Works with: ALGOL 68 version Revision 1 - no extensions to language used - requires ansi/xterm & ascii
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
PROC clrscr = VOID: 
        printf(($g"[2J"$,REPR 27)); # ansi.sys #

PROC gotoxy = (INT x,y)VOID: 
        printf(($g"["g(0)";"g(0)"H"$,REPR 27, y,x)); # ansi.sys #

MODE POINT = STRUCT(
    INT x,y
);

INT radius = 15;
INT inside radius = 10;

POINT center = (radius+1, radius+1);

FLEX[0]POINT set;

PROC swap with last set = (INT position,INT where last set)VOID:
(
        INT temp := x OF set[position];
        x OF set[position]:=x OF set[where last set];
        x OF set[where last set] := temp;

        temp := y OF set[position];
        y OF set[position]:=y OF set[where last set];
        y OF set[where last set] := temp
);

PROC create set = VOID:
(
        set := HEAP[(2*radius+1)**2]POINT;
        INT x,y,i:=LWB set;

        FOR x FROM -radius TO radius DO
                FOR y FROM -radius TO radius DO
                        IF sqrt(x*x+y*y)>=inside radius AND sqrt(x*x+y*y)<=radius THEN
                                x OF set[i] := x;
                                y OF set[i] := y;
                                i+:=1
                        FI
                OD
        OD;

        set:=set[:i-1]
);

PROC plot fuzzy set = (CHAR ch)VOID:
(
        INT pos,i;

        TO UPB set DO
                pos := ENTIER(random * UPB set) + 1;

                gotoxy(x OF center + x OF set[pos],y OF center + y OF set[pos]);

                print(ch);

                swap with last set(pos,UPB set)

        OD
);

main:
(
        # srand((INT)time(NIL)); #

        clrscr;
        create set;
        plot fuzzy set("*");
        gotoxy(2*radius+1, 2*radius+1);
        newline(stand in)
)

Sample output: 

           *  * **
        * * *  * ** **
      ***** **   ***** **
     ** **  *  * * * ***
      *  ******** *** *** *
   ** *****         ** * ***
        *            ***** *
   ** **               **** *
   * * *               ****
  ****                  * ****
 * **                    *** *
 ** **                    **
 **                      * * *
  ****                   **  *
 ** *                    ****
 ****                     ** *
 *  **                   *  **
  * **                    *  *
 * ***                    *  *
 ******                 * * **
  * * **               **** *
   ** *                ***  *
   **** **           *    **
    ** ***            * ***
    * *  *** * **  *** ***
      *  *  ** ***** ****
      ** ******* *  *
        * ** ** *******
          *  ****** *
               *

AutoHotkey

Requires the GDI+ standard library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238
Works with individual pixels. 

z=100 ; x = x-coord; y = y-coord; z = count; pBitmap = a pointer to the image; f = filename

pToken	:= Gdip_Startup()
pBitmap := Gdip_CreateBitmap(31, 32)

While z
{
	Random, x, -20, 20
	Random, y, -20,20
	If ( t := sqrt(x**2 + y**2) ) >= 10 && t <= 15
		Gdip_SetPixel(pBitmap, x+15, y+16, 255<<24), z--
}

Gdip_SaveBitmapToFile(pBitmap, f := A_ScriptDir "\ahk_fuzzycircle.png")
run % f

Gdip_DisposeImage(pBitmap)
Gdip_Shutdown(pToken)

BASIC

BASIC256

Translation of: PureBasic
graphsize 31, 31

for i = 1 to 100
    do
	x = int(rand * 30) - 15
	y = int(rand * 30) - 15
	r = sqr(x*x + y*y)
    until 10 <= r and r <= 15
    color rgb(255, 0, 0)
    plot(x+15, y+15)
next i
end

BBC BASIC

      MODE 8
      ORIGIN 640, 512
      FOR i% = 1 TO 1000
        x% = RND(31)-16
        y% = RND(31)-16
        r = SQR(x%^2 + y%^2)
        IF r >= 10 IF r <= 15 PLOT x%*2, y%*2
      NEXT

FreeBASIC

Pre calculate and plot 100 points to the console 

'Free Basic version .9

#define Intrange(f,l) int(Rnd*(((l)+1)-(f))+(f))

Type pair
    As Integer x,y
End Type

Operator =(a As pair,b As pair) As Integer
Return a.x=b.x And a.y=b.y
End Operator

Function NotInArray(a() As pair,n As pair) As Integer
    For z As Integer=Lbound(a) To Ubound(a)
        If a(z)=n Then Return 0
    Next z
    Return -1
End Function

Redim As pair pts(0)
Dim As Integer x,y,counter
Do
    counter=counter+1
    x=IntRange(-20,20)
    y=IntRange(-20,20)
    var root=Sqr(x*x+y*y)
    If 10<= root And root<=15 Then
        If NotInArray(pts(),Type<pair>(x,y)) Then
            Redim Preserve pts(1 To Ubound(pts)+1)
            pts(Ubound(pts))=Type<pair>(x,y)
        End If
    End If
Loop Until counter=100000

'============== Plot to Console ====================== 

dim as integer yres=hiword(width)
dim as integer xres=loword(width)

#define map(a,b,x,c,d)  ((d)-(c))*((x)-(a))/((b)-(a))+(c)
#define _X(num) int( map(0,xres,(num),0,loword(width))) 
#define _Y(num) int( map(0,yres,(num),0,hiword(width)))

counter=0
For n As Integer=Lbound(pts) To Ubound(pts)
    counter=counter+1
    if counter <=100 then 
    var xpos=map(-20,20,pts(n).x,0,xres)
    var ypos=map(-20,20,pts(n).y,0,yres)
    locate _Y(ypos),_X(xpos)
    print "*"
    end if
Next n

print
locate 1,1
Print "Total number of points "; counter
print "Total number plotted   ";100
print "done"
Sleep

Console output: 

Total number of points  404
Total number plotted    100
done                                           * *
                         *                 *       *
                           *     * * *       *           *
                 * * * *     *                 * * *     *     *
                 * *                               *   * *
             *   * * * *                                         *
                                                             *
             * *                                           *     * *
           * *   *                                         * *     *
               *                                             * *   *
             * * *                                           *     *

                   *                                         * * * *
               *   * *                                     * * *
               *           *                         *
                 *         *         *   *     * *     *     *
                               *         *     * *
                     *   *   *   *   * * *   *   *     * *
                                       * *   * * *

Yabasic

Translation of: PureBasic
open window 100, 100
clear window

for i = 1 to 100
	repeat
		x = ran(30)-15
		y = ran(30)-15
		r = sqr(x*x + y*y)
	until 10 <= r and r <= 15
	color 255, 0, 0
	dot x+15, y+15
next i
end

C

#include <stdio.h>
#include <stdlib.h>

inline
int randn(int m)
{
	int rand_max = RAND_MAX - (RAND_MAX % m);
	int r;
	while ((r = rand()) > rand_max);
	return r / (rand_max / m);
}

int main()
{
	int i, x, y, r2;
	unsigned long buf[31] = {0}; /* could just use 2d array */

	for (i = 0; i < 100; ) {
		x = randn(31) - 15;
		y = randn(31) - 15;
		r2 = x * x + y * y;
		if (r2 >= 100 && r2 <= 225) {
			buf[15 + y] |= 1 << (x + 15);
			i++;
		}
	}

	for (y = 0; y < 31; y++) {
		for (x = 0; x < 31; x++)
			printf((buf[y] & 1 << x) ? ". " : "  ");
		printf("\n");
	}

	return 0;
}

Output

                            .   .     . .                     
                    .           .         .                   
                  .           .           . .                 
                              .             .     .           
                    .       .       .     . .                 
          .                                 .       .         
          .       .                               .           
          .                                     .             
                                                . .           
                                                  .   .       
      . .                                                     
        . .                                       . .         
  .       .                                               .   
                                                              
                                                    .         
  .                                                           
                                                              
      . .                                                 .   
    .                                                 . .     
      .   . .                                                 
      .   .                                   .         .     
        .                                       . . .   .     
          .       .                                           
      . .     .                                 .             
          .   .     .   .   .         .           .           
                    .       . .         .                     
              . . .   . . .       .                           
                  . .     .               .                   
                                        .                     
                              .

C#

using System;
using System.Diagnostics;
using System.Drawing;

namespace RosettaConstrainedRandomCircle
{
    class Program
    {
        static void Main(string[] args)
        {
            var points = new Point[404];
            int i = 0;
            for (int y = -15; y <= 15; y++)
                for (int x = -15; x <= 15 && i < 404; x++)
                {
                    var c = Math.Sqrt(x * x + y * y);
                    if (10 <= c && c <= 15)
                    {
                        points[i++] = new Point(x, y);
                    }
                }

            var bm = new Bitmap(600, 600);
            var g = Graphics.FromImage(bm);
            var brush = new SolidBrush(Color.Magenta);

            var r = new System.Random();
            for (int count = 0; count < 100; count++)
            {
                var p = points[r.Next(404)];
                g.FillEllipse(brush, new Rectangle(290 + 19 * p.X, 290 + 19 * p.Y, 10, 10));
            }
            const string filename = "Constrained Random Circle.png";
            bm.Save(filename);
            Process.Start(filename);
        }
    }
}

C++

#include <windows.h>
#include <list>
#include <iostream>

//--------------------------------------------------------------------------------------------------
using namespace std;

//--------------------------------------------------------------------------------------------------
class point
{
public:
    int x, y;
    point()                  { x = y = 0; }
    point( int a, int b )    { x = a; y = b; }
    void set( int a, int b ) { x = a; y = b; }
};
//--------------------------------------------------------------------------------------------------
class rndCircle
{
public:
    void draw()
    {
	createPoints();
	drawPoints();
    }

private:
    void createPoints()
    {
	point pt;
	for( int x = 0; x < 200; x++ )
	{
	    int a, b, c;
	    while( true )
	    {
		a = rand() % 31 - 15;
		b = rand() % 31 - 15;
		c = a * a + b * b;
		if( c >= 100 && c <= 225 ) break;
	    }
	    pt.set( a, b );
	    _ptList.push_back( pt );
	}
    }

    void drawPoints()
    {
	HDC dc = GetDC( GetConsoleWindow() );
	for( list<point>::iterator it = _ptList.begin(); it != _ptList.end(); it++ )
	    SetPixel( dc, 300 + 10 * ( *it ).x, 300 + 10 * ( *it ).y, RGB( 255, 255, 0 ) );
    }

    list<point> _ptList;
};
//--------------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
    ShowWindow( GetConsoleWindow(), SW_MAXIMIZE );
    srand( GetTickCount() );
    rndCircle c;
    c.draw();
    system( "pause" );
    return 0;
}
//--------------------------------------------------------------------------------------------------

Clojure

(ns rosettacode.circle-random-points
  (:import [java.awt Color Graphics Dimension]
           [javax.swing JFrame JPanel]))
 
(let [points (->> (for [x (range -15 16), y (range -15 16)
			:when (<= 10 (Math/hypot x y) 15)]
		    [(+ x 15) (+ y 15)])
		  shuffle
		  (take 100))]
  (doto (JFrame.)
    (.add (doto (proxy [JPanel] []
		  (paint [^Graphics g]
                    (doseq [[x y] points]
                      (.fillRect g (* 10 x) (* 10 y) 10 10))))
	    (.setPreferredSize (Dimension. 310 310))))
    (.setResizable false)
    (.setDefaultCloseOperation JFrame/DISPOSE_ON_CLOSE)
    .pack
    .show))

COBOL

       identification division.
       program-id. circle.
       environment division.
       input-output section.
       file-control.
           select plot-file assign "circle.txt".
       data division.
       file section.
       fd plot-file report plot.
       working-storage section.
       1 binary.
        2 seed pic 9(18).
        2 x pic s9(4).
        2 y pic s9(4).
        2 i pic 9(4).
        2 dot-count pic 9(4) value 0.
        2 dot-count-save pic 9(4) value 0.
        2 temp-points.
         3 pic s9(4) occurs 2.
        2 xy-table.
         3 point-pair occurs 0 to 404 depending dot-count.
          4 x-point pic s9(4).
          4 y-point pic s9(4).
       1 plot-table value all "0".
        2 occurs 31.
         3 dot pic 9 occurs 31.
       1 cur-date-time.
        2 yyyymmdd pic 9(8).
        2 hh pic 9(2).
        2 mm pic 9(2).
        2 ss pic 9(2).
       1 plot-work.
        2 plot-item pic xb occurs 31.
       report section.
       rd plot.
       1 plot-line type de.
        2 line plus 1.
         3 column is 1 source is plot-work pic x(62).
       procedure division.
       begin.
           perform compute-seed
           perform find-all-valid-points
           perform shuffle-point-pairs
           perform select-100-dots
           perform print-dots
           stop run
           .

       find-all-valid-points.
           perform varying x from -15 by 1 until x > +15
               perform varying y from -15 by 1 until y > +15
                   if (function sqrt (x ** 2 + y ** 2))
                       >= 10 and <= 15
                   then
                       move 1 to dot (x + 16 y + 16)
                       add 1 to dot-count
                       compute x-point (dot-count) = x + 16
                       compute y-point (dot-count) = y + 16
                   end-if
               end-perform
           end-perform
           display "Total points: " dot-count
           .

       shuffle-point-pairs.
           move dot-count to dot-count-save
           compute i = function random (seed) * dot-count + 1
           perform varying dot-count from dot-count by -1
           until dot-count < 2
               move point-pair (i) to temp-points
               move point-pair (dot-count) to point-pair (i)
               move temp-points  to point-pair (dot-count)
               compute i = function random * dot-count + 1
           end-perform
           move dot-count-save to dot-count
           .

       select-100-dots.
           perform varying i from 1 by 1
           until i > 100
               compute x = x-point (i)
               compute y = y-point (i)
               move 2 to dot (x y)
           end-perform
           .

       print-dots.
           open output plot-file
           initiate plot
           perform varying y from 1 by 1 until y > 31
               move spaces to plot-work
               perform varying x from 1 by 1 until x > 31
                   if dot (x y) = 2
                       move "o" to plot-item (x)
                   end-if
               end-perform
               generate plot-line
           end-perform
           terminate plot
           close plot-file
           .

       compute-seed.
           unstring function current-date into
               yyyymmdd hh mm ss
           compute seed =
               (function integer-of-date (yyyymmdd) * 86400)
           compute seed = seed
                 + (hh * 3600) + (mm * 60) + ss
           compute seed = function mod (seed 32768)
           .

       end program circle.


                      o   o           o
                o       o   o     o
            o     o   o o
            o         o     o       o o   o   o
        o     o   o o o o                           o
      o   o   o o   o                   o o       o
          o o                               o   o
        o                                               o
          o                                   o
  o                                             o o     o
      o                                                 o
                                                        o
      o                                           o       o
                                                        o o
o       o o                                           o
    o   o                                         o
          o                                       o o
      o
      o                                           o     o
      o   o
      o
    o     o   o                                 o
                                            o   o
      o       o                                   o
          o                     o           o o     o
          o   o                   o
            o o     o o                 o   o
                              o o           o
                            o   o     o
                              o

CoffeeScript

NUM_POINTS = 100
MIN_R = 10
MAX_R = 15

random_circle_points = ->
  rand_point = ->
    Math.floor (Math.random() * (MAX_R * 2 + 1) - MAX_R)
    
  points = {}
  cnt = 0
  while cnt < 100
    x = rand_point()
    y = rand_point()
    continue unless MIN_R * MIN_R <= x*x + y*y <= MAX_R * MAX_R
    points["#{x},#{y}"] = true
    cnt += 1
  points
    
plot = (points) ->
  range = [-1 * MAX_R .. MAX_R]
  for y in range
    s = ''
    for x in range
      s += if points["#{x},#{y}"] then '*' else ' '
    console.log s
        
plot random_circle_points()

The output may be a bit distorted, since even monospace fonts take more vertical space per character than horizontal space. 

> coffee foo.coffee
                               
          **    *              
         * ** *     *          
          *  * *      *        
     *     **           *      
      *  *      *       *      
    *               *          
                      *        
    *                    *     
  ***                          
     **                 **** * 
  * *                          
     *                      *  
  **                           
                          *    
                               
    *                     **   
 *  *                    *     
   **                          
   *                      * ** 
     *                     *   
  *                         *  
                       *    *  
     *  *                      
                       ***     
      *** * *     *     * *    
     ***           *           
      * *       * *  *         
               * *   *

Common Lisp

(flet ((good-p (x y) (<= 100 (+ (* x x) (* y y)) 255)))
  (loop with x with y with cnt = 0
	with scr = (loop repeat 31 collect (loop repeat 31 collect "  "))
	while (< cnt 100)
	do (when (good-p (- (setf x (random 31)) 15)
			 (- (setf y (random 31)) 15))
	     (setf (elt (elt scr y) x) "@ ")
	     (incf cnt))
	finally (mapc #'(lambda (row) (format t "~{~a~^~}~%" row)) scr)))

D

This uses std.complex because D built-in complex numbers will be deprecated. 

import std.stdio, std.random, std.math, std.complex;

void main() {
    char[31][31] table = ' ';

    foreach (immutable _; 0 .. 100) {
        int x, y;
        do {
            x = uniform(-15, 16);
            y = uniform(-15, 16);
        } while(abs(12.5 - complex(x, y).abs) > 2.5);
        table[x + 15][y + 15] = '*';
    }

    writefln("%-(%s\n%)", table);
}
Output:
                               
                   *           
          * **  *              
                  * *          
     **  * *   **  *  *        
    *    *            **  *    
        **            **  *    
                       *   *   
                        *      
       *                 ***   
 *  * *                        
   * *                     *   
   *                        *  
     *                      *  
   **                    * *   
  *                       *    
                            *  
                             * 
  *                          * 
                               
   *                           
     *                     **  
    * *                  *     
         *           * *  *    
   *     *             **      
    *     *  *  *     * *      
     **     *  **   **   *     
          **                   
        *     *  *  *          
               **

Delphi

Library: Winapi.Windows
Library: System.SysUtils
Library: Vcl.Graphics
Library: Vcl.Controls
Library: Vcl.Forms
Library: Vcl.ExtCtrls
Translation of: C#
unit Main;

interface

uses
  Winapi.Windows, System.SysUtils, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.ExtCtrls;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormPaint(Sender: TObject);
  end;

var
  Form1: TForm1;
  Points: TArray<TPoint>;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  ClientHeight := 600;
  ClientWidth := 600;
end;

procedure TForm1.FormPaint(Sender: TObject);
var
  i: integer;
  p: TPoint;
  index: integer;
begin
  SetLength(Points, 404);
  i := 0;
  for var y := -15 to 15 do
    for var x := -15 to 15 do
    begin
      if i >= 404 then
        Break;
      var c := Sqrt(x * x + y * y);
      if (10 <= c) and (c <= 15) then
      begin
        inc(i);
        points[i] := TPoint.Create(x, y);
      end;
    end;
  var bm := TBitmap.create;
  bm.SetSize(600, 600);
  with bm.Canvas do
  begin
    Pen.Color := clRed;
    Brush.Color := clRed;
    Brush.Style := bsSolid;
    Randomize;

    for var count := 0 to 99 do
    begin
      repeat
        index := Random(404);
        p := points[index];
      until (not p.IsZero);
      points[index] := TPoint.Zero;

      var cx := 290 + 19 * p.X;
      var cy := 290 + 19 * p.Y;
      Ellipse(cx - 5, cy - 5, cx + 5, cy + 5);
    end;
  end;
  Canvas.Draw(0, 0, bm);
  bm.Free;
end;
end.

EasyLang

Run it 

while cnt < 100
   x = randint 31 - 16
   y = randint 31 - 16
   r = sqrt (x * x + y * y)
   if 10 <= r and r <= 15
      cnt += 1
      move 50 + x * 2 50 + y * 2
      circle 1
   .
.

EchoLisp

Using the plot library. For a greater visual appeal, points are plotted as circles of random radius and color. The resulting image is at [1]. 

(lib 'math)
(lib 'plot)

(define (points (n 100) (radius 10) (rmin 10) (rmax 15)   (x) (y))
	(plot-clear)
	(plot-x-minmax (- rmax))
	(plot-y-minmax( - rmax))
	
	(for [(i n)]
	(set! x (round (* (random -1) rmax)))
	(set! y (round (* (random -1) rmax)))
	#:when (in-interval? (pythagore x y) rmin rmax)
	;; add a little bit of randomness : dots color and radius
	(plot-fill-color   (hsv->rgb (random) 0.9 0.9))
	(plot-circle x y (random radius)))
	(plot-edit))

Elixir

Algorithm 1: Generate random pairs

Works with: Elixir version 1.1
defmodule Random do
  defp generate_point(0, _, _, set), do: set
  defp generate_point(n, f, condition, set) do
    point = {x,y} = {f.(), f.()}
    if x*x + y*y in condition and not point in set,
      do:   generate_point(n-1, f, condition, MapSet.put(set, point)),
      else: generate_point(n,   f, condition, set)
  end
  
  def circle do
    f = fn -> :rand.uniform(31) - 16 end
    points = generate_point(100, f, 10*10..15*15, MapSet.new)
    range = -15..15
    for x <- range do
      for y <- range do
        IO.write if {x,y} in points, do: "x", else: " "
      end
      IO.puts ""
    end
  end
end

Random.circle

Example output: 

               x
           x x xx    x
      x x  x  x xxx x
         x x x   xx    x
    x  x  x   x     x   x
        xx               x
    xx  x             x
                          xxx
     xxx
                          xxx
 x                           x

 x                          xx
   xx                        x
 x
                            xx
   x                     x  x
  xx
  x                      x
  xx x                   x   x
  x x                     x
       x                 x
      x               xx  xx
     x                x  x
          x  x      x   x
       x xx          x xx
          x    xx x    x
           x xx  x
                x  xx

Algorithm 2: Precalculate

Translation of: Ruby
Works with: Elixir version 1.2
defmodule Constrain do
  def circle do
    range = -15..15
    r2 = 10*10..15*15
    all_points = for x <- range, y <- range, x*x+y*y in r2, do: {x,y}
    IO.puts "Precalculate: #{length(all_points)}"
    points = Enum.take_random(all_points, 100)
    Enum.each(range, fn x ->
      IO.puts Enum.map(range, fn y -> if {x,y} in points, do: "o ", else: "  " end)
    end)
  end
end

Constrain.circle
Example:
Precalculate: 404

                      o       o
                                          o
                  o o o     o         o         o
          o o         o                   o o
            o   o o o     o             o o
      o o   o                                   o
        o o o o                           o
    o         o                                 o       o
    o o                                       o   o     o
    o   o                                               o

                                                  o   o   o
                                                  o     o
  o       o                                               o
o     o                                               o   o o
                                                    o
      o                                           o       o
      o   o                                       o o   o o
                                                        o
                                                  o       o
    o o                                         o
            o                                   o     o
                                          o o   o o   o
            o                           o     o
                o                 o o o o       o o
          o   o           o               o o   o
                                      o
                  o o
                      o       o

Euphoria

Works with: Euphoria version 4.0.3, 4.0.0 or later

This program generates the set of 404 possible points in the ring. It randomly chooses 100 pairs from the set. The 100 pairs are a subset of that set because duplicates are discarded. 

include std/console.e

sequence validpoints = {}
sequence discardedpoints = {}
sequence rand100points = {}
atom coordresult
integer randindex

--scan for all possible values. store discarded ones in another sequence, for extra reference.
for y = -15 to 15 do
    for x = -15 to 15 do
        
        coordresult = sqrt( x * x + y * y )
        
        if coordresult >= 10 and coordresult <= 15 then --if it would fall in the ring area
            validpoints &= {{x, y, coordresult}} --concatenate (add to the end) the coordinate pair x, y and the
            -- result into a subsequence of sequence validpoints
            else
                discardedpoints &= {{x, y, coordresult}} --else put it in the discarded sequence    
        end if
        
    end for
end for

for i = 1 to 100 label "oneofhundred" do --make 100 random coordinate pairs
    randindex = rand(length(validpoints) ) --random value from 1 to the number of 3 value subsequences in validpoints (the data)

    if length(rand100points) = 0 then --if rand100points sequence is empty, add the first subsequence to it.
        rand100points &= {validpoints[randindex]}
        
        else --if it isn't empty, then..
            for j = 1 to length(rand100points) do --loop through each "data chunk" in rand100points
                
                if equal(validpoints[randindex], rand100points[j]) = 1 then --if any are the same as the randomly chosen chunk in
                    retry "oneofhundred" -- validpoints, then retry from one line below the "oneofhundred" loop without incrementing i.
                end if --the continue keyword would increment i instead.

            end for
        
            rand100points &= {validpoints[randindex]} --length of rand100points isnt 0 and no data chunks match ones that the program
            --already picked before, so add this subsequence chunk to rand100points.
    end if
            
end for

for i = 1 to 32 do --32 lines
    printf(1,"\n")
    for j = 1 to 32 label "xscan" do --32 characters on each line
        
        for k = 1 to length(rand100points) do --for every subsequence in this
            if rand100points[k][1]+16 = j and rand100points[k][2]+16 = i then --if the x and y coordinates in the picked points
                printf(1, 178) --(adjusted to minimum of 1,1) are at the same place as in the console output grid
                continue "xscan" --print a funny character and continue to the next "xscan"
            end if
        end for
        
        printf(1, 176) --if no picked points were there, print another funny character to represent a blank space
        
    end for
end for

printf(1, "\nNumber of valid coordinate pairs %d :", length(validpoints) )
printf(1, "\nNumber of discarded coordinate pairs : %d", length(discardedpoints) )
printf(1, "\nNumber of randomly picked coordinate pairs : %d\n", length(rand100points) )
any_key()

Output: 

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▓░░░░░░░░░░░░░░
░░░░░░░░░░░░░▓░░░░░░░░░░░░░░░░░░
░░░░░░░░░▓░░░▓▓░▓░░░▓░░░░░░░░░░░
░░░░░░▓░░░░░░▓░░░▓░░░░░▓░▓░░░░░░
░░░░░░░░░▓░▓░░░░░░░▓░░▓░░▓▓░░░░░
░░░▓░░░░▓░▓░░░░░░░░░░░░▓░░░░░░░░
░░░░░░░░░▓░░░░░░░░░░░▓░░░▓░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▓▓░░▓░░░
░░░░░░▓▓░░░░░░░░░░░░░░░▓░░░░░░░░
░░░░░░▓░░░░░░░░░░░░░░░░░░░░░░░░░
░▓░░▓▓░░░░░░░░░░░░░░░░░░░░░░░▓░░
░░░░░▓░░░░░░░░░░░░░░░░░░░░░░▓░░░
░░▓░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓░░░
░▓░░▓░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░▓░░░░░░░░░░░░░░░░░░░░▓▓▓░▓░░
░░░▓░░░░░░░░░░░░░░░░░░░░░▓░▓░▓░░
░▓▓░░░░░░░░░░░░░░░░░░░░░░░▓▓░░░░
░░░▓░▓░░░░░░░░░░░░░░░░░░░▓░░░░░░
░░░▓░░░░░░░░░░░░░░░░░░░░░▓░░░▓░░
░░▓░▓░░░░░░░░░░░░░░░░░░░▓░░░▓░░░
░░░░░░░▓░░░░░░░░░░░░░░░▓░░░░░░░░
░░░▓░░░░░░░░░░░░░░░░░░░▓░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▓░░░░░░░
░░░░░░▓░░▓░░░░░░░░░░░▓░▓░░░░░░░░
░░░░░░░░░░░░░░░░░▓░░░░░░░░░░░░░░
░░░░░░░▓░░▓░░░░░░░░░░░░▓░░░░░░░░
░░░░░░░░░░░░░▓░▓▓▓▓░░░▓▓░░░░░░░░
░░░░░░░░░▓▓░░▓░░▓░░▓▓░░░░░░░░░░░
░░░░░░░░░░▓░░▓░▓▓▓░░▓░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
Number of valid coordinate pairs 404 :
Number of discarded coordinate pairs : 557
Number of randomly picked coordinate pairs : 100
Press Any Key to continue...

Extra EuSDL code : 

for i = 1 to length(validpoints) do --simple each pixel output to screen surface
    dummy=pixelColor(surface,validpoints[i][1]+18,validpoints[i][2]+18,#AA0202FF) --i is index number of each subsequence 'chunk'. 
    --index 1 is x, index 2 is y, inside that chunk.
end for
        
for i = 1 to length(discardedpoints) do
    dummy=pixelColor(surface,discardedpoints[i][1]+18,discardedpoints[i][2]+52,#0202AAFF)
end for
                
for i = 1 to length(rand100points) do
    dummy=pixelColor(surface,rand100points[i][1]+55,rand100points[i][2]+52,#02AA02FF)
end for

dummy=boxColor(surface,0,71,395,111,#232323FF) --background box
dummy=stringColor(surface,0,73,sprintf("Number of valid coordinate pairs %d :", length(validpoints) ),#AA0202FF)

dummy=stringColor(surface,0,83,sprintf("Number of discarded coordinate pairs : %d", length(discardedpoints) ),#0202AAFF)

dummy=stringColor(surface,0,93,sprintf("Number of randomly picked coordinate pairs : %d", length(rand100points) ),#02AA02FF)

SDL Output :

That particular program used a -16 to +16 square area, so more was discarded.

F#

This version uses method 1 from the task description and just calculates 100 suitable points to plot. The INTERACTIVE bit just permits this code in a .fsx file to be run with the interactive interpreter or compiled to an exe. 

module CirclePoints =
    let main args =
        let rnd = new System.Random()
        let rand size = rnd.Next(size) - size/2
        let size = 30
        let gen n =
            let rec f (x,y) =
                let t = (int (sqrt (float (x*x + y*y)) ))
                if 10 <= t && t <= 15 then (x,y) else f (rand size, rand size)
            f (rand size, rand size)
        let plot = Array.init 100 (fun n -> gen n)
        for row in 0 .. size-1 do
            let chars = Array.create (size+1) ' '
            Array.choose (fun (x,y) -> if y = (row-size/2) then Some(x) else None) plot
            |> Array.iter (fun x -> chars.[x+size/2] <- 'o')
            printfn "%s" (new string(chars))
        0
    
#if INTERACTIVE
CirclePoints.main fsi.CommandLineArgs
#else
[<EntryPoint>]
let main args = CirclePoints.main args
#endif

An example of the output: 

          o  o oo
              o       o

         o o        o o
    o   o o oo o o       o o
   o                      o
     o  oo             oooo
     o                  oo
                       o  o
   oo                      o
  oooo                   o  o
 o                         o
    o
  o
  o                       oo
 o                          o
   o
     o
                         o
      o
   oo                    oo  o
                           o
   o  o  o                o
    o                   o o
    o         o  o  oo
       oo         o oo    o
     o   o      o  o
      o o      o oo   o
              o   o

Factor

Works with: Factor version 0.99 2020-01-23
USING: io kernel math.matrices math.order math.ranges
math.statistics math.vectors random sequences strings ;

CHAR: X -15 15 [a,b] dup cartesian-product concat
[ sum-of-squares 100 225 between? ] filter 100 sample
[ 15 v+n ] map 31 31 32 <matrix> [ matrix-set-nths ] keep
[ >string print ] each
Output:
            XX X X             
        XX  XXX  X X X         
        X           XXX        
        XX     X  X            
      X  X   XX  X    X   X    
       X  X             X      
   X  X              X  XXXX   
  X   X                X  XXX  
     XXX                       
  X                            
                               
  XXX                       XX 
 X                         XX  
                             X 
  X                         X  
                               
     X                         
     X                    X    
    X                          
                        XXX  X 
      X                  X     
  XX                     X     
    XX  X                      
   XX X                   X    
            X  X               
        XXX X          X       
         X   X XX      XX      
         X   X XX X XX         
          X  X

Falcon

// Generate points in [min,max]^2 with constraint
function random_point (min, max, constraint)
  [x, y] = [random(min, max), random(min, max)]
  return constraint(x, y) ? [x, y] : random_point(min, max, constraint)
end

// Generate point list
in_circle = { x, y => 10**2 <= x**2 + y**2 and x**2 + y**2 <= 15**2 }
points = [].comp([0:100], {__ => random_point(-15, 15, in_circle)})

// Show points
for i in [-15:16]
  for j in [-15:16]
    >> [i, j] in points ? "x" : " " 
  end 
  >
end

Example output: 

          xxx  x               
        xx x  x  xx            
          x    xx      xx      
      x x     x x x x x x      
              x      x         
     xx   x          x         
   x    x            x         
     xx                        
  x  x                   xx    
      x                 x      
                         x   x 
 x                        xx   
                             x 
                               
                           xx  
     x                   xx    
 x                       xx  x 
    x                          
                               
  xx  x                     xx 
  xx                    x   x  
                               
         x                 x   
       x x           x    x    
         x     x   x           
     x     x x   x  x    x     
                    x x        
              x x x x

Forth

Works with: gforth version 0.7.3


#! /usr/bin/gforth
\ Constrained random points on a circle

require random.fs

\ initialize the random number generator with a time-dependent seed
utime drop seed !

\ generates a random integer in [-15,15]
: random-coord ( -- n )
    31 random 15 -
;

\ generates a random point on the constrained circle
: random-point ( -- x y )
    0 0
    BEGIN
        2drop
        random-coord random-coord
        2dup dup * swap dup * +
        dup 100 >= swap 225 <= and
    UNTIL
;

31 31 * CONSTANT SIZE
CREATE GRID SIZE cells allot GRID SIZE cells erase

\ get the address of point (x,y)
: point-addr ( x y -- addr )
    15 + 31 * + 15 + cells GRID +
;

\ generate 100 random points and mark them in the grid
: gen-points ( -- )
    100 0 ?DO
        true random-point point-addr !
    LOOP
;

\ prints the grid
: print-grid ( -- )
    16 -15 ?DO
        16 -15 ?DO
            i j point-addr @
            IF
                42
            ELSE
                32
            THEN
            emit
        LOOP
        cr
    LOOP
;

gen-points print-grid
bye
Output:
               *               
          *****                
           *    **  **         
       * * *            *      
             * **              
                ***            
     * **             *        
         *                 *   
      *                 *  **  
                           *   
                               
 *                             
                         *  *  
                               
  * *                    *     
   *                           
                           **  
   *                       *   
                               
 *  *                    *  *  
                           *   
       *                **     
   * **                  * **  
    *   *                 *    
     *  *             **   *   
      **  *  * *  *       *    
            *                  
              ***  *   *       
        **           **        
           *     *

Fortran

Works with: Fortran version 90 and later
program Constrained_Points
  implicit none
 
  integer, parameter :: samples = 100
  integer :: i, j, n, randpoint
  real :: r
 
  type points
    integer :: x, y
  end type

  type(points) :: set(500), temp

! Create set of valid points
  n = 0
  do i = -15, 15
    do j = -15, 15
      if(sqrt(real(i*i + j*j)) >= 10.0 .and. sqrt(real(i*i + j*j)) <= 15.0) then
        n = n + 1
        set(n)%x = i
        set(n)%y = j
      end if
    end do
  end do

! create 100 random points
! Choose a random number between 1 and n inclusive and swap point at this index with point at index 1
! Choose a random number between 2 and n inclusive and swap point at this index with point at index 2
! Continue in this fashion until 100 points have been selected
  call random_seed
  do i = 1, samples
    call random_number(r)
    randpoint = r * (n + 1 - i) + i
    temp = set(i)
    set(i) = set(randpoint)
    set(randpoint) = temp
  end do

! In order to facilitate printing sort random points into ascending order
! sort x in ascending order
  do i = 2, samples
     j = i - 1
     temp = set(i)
        do while (j>=1 .and. set(j)%x > temp%x)
           set(j+1) = set(j)
           j = j - 1
        end do
     set(j+1) = temp
  end do

! sort y in ascending order for same x
  do i = 2, samples
     j = i - 1
     temp = set(i)
        do while (j>=1 .and. set(j)%x == temp%x .and. set(j)%y > temp%y)
           set(j+1) = set(j)
           j = j - 1
        end do
     set(j+1) = temp
  end do
  
! print circle
  write(*,"(a,a)", advance="no") repeat(" ", set(1)%y+15), "*"
  do i = 2, samples
    if(set(i)%x == set(i-1)%x) then
      write(*,"(a,a)", advance="no") repeat(" ", set(i)%y - set(i-1)%y-1), "*"
    else
      n = set(i)%x - set(i-1)%x
      do j = 1, n
        write(*,*)
      end do
      write(*,"(a,a)", advance="no") repeat(" ", set(i)%y+15), "*"
    end if
  end do
 
end program

Output 

                  * * 
        *   *         * 
      ** **    * **    * 
                ** 
     *  **   * **    * 
   ***   **               * 
    *    *           * 
                           * 
  *                      *  * 
     **                   * 
   *                      * 
  *  *                   * 
    *                        * 
    * 
    **                   ***  * 
    *                    * 
    **                   * 
    *                    * 
   *                      * 
  *   *                      * 
      **                 *  * 
    * *                *  ** 
   ** * *               * 
     * 
          ***         * * * 
     **         *   *    * 
         *  * * * 
         *     *  ** * 
            *

Frink

g = new graphics

count = 0
do
{
   x = random[-15,15]
   y = random[-15,15]
   r = sqrt[x^2 + y^2]
   if 10 <= r and r <= 15
   {
       count = count + 1
       g.fillEllipseCenter[x,y,.3, .3]
   }
}  while count < 100

g.show[]

gnuplot

Works with: gnuplot version 5.0 (patchlevel 3) and above
File:RingRandPntsGnu.png
Output RingRandPntsGnu.png
## Ring of random points 2/18/17 aev
reset
fn="RingRandPntsGnu";
ttl="Ring of random points"
ofn=fn.".png"; lim=1000;
randgp(top) = floor(rand(0)*top)
set terminal png font arial 12 size 640,640
set output ofn
set title ttl font "Arial:Bold,12"
unset key;
set size square 
set parametric
set xrange [-20:20]; set yrange [-20:20];
set style line 1 lt rgb "red"
$rring << EOD
EOD
set print $rring append
do for [i=1:lim] {
  x=randgp(30); y=randgp(30);
  r=sqrt(x**2+y**2);
  if (r>=10&&r<=15) \
    {print x," ",y; print -x," ",-y;print x," ",-y; print -x," ",y;}
}
plot [0:2*pi] sin(t)*10,cos(t)*10, sin(t)*15,cos(t)*15 ls 1,\
$rring using 1:2 with points  pt 7 ps 0.5 lc "black"
set output
unset print
Output:
File: RingRandPntsGnu.png

Go

Algorithm 1: 

package main

import (
    "bytes"
    "fmt"
    "math/rand"
    "time"
)

const (
    nPts = 100
    rMin = 10
    rMax = 15
)

func main() {
    rand.Seed(time.Now().Unix())
    span := rMax + 1 + rMax
    rows := make([][]byte, span)
    for r := range rows {
        rows[r] = bytes.Repeat([]byte{' '}, span*2)
    }
    u := 0 // count unique points
    min2 := rMin * rMin
    max2 := rMax * rMax
    for n := 0; n < nPts; {
        x := rand.Intn(span) - rMax
        y := rand.Intn(span) - rMax
        // x, y is the generated coordinate pair
        rs := x*x + y*y
        if rs < min2 || rs > max2 {
            continue
        }
        n++ // count pair as meeting condition
        r := y + rMax
        c := (x + rMax) * 2
        if rows[r][c] == ' ' {
            rows[r][c] = '*'
            u++
        }
    }
    for _, row := range rows {
        fmt.Println(string(row))
    }
    fmt.Println(u, "unique points")
}

Algorithm 2: 

package main

import (
    "bytes"
    "fmt"
    "math/rand"
    "time"
)

const (
    nPts = 100
    rMin = 10
    rMax = 15
)

func main() {
    rand.Seed(time.Now().Unix())
    var poss []struct{ x, y int }
    min2 := rMin * rMin
    max2 := rMax * rMax
    for y := -rMax; y <= rMax; y++ {
        for x := -rMax; x <= rMax; x++ {
            if r2 := x*x + y*y; r2 >= min2 && r2 <= max2 {
                poss = append(poss, struct{ x, y int }{x, y})
            }
        }
    }
    fmt.Println(len(poss), "possible points")
    span := rMax + 1 + rMax
    rows := make([][]byte, span)
    for r := range rows {
        rows[r] = bytes.Repeat([]byte{' '}, span*2)
    }
    u := 0
    for n := 0; n < nPts; n++ {
        i := rand.Intn(len(poss))
        r := poss[i].y + rMax
        c := (poss[i].x + rMax) * 2
        if rows[r][c] == ' ' {
            rows[r][c] = '*'
            u++
        }
    }
    for _, row := range rows {
        fmt.Println(string(row))
    }
    fmt.Println(u, "unique points")
}
Output:
404 possible points
                                                              
                            * *       *                       
                          *           * *                     
                    *     * *       * *                       
            *   *   * * *             *   *                   
          *   *     *   *     *     *       *                 
                                              * * *           
            *   *                                 * * *       
    * *   *                                       *           
    * *   *                                     * *           
        *                                                     
      *                                             *     *   
                                                              
      *                                               * *     
      * *                                                     
* *                                                       *   
    *                                                         
                                                              
      * *                                                     
    *                                               *   *     
      *                                           *           
                                                    *         
    *       *                                                 
          * *                                       *         
              *                         *                     
                  * *         *     *   *     * *             
            *     *   * *                                     
                            *     *     *     *               
                      *   *       *                           
                      *                                       
                              *                               
90 unique points

Haskell

Using Knuth Shuffle 

import Data.List
import Control.Monad
import Control.Arrow
import Rosetta.Knuthshuffle

task = do
  let blanco = replicate (31*31) "  "
      cs = sequence [[-15,-14..15],[-15,-14..15]] :: [[Int]]
      constraint = uncurry(&&).((<= 15*15) &&& (10*10 <=)). sum. map (join (*))
-- select and randomize all circle points
  pts <- knuthShuffle $ filter constraint cs
-- 'paint' first 100 randomized circle points on canvas
  let canvas = foldl (\cs [x,y] -> replaceAt (31*(x+15)+y+15) "/ " cs ) blanco (take 100 pts)
-- show canvas      
  mapM_ (putStrLn.concat). takeWhile(not.null). unfoldr (Just . splitAt 31) $ canvas

Output (added a trailing space per 'pixel' 

*Main> task
                                                              
                      /             / /                       
                          /     /       /                                       
              /                 /                                               
          /     /               /       / / /   /                               
            /                 / /       /                                       
      /     /     /                       /   /                                 
      /         /                           /                                   
        /   / /                                     /   /                       
        / / /                                 /       / /                       
                                                    /                           
    /     /                                       /                             
      / /                                             /                         
      /                                               /   /                     
        /                                                                       
/ /                                                   /     / 
                                                      /   /                     
                                                      /   /                     
      /                                                                         
      /                                             /                           
  /                                                   /       
                                                /     /                         
    /     /                                       /           
              / /                         / /         /       
        /   /       /                             /           
                          / /     / / /   / /                 
          / /             /                   /               
                            / /                               
                /   /   / / /   /       / /                   
                      /             / /

Hy

(import
  math [sqrt]
  random [choice]
  matplotlib.pyplot :as plt)
 
(setv possible-points 
  (lfor
    x (range -15 16) 
    y (range -15 16)
    :if (<= 10 (sqrt (+ (** x 2) (** y 2))) 15)
	  [x y]))

(setv [xs ys] (zip #* (map (fn [_] (choice possible-points)) (range 100))))
  ; We can't use random.sample because that samples without replacement.
  ; #* is also known as unpack-iterable
(plt.plot xs ys "bo")
(plt.show)

Icon and Unicon

Generate random points in the bounded by the outside edge. Reject any found out of the prescribed bounds and stop when the required numbers of points have been generated.

plot of 2000, 100, 120
link graphics

procedure main(A)  # points, inside r, outside r in pixels - default to task values

if \A[1] == "help" then stop("Usage: plot #points inside-radius outside-radius")
points  := \A[1] | 100
outside := \A[2] | 15
inside  := \A[3] | 10
if inside > outside then inside :=: outside

wsize   := integer(2.2*outside) 
wsize  <:= 150
center  := wsize/2

WOpen("size="||wsize||","||wsize,"bg=black","fg=white") | stop("Unable to open window")

until(points -:= 1) <= 0 do {
   x := ?(2*outside)-outside   # random x
   y := ?(2*outside)-outside   # and y
   if (inside <= integer(sqrt(x^2+y^2)) ) <= outside then 
      DrawPoint(x + center,y + center)
   }
WDone()

end

J

This version deals 100 distinct coordinates from the set of acceptable coordinates (much like dealing cards from a shuffled deck): 

gen=: ({~ 100?#)bind((#~ 1=99 225 I.+/"1@:*:),/,"0/~i:15)

Example use (gen'' generates the points, the rest of the example code deals with rendering them as a text array): 

   '*' (<"1]15+gen '')} 31 31$' '
                               
          *                    
               *               
           *  *  * * * *       
     *   *      *  *   *       
                   *   ***     
    **    *         *     **   
    * **                       
       *                   **  
  * *                  *   *   
 *   *                  **     
 * **                       ** 
 ** *                      *** 
 * **                    *   * 
 **                        *   
    *                    **  * 
 **  *                         
 * **                       *  
 *                           * 
    *                        * 
  *                       *    
   **  *                       
       *                  **   
      *                        
      * *            *    *    
     *       ** *     * *      
       *                *      
       **                      
         *   *       *         
            **  *

Java

import java.util.Random;

public class FuzzyCircle {
	static final Random rnd = new Random();
	public static void main(String[] args){
		char[][] field = new char[31][31];
		for(int i = 0; i < field.length; i++){
			for(int j = 0; j < field[i].length; j++){
				field[i][j] = ' ';
			}
		}
		int pointsInDisc = 0;
		while(pointsInDisc < 100){
			int x = rnd.nextInt(31) - 15;
			int y = rnd.nextInt(31) - 15;
			double dist = Math.hypot(x, y);
			if(dist >= 10 && dist <= 15 && field[x + 15][y + 15] == ' '){
				field[x + 15][y + 15] = 'X';
				pointsInDisc++;
			}
		}
		for(char[] row:field){
			for(char space:row){
				System.out.print(space);
			}
			System.out.println();
		}
	}
}

Output: 

                               
            XX X               
        X X    X  X   X        
       X        XX  X          
     XXXX      X        X      
    X    X      X  XXX         
        X             X        
    X                 X  XXX   
    X                     X    
       X               X   XX  
 X   X                       X 
    XX                    X    
                           X   
                               
 X                         X   
 XXXXX                   X   X 
                          X X  
                         X   X 
                          X X  
 X   X                    X    
 X                        X    
    XX                 X       
    XX                  X      
        X            XX   X    
     X XX              X       
    X       X X  X      X      
     XX   X     X      XXX     
        X    X X X     XX      
            X         X        
               X               
               X

JavaScript

JavaScript embedded in HTML, using canvas: 

<html><head><title>Circle</title></head>
<body>
<canvas id="cv" width="320" height="320"></canvas>
<script type="application/javascript">

var cv = document.getElementById('cv');
var ctx = cv.getContext('2d');

var w = cv.width;
var h = cv.height;

//draw circles
ctx.fillStyle = 'rgba(0, 255, 200, .3)';
ctx.strokeStyle = 'rgba(0,0,0,.1)';
ctx.beginPath();
ctx.arc(w/2, h/2, 150, 0, Math.PI*2, true); 
ctx.arc(w/2, h/2, 100, 0, Math.PI*2, false);
ctx.closePath();
ctx.fill();

// draw grids
ctx.beginPath();
for (var i = 10; i < w; i += 10) {
	ctx.moveTo(i, 0);
	ctx.lineTo(i, h);
	ctx.moveTo(0, i);
	ctx.lineTo(w, i);
}
ctx.closePath();
ctx.stroke();

//draw points
ctx.fillStyle = 'navy';
var pts = 0;
while (pts < 100) {
	var x = Math.floor(Math.random() * 31) - 15;
	var y = Math.floor(Math.random() * 31) - 15;
	var r = x * x + y * y;
	if (r < 100 || r > 225) continue;
	x = x * 10 + w/2;
	y = y * 10 + h/2;
	ctx.fillRect(x - 2, y - 2, 4, 4);
	pts++;
}

</script></body></html>

jq

Works with: jq

This solution uses a "generate and test" approach to find exactly 100 points within the specified annulus.

Since jq does not have a built-in PRNG, /dev/random is used instead. gnuplot and a bash or bash-like environment are also assumed. 

#!/bin/bash

< /dev/random tr -cd '0-9' | fold -w 1 | jq -Mcnr '

# Output: a PRN in range(0;$n) where $n is .
def prn:
  if . == 1 then 0
  else . as $n
  | (($n-1)|tostring|length) as $w
  | [limit($w; inputs)] | join("") | tonumber
  | if . < $n then . else ($n | prn) end
  end;

def ss: map(.*.) | add;

# Input: [x,y]
# Emit . iff ss lies within the given bounds
def annulus($min; $max) : ss as $sum | select($min <= $sum and $sum <= $max);

limit(100; 
      repeat([((30 | prn) - 15), ((30 | prn) - 15)]
             | select( annulus(100; 225)) ))
| "\(.[0]) \(.[1])"
' > rc-annulus.dat

The plot can now be generated as a .png file using these gnuplot commands: 

reset
set terminal pngcairo
set output 'rc-annulus.png'
set xrange [-20:20]
set yrange [-20:20]
plot "rc-annulus.dat" with points pt 1

Julia

Works with: Julia version 0.6

This solution uses the "pick random x, y and cull" rather than the "calculate valid and choose randomly" approach. 

function printcircle(lo::Integer, hi::Integer, ndots::Integer; pad::Integer = 2)
    canvas = falses(2hi + 1, 2hi + 1)
    i = 0
    while i < ndots
        x, y = rand(-hi:hi, 2)
        if lo ^ 2 - 1 < x ^ 2 + y ^ 2 < hi ^ 2 + 1
            canvas[x + hi + 1, y + hi + 1] = true
            i += 1
        end
    end
    # print
    for i in 1:(2hi + 1)
        row = map(j -> j ? "\u25cf " : "  ", canvas[i, :])
        println(" " ^ pad, join(row))
    end
    return canvas
end

printcircle(10, 15, 100)
Output:
                                                                 
                          ●                 ●                     
                          ●     ● ● ●           ●                 
                  ●         ● ●                 ●                 
                ●           ●                 ●     ●             
                    ●           ●               ● ●               
                  ●                                 ●             
                    ●                         ●       ●           
        ●       ●                                     ●           
        ●                                               ●         
                                                        ● ● ● ●   
              ●                                       ●           
          ●                                                       
        ● ● ●                                             ●   ●   
                                                        ●     ●   
                                                                  
          ●                                             ●   ●     
                                                          ●       
      ●                                                 ● ●       
            ●                                         ●           
      ●   ●                                                       
          ● ●     ●                                 ●       ●     
                ● ●                                   ●   ●       
                      ●                                           
            ● ●       ● ●                       ●                 
              ●         ● ● ● ●   ●             ● ● ● ●           
                ●   ●           ●   ● ● ●                         
                            ● ●   ●                               
                        ●             ●                           
                            ● ●

Kotlin

// version 1.1.3

fun main(args: Array<String>) {
    val r = java.util.Random()
    val points = Array(31) { CharArray(31) { ' ' } }
    var count = 0
    while (count < 100) {
        val x = r.nextInt(31) - 15
        val y = r.nextInt(31) - 15
        val h = x * x + y * y
        if (h in 100..225) {
            points[x + 15][y + 15] = 'o'
            count++
        }
    }
    for (i in 0..30) println(points[i].joinToString(""))
}

Sample output: 

            ooo oo  o          
           o                   
               oo   oo         
       o      oo      o        
      o   ooo oo               
                    o    oo    
     o  o               o      
     o o                 oo o  
     o o                       
                         o o   
     o                   ooo   
    o                    oo    
  o oo                         
  o                       o    
  o                         o o
  o o                          
     o                   ooo   
 o  o                    o     
   o                           
 oo                      o  oo 
   oo                      o   
   o  o                 o      
                               
                     ooo o     
     oo               o        
     o         o   o           
          oo  o     o          
                    o o        
                 o  o

Lambdatalk

{def circ
 {lambda {:cx :cy :r}
  {div {@ style="position:absolute;
                 top: {- :cy :r}px; left: {- :cx :r}px;
                 width: {* 2 :r}px; height: {* 2 :r}px;
                 border: 1px solid #000; border-radius: :rpx;"}} }}
-> circ

{def fuzzy_circle
 {lambda {:cx :cy :rmin :rmax :n}
  {circ :cx :cy :rmax}
  {circ :cx :cy :rmin}
  {S.map {{lambda {:cx :cy :rmin :rmax :i}       
                {let { {:cx :cx} {:cy :cy}
                       {:rmin :rmin} {:rmax :rmax}
                       {:x {- {round {* {random} {* 2 :rmax}}} :rmax}}  
                       {:y {- {round {* {random} {* 2 :rmax}}} :rmax}}  
                     } {let { {:x {+ :cx :x }}
                              {:y {+ :cy :y }}  
                              {:rr {+ {* :x :x} {* :y :y}}}  
                              {:r2min {* :rmin :rmin}}
                              {:r2max {* :rmax :rmax}}
                    } {if {or {< :rr :r2min} {> :rr :r2max}}
                       then else {circ :x :y 2}} 
           }}} :cx :cy :rmin :rmax}
          {S.serie 1 :n}} }}
-> fuzzy_circle  

{fuzzy_circle 200 700 80 120 1000} 
-> plots 1000 dots between the circles r=80 and r=120 centered at [200,700]
   directly in the wiki page (out of any canvas or svg contexts) as it
   can be seen in http://lambdaway.free.fr/lambdawalks/?view=fuzzy_circle

Liberty BASIC

'   RC Constrained Random Points on a Circle

nomainwin

WindowWidth  =400
WindowHeight =430

open "Constrained Random Points on a Circle" for graphics_nsb as #w

#w "trapclose [quit]"
#w "down ; size 7 ; color red ; fill black"

for i =1 to 1000
  do
     x =int( 30 *rnd( 1)) -15
     y =int( 30 *rnd( 1)) -15
  loop until IsInRange( x, y) =1
  #w "set "; 200 +10 *x; " "; 200 - 10 *y
next

wait

function IsInRange( x, y)
  z =sqr( x*x +y*y)
  if 10 <=z and z <=15 then IsInRange =1 else IsInRange =0
end function

[quit]
close #w
end

Locomotive Basic

10 MODE 1:RANDOMIZE TIME
20 FOR J=1 TO 100
30 X=INT(RND*30-15)
40 Y=INT(RND*30-15)
50 D=X*X+Y*Y
60 IF D<100 OR D>225 THEN GOTO 40
70 PLOT 320+10*X,200+10*Y:LOCATE 1,1:PRINT J
80 NEXT
90 CALL &BB06 ' wait for key press

Lua

Method 1, modified so that the 100 points must be unique.. 

t, n = {}, 0
for y=1,31 do t[y]={} for x=1,31 do t[y][x]="  " end end
repeat
  x, y = math.random(-15,15), math.random(-15,15)
  rsq = x*x + y*y
  if rsq>=100 and rsq<=225 and t[y+16][x+16]=="  " then
    t[y+16][x+16], n = "██", n+1
  end
until n==100
for y=1,31 do print(table.concat(t[y])) end
Output:
                      ██          ██
                  ██  ████            ██    ██
              ████        ████      ██
                ██      ██  ████            ██    ██
            ██          ████                ██  ██
        ██      ██                          ██      ██
      ██  ██  ██  ██                        ██    ████
            ██                                        ████
      ██                                      ██
    ████                                              ██
      ██████
          ██
  ██    ██                                        ██
    ██  ██                                              ██
  ██  ██                                          ██
          ██
      ██
  ██    ██                                            ██
                                                    ██
                                                      ██████
        ██                                          ██  ██
    ████
                                                  ██  ██
          ████                                      ██
            ████  ██████          ████        ██
            ██            ████  ██  ██  ██  ██    ██
                  ████  ██                    ████
                  ██            ██
                      ██        ████

Maple

 a := table():
 i := 1:
 while i < 100 do
 ba := (rand(-15 .. 15))():
 bb := (rand(-15 .. 15))():
 b := evalf(sqrt(ba^2+bb^2)):
 if b <= 15 and b >= 10 
  then a[i] := [ba, bb]: 
  i := i+1: 
 end if:
 end do:
 plots:-pointplot(convert(a,list));

Mathematica / Wolfram Language

This algorithm generates 500 pairs of random integers between +/- 15, picks out the ones that satisfy the inequality, and then takes the first 100 of those. It oversamples to reduce the chance of having less than 100 "candidates", which is not impossible, though extremely unlikely. 

sample = Take[Cases[RandomInteger[{-15, 15}, {500, 2}], {x_, y_} /; 10 <= Sqrt[x^2 + y^2] <= 15], 100];

Show[{RegionPlot[10 <= Sqrt[x^2 + y^2] <= 15, {x, -16, 16}, {y, -16, 16}, Axes -> True], ListPlot[sample]}]

MATLAB

Uses the Monte-Carlo method described above. 

function [xCoordinates,yCoordinates] = randomDisc(numPoints)

    xCoordinates = [];
    yCoordinates = [];

    %Helper function that samples a random integer from the uniform
    %distribution between -15 and 15.
    function nums = randInt(n)
        nums = round((31*rand(n,1))-15.5);
    end

    n = numPoints;

    while n > 0
        
        x = randInt(n);
        y = randInt(n);

        norms = sqrt((x.^2) + (y.^2));
        inBounds = find((10 <= norms) & (norms <= 15));
        
        xCoordinates = [xCoordinates; x(inBounds)];
        yCoordinates = [yCoordinates; y(inBounds)];
        
        n = numPoints - numel(xCoordinates);
    end
    
    xCoordinates(numPoints+1:end) = [];
    yCoordinates(numPoints+1:end) = [];
    
end

Output: 

>> [x,y] = randomDisc(100);
>> plot(x,y,'.')

Maxima

randomDisc(numPoints):= block([p: []],
  local(goodp, random_int),
  goodp(x, y):=block([r: sqrt(x^2+y^2)],
    r>=10 and r<=15
    ),
  random_int():= block([m: 15], m - random(2*(m+1)-1)),
  while length(p)<numPoints do block (
    [x: random_int(), y : random_int()],
    if goodp(x, y) then (
      p: cons([x, y], p)
      )
    ),
  p)$
  
p: randomDisc(100)$
plot2d(['discrete, p], ['style, 'points]);

Nim

Translation of: Python
import tables, math, complex, random

type Point = tuple[x, y: int]

var world = initCountTable[Point]()
var possiblePoints = newSeq[Point]()

for x in -15..15:
  for y in -15..15:
    if abs(complex(x.float, y.float)) in 10.0..15.0:
      possiblePoints.add((x,y))

randomize()
for i in 0..100: world.inc possiblePoints.sample

for x in -15..15:
  for y in -15..15:
    let key = (x, y)
    if key in world and world[key] > 0:
      stdout.write ' ' & $min(9, world[key])
    else:
      stdout.write "  "
  echo ""
Output:
                               1                              
                       1 1           1                        
                       3                                      
             1 1 1     1                                      
           1 2 1       1             1       1     1          
                                                     2        
         1       1                         1       1 1 1      
                                                   1          
       1     1                                   1     1      
     1                                               2 1      
   1                                               1          
       1                                                   1  
       1                                           1   1      
     1   1                                                    
                                                           1  
 1         1                                         1   1 1 1
       1                                                      
     1                                                 1      
                                                         2    
       1   1                                           2      
           1                                       1          
     1 1   1 1                                     1          
                                                     1        
               1 2 2                           1     1        
       1                                 1           1 1      
                       1             1               1        
                 1                 1       1                  
                         1                     1              
                     1 1     2 1 1         2                  
                       1   1         1   1                    
                               1

OCaml

let p x y =
  let d = sqrt(x ** 2.0 +. y ** 2.0) in
  10.0 <= d && d <= 15.0

let () =
  Random.self_init();
  let rec aux i acc =
    if i >= 100 then acc else
      let x = (Random.float 40.0) -. 20.0
      and y = (Random.float 40.0) -. 20.0 in
      if (p x y)
      then aux (succ i) ((x,y)::acc)
      else aux i acc
  in
  let points = aux 0 [] in
  let g = Array.init 40 (fun _ -> String.make 40 ' ') in
  List.iter (fun (x,y) ->
    let x = (int_of_float x) + 20
    and y = (int_of_float y) + 20 in
    g.(y).[x] <- 'o'
  ) points;
  Array.iter print_endline g



                o   o     o
                o
           oo      oo     oooo
               o      o   oo o
        oo
          o                o   o
         o
      oo  o
       oo o                 oo  o
                              oo
                              oo
         o                     o
      oooo                     o o
        oo                  o o
        o                    oo
                                 o
      o  o                  o  o
        o  o                 o o
       o  o
          o                   o
        o    o              oo
            o             oo
         o            o
             ooo o o       o
             o  ooo     o
              o
                 oo  o

PARI/GP

crpc()={
  my(v=vector(404),t=0,i=0,vx=vy=vector(100));
  for(x=1,14,for(y=1,14,
    t=x^2+y^2;
    if(t>99&t<226,
      v[i++]=[x,y];
      v[i++]=[x,-y];
      v[i++]=[-x,y];
      v[i++]=[-x,-y]
    )
  ));
  for(x=10,15,
    v[i++]=[x,0];
    v[i++]=[-x,0];
    v[i++]=[0,x];
    v[i++]=[0,-x]
  );
  for(i=1,#vx,
    t=v[random(#v)+1];
    vx[i]=t[1];
    vy[i]=t[2];
  );
  plothraw(vx,vy)
};

Perl

Graphical output

my @points;
while (@points < 100) {
        my ($x, $y) = (int(rand(31))-15, int(rand(31)) - 15);
        my $r2 = $x*$x + $y*$y;
        next if $r2 < 100 || $r2 > 225;
        push @points, [$x, $y];
}

print << 'HEAD';
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox 0 0 400 400
200 200 translate 10 10 scale
0 setlinewidth
1 0 0 setrgbcolor
0 0 10 0 360 arc stroke
0 0 15 360 0 arcn stroke
0 setgray
/pt { .1 0 360 arc fill } def
HEAD

print "@$_ pt\n" for @points;
print "%%EOF";

Randomly generates points and reject ones not in the ring. Writes an EPS file.

Plain-text output

@range = -15..16;

for $x (@range) {
    for $y (@range) {
        $radius = sqrt $x**2 + $y**2;
        push @points, [$x,$y] if 10 <= $radius and $radius <= 15
    }
}

push @sample, @points[int rand @points] for 1..100;
push @matrix, ' ' x @range for 1..@range;
substr $matrix[15+$$_[1]], 15+$$_[0], 1, '*' for @sample;
print join(' ', split '', $_) . "\n" for @matrix;
Output:
                                  *   * *
                              *     *   *
                        *     *   *
                                  *   *
          *                 * *               *
                *                         *
      *       * *                                 *
    *                                             * *
          *   *
  *                                                       *
      *   *                                       * * * * *
                                                      *

        *                                         * *
      *
  *                                                 *   * *
                                                        * *
    * *                                           *
  *                                                     * *
  * *     *                                             *
        * *   *
        *                                     *   *     *
                *                         *
              *                             *
                              *         *       *   *
          * *       *       *           *
            *   *     *                   *   *
                  *       *
                          *

Phix

with javascript_semantics
sequence screen = repeat(repeat(' ',31),31)
integer x, y, count = 0
atom r
while 1 do
    x = rand(31)
    y = rand(31)
    r = sqrt(power(x-16,2)+power(y-16,2))
    if r>=10 and r<=15 then
        screen[x][y] = 'x'
        count += 1
        if count>=100 then exit end if
    end if
end while
puts(1,join(screen,"\n"))
Output:
                x  xx
              x   x   x
         x x   x  x    x
          x     x   x   x
     x     x      xx
    x                x x  x
   xx xx              x
                         x
       x
  x
  x                       x
                           x
    x                    x  x
 xx                      xxxx
    x                       x
                          x  x
                           x
  x x                     x
     x
  x                       x
  xx x                   x x
   x                     x
        x             x   x
       x  x         x   x
          x x xx          x
      x  x       x  xx xx
                   xx x
          x    xx
             x   x  x

PicoLisp

(let Area (make (do 31 (link (need 31 " "))))
   (use (X Y)
      (do 100
         (until
            (>=
               15
               (sqrt
                  (+
                     (* (setq X (rand -15 15)) X)
                     (* (setq Y (rand -15 15)) Y) ) )
               10 ) )
         (set (nth Area (+ 16 X) (+ 16 Y)) "#") ) )
   (mapc prinl Area) )

Output: 

           #
        ##
           #  #  #  #
         ## #    #  #   #
       #      #   # # #
    #       #     # #   #
      #   #         #    #
      #                #   #
                       #
       #               #
     ##                      #
                          #
   #                      # #
  ###                      #
 #                         # #
##                          # #
  #                        #
 #                        #
 ## #
                           #
   #
     #                 #
     #
   ###                  #   #
      ###           # #    #
    #      #
         #  #   ##
                 # #
      #     #           #
                # #  #

PL/I

version 1

constrain: procedure options (main);
   declare 1 point (100),
            2 x fixed binary,
            2 y fixed binary;
   declare (i, j, a, b, c) fixed binary;

   j = 0;
   do i = 1 to 100;
      a = 30*random()-15; b = 30*random()-15;
      c = sqrt(a**2 + b**2);
      if abs(c) >= 10 & abs(c) <= 15 then
         do; j = j + 1; x(j) = a; y(j) = b; end;
   end;

   /* PLOT */
   declare table(-15:15, -15:15) character (1);
   table = ' ';
   do i = 1 to j;
      table(x(i), y(i)) = '*';
   end;
   do i = -15 to 15;
      put skip;
      do j = -15 to 15;
         put edit (table(i,j)) (a);
      end;
   end;
end constrain;

Output: 

        **  *                  
                *   *          
                               
    **                         
         **                    
                               
                         *     
                           *** 
      *                        
                               
                               
                         *     
    **                         
                               
                           *   
 * **                          
                               
                               
                        * *    
  **                        *  
     * *                       
                               
                     ***       
                         ***   
       ***                     
            *                  
                     *

version 2

*process source attributed xref or(!);
 annulus: procedure options (main);
 /* version 1 does not handle (0/15) etc. this does. */
 /* we show 1000 points here                         */
   declare 1 point(10000),
            2 x fixed binary,
            2 y fixed binary;
   declare (i, j, a, b, a2, b2, c) fixed binary(31);
   j = 0;
   do i = 1 to 1000;
      r=rand(31); a=r-16;
      r=rand(31); b=r-16;
      a2=a*a;
      b2=b*b;
      c2=a2+b2;
      if c2>= 100 & c2 <= 225 then
         do; j = j + 1; x(j) = a; y(j) = b;
         /* put Edit(a,b,c)(3(F(3))); */ end;
   end;
   /* PLOT */
   declare table(-15:15, -15:15) character (2);
   table = ' ';
   do i = 1 to j;
      table(x(i), y(i)) = '*';
   end;
   do i = -15 to 15;
      put skip;
      do j = -15 to 15;
         put edit (table(i,j)) (a);
      end;
   end;

 rand: Proc(n) Returns(Bin Fixed(31));
 /*--------------------------------------------------------------------
 * Return a random integer between 1 and n
 *-------------------------------------------------------------------*/
 Dcl r Bin Float(31);
 Dcl (n,d) Bin Fixed(31);
 r=random();
 d=r*n+1;
 Return(d);
 End;
 End annulus;

output 

                             *
                      * *   *   * *   * *
                  * * * * *   * *   * * *
            * * * * *   * * * *     * *   * * * *
          * * * * * * * *       * * * *   * * * *
        * * * * * *     * *   *     * *       * * * *
      *     * *     *                   * * *     *   *
          *   * *                           * *   *   *
        * *   *                               * *   * * *
      * * * * *                               * *     * *
        *   *                                     *     * *
  *   * * *                                       * *   * *
  * * *   *                                       *   *   *
  * * * *                                         * * * * *
    *   *                                         * *     *
* * * *   *                                       * *   * * *
  * * *                                           * * *
    *   * *                                       *   * *
    *   * *                                       *   * * *
    * * *                                         * * *   *
  *   * *   *                                     *     * *
      * * * * *                                         *
      * *                                     * * * * * *
      * *   * * * *                       * * * *     *
          * * * *   *                     * *     * * *
        * * * * *   * *   *     * *   *   *   *     *
          *       * * * *   * *   * * * *   *   *
              * *   *   * * *   *     * * * *   *
                  * * * *     * *     * *
                        * * *   *     * *

PowerShell

Works with: PowerShell version 3
$MinR2 = 10 * 10
$MaxR2 = 15 * 15
 
$Points = @{}
 
While ( $Points.Count -lt 100 )
    {
    $X = Get-Random -Minimum -16 -Maximum 17
    $Y = Get-Random -Minimum -16 -Maximum 17
    $R2 = $X * $X + $Y * $Y
 
    If ( $R2 -ge $MinR2 -and $R2 -le $MaxR2 -and "$X,$Y" -notin $Points.Keys )
        {
        $Points += @{ "$X,$Y" = 1 }
        }
    }
 
ForEach ( $Y in -16..16 ) { ( -16..16 | ForEach { ( " ", "*" )[[int]$Points["$_,$Y"]] } ) -join '' }
Output:
            ***                  
           *     **   *          
           *     ***     *       
           * * * ** *    *       
     *    *    *     *           
           *          *     *    
    * *               ***  *     
    *                    *****   
      **                * *      
   * *                    ***    
  ** *                    ***    
  *                        * *   
     *                           
  *                       *   *  
      *                          
    *                            
    **                        *  
    * *                    **    
     *                           
                           *     
                                 
        *                **      
         *            * * *      
    * *   **           *         
      *   **          **   *     
        * * *       * *          
         *                       
                      **         
             ** *

Prolog

Works with SWI-Prolog 

:- use_module(library(clpfd)).

circle :-
	bagof([X,Y], init(X,Y), BL),
	length(BL, N),
	length(L, 100),
	maplist(choose(BL, N), L),
	draw_circle(L).


% point selection
choose(BL, N, V) :-
	I is random(N),
	nth0(I, BL, V).

% to find all couples of numbers verifying 
% 100 <= x^2 + y^2 <= 225
init(X1, Y1) :-
	X in -15..15,
	Y in -15..15,
	X*X + Y*Y #>= 100,
	X*X + Y*Y #=< 225,
	label([X,Y]),
	X1 is 10 * X + 200,
	Y1 is 10 * Y + 200.


draw_circle(L) :-
	new(D, window('Circle')),
	send(D, size,size(400,400)),
	forall(member([X,Y], L),
	       (   new(C, circle(4)),
		   send(C, fill_pattern, colour(@default, 0, 0, 0)),
		   send(C, center(point(X,Y))),
		   send(D, display, C))),
	send(D, open).

PureBasic

CreateImage(0,31,31)
StartDrawing(ImageOutput(0))
  For i=1 To 100
    Repeat
      x=Random(30)-15
      y=Random(30)-15
      R.f=Sqr(x*x+y*y)
    Until 10<=R And R<=15
    Plot(x+15,y+15,#Red)
  Next
StopDrawing()

Title$="PureBasic Plot"
Flags=#PB_Window_SystemMenu
OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags)
ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0))
Repeat: Until WaitWindowEvent()=#PB_Event_CloseWindow

Python

Note that the diagram shows the number of points at any given position (up to a maximum of 9 points). 

>>> from collections import defaultdict
>>> from random import choice
>>> world = defaultdict(int)
>>> possiblepoints = [(x,y) for x in range(-15,16)
		  for y in range(-15,16)
		  if 10 <= abs(x+y*1j) <= 15]
>>> for i in range(100): world[choice(possiblepoints)] += 1

>>> for x in range(-15,16):
	print(''.join(str(min([9, world[(x,y)]])) if world[(x,y)] else ' '
			  for y in range(-15,16)))

	
                               
             1     1           
          1 1                  
      11 1     1  1     1      
     111  1     1211           
      1   2    1 1    11       
      1  11         21         
     1   1            11  1    
   1  2                1 1     
                               
 1  2                          
   1 1                      1  
   1 1                         
   2                      11   
  1                         1  
                         1     
                               
                               
  1                          1 
                         1     
                         2     
                            1  
     1                  1 1    
      1                2   1   
   1   3            11  2      
    11   1    1      1   2     
            1   1    2         
        1  1                   
         1      1     1        
          2 2   1              
               1

If the number of samples is increased to 1100: 

>>> for i in range(1000): world[choice(possiblepoints)] += 1

>>> for x in range(-15,16):
	print(''.join(str(min([9, world[(x,y)]])) if world[(x,y)] else ' '
			  for y in range(-15,16)))

	
               2               
          41341421333          
        5133333131253 1        
      5231514 14214721 24      
     326 21222143234122322     
    54235153132123344125 22    
   32331432         2422 33    
   5453135           4144344   
  132595               323123  
  4 6353               432224  
 5 4323                 3 5313 
 23214                   41433 
 42454                   33342 
 332 4                   34314 
 142 1                   35 53 
124211                   53131 
 22221                   152 4 
 22213                   34562 
 654 4                   4 212 
 24354                   52232 
 544222                 283323 
  411123               453325  
  251321               124332  
   2124134           2443226   
   2 113315         64324334   
    2412452 324 32121132363    
      4222434324635 5433       
      3113333123432112633      
        2131181233  424        
          47414232164          
               4

Quackery

  [ 0 31 of ]                is grid    (       --> [   )

  [ dup * ]                  is squared (     n --> n   )

  [ squared swap squared +
    10 squared 15 squared 1+
    within ]                 is inrange (   n n --> b   )

  [ 32 random 16 -
    32 random 16 -
    2dup inrange not while
    2drop again ]            is randxy  (       --> n n )

  [ 15 + swap 15 +
    dip [ 2dup peek  ]
    bit | unrot poke ]       is plot    ( [ n n --> [   )

  [ witheach
      [ 31 times
          [ dup
            i^ bit & iff
              [ $ "[]" ]
            else
              [ $ "  " ]
            echo$ ]
        drop
        cr ] ]               is draw    (     [ -->     )

  [ grid
    swap times
      [ randxy plot ]
    draw ]                   is circle  (     n -->     )

  100 circle
Output:
                                                             
                    []          []  []                        
                          []          []  []                  
                []    [][]    []                              
          []        []      []            [][]                
        []  []              [][][][]  []    []                
                                        []                    
      []  []                                                  
        []                                        [][]        
          []                                                  
    [][]                                                []    
    []    []                                      []    []    
                                                              
    []                                            []          
                                                        []    
  []                                                        []
        [][]                                              []  
      [][]                                        []          
    []                                            [][][]      
      []                                          []          
  []        []                                        []  []  
              []                                              
      []                                            []        
                  []                              []          
            [][][]                        []                  
              []        []    [][]    []        []            
              []      [][][]    []  []      []                
                              []            []  []            
                  []    [][]                                  
                    []      []

Code check as per task discussion, as a dialogue in the Quackery shell. 

/O> 10000 circle
... 
                              []                              
                    [][][][][][][][][][][]                    
                [][][][][][][][][][][][][][][]                
            [][][][][][][][][][][][][][][][][][][]            
          [][][][][][][][][][][][][][][][][][][][][]          
        [][][][][][][][][][][][][][][][][][][][][][][]        
      [][][][][][][][]                  [][][][][][][][]      
      [][][][][][][]                      [][][][][][][]      
    [][][][][][]                              [][][][][][]    
    [][][][][][]                              [][][][][][]    
  [][][][][][]                                  [][][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
[][][][][][]                                      [][][][][][]
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][]                                      [][][][][]  
  [][][][][][]                                  [][][][][][]  
    [][][][][][]                              [][][][][][]    
    [][][][][][]                              [][][][][][]    
      [][][][][][][]                      [][][][][][][]      
      [][][][][][][][]                  [][][][][][][][]      
        [][][][][][][][][][][][][][][][][][][][][][][]        
          [][][][][][][][][][][][][][][][][][][][][]          
            [][][][][][][][][][][][][][][][][][][]            
                [][][][][][][][][][][][][][][]                
                    [][][][][][][][][][][]                    
                              []                              

Stack empty.

R

RMin <- 10
RMax <- 15
NPts <- 100

# instead of a for loop, we generate what should be enough points
# also take care to have enough range to avoid rounding inaccuracies
nBlock <- NPts * ((RMax/RMin) ^ 2)
nValid <- 0
while (nValid < NPts) {
	X <- round(runif(nBlock, -RMax - 1, RMax + 1))
	Y <- round(runif(nBlock, -RMax - 1, RMax + 1))
	R <-  sqrt(X^2 + Y^2)
	Valid <- ( (R >= RMin) & (R <= RMax) )
	nValid <- sum(Valid)
	nBlock <- 2 * nBlock
}
plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue", 
	xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )

Example of solution

Racket

#lang racket

(require plot plot/utils)

(plot (points (for*/lists (result)
                ([_ (in-naturals)]
                 #:break (= 100 (length result))
                 [xy (in-value (v- (vector (random 31) (random 31))
                                   #(15 15)))]
                 #:when (<= 10 (vmag xy) 15))
                xy)))

Raku

(formerly Perl 6)

Works with: rakudo version 2015.09
my @range = -15..16;

my @points = gather for @range X @range -> ($x, $y) {
    take [$x,$y] if 10 <= sqrt($x*$x+$y*$y) <= 15
}
my @samples = @points.roll(100); # or .pick(100) to get distinct points

# format and print
my %matrix;
for @range X @range -> ($x, $y) { %matrix{$y}{$x} = ' ' }
%matrix{.[1]}{.[0]} = '*' for @samples;
%matrix{$_}{@range}.join(' ').say for @range;
Output:
                                  *
                    *                 *
              *     *   *         *         *
            * *         *               *
                      *           *       *   *     *
              *   *
            *     *                                   *
      *     *                                 *       *
                                              *
            *                                   * *   *
      *   *                                         *
      * *                                         *     *
      *
  *     *
                                                      * * *
  * *   * *
      *                                             *   *
    *
    *     *
  *     *
            * *                                       *
      *                                           *   *
                                          *         *
          *                                   *       *
              *         *       *         * * *     *
          *   *     *                   *     * *
                              *     *   *   *
                  *                 *
                                *     * *

Turning that program completely inside-out and reducing to a single statement with a single non-parameter variable, we get another version that also works.

This uses, among other things, a 0-based matrix rather than a hash, a given on the first line that allows us to print the final value of the matrix straight from its initial declaration, a for statement feeding a for statement modifier, a lambda that unpacks a single x-y argument into two variables, the functional form of pick rather than the method form, a quasi-list comprehension in the middle loop that filters each given with a when, precalculated squared limits so we don't have to take the square root, use of X- and X** to subtract and exponentiate both $x and $y in parallel.

After the given do has loaded up @matrix with our circle, the map on the first line substitutes a space for any undefined matrix element, and the extra space between elements is supplied by the stringification of the list value, performed by the prefix ~ operator, the unary equivalent of concatenation in Raku.

At this point you would be justified in concluding that we are completely mad. :-) 

(say ~.map: { $_ // ' ' } for my @matrix) given do
    -> [$x, $y] { @matrix[$x][$y] = '*' } for pick 100, do
        for ^32 X ^32 -> ($x, $y) {
            [$x,$y] when 100..225 given [+] ($x,$y X- 15) X** 2;
        }
Output:
                       *   *     *
                        * *     *
                          *       * * *   *     *
                    *   * * *         *         *
        *     *             *         *     *     *
          *     *                             *
      *                                   * * *   *
          * *                                 *     *
      * *
                                                    *   *
                                                    *
  *                                               *     *

    *                                               *
* *                                                 * * *   *
      *   *

        *                                         * *   *
          *                                         * *
      * *   *                                         *
                                                  *   *
    *   *
        * *                                     *
      * *   *                           * *           *
              *               *         *         *
              * *       *   *           *     *
              * * *                         *
                  * *   *       * *
                    *       * *

REXX

version 1

This REXX version uses aspect adjustment for the plot of the (sparse) annulus. 

/*REXX program  generates  100  random points  in an  annulus:   10  ≤  √(x²≤y²)  ≤  15 */
parse arg pts LO HI .                            /*obtain optional args from the C.L.   */
if pts==''  then pts= 100                        /*Not specified?  Then use the default.*/
if  LO==''  then  LO= 10;            LO2= LO**2  /*define a shortcut for squaring   LO. */
if  HI==''  then  HI= 15;            HI2= HI**2  /*   "   "    "      "      "      HI. */
$=
       do x=-HI;                      xx= x*x    /*generate all possible annulus points.*/
       if x>0  &  xx>HI2  then leave             /*end of annulus points generation ?   */
           do y=-HI;          s= xx + y*y
           if (y<0 & s>HI2) | s<LO2  then iterate
           if  y>0 & s>HI2           then leave
           $= $  x','y                           /*add a point─set to the  $  list.     */
           end   /*y*/
       end       /*x*/
                                         #= words($);   @.=  /*def: plotchr; #pts; lines*/
   do pts;  parse value word($, random(1,#))  with  x ',' y  /*get rand point in annulus*/
   @.y= overlay('☼',  @.y,  x+x + HI+HI + 1)                 /*put a plot char on a line*/
   end   /*pts*/                                 /* [↑]  maintain aspect ratio on X axis*/
                                                 /*stick a fork in it,  we're all done. */
   do y=-HI  to HI;      say @.y;   end          /*display the annulus to the terminal. */
output   when using the default inputs:

                    ☼     ☼
                    ☼ ☼       ☼
              ☼ ☼           ☼           ☼     ☼
                      ☼ ☼           ☼
              ☼     ☼             ☼       ☼
                                        ☼   ☼         ☼
                                            ☼ ☼
      ☼                                         ☼   ☼
          ☼                                     ☼     ☼
    ☼     ☼                                         ☼     ☼
    ☼                                             ☼   ☼
                                                    ☼ ☼
                                                    ☼   ☼

☼   ☼     ☼
                                                          ☼
  ☼     ☼ ☼                                       ☼
          ☼                                           ☼
        ☼ ☼                                               ☼
      ☼ ☼   ☼                                   ☼
        ☼     ☼                                 ☼ ☼ ☼
    ☼     ☼                                   ☼     ☼
          ☼                                 ☼   ☼
              ☼                                   ☼ ☼
                  ☼
              ☼         ☼             ☼       ☼   ☼
                    ☼       ☼ ☼             ☼
                ☼           ☼ ☼   ☼     ☼
                          ☼       ☼
                              ☼

version 2

Translation of: REXX version 1
/* REXX ---------------------------------------------------------------
* show 100 random points of an annulus with radius 10 to 15
* 18.06.2014 Walter Pachl 'derived/simplified' from REXX version 1
*--------------------------------------------------------------------*/
  Parse Arg points low high scale . /* allow parms from command line.*/
  If points=='' Then  points=100    /* number of points              */
  If low==''    Then  low=10        /* inner radius                  */
  If high==''   Then  high=15       /* outer radius                  */
  If scale==''  Then  scale=2       /* horizontal scaling            */
  low2=low**2
  high2=high**2
  /* first compute all possible points                               */
  point.=0
  Do x=-high To high
    x2=x*x
    Do y=-high To high
      y2=y*y
      s=x2+y2
      If s>=low2 &s<=high2 Then Do
        z=point.0+1
        point.z=x y
        point.0=z
        End
      End
    End
  plotchar='O'
  line.=''
  np=point.0                           /* available points           */
  Do j=1 To points                     /* pick the needed points     */
    r=random(1,np)
    Parse Var point.r x y              /* coordinates                */
    line.y=overlay(plotchar,line.y,scale*(x+high)+1) /* put into line*/
    point.r=point.np                   /* replace taken point by last*/
    np=np-1                            /* reduce available points    */
    If np=0 Then Leave                 /* all possible points taken  */
    End
/* now draw the picture                                              */
  Do y=-high To high
    Say line.y
    End

output using default parameters 

                                  O
                    O O           O
                          O O         O     O   O
          O O O       O   O O       O         O   O
        O     O       O             O O O O O
                    O                     O O O O O O
      O         O
        O
        O                                         O
  O         O
          O
    O   O O                                             O O
      O   O                                         O
                                                        O
  O       O                                           O
    O
                                                  O
        O
          O                                             O
      O   O O                                   O
      O                                         O       O
        O   O                                     O   O O
              O                               O O   O O
                O                               O
                      O   O O O   O
            O                                   O
              O O O   O O O               O O   O
                  O       O O             O O
                    O               O

output using rexx fcaa 100 3 4 2 

        O
    O O O O O
  O           O
  O           O
O O           O O
  O           O
  O           O
    O O O O O
        O

version 3

/* REXX ---------------------------------------------------------------
* 19.06.2014 Walter Pachl alternate algorithm
* the idea: yl is a list of y coordinates which may have unused points
* one of the y's is picked at random
* Then we look for unused x coordinates in this line
* we pick one at random or drop the y from yl if none is found
* When yl becomes empty, all points are used and we stop
*--------------------------------------------------------------------*/
Parse Arg n r rr scale
If r=''     Then r=10
If rr=''    Then rr=15
If n=''     Then n=100
If scale='' Then scale=2
r2=r*r
rr2=rr*rr
ymin=0
ymax=rr*2
ol=''
pp.=0
used.=0
yl=''                                  /* list of available y values */
Do y=-rr To rr
  yl=yl y
  End
Do Until pp.0=n                        /*look for the required points*/
  If yl='' Then Do                     /* no more points available   */
    Say 'all points filled'
    Leave
    End
  yi=random(1,words(yl))               /* pick a y                   */
  y=word(yl,yi)
  y2=y*y
  p.=0
  Do x=0 To rr                         /* Loop through possible x's  */
    x2=x*x
    xy2=x2+y2
    If xy2>=r2&xy2<=rr2 Then Do        /* within the annulus         */
      Call take x y
      Call take (-x) y
      End
    End
  If p.0>0 Then Do                     /* some x's found (or just 1) */
    xi=random(1,p.0)                   /* pick an x                  */
    z=pp.0+1
    pp.z=p.xi
    pp.0=z
    Parse Var pp.z xa ya
    used.xa.ya=1                       /* remember it's taken        */
    End
  Else Do                              /* no x for this y            */
    yi=wordpos(y,yl)                   /* remove y from yl           */
    Select
      When yi=1 Then yl=subword(yl,yi+1)
      When yi=words(yl) Then yl=subword(yl,1,yi-1)
      Otherwise yl=subword(yl,1,yi-1) subword(yl,yi+1)
      End
    End
  End
line.=''                               /* empty the raster           */
Do i=1 To pp.0                         /* place the points           */
  Parse Var pp.i x y
  line.y=overlay('+',line.y,scale*(rr+x)+1)
  End
Do y=-rr To rr                         /* show the result            */
  Say line.y
  End
say pp.0 'points filled'
Exit
Return

take: Procedure Expose p. used.        /* add x to p. if its not used*/
  Parse Arg x y
  If used.x.y=0 Then Do
    z=p.0+1
    p.z=x y
    p.0=z
    End
  Return

output using rexx fcaa 100 3 5 2 

all points filled
          +
    + + + + + + +
  + + + + + + + + +
  + +           + +
  + +           + +
+ + +           + + +
  + +           + +
  + +           + +
  + + + + + + + + +
    + + + + + + +
          +
56 points filled

Ring

load "guilib.ring"

new qapp 
        {
        win1 = new qwidget() {
                   setwindowtitle("drawing using qpainter")
                   setgeometry(100,100,500,500)
                   label1 = new qlabel(win1) {
                            setgeometry(10,10,400,400)
                            settext("")
                  }
                  new qpushbutton(win1) {
                      setgeometry(200,400,100,30)
                      settext("draw")
                      setclickevent("draw()")
                  }
                  show()
         }
         exec()
         }

func draw
        p1 = new qpicture()
             color = new qcolor() {
             setrgb(0,0,255,255)
        }
        pen = new qpen() {
              setcolor(color)
              setwidth(1)
        }
        new qpainter() {
            begin(p1)
            setpen(pen)

        for i = 1 to 1000
            x = random(31)-16
            y = random(31)-16
            r = sqrt (pow(x,2) + pow(y,2))
            if r >= 10 if r <= 15 drawpoint(x*2, y*2) ok ok
        next

        endpaint()
        }
        label1 { setpicture(p1) show() }

Output:

RPL

Works with: HP version 48G
« ERASE -15 15 DUP2 XRNG YRNG             @ set graphics boundaries
  DEG -19 SF 0                            @ set degrees mode, polar vector mode, count = 0
  DO RAND 5 * 10 + RAND 360 * →V2         @ z = rand(10..15).exp(i.rand(360))
     C→R IP SWAP IP R→C                   @ make z a complex with integer coordinates
     IF DUP ABS DUP 10 ≥ SWAP 15 ≤ AND    @ if 10 ≤ | z | ≤ 15
     THEN PIXON 1 +                       @ then set pixel and increment count
     ELSE DROP END
  UNTIL DUP 100 ≥ END 
  DROP { } PVIEW
  -19 CF
» 'TASK' STO

Screenshot of a HP-48G emulator, displaying constrained random points on a circle

The circle is actually an ellipse because RPL display screens are not squared.

Ruby

Create the image with Raster graphics operations/Ruby 

points = (1..100).map do
  # choose a random radius and angle
  angle = rand * 2.0 * Math::PI
  rad   = rand * 5.0 + 10.0
  # convert back from polar to cartesian coordinates
  [rad * Math::cos(angle), rad * Math::sin(angle)].map(&:round)
end

(-15..15).each do |row|
  puts (-15..15).map { |col| points.include?([row, col]) ? "X" : " " }.join
end

load 'raster_graphics.rb'

pixmap = Pixmap.new(321,321)
pixmap.draw_circle(Pixel.new(160,160),90,RGBColour::BLACK)
pixmap.draw_circle(Pixel.new(160,160),160,RGBColour::BLACK)
points.each {|(x,y)| pixmap[10*(x+16),10*(y+16)] = RGBColour::BLACK}
pngfile = __FILE__
pngfile[/\.rb/] = ".png"
pixmap.save_as_png(pngfile)
Output:
Sample output from Ruby program
Sample output from Ruby program
          X X
         X      XX
           X XXX
         XX X  X  X X  X
               XXXXX
      XX            XX
   X  X                    X
    X                   X
   X                   X
     X                   X XXX
     X
 XX X                     X
  X                           X
 X                        X
   XXX                      X
XX  X
  XXX                     X  X

  XX X                   X X
   XX                  X   X
   X                      X
                            X
  XX  X                   X
   X               X      X
      X        X   X
              X
             X       X X
          X    X     X
            X      X

algorithm 2:

r2 = 10*10..15*15
range = (-15..15).to_a
points = range.product(range).select {|i,j| r2.cover?(i*i + j*j)}

puts "Precalculate: #{points.size}"
pt = Hash.new("  ")
points.sample(100).each{|ij| pt[ij] = " o"}
puts range.map{|i| range.map{|j| pt[[i,j]]}.join}
Output:
Precalculate: 404
                                                              
                               o o o                          
                 o o o     o                                  
                 o           o     o o       o                
           o   o     o                 o         o o          
               o       o             o   o           o        
                                               o     o        
       o                                       o              
                                                   o o o      
     o         o                                     o        
     o o                                           o       o  
       o                                             o        
                                                           o  
         o                                                    
           o                                             o    
         o                                               o   o
                                                              
                                                           o  
   o o   o                                         o   o      
   o       o                                         o        
   o   o     o                                         o      
                                                   o          
             o                                   o     o      
                 o                                   o o      
       o       o                           o   o   o   o      
           o o     o   o     o       o     o o   o            
                         o           o   o o   o              
             o     o o   o                 o o                
                   o o   o o             o                    
                         o o                                  
                               o

Run BASIC

w = 320
h = 320
dim canvas(w,h)
for pts = 1 to 1000
  x = (rnd(1) * 31) - 15
  y = (rnd(1) * 31) - 15
  r = x * x + y * y
  if (r > 100) and (r < 225) then
    x = int(x * 10 + w/2)
    y = int(y * 10 + h/2)
    canvas(x,y) = 1
  end if
next pts    

' -----------------------------
' display the graphic
' -----------------------------
graphic #g, w,h
for x = 1 to w
  for y = 1 to h
     if canvas(x,y) = 1 then  #g "color green ; set "; x; " "; y else #g "color blue ; set "; x; " "; y
  next y
next x
render #g 
#g "flush"

Rust

extern crate rand;

use rand::Rng;

const POINTS_N: usize = 100;

fn generate_point<R: Rng>(rng: &mut R) -> (i32, i32) {
    loop {
        let x = rng.gen_range(-15, 16); // exclusive
        let y = rng.gen_range(-15, 16);

        let r2 = x * x + y * y;
        if r2 >= 100 && r2 <= 225 {
            return (x, y);
        }
    }
}

fn filtering_method<R: Rng>(rng: &mut R) {
    let mut rows = [[" "; 62]; 31];

    // Generate points
    for _ in 0..POINTS_N {
        let (x, y) = generate_point(rng);
        rows[(y + 15) as usize][(x + 15) as usize * 2] = "*";
    }

    // draw the points
    for row in &rows {
        println!("{}", row.concat());
    }
}

fn precalculating_method<R: Rng>(rng: &mut R) {
    // Generate all possible points
    let mut possible_points = Vec::with_capacity(404);
    for y in -15..=15 {
        for x in -15..=15 {
            let r2 = x * x + y * y;
            if r2 >= 100 && r2 <= 225 {
                possible_points.push((x, y));
            }
        }
    }

    // A truncated Fisher-Yates shuffle
    let len = possible_points.len();
    for i in (len - POINTS_N..len).rev() {
        let j = rng.gen_range(0, i + 1);
        possible_points.swap(i, j);
    }

    // turn the selected points into "pixels"
    let mut rows = [[" "; 62]; 31];
    for &(x, y) in &possible_points[len - POINTS_N..] {
        rows[(y + 15) as usize][(x + 15) as usize * 2] = "*";
    }

    // draw the "pixels"
    for row in &rows {
        println!("{}", row.concat());
    }
}

fn main() {
    let mut rng = rand::weak_rng();

    filtering_method(&mut rng);

    precalculating_method(&mut rng);
}

Scala

Library: Scala
import java.awt.{ Color, geom,Graphics2D ,Rectangle}
import scala.math.hypot
import scala.swing.{MainFrame,Panel,SimpleSwingApplication}
import scala.swing.Swing.pair2Dimension
import scala.util.Random

object CirculairConstrainedRandomPoints extends SimpleSwingApplication {
  //min/max of display-x resp. y
  val dx0, dy0 = 30; val dxm, dym = 430
  val prefSizeX, prefSizeY = 480

  val palet = Map("b" -> Color.blue, "g" -> Color.green, "r" -> Color.red, "s" -> Color.black)
  val cs = List((0, 0, 10, "b"), (0, 0, 15, "g")) //circle position and color
  val xmax, ymax = 20; val xmin, ymin = -xmax

  class Coord(x: Double, y: Double) {
    def dx = (((dxm - dx0) / 2 + x.toDouble / xmax * (dxm - dx0) / 2) + dx0).toInt
    def dy = (((dym - dy0) / 2 - y.toDouble / ymax * (dym - dy0) / 2) + dy0).toInt
  }

  object Coord {
    def apply(x: Double, y: Double) = new Coord(x, y)
  }

  //points:
  val points =
    new Iterator[Int] { val r = new Random;def next = r.nextInt(31) - 15; def hasNext = true }.toStream.
      zip(new Iterator[Int] { val r = new Random; def next = r.nextInt(31) - 15; def hasNext = true }.toStream).
      map { case (x, y) => (x, y, hypot(x, y)) }.filter { case (x, y, r) => r >= 10 && r <= 15 }.take(100).toSeq.
      map { case (x, y, r) => new Rectangle(Coord(x, y).dx - 2, Coord(x, y).dy - 2, 4, 4) }

  private def ui = new Panel {
    background = Color.white
    preferredSize = (prefSizeX, prefSizeY)

    class Circle(center: Coord, r: Double, val color: Color) {
      val dr = (Coord(r, 0).dx - pcentre.dx) * 2
      val dx = center.dx - dr / 2
      val dy = center.dy - dr / 2
    }

    object Circle {
      def apply(x: Double, y: Double, r: Double, color: Color) =
        new Circle(Coord(x, y), r, color)
    }

    val pcentre = Coord(0, 0)
    val pxmax = Coord(xmax, 0); val pxmin = Coord(xmin, 0)
    val pymax = Coord(0, ymax); val pymin = Coord(0, ymin)

    //axes:
    val a_path = new geom.GeneralPath
    a_path.moveTo(pxmin.dx, pxmin.dy); a_path.lineTo(pxmax.dx, pxmax.dy) //x-axis
    a_path.moveTo(pymin.dx, pymin.dy); a_path.lineTo(pymax.dx, pymax.dy) //y-axis

    //labeling:
    val labels = List(-20, -15, -10, -5, 5, 10, 15, 20)
    labels.foreach { x => { val p = Coord(x, 0); a_path.moveTo(p.dx, p.dy - 3); a_path.lineTo(p.dx, p.dy + 3) } }
    labels.foreach { y => { val p = Coord(0, y); a_path.moveTo(p.dx - 3, p.dy); a_path.lineTo(p.dx + 3, p.dy) } }
    val xlabels = labels.map(x => { val p = Coord(x, 0); Triple(x.toString, p.dx - 3, p.dy + 20) })
    val ylabels = labels.map(y => { val p = Coord(0, y); Triple(y.toString, p.dx - 20, p.dy + 5) })

    //circles:
    val circles = cs.map { case (x, y, r, c) => Circle(x, y, r, palet(c)) }

    override def paintComponent(g: Graphics2D) = {
      super.paintComponent(g)
      circles.foreach { c => { g.setColor(c.color); g.drawOval(c.dx, c.dy, c.dr, c.dr) } }
      g.setColor(palet("r")); points.foreach(g.draw(_))
      g.setColor(palet("s")); g.draw(a_path)
      xlabels.foreach { case (text, px, py) => g.drawString(text, px, py) }
      ylabels.foreach { case (text, px, py) => g.drawString(text, px, py) }
    }
  } // def ui

  def top = new MainFrame {
    title = "Rosetta Code >>> Task: Constrained random points on a circle | Language: Scala"
    contents = ui
  }
}

Sidef

Translation of: Perl

Generates an EPS file. 

var points = []
while (points.len < 100) {
    var (x, y) = 2.of{ 30.irand - 15 }...
    var r2 = (x**2 + y**2)
    if ((r2 >= 100) && (r2 <= 225)) {
        points.append([x, y])
    }
}

print <<'HEAD'
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox 0 0 400 400
200 200 translate 10 10 scale
0 setlinewidth
1 0 0 setrgbcolor
0 0 10 0 360 arc stroke
0 0 15 360 0 arcn stroke
0 setgray
/pt { .1 0 360 arc fill } def
HEAD

points.each { |pt| say "#{pt.join(' ')} pt" }
print '%%EOF'

Standard ML

Works with PolyML. Plotting function from 'Draw a pixel' task. Uniform random generator: copy from Random_numbers#Standard_ML. x,y plotted scaled x 10 px 

open XWindows ;
open Motif ;

val plotWindow = fn coords =>                                                               (*  input list of int*int  within 'dim' *)  
let
  val dim    =  {tw=325,th=325} ;
  val shell  =  XtAppInitialise      ""    "demo" "top" [] [ XmNwidth (#tw dim), XmNheight (#th dim) ] ;        (* single call only *)
  val main   =  XmCreateMainWindow   shell    "main"       [ XmNmappedWhenManaged true ]   ;
  val canvas =  XmCreateDrawingArea  main   "drawarea"     [ XmNwidth (#tw dim), XmNheight (#th dim) ] ;
  val usegc  =  DefaultGC (XtDisplay canvas) ;
  val put    =  fn (w,s,t)=> (
                    XSetForeground usegc 0xfffffff ;
                    XFillRectangle (XtWindow canvas) usegc (Area{x=0,y=0,w = #tw dim, h= #th dim})  ;
		    XSetForeground usegc 0  ;
                    XDrawPoints  (XtWindow canvas) usegc (  List.map  (fn (x,y)=>XPoint {x=x,y=y}) coords )  CoordModeOrigin ;
		    t )
in
 
  (
   XtSetCallbacks   canvas [ (XmNexposeCallback , put) ] XmNarmCallback ;
   XtManageChild    canvas ;
   XtManageChild    main ; 
   XtRealizeWidget  shell 
  )
 
end;

val urandomlist =  fn seed => fn n => 
(* put code from (www.rosettacode.org) wiki/Random_numbers#Standard_ML 'urandomlist' here 
input : seed and number of drawings *)
end;

val normalizedPts = fn () =>                                                  (* select ([0,1]*[0,1]) points in normalized bandwidth *)
 let
   val realseeds  =  ( 972.1 , 10009.3 ) ;
   val usum       =  fn  (u,v)     => u*(u-1.0) + v*(v-1.0) ;
   val lim        =  ( ~350.0/900.0, ~225.0/900.0 ) ;                                                              (* limits to usum  *)
   val select     =  fn i =>  usum i <= #2 lim  andalso  usum i >= #1 lim  ;                      (* select according to inequalities *)
   val uv         =  ListPair.zip ( urandomlist (#1 realseeds) 2500 , urandomlist (#2 realseeds) 2500 )          (* take 2500 couples *)
 in
   List.take ( List.filter select uv , 1000 ) 
end ;

call 

> val scaledXY =   map (fn (x,y)=>
                    ( Real.toInt  IEEEReal.TO_NEAREST (10.0+300.0*x), Real.toInt  IEEEReal.TO_NEAREST (10.0+300.0*y) )) (normalizedPts ()) ;
> plotWindow scaledXY ;

Swift

Translation of: Rust
let nPoints = 100

func generatePoint() -> (Int, Int) {
  while true {
    let x = Int.random(in: -15...16)
    let y = Int.random(in: -15...16)
    let r2 = x * x + y * y

    if r2 >= 100 && r2 <= 225 {
      return (x, y)
    }
  }
}

func filteringMethod() {
  var rows = [[String]](repeating: Array(repeating: " ", count: 62), count: 31)

  for _ in 0..<nPoints {
    let (x, y) = generatePoint()

    rows[y + 15][x + 15 * 2] = "*"
  }

  for row in rows {
    print(row.joined())
  }
}

func precalculatingMethod() {
  var possiblePoints = [(Int, Int)]()

  for y in -15...15 {
    for x in -15...15 {
      let r2 = x * x + y * y

      if r2 >= 100 && r2 <= 225 {
        possiblePoints.append((x, y))
      }
    }
  }

  possiblePoints.shuffle()

  var rows = [[String]](repeating: Array(repeating: " ", count: 62), count: 31)

  for (x, y) in possiblePoints {
    rows[y + 15][x + 15 * 2] = "*"
  }

  for row in rows {
    print(row.joined())
  }
}

print("Filtering method:")
filteringMethod()

print("Precalculating method:")
precalculatingMethod()
Output:
Filtering method:
                              *                               
                            **  *                             
                         **   **     *                        
                      *     ** *    *                         
                       **     *      *                        
                   * **   **                                  
                   *                     *                    
                        *                                     
                  *  **                    *                  
                   *                       *                  
                *   *                  * ***                  
                                            *                 
                *  *                      *                   
                                          **                  
                 *  *                                         
               *  *                                           
                                          *                   
                * *                      *                    
                                           *                  
                *                          **                 
                   *                                          
                  *                      * *                  
                    *                    *                    
                                       *                      
                       **                **                   
                          * **                                
                        ***         *  *                      
                            *  ** *    *                      
                             *   *                            
                         *   *     *                          
                              *                               
Precalculating method: 
                              *                               
                         ***********                          
                       ***************                        
                     *******************                      
                    *********************                     
                   ***********************                    
                  ********         ********                   
                  *******           *******                   
                 ******               ******                  
                 ******               ******                  
                ******                 ******                 
                *****                   *****                 
                *****                   *****                 
                *****                   *****                 
                *****                   *****                 
               ******                   ******                
                *****                   *****                 
                *****                   *****                 
                *****                   *****                 
                *****                   *****                 
                ******                 ******                 
                 ******               ******                  
                 ******               ******                  
                  *******           *******                   
                  ********         ********                   
                   ***********************                    
                    *********************                     
                     *******************                      
                       ***************                        
                         ***********                          
                              *

SystemVerilog

program main;

  bit [39:0] bitmap [40];

  class Point;
    rand bit signed [4:0] x;
    rand bit signed [4:0] y;

    constraint on_circle_edge {
      (10*10) <= (x*x + y*y);
      (x*x + y*y) <= (15*15);
    };

    function void do_point();
      randomize;
      bitmap[x+20][y+20] = 1;
    endfunction
  endclass

  initial begin
    Point p = new;
    repeat (100) p.do_point;
    foreach (bitmap[row]) $display( "%b", bitmap[row]);
  end

endprogram

Piping the output through sed to improve the contrast of the output: 

% vcs -sverilog -R circle.sv | sed 's/0/ /g'
                                        
                   1                    
                11 1  1                 
            1 1  1    11                
          1     1   1   11              
            1           1  1            
             1      1      1            
            1                           
       1   1                  1         
      1    1               1            
                             1          
       11                               
                                11      
         1                              
     11  1                     1 1      
         1                   1          
    1   1                    1   1      
     1                        1  1      
     11 1                       1       
                             11         
     1111                        1      
      1 111                  1          
       11 1                111  1       
       11                               
                          1  1          
            1            1   1          
                   1                    
             1  11                      
                          1             
                   1    1               
               11  1 1

Tcl

package require Tcl 8.5

# Generate random point at specified distance from the centre
proc getPoint {range from to} {
    set r2 [expr {$range / 2}]
    set f2 [expr {$from ** 2}]
    set t2 [expr {$to ** 2}]
    while 1 {
	set x [expr {int($range * rand())}]
	set y [expr {int($range * rand())}]
	set d2 [expr {($x-$r2)**2 + ($y-$r2)**2}]
	if {$d2 >= $f2 && $d2 <= $t2} {
	    return [list $y $x]
	}
    }
}

# Make somewhere to store the counters
set ary [lrepeat 31 [lrepeat 31 0]]

# Generate 100 random points
for {set i 0} {$i < 100} {incr i} {
    set location [getPoint 31 10 15]
    # Increment the counter for the point
    lset ary $location [expr {1 + [lindex $ary $location]}]
}

# Simple renderer
foreach line $ary {
    foreach c $line {
	puts -nonewline [expr {$c == 0 ? " " : $c > 9 ? "X" : $c}]
    }
    puts ""
}

Example output: 

               1               
           1  1                
                               
         1 1 1   2   1 1       
        11   1        1  1     
       11 1            1  1    
   1     1                     
   1    12               1     
     1 1               1       
  1 1                    1     
      1                    1   
   1                       1 1 
                          1  2 
                           1   
 1                         1   
 2   1                    2    
  2                         1  
                             1 
    1                    11    
     1                   1     
      1                        
  1                       1    
     2                 1    1  
   1                     1     
   1 1   1          11     1   
     2  1  1        11         
        11      1      1 1     
      1 2   1       11         
         121   1  1            
           1  1   1            
               1

Wren

Library: DOME
import "graphics" for Canvas, Color
import "dome" for Window
import "random" for Random

class Game {
    static init() {
        Window.title = "Constrained random points on a circle"
        var width = 800
        var height = 800
        Window.resize(width, height)
        Canvas.resize(width, height)
        var rand = Random.new()
        var count = 0
        var max = 100 // set to 1000 to produce a much more pronounced annulus
        while (true) {
            var x = rand.int(-15, 16)
            var y = rand.int(-15, 16)
            var dist = (x*x + y*y).sqrt
            if (10 <= dist && dist <= 15) {
                // translate coordinates to fit in the window
                Canvas.circlefill((x + 16) * 25, (y + 16) * 25, 2, Color.white)
                count = count + 1
                if (count == max) break
            }
        }
    }

    static update() {}

    static draw(alpha) {}
}

XPL0

include c:\cxpl\codes;  \intrinsic 'code' declarations
int X, Y, C, R2;
[SetVid($13);           \set 320x200x8 graphics mode
C:= 0;                  \initialize point counter
repeat  X:= Ran(31)-15; \range -15..+15
        Y:= Ran(31)-15;
        R2:= X*X + Y*Y;
        if R2>=10*10 & R2<=15*15 then
                [Point(X+160, Y+100, $F);  C:= C+1];
until C >= 100;
C:= ChIn(1);            \wait for keystroke
SetVid(3);              \restore normal text mode
]

zkl

xy:=(0).walker(*).tweak(fcn{  // generate infinite random pairs (lazy)
   x:=(-15).random(16); y:=(-15).random(16); 
   if(not (100<=(x*x + y*y)<=225)) Void.Skip else T(x,y)
});

const N=31;  // [-15..15] includes 0
array:=(" ,"*N*N).split(",").copy();  // bunch of spaces (list)

xy.walk(100).apply2(fcn([(x,y)],array){array[x+15 + N*(y+15)]="*"},array);
foreach n in ([0..30]){ array[n*N,30].concat().println(); }
Output:
                              
          *   *     *         
               **   ***       
         *  *  * **     *     
       * **                   
        *      *    *     *   
       *                *  *  
    *                *   ***  
       *                      
      *                   *   
  * *                    *   *
 *                       *    
     *                     *  
                           *  
                         *   *
  ****                      **
                           *  
   *                          
 *  *                         
                          *  *
 **  *                       *
   * *                        
                       * *  * 
        *             *       
   *      *                   
            ** * **           
         *         *  ***     
       * *        *           
        *    *                
           *

ZX Spectrum Basic

Translation of: BBC_BASIC
10 FOR i=1 TO 1000
20 LET x=RND*31-16
30 LET y=RND*31-16
40 LET r=SQR (x*x+y*y)
50 IF (r>=10) AND (r<=15) THEN PLOT 127+x*2,88+y*2
60 NEXT i
Retrieved from "https://rosettacode.org/wiki/Constrained_random_points_on_a_circle?oldid=350294"