Find the odd one out

Question

Challenge

The goal of this challenge is to generate and output a \$16 \times 32\$ (height \$\times\$ width) grid where all cells contain a decoy character, except for a random single cell that contains the target character. The input will be a pair of ASCII (32-126) characters: [target,decoy], where target is the character to find, and decoy is the character that fills the rest of the grid. The selection of the target cell must be uniformly random from among the \$512\$ cells, ensuring that each cell has an equal chance (\$\frac{1}{512}\$) of being chosen for modification.

Examples

The preferable output format should closely resemble these examples below as this enhances the challenge of locating the target character. However, creative solutions are welcome and minor deviations in format (e.g., additional leading/trailing whitespace, alternative ways of representing the grid) are acceptable.

Input

[0,O]

Output

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOO0OOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

Input

[v,w]

Output

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wvwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

[target,decoy] suggestions

[0,O] [1,l] [1,I] [2,Z] [5,S] [8,B] [v,u] [m,n]
[b,d] [p,q] [C,G] [E,F] [V,U] [V,Y] [s,z] [6,9]
[D,O] [&,8] [C,O] [$,S] [R,P] [8,3] [4,A] [c,o]

Answer 1

Python, 87 bytes

import random as r,textwrap as w
f=lambda t,d:w.fill("".join(r.sample(t+d*511,512)),32)

Attempt This Online!

Same sampling technique as @movatica, but a different approach to wrapping, using textwrap

Answer 2

Google Sheets, 52 bytes

=index(if(randbetween(1,512)=sequence(16,32),B1,A1))

Put the decoy in cell A1, the target in cell B1, and the formula in cell C1. The formula outputs in cells C1:AH16.

In Google Sheets, array formulas take the dimensions of the argument that has the biggest dimensions. In this instance, it is the matrix produced by sequence(). The value given by randbetween() is compared with each element in the matrix in turn.

_{(-14 bytes thanks to z..)}

Answer 3

R, 59 46 44 bytes

\(x)write(sample(rep(x,c(1,511))),"",32,,"")

Attempt This Online!

Takes input as a vector c(target,decoy).

Answer 4

Pip, 17 bytes

(SHaX511.b)<>32Jn

Attempt This Online!

First time trying Pip!

Explanation:

(SH...) shuffle the following:

• aX511 first input repeated 511 times
• .b append second input

<>32 split into chunks of length 32

Jn join on newlines

This can be 14 bytes with the -n flag:

Pip -n, 14 bytes

SHaX511.b<>:32

Attempt This Online!

Same as above, but uses assignment at the end to reduce the operator precedence of <> and save a parenthesis. The -n flag joins the output list on newlines at the end of the program. We can't do anything else after the assignment trick because of how it works, so this isn't applicable to the first solution.

Answer 5

Perl 5 -pl, 47 45 bytes

Credit @DomHastings for saving 2 bytes.

$_ x=512;substr$_,rand 512,1,<>;s/.{32}\K/
/g

Try it online!

Answer 6

JavaScript (ES6), 66 bytes

Expects (target)(decoy).

(a,k=Math.random(n=512)*n)=>g=b=>n--?(n^k?a:b)+[`
`[n&31]]+g(b):''

Try it online!

Answer 7

APL (Dyalog Unicode), 15 bytes

Full program. Prompts for target+decoy. Requires 0-based indexing (⎕IO←0).

⍞[16 32⍴×?⍨512]

Try it online!

⍞[…] prompt for target (index 0) + decoy (index 1) and index with the following array:

 ?⍨512 random permutation of integers 0…511

 × sign (leaves a single 0 and the rest as 1s)

 16 32⍴ reshape into 16 rows and 32 columns

Answer 8

Vyxal j, 57 bits^v2, 7.125 bytes

k¶ø↳Þ℅32ẇ

Try it Online!

Bitstring:

100000101110010111110010011011011010000100001111110101001

Answer 9

Python, 108 105 103 101 95 bytes

-2 bytes thanx to CursorCoercer -2 bytes thanx to vengy

from random import*
f=lambda*x,k=randrange(512):''.join('\n'[i%32:]+x[i!=k]for i in range(512))

Attempt This Online!

Target and Decoy can be given as iterable or two arguments. Returns grid as string with an extra newline in front.

Still a little longer than the textwrap-approach though :)

Answer 10

Uiua ^SBCS, 16 15 bytes

↯∞_32deal⚂⊂↯511

Try it!

-1 byte thanks to noodle man!

Note that deal was deprecated after I submitted this answer. It still works for now, but won't in the future. I'll leave this here for posterity.

↯∞_32deal⚂⊂↯511
           ↯511  # create an array of 511 decoy characters
          ⊂      # prepend target character
     deal⚂       # shuffle
↯∞_32            # reshape to 16x32

Answer 11

APL+WIN, 20 bytes

Prompts for decoy followed by target.

16 32⍴(?512)⌽⎕,511⍴⎕

Try it online! Thanks to Dyalog Classic

Answer 12

Retina, 29 bytes

^"/./@_`$0"~L$0`.
16*$(32*$0¶

Try it online!

A nice single eval stage (that hides several stages inside). Takes as input the decoy character followed by the target character, with a newline separating them.

Explanation

^"/./@_`$0"~[...]

This is an eval (~) stage, that builds a Retina program as a string and runs it against the input. Normally the following stage would build the program, and the input of this stage would be used as input to that program as well. We are changing this behaviour in two ways:

• ^ swaps the input and the program, so the following stage will generate the new input instead
• "/./@_`$0" is a string option that will be applied as a substitution to the input to generate the new program

All this means that when we have an input of O\n0, we will apply the string substitution to generate the program "/./@_`O\n0".

This is a Replace stage O\n0 that can replace Os with 0s. This stage is applied to a random character thanks to the match mask _, with the option @ selecting a single random match of the regex . (any non-newline character).

So we have a program replacing one random decoy character with our target character, all that's left is generating a 16*32 rectangle of decoy characters:

L$0`.
16*$(32*$0¶

This Lists the character (.) in position 0 (first character of the input, that's the decoy character), and $ubstitutes it with 16*$(32*$0¶, which means 16 times ((32 times that character) plus a newline).

Answer 13

Rattle, 39 bytes

|!Ig0[s>]512P1=?512+$>^~sP2[[b~>]32B]16

Try it Online!

Takes input as [decoy, target] e.g. ['.','X']. This would also work for .X

Explanation

|                                         take input
 !                                        disable implicit output
  I                                       save decoy, target to memory slots 0,1
   g0                                     get value in slot 0 (decoy)
     [  ]512                              loop 512 times
      s                                   save decoy to memory at the pointer (starting at 2)
       >                                  shift pointer right
            P1                            set pointer to 1
              =?512                       set top of stack to a random value 0-511
                   +                      increment (random 1-512)
                    $                     swap target value with random value in memory
                     >^~                  move pointer right by the value in memory (random value)
                         s                save target value to its random slot
                          P2              set pointer to 2
                            [........]16  loop 16 times
                             [...]32      loop 32 times
                              b~          add the value in memory to the print buffer
                                >         move pointer right
                                    B     print and clear buffer

Basically, this generates a 512-character string of the decoy character, makes one of these characters the target character, then outputs as a 16x32 array.

This code is relatively slow. This is due to Rattle's expanding data tape - the data tape is set to a width of 100 slots by default but will automatically expand as needed (which I apparently need to optimize more because it slows execution down here).

Answer 14

Retina, 24 21 bytes

^.
511*$&
V?`
L`.{32}

Try it online! Takes input as a pair of characters <decoy><target>. Explanation:

^.
511*$&

Make 511 copies of the decoy.

V?`

Shuffle the characters randomly.

L`.{32}

Split into rows of 32.

Edit: Saved 3 bytes thanks to @Leo.

Answer 15

Knight (v2), 51 bytes

;=r+%R512=a!=p*P32W>17=a+1aO Sp%r 16T I?a+1/r 32P[p

Input the decoy in the first line and the target in the second line.

Try it online!

I think there are way too many spaces in this code, but this is what I got for now.

Answer 16

MathGolf, 11 bytes

•r_wm=§y♥/n

Inputs as a pair \$[fillterChar,randomChar]\$.

Try it online.

Explanation:

•r          # Push a list in the range [0,512)
  _         # Duplicate this list
   w        # Pop and push a random item from this list
    m       # Map over the list with this random item as argument
     =      #  Check which item equals this argument
            # (we now have a list of 511 0s and a random 1)
      §     # (0-based) index those into the (implicit) input-pair characters
       y    # Join this list of characters to a string
        ♥/  # Split it into parts of size 32
          n # Join by newlines
            # (after which the entire stack is output implicitly as result)

Answer 17

K(ngn/k) 20 19 16 bytes:

Input comes in as [decoy,target].

{x@&/:/(*1?=)'32 16}
{16 32#x@~-512?512}

-3 bytes thanks to @ngn.

{16 32#x@~<?512}

try it online

Answer 18

Ruby, 42 41 bytes

->a,b{[b,*[a]*511].shuffle.each_slice 32}

Attempt This Online!

Outputs an Enumerator of lines. Jordan had the nice idea to use * to combine the lists instead of +, which saved a byte.

Answer 19

Ruby, 43 42 bytes

A byte longer than noodle man’s Ruby solution but I liked it anyway.

->a,b{a*=512
a[rand 512]=b
a.scan /.{32}/}

Attempt This Online!

Answer 20

Easyfuck, 50 49 48 47 43 bytes

¡ã$SPAÖ¼\úëå8CCH>|ÅókVTSÞ[[NELòçEPAT¬|³␓ô¿U¼~MW[èòEPA␀ÿ

^{due to lack of unicode representations for c1 control characters, they have been replaced by their superscripted abbreviations}

Decompressed:

a(<2$[-<.>]>)b(>>1>6\+<[-a>.<]),>,b?%}+<?%+>GJ.

Explanation:

a( )b( ) declares functions a and b

,>,b takes input into 1st and 2nd cell, then executes b

>>1>6\+< sets cell 3 to 16 and cell 4 to 10

[-a>.<] 16 times executes a and prints a new line

<2$[-<.>]> prints second input 32 times

?%}+<?%+> sets cells 3 and 4 to random numbers in the correct range

GJ. moves the cursor and prints first input

This one is shorter but may be breaking the rules as it generates the rectangle, moves the cursor to a random spot on it, and from there asks for input, immediately outputting it.

a(<2$[-<.>]>)b(>>1>6\+<[-a>.<]),b?%}+<?%+>G,.

I'd greatly appreciate it if OP could discern the illegalness of the second solution.

Answer 21

Uiua, 16 15 bytes

↯∞_32⊏=⌊×⚂⟜⇡512

Try it

Explained:

↯∞_32⊏=⌊×⚂⟜⇡512­⁡​‎‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁤‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌­
             512  # ‎⁡Push 512
          ⟜⇡     # ‎⁢Push the range [0, 512) behind it
       ⌊×⚂        # ‎⁣Multiply 512 by a random float and round down
      =           # ‎⁤For each in the range, a 1 if it’s equal to this number and 0 otherwise
     ⊏            # ‎⁢⁡Index into the input with this
↯∞_32             # ‎⁢⁢Reshape this list to have 32 equal columns
💎

Created with the help of Luminespire.

Uiua, 17 bytes

↯16_32⊏=0⍏[⍥⚂512]

Try it online

This was my first attempt at the problem, but I ended up saving a byte with a slightly different method.

Explained:

↯16_32⊏=0⍏[⍥⚂512]­⁡​‎‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣⁢‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌­
          [⍥⚂512]  # ‎⁡512 random floats
         ⍏         # ‎⁢Indices of this sorted
       =0          # ‎⁣Is each equal to 0? (Leaves a 1 in a random position and 0 everywhere else)
      ⊏            # ‎⁤Index into the input with this
↯16_32             # ‎⁢⁡Reshape list to 16*32
💎

Created with the help of Luminespire.

Answer 22

05AB1E, 11 bytes

žA<׫.ržwô»

Try it online!

How?

žA<׫.ržwô»             
   ×                    String of first input
žA<                        of length 511
    «                   Append second input
     .r                 Shuffle
       žwô              Split into chuncks of 32
          »             Join by new lines

Answer 23

Charcoal, 15 bytes

ＵＯ³²⊗⁸ＳＪ‽³²‽¹⁶Ｓ

Try it online! Link is to verbose version of code. Takes the decoy as the first input and the target as the second input. Explanation:

ＵＯ³²⊗⁸Ｓ

Fill a 32×16 oblong grid with the first input.

Ｊ‽³²‽¹⁶

Jump to a random cell.

Ｓ

Overwrite it with the second input.

Answer 24

Jelly, 10 bytes

x511;Ẋs32Y

Try it online!

I'm revisiting this language after several years and I kinda want to write a tool that translates something like (Y (s (Ẋ (; (x λ 511) ρ)) 32)) into the above.

12 bytes

2*511BẊṃs32Y

Try it online!

Answer 25

Go (1.19+), 138137 bytes

import."math/rand"
type S=string
func f(a S,b S){p:=Intn(512)
for i:=0;i<512;i++{if i==p{print(b)}else{print(a)}
if i%32==31{println()}}}

Try it online!

Note: On the Tio platform you will get the same output each time. This is because it is using an older version of Go that do not auto seed the RNG which was introduced in 2022. See the Go Playground for a working (but force-ungolfed) example.

Answer 26

Jelly, 9 bytes

⁹ḤṬẊịs32Y

A monadic Link that accepts a pair of characters, [Target, Decoy], and yields a list of characters.

Try it online!

How?

⁹ḤṬẊịs32Y - Link: pair of characters, TD
⁹         - 256
 Ḥ        - double -> 512
  Ṭ       - untruth -> [0,0,...,0,1] (511 zeros, 1 one)
   Ẋ      - shuffle
    ị     - index into {TD} (1:T; 0:D)
     s32  - split into chunks of length 32
        Y - join with newline characters

Answer 27

C (gcc), 73 70 69 bytes

-3 bytes, thanks to Arnauld
-1 byte, thanks to ceilingcat

r,i;f(t,d){for(i=512,r=rand()%i;i--;i&31?:puts(""))putchar(i-r?d:t);}

Try it online!

Note To possibly increase performance (why not?) and keep the same number of bytes, I've replaced \$i\%32\$ (modulus operation) with \$i\&31\$ (bitwise AND operation) since when the divisor is a power of 2, these are equivalent

$$i\%2^n \quad \equiv \quad i\&(2^n - 1)$$

for any positive integer \$n\$.

Answer 28

Windows Batch Scripting, 183 bytes

@echo off&setlocal enabledelayedexpansion&set/ar=%random%%%512
for /l %%i in (0,1,511)do (if %%i==%r% (set c=%1)else set c=%2
set a=!a!!c!&set/ae=%%i%%32&if !e!==31 echo !a!&set a=)

Answer 29

Scala 3, 85 bytes

A port of @Nicola Sap's Python answer in Scala.

---

Golfed version. Attempt This Online!

(t,d)=>scala.util.Random.shuffle((t+d*511).toSeq).mkString.grouped(32).mkString("\n")

Ungolfed version. Attempt This Online!

object Main {
  def main(args: Array[String]): Unit = {
    val t = "0"
    val d = "O"
    println(f(t, d))
  }

  def f(t: String, d: String): String = {
    // Create a long string by concatenating `t` with `d` repeated 511 times
    val longString = t + d * 511
    
    // Convert the string to a sequence of characters, shuffle it, and convert back to string
    val shuffledString = scala.util.Random.shuffle(longString.toSeq).mkString
    
    // Split the shuffled string into lines of 32 characters each and join them with newline characters
    wrapText(shuffledString, 32)
  }

  def wrapText(text: String, lineLength: Int): String = {
    // Split the text into lines of `lineLength` characters
    text.grouped(lineLength).mkString("\n")
  }
}

Answer 30

AWK, 76 71 bytes

srand(){for(r=int(rand()*512);i<512;++i%32?b:a=a"\n")a=r-i?a$2:a$1}$0=a

• -5 bytes, thanks to cnamejj

Try it online!