Make a haystack (with a needle)

Question

(Essentially the inverse of Find the needle in the haystack)

Given two tuples, (w, h) and (x, y), generate a haystack composed of a single random printable ASCII character of w width and h height with a needle made of a different random printable ASCII character at (x, y) when measured from the upper-left.

For example, when given (5,4) for the width and height, and (3,1) (zero-indexed) for the location of the needle, a possible haystack could be the following:

#####
###N#
#####
#####

Another possibility could be

*****
***$*
*****
*****

among hundreds of others.

Rules and Clarifications

• Input and output can be given by any convenient method. This means you can take input as a list of list of integers, as a single string, as two integers via command-line and a tuple via function argument, etc.
• You can print the result to STDOUT or return it as a function result.
• Either a full program or a function are acceptable.
• You can choose whether the (x, y) tuple is zero-indexed or one-indexed, but please specify in your solution which you're using.
• You do not get to pick which characters to use. That's part of the challenge - randomly selecting the characters.
• Every possible output for a given input must have a non-zero chance of appearing, but the randomness doesn't need to be uniform.
• The haystack is guaranteed to be at least 2x2 in size, so it's unambiguous which is the needle and which is the hay.
• There is only ever one needle, and it's only ever one character in size, and it's guaranteed to be within the boundaries of the haystack.
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Answer 1

JavaScript (Node.js),  122 120 106  103 bytes

Recursively builds the output character by character. The coordinates are 0-indexed.

(w,h,x,y)=>(s=new Date%9023,g=X=>Y<h?Buffer([X-w?(x-X|y-Y?s+1:s%96)%95+32:13])+g(X<w?X+1:!++Y):'')(Y=0)

Try it online!

How?

Problem

To generate the haystack and the needle, we could either:

• generate a random haystack and process some loop to generate a random needle until it's different from the haystack
• shuffle the whole range of printable characters and pick the first 2 of them

Unfortunately, both approaches are rather lengthy in JS.

Solution

We use instead a method that guarantees to generate 2 distinct characters with a single random number and without any loop.

We pick a random seed \$s\$ in \$[0..9022]\$ and define the haystack \$h\$ and needle \$n\$ as:

$$\begin{align}&h=(s+1)\bmod 95\\ &n=(s\bmod 96)\bmod 95\end{align}$$

(we then need to add \$32\$ to turn them into printable ASCII codes)

Basically, \$h\$ follows the pattern:

$$1,2,3,...,94,0,1,2,3,...$$

while \$n\$ follows the pattern:

$$0,1,2,3,...,94,\color{red}0,0,1,2,3,...$$

The sequences are progressively shifted relative to each other because of the extra \$0\$ in the needle pattern.

This code shows that it does eventually lead to all possible pairs \$(h,n)\$ with \$h\neq n\$ (there are \$95\times 94=8930\$ of them).

And because we need only one random number, we can afford to use the current timestamp in milliseconds as our entropy source with new Date%9023 instead of the longer Math.random()*9023.

Commented

(w, h, x, y) => (      // w = width, h = height, (x, y) = coordinates
  s = new Date % 9023, // s = random seed in [0..9022]
  g = X =>             // g = recursive function taking X
    Y < h ?            //   if we've not reached the end of the grid:
      Buffer([         //     append the next character:
        X - w ?        //       if we haven't reached the end of the line:
          ( x - X |    //         if this is not the position of the needle:
            y - Y ?    //
              s + 1    //           append the haystack character
            :          //         else:
              s % 96   //           append the needle character
          ) % 95 + 32  //
        :              //       else:
          13           //         append a linefeed
      ]) +             //
      g(X < w ? X + 1  //     append the result of a recursive call
              : !++Y)  //     with either (X+1, Y) or (0, Y+1)
    :                  //   else:
      ''               //     stop recursion
)(Y = 0)               // initial call to g with X = Y = 0

Answer 2

Jelly, 14 13 bytes

p/⁼€ịØṖẊ¤s⁸Ḣ¤

Try it online!

-1 byte thanks to Unrelated String

Returns a list of lines. The last line in the Footer section displays it as a square. Takes input as [w, h] and [y, x], where x and y are 0-indexed.

How it works

p/⁼€ịØṖẊ¤s⁸Ḣ¤ - Main link. Takes [w, h] on the left and [y, x] on the right
p/            - Reduce Cartesian product over the arguments.
                This yields a list of co-ordinates from (1, 1) to (h, w)
   €          - Over each list:
  ⁼           -   Is it equal to [x, y]?
              - This yields a list where every element except 1 is 0
        ¤     - Create a nilad:
     ØṖ       -   Printable ASCII characters
       Ẋ      -   Shuffled
    ị         - Index into the shuffled characters, replacing 1 with the first char in the shuffled list and 0 with the last. Therefore, the two characters will be distinct
            ¤ - Create a nilad:
          ⁸   -   Yield [w, h]
           Ḣ  -   Extract w
        s     - Split the list of characters into rows of length w
              - Implicitly output

Answer 3

Excel VBA, 128 118 106 94 96 bytes

^{-12 bytes inspired by agtoever
-12 bytes thanks to Taylor Scott, VBA extraordinaire
+2 bytes and -1 bug thanks to Taylor's unnecessary, intimidating, and much appreciated work}

Sub n(w,h,x,y)
a=94*Rnd
[A1].Resize(h,w)=Chr(a+32)
Cells(y,x)=Chr(32+(a+93*Rnd+1)Mod 95)
End Sub

Input and output are one-indexed. Output is to the top left cell range of the active sheet.

a=94*Rnd+32: (126-32)*Rnd+32 gives a number between 32 and 126, inclusive.

Range(~)=Chr(a): Fills all the cells with the ASCII character.

Cells(y,x)=Chr(~): Fills just that one cell with the other ASCII character.

(a+62*Rnd)Mod 95+32: {(a+[94-32]*Rnd) Mod (126-32+1)}+32 gives a random number between 32 and 126 inclusive that is not the same as a. (I can't prove that mathematically but 100 million tests showed no collisions.)

Example output:

Answer 4

Python 2, 134 133 120 112 111 bytes

lambda w,h,x,y:zip(*[iter(chr(r[x+y*w==i]+32)for i in range(w*h))]*w)
from random import*
r=sample(range(95),2)

Try it online!

Answer 5

PowerShell v6, 102 96 bytes

param($x,$y,$a,$b)$j,$k=' '..'~'|random -C 2
-join((,$j*$x+++'
')*$y|%{"$_$k"[$i++-eq$b*$x+$a]})

Try it online!

This answer, thanks to mazzy, uses the character range feature added in v6 to save several bytes over the more flexible answer below.

PowerShell, 119..105 102 bytes

^{-16 bytes thanks to mazzy
-1 byte thanks to AdmBorkBork}

param($x,$y,$a,$b)$j,$k=32..126|random -C 2
-join((,$j*$x+++'
')*$y|%{[char]($_,$k)[$i++-eq$b*$x+$a]})

Try it online!

Gets two ints in the range of [32,126]. We first make a 1D array out of the first value, appending a new line after every $xchars. Doing this means we also have to increment $x so that our index math isn't affected. We then iterate through the array, and either yield a char-ified first value or the needle. Finally, we join all the yielded values and output it.

Answer is 0-indexed by the way.

Answer 6

Jelly, 11 bytes

QŒṬƤSḂịØṖẊ¤

A monadic Link accepting a list of lists, [[height, width], [row, column]] (1-indexed), which yields a list of lists of characters.

Try it online! (The footer calls the link and joins with newlines.)

How?

QŒṬƤSḂịØṖẊ¤ - Link: [[h, w], [r, c]]
Q           - de-duplicate (i.e. [[h, w]] if [r, c] == [h, w] else [[h, w], [r, c]])
   Ƥ        - for prefixes (of that list):
 ŒṬ         -   get a 2D array with ones at the coordinates specified
    S       - sum (vectorises) (giving us an h*w matrix with zeros almost everywhere,
                                except a 1 at our needle and, if [h, w] != [r,c], a 2 at
                                the bottom-right)
     Ḃ      - modulo two (replacing the 2 with a zero if it exists)
          ¤ - nilad followed by link(s) as a nilad:
       ØṖ   -   list of printable characters
         Ẋ  -   shuffled
      ị     - (left) index into (right) (vectorises)

Answer 7

Dyalog APL, 24 23 21 bytes

⎕UCS(32+2?95)[⎕∘≡¨⍳⎕]

Try it online! 0-indexed.

-1 thanks to ngn, -2 thanks to Adám suggesting to use a different I/O format.

Answer 8

Python 2, 133 bytes

from random import*
r=range
def f(h,w,x,y):
 p=sample(r(32,127),2)
 for i in r(h):
	print ''.join(chr(p[i==y and j==x])for j in r(w))

Try it online!

-12 thanks to Value Ink for suggesting using a loop comprehension. -2 thanks to Unrelated String for suggesting python 2 instead of python 3 to get rid of parenthesis in the print function!

Answer 9

Python 2, 110 bytes

from random import*
w,h,x,y=input()
m,n=sample(map(chr,range(32,127)),2)
l=eval(`[[m]*w]*h`)
l[x][y]=n
print l

Try it online!

I copied TFeld's solution and managed to golf a char using list assignment. The eval() trick is used to make a mutable matrix to avoid the list mutation applying to every row.

111 bytes

lambda w,h,x,y:[[chr(r[x^i<1>y^j]+32)for i in R(w)]for j in R(h)]
from random import*
R=range
r=sample(R(95),2)

Try it online!

A smaller change that only tied. Calling the function multiple times always give the same random choices, which I hope is OK.

109 bytes

lambda w,h,x,y:[m*w]*y+[m*x+n+m*(w+~x)]+[m*w]*(h+~y)
from random import*
m,n=sample(map(chr,range(32,127)),2)

Try it online!

A shorter function making the list of lines via multiplication. Also generates the characters just once.

Answer 10

Perl 5, 86 bytes

($,,$b)=keys%{{map{chr,1}33..126}};$_=($,x$F[0].$/)x$F[1];s;(.*
){$F[3]}.{$F[2]}\K.;$b

Try it online!

Answer 11

Julia 1.0, 71 bytes

f(w,h,x,y)=(z=unique(rand(' ':'~',9));g=fill(z[1],(h,w));g[y,x]=z[2];g)

x,y are one indexed. Returns a 2d array of characters, I spent the extra bytes to make sure the default printing has the right orientation (' for transpose no longer works because they stick to a strict mathematical meaning). Getting two distinct randoms is surprisingly verbose, this has about a 1e-18 chance of failing to do so, one more byte could make it 1e-196.

Try it online!

Answer 12

J, 21 bytes

u:@(32+2?95){~#.=i.@[

Try it online!

Inspired by dzaima's APL answer.

Thanks to Galen and Adam for the randomize fix.

Answer 13

Octave with Statistics Package, 45 bytes

@(x)randsample(' ':'~',2)(sparse(x{:},0:1)+1)

The input is a cell array of 2 numeric vectors of length 2: {[h y] [w x]}, with x,y 1-based.

Try it online!

Answer 14

Ruby, 62 bytes

->w,h,x,y{a,b=[*?\s..?~].sample 2;r=[a*w]*h*$/;r[y*-~w+x]=b;r}

Try it online!

Answer 15

Excel + CSV, 104 bytes

,,,,=94*RAND()+32,=REPLACE(REPT(REPT(CHAR(E1),A1)&"
",B1),D1*A1+D1+C1+1,1,CHAR(MOD(E1+62*RAND(),95)+32))

Save as CSV, add input as A1 - D1. Output will be in F1.

Using @Engineer Toast's solutoin for generating 2 unique characters.

Needle position is 0-indexed, which is curious, as Excel itself if 1-indexed. Changing to 1-indexed input adds 3 bytes ((D2-1)*(A2+1)+C2 instead of D1*A1+D1+C1+1).

Answer 16

Pyth, 56 50 48 41 bytes

JEKE=TE=Yrd\~=Zh.SYVJVQ ?qHK?qNTpeYpZpZ)d

I'm somewhat struggling to golf Pyth, but posting this to force myself to learn.

Edit 1: Golfed it down a bit, and made it an actual solution -6 bytes

Edit 2: Looked at it after posting it and realized a few bytes save by ignoring space. -2 bytes

Edit 3: Today I learned about character ranges, which shortens things significantly. -7 bytes

Answer 17

PHP, 113 109 bytes

for([,$w,$h,$x,$y]=$argv,$a=range(' ','~'),shuffle($a);$i++<$h;print"
")for(;$$i++<$w;)echo$a[$i-$y||$$i-$x];

Try it online!

Pass inputs as command arguments ($argv) in order of w, h, x and y. The x and y are one-indexed.

for(
  [,$w,$h,$x,$y]=$argv, // put inputs from $argv array into 4 short named variables
  $a=range(' ','~'),    // create $a array containing printable ASCII characters
  shuffle($a);          // shuffle the array
  $i++<$h;              // loop $h times (rows)
  print"\n"             // print a newline after every row
)
  for(;$$i++<$w;)       // loop $w times (columns)
    echo                // print
      $a[               //   a character from $a (1st char for needle and 2nd for heystack)
        $i-$y ||        //   when row and y don't match
        $$i-$x          //   or when col and x don't match (will be false only for needle)
      ];

Answer 18

Add++, 65 bytes

D,g,?!,
L,c95Rdb[€BXd¦=BFV#@G+b[95€Ω%31€+€CA€RbU‽g$€=$€Ω:A$pbUp$T

Try it online!

Takes input as [y x] and [w h]. x and y are 1-indexed. Outputs a list of lines.

Added 17 bytes to make sure the needle is distinct.

How it works

We start by generating two ranges from \$1\$ to \$95\$ inclusive, before choosing a random value from each. If the two values are equal, we add one to the one of them. We then add \$31\$ to each, yielding two characters ord points in the ASCII range. Finally, we convert them to characters.

Next, we generate a list of all co-ordinates in the grid, and compare them with [y x]. If the co-ordinates match, we yield \$1\$, otherwise \$0\$. Next, we index each of these \$1\$s and \$0\$s into the two characters, creating a grid of \$0\$ characters with 1 \$1\$ character in it at [y x]. Finally, we retrieve the width and split the grid into that many rows.

Answer 19

SOGL, 18 bytes

 ~Δψ] ~Δψ⁴⁴=}A*∙až

Try it here! 1-indexed.

Answer 20

C# (Visual C# Interactive Compiler), 145 bytes

(a,b,c,d)=>{int l=0;for(var j=Enumerable.Range(32,95).OrderBy(k=>Guid.NewGuid()).ToList();l<a*b;)Write((char)j[l==c*a+d?1:0]+(++l%a<1?"\n":""));}

Try it online!

Answer 21

Icon, 119 bytes

procedure f(w,h,x,y)
until m:=char(32+?95)&n:=char(32+?95)&m~==n
t:=[];1to h&put(t,repl(m,w))&\z
t[y,x]:=n
return t
end

Try it online!

xand yare 1-indexed

Answer 22

Python 3, 137 bytes

lambda w,h,x,y,c=chr:"\n".join([c(a)*w,c(a)*x+c(n)+c(a)*(w-x-1)][r==y]for r in range(h));a,n=__import__("random").sample(range(32,127),2)

Try it online!

Uses zero-based indexing for the needle position.

Answer 23

Perl 6, 57 bytes

{(' '..'~').pick(2)[0 xx$^a*$^b-1,1;*].pick(*).rotor($a)}

Try it online!

Answer 24

Charcoal, 17 bytes

ＵＯＮＮ‽γＪＮＮ‽Φγ¬⁼ιＫＫ

Try it online! Link is to verbose version of code. Explanation:

ＵＯＮＮ‽γ

Draw a rectangle of the given width and height using a random printable ASCII character.

ＪＮＮ

Jump to the 0-indexed position of the needle.

‽Φγ¬⁼ιＫＫ

Print a random printable ASCII character, but filtering out the character under the cursor.

Answer 25

K (oK), 27 23 bytes

-4 bytes thanks to ngn!

{`c$(32+-2?95)x#&/y=!x}

Try it online!

0-indexed x and y

Similar to Dzaima's APL and Jonah's J solutions.

Answer 26

Red, 156 bytes

func[w h x y][c: :collect p: take/part random c[repeat i 95[keep to sp 32 + i]]2
c[repeat i h[keep/only c[repeat j w[keep pick p i * w + j
=(y * w + x)]]]]]

Try it online!

x and y are 1-indexed. Returns a list of strings.

Readable:

f: func [w h x y] [
    c: take/part random collect [
        repeat i 95 [
            keep to sp 32 + i
        ]
    ] 2
    collect[
        repeat i h [
            keep/only collect [
                repeat j w [
                    keep pick c i * w + j = (y * w + x)
                ]
            ]
        ]
    ]
]

Answer 27

Python 2, 144 132 131 bytes

from random import*
i,j,k,l=input()
n,h=sample(range(32,127),2)
for x in range(j):a=[chr(n)]*i;a[k]=chr((n,h)[x==l]);print`a`[2::5]

Try it online!

Corrected the problem with the guaranteed uniqueness of the characters and saved 12 bytes along the way.

Answer 28

Forth (gforth), 140 bytes

include random.fs
: x 95 random 32 + ;
: f x -rot 0 do cr dup 0 do 2over i j d= >r over r> if begin x 2dup - until nip then emit loop loop ;

Try it online!

0-indexed

Code Explanation

include random.fs        \ import the random library

\ Generate a random number in range 32 to 126 inclusive
: x                      \ start a new word definition
  95 random              \ generate a random number between 0 and 94
  32 +                   \ add 32
;                        \ end word definition

: f                      \ start a new word definition
  x -rot                 \ generate a random number for the haystack, then move it
  0 do                   \ loop from 0 to h-1 (inclusive)
    cr                   \ output a newline
    dup 0 do             \ loop from 0 to w-1 (inclusive)
      2over i j d=       \ check if this is the needle square
      >r over r>         \ hide result, grab a copy of the haystack char, then grab result back
      if                 \ if it is a needle
        begin            \ begin indefinite loop
          x 2dup -       \ generate a new random number and compare to haystack char
        until            \ only end loop when values differ
        nip              \ drop haystack char
      then               \ end if block
      emit               \ output ascii char for value on top of stack
    loop                 \ end row loop
  loop                   \ end column loop
;                        \ end word definition

Answer 29

C (clang), 87 bytes

f(w,h,x,y){x+=y*w;h*=++w;for(y=time(0)%9023;h--;)putchar(h%w?(x--?y+1:y%96)%95+32:10);}

Try it online!

Stealing from @Arnauld answer

Answer 30

Japt -R,34 30 29 24 bytes

;E=öx)ÎpU*V hW*U+XEg1)òU

Try it

5 Bytes saved thanks to @Shaggy.

Inputs are U,V => size , W,X => needle coords 0 indexed

 ;E=   // set of printable characters 
     öx) // random permutation 
 Î // => g0  pU*V    repeats U*V times first element of set
           hW*U+XEg1) // overwrite at W,X with 2nd element 
                      òU // split

Answer 31

05AB1E, 15 bytes

žQΩIPמQΩIPǝ¹нô

Coordinates are 1-indexed. Outputs as a list of lines.

Try it online (» in the footer joins the list of strings by newlines to pretty-print, feel free to remove it to see the actual output).

Explanation:

žQ              # Push all printable ASCII characters
  Ω             # Pop and push a random character
   IP           # Push the first input (rectangle-size), and take its product
     ×          # Repeat the random character that many times as string
      žQΩ       # Push a random character again
         IP     # Push the second input (1-based coordinate), and take its product as well
           ǝ    # Insert the random character at this (0-based) index into the string
            ¹н  # Push the first input again, and only leave its first value (width)
              ô # Split the string into parts of that size
                # (after which the resulting list of strings it output implicitly as result)

Answer 32

C (clang), 130 117 116 109 106 bytes

c[2];f(w,h,x,y){x+=y*w;for(h*=++w;y++<h|*c==c[1];)c[y%2]=time(0)%94+33;for(;h--;)printf(h%w?c+!x--:"\n");}

Try it online!

Saved 13 thanks to @ceilingcat Didn't thought using just only time() was enough And also didn't thought printf accepted a int pointer as a format string!

Needle is 0 indexed

c[2]; // needle and hay stored in array 
f(w,h,x,y){
 x+=y*w; // sets counter for needle (x no more needed)
 for(
     h*=++w; // while incrementing w for newline sets counter for haystack 
     y++<h  // more than 2 iterations to fill array
     |*c==c[1]; // until they're different 
     )
     c[y%2]=time(0)%94+33; // assign value to array (I've excluded spaces )
 for( ;h--; ) printf(h%w?c+!x--:"\n")
 // output: on h%w =0 => newline 
 //              if  x != 0 => hay
 //              when x=0 => needle 
 //              and continue to finish haystack 

Answer 33

Zsh, 108 bytes

Needle location is 1-indexed

repeat $2 : $[h=r++?h:RANDOM%95]&&(repeat $1 s+=${(#)$((n=r-$4||++c-$3?h:(n=RANDOM%94)+(n>=h),32+n))};<<<$s)

Try it online!

repeat $2
  # set hay when row is 0 (shorter than setting it before due to the cost of "(( ))")
  # ": $[  ]" always exits true. "((  ))" would exit false if hay == 0
  : $[hay = row++ ? hay : RANDOM % 95] && (
    # inner loop in (subshell), $str and $col will be empty every time
    repeat $1
      # ${(#)$((x))} expands to the Unicode character at codepoint $x
      str+=${(#)$((offset =
        row - $4 || ++col - $3
        ? hay
        : (offset = RANDOM % 94) + (offset >= hay),
        32 + offset
      ))}
      <<< $str
  )

Proof of correctness by exhaustion, for all combinations of RANDOM%95 and RANDOM%94.