Сапер - гра-головоломка, де міни ховаються навколо дошки неписаних плиток з метою визначення місця розташування всіх мін. Натиснувши на міну, ви втратите гру, але натискання на будь-яку іншу плитку виявить число від 0-8, що означає, скільки мін безпосередньо оточує її.

Давши номер, ви повинні відобразити випадкову * можливу комбінацію порожніх плиток та мін, що оточують її. Це має бути у вигляді масиву 3x3. Середня плитка повинна бути кількістю мін, прийнятих за вхід.

* Повинен мати ненульовий шанс для всіх комбінацій.

Приклади

_ = blank square
X = mine

0

___
_0_
___

1

_X_
_1_
___

1

___
_1_
X__

___
_1_
__X

4

_X_
X4X
_X_

4

X_X
_4_
X_X

4

___
X4X
X_X

8

XXX
X8X
XXX

Вхідні дані

• Кількість мін, що оточують центральну плитку (0-8)

Вихід

• Будь-яка розумна форма виводу, що відображає масив плиток 3x3

Інші правила

• Кожна комбінація не повинна мати рівних шансів на це. Просто під час виконання вашої програми має бути ненульовий шанс виникнення кожної комбінації.
• Для шахти та порожньої плитки можна вибрати будь-які 2 символи.
• Це кодовий гольф, виграє програма з найменшою кількістю байтів.

Желе , 9 байт

<Ɱ8Ẋs4js3

Спробуйте в Інтернеті!

порожній = 1
мій =0

Зауважте, що 1і 0є цілими числами.

Ще одне зауваження: це дещо схоже на 10-байтну відповідь Джонатана Аллана, але на неї це ніяк не впливає, і механізм, якщо ви звернете пильну увагу, насправді більше відрізняється, ніж на перший погляд.

APL (Dyalog Unicode) , 28 15 байт

-13 байт завдяки ngn!

{3 3⍴5⌽⍵,⍵≥8?8}

Пояснення:

{...}Пряма функція (D-Fn) ⍵- її правильний аргумент.

8?8 розберіть 8 випадкових чисел зі списку 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ чи аргумент більший чи рівний кожному з них ?:

      5 ≥ 7 2 1 8 4 6 5 3   
0 1 1 0 1 0 1 1

⍵, додайте аргумент до булевого списку:

      5 , 0 1 1 0 1 0 1 1
5 0 1 1 0 1 0 1 1

5⌽ поверніть список на 5 позицій зліва, щоб аргумент знаходився в центрі:

      5 ⌽ 5 0 1 1 0 1 0 1 1
1 0 1 1 5 0 1 1 0

3 3⍴ переформатуйте список до матриці 3x3:

      3 3 ⍴ 1 0 1 1 5 0 1 1 0
1 0 1
1 5 0
1 1 0

Спробуйте в Інтернеті!

J , 15 байт

Також багато байтів завдяки ngn!

3 3$5|.],]>8?8:

Спробуйте в Інтернеті!

JavaScript (ES6), 67 байт

Коротша версія, запропонована @tsh

Порожні прорізи є 0, міни є 1.

n=>`___
_${t=9,n}_
___`.replace(/_/g,_=>n-(n-=Math.random()<n/--t))

Спробуйте в Інтернеті!

Оригінальна версія проб і помилок, 78 байт

Порожні прорізи є _, міни є 7.

f=(n,o=`___
_${k=n}_
___`.replace(/_/g,c=>Math.random()<.5?--k|7:c))=>k?f(n):o

Спробуйте в Інтернеті!

Прокоментував

f = (                         // f = recursive function
  n,                          // n = input
  o = `___\n_${k = n}_\n___`  // o = minesweeper field / k = backup of n
    .replace(/_/g, c =>       // for each underscore character c in o:
      Math.random() < .5 ?    //   random action:
        --k | 7               //     either decrement k and yield 7
      :                       //   or:
        c                     //     let the underscore unchanged
    )                         // end of replace()
) =>                          //
  k ?                         // if k is not equal to 0:
    f(n)                      //   try again
  :                           // else:
    o                         //   stop recursion and return o

Желе ,  13  10 байт

8Ẉ>RẊs4js3

Повернений список списків має відображене ціле число в центрі, оточене 0s та 1s, що представляють міни та пробіли відповідно.

Спробуйте в Інтернеті! (колонтитул симпатично друкує масив)

Як?

8Ẉ>RẊs4js3 - Link: integer, n                   e.g.  3
8          - eight                                    8
 Ẉ         - length of each (implicit range of eight) [1,1,1,1,1,1,1,1]
   R       - range of n                               [1,2,3]
  >        - greater than? (vectorises)               [0,0,0,1,1,1,1,1]
    Ẋ      - shuffle                                  [1,1,1,0,0,1,1,0]
     s4    - split into chunks of 4                   [[1,1,1,0],[0,1,1,0]]
       j   - join (with n)                            [1,1,1,0,3,0,1,1,0]
        s3 - split into chunks of 3                   [[1,1,1],[0,3,0],[1,1,0]]

Pyth, 16 14 байт

c3jQc2.S.[d8*N

Збережено 2 байти завдяки isaacg.
Використовує простір для безпечних місць та пропозиції для мін.
Спробуйте тут

Пояснення

c3jQc2.S.[d8*N
            *NQ     Get (implicit) input number of quotes...
        .[d8        ... and pad to length 8 with spaces.
      .S            Shuffle.
  jQc2              Stick the input in the middle.
c3                  Split into three.

Oracle 18 SQL, 230 байт

Не мова про гольф, але ...

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n
ORDER BY DBMS_RANDOM.VALUE
FETCH NEXT ROW ONLY

Вхідне значення знаходиться в таблиці nзі стовпцем n:

CREATE TABLE n(n) AS
SELECT 7 FROM DUAL;

Спробуйте в Інтернеті - увійдіть на сторінку https://livesql.oracle.com та вставте її в робочий аркуш.

Вихід:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
101 
171 
111

Щоб отримати всі можливі комбінації (183 байт):

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n

Вихід:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
111 
171 
110

111 
171 
101

111 
171 
011

111 
170 
111

111 
071 
111

110 
171 
111

101 
171 
111

011 
171 
111

Japt, 13 байт

çÊú8 öÊi4U ò3

Спробуй це

Пояснення

                   :Implicit input of integer U
 Ê                 :"l"
ç                  :Repeat U times
  ú8               :Pad right to length 8
    öÊ             :Random permutation
       i4U         :Insert U at index 4
            ò3     :Split at every 3rd character

QBasic 1.1 , 206 186 байт

RANDOMIZE TIMER
INPUT N
O=N
Z=8-N
FOR I=0TO 7
IF O*Z THEN
R=RND<.5
O=O+R
Z=Z-1-R
A(I)=-R
ELSEIF O THEN
O=O-1
A(I)=1
ELSE
Z=Z-1
A(I)=0
ENDIF
NEXT I
?A(0)A(1)A(2)
?A(3)N;A(4)
?A(5)A(6)A(7)

-20 завдяки DLosc (нещодавно опублікований трюк з гольфу).

Порожній = 0
Моя =1

Зауважте, що 0 і 1цілі числа, але я використовую STDOUT в будь-якому випадку, так що ...

Результат виглядає так:

 A  B  C
 D  x  E
 F  G  H

Де AH 0/1, а x - вхід.

Вугілля деревне , 19 байт

Ｗ¬⁼ΣＩＫＡ⁸«Ｅ³⭆³‽²↑↗↖θ

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Використовується 0для шахти, 1для порожнього місця. Пояснення:

     ＫＡ             Peek the entire canvas
    Ｉ               Cast to integer
   Σ                Take the sum
       ⁸            Literal 8
  ⁼                 Equals
 ¬                  Logical Not
Ｗ       «           While
          ³ ³       Literal 3
         Ｅ          Map over implicit range
           ⭆        Map over implicit range and join
              ²     Literal 2
             ‽      Random element of implicit range
                    Implicitly print on separate lines
               ↑↗↖θ Print the original input in the middle

• Peek повертає масив рядків, який Sum просто об'єднується, і тому нам потрібно передати ціле число. ( Sum(Sum(PeekAll()))також працює.)
• Sum повертає None порожній масив (перший цикл), тому єдиним безпечним порівнянням є Not(Equals(...)).
• Ніларі Randomзавжди повертається0 , хоча його документація говорить інакше.

Альтернативним рішенням було 19 байт, зараз 17 байтів після помилки деревного вугілля:

θ←9Ｗ⁻ΣＩＫＡ⁸ＵＭＫＭＩ‽²

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Використовується 0для шахти, 1для порожнього місця. Пояснення:

θ

Роздрукуйте оригінальний ввід.

←9

Роздрукуйте 9зліва. Це переміщує курсор назад над початковим входом, а також змушує принаймні одну ітерацію циклу while (інакше введення 8нічого не зробить).

Ｗ⁻ΣＩＫＡ⁸

Повторіть, поки різниця між сумою всіх цифр на полотні та 8 не дорівнює нулю:

ＵＭＫＭＩ‽²

Замініть кожного з оточуючих символів випадковим чином на 0або 1.

R , 67 63 62 59 байт

matrix(c(sample(rep(1:0,c(n<-scan(),8-n))),n),6,5)[2:4,1:3]

Спробуйте в Інтернеті!

Використання 1та 0. Побудуйте n* 1 +(8-n)* 0вектор, перетасуйте його, додайте n, побудуйте більшу матрицю, показану нижче (де a...iстоїть для елементів оригінального вектора) та витягує відповідну підматрицю, показану у верхньому регістрі:

     [,1] [,2] [,3] [,4] [,5]
[1,] "a"  "g"  "d"  "a"  "g" 
[2,] "B"  "H"  "E"  "b"  "h" 
[3,] "C"  "I"  "F"  "c"  "i" 
[4,] "D"  "A"  "G"  "d"  "a" 
[5,] "e"  "b"  "h"  "e"  "b" 
[6,] "f"  "c"  "i"  "f"  "c"

Python 2 , 93 байт

from random import*
def f(n):a=[1]*n+[0]*(8-n);shuffle(a);a[4:4]=[n];return zip(*[iter(a)]*3)

Спробуйте в Інтернеті!

0для порожнього; 1для шахти; і nдля себе.

Прикріпити , 51 байт

{[3,3]&Rotate[Sample[{Sum@_=_2}&_\BinBelow@8]'_,4]}

Спробуйте в Інтернеті!

Пояснення

Схожий на Галена J / APL , основна методика полягає у формуванні масиву 1s та 0s з правильною кількістю мін, вставляючи вхід, додаючи його до кінця, обертаючи масив таким чином, щоб вхід лежав у центрі, потім переформатування в матрицю 3x3.

Частина 1: генерація двійкового масиву

Є багато способів зробити це, але я в основному траплявся через два типи: грубу силу та відбір.

Основний метод грубої сили виглядає так:

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]

Це генерує випадкові масиви з 8 двійкових цифр ( Random[8&2]), тоді як їх сума не дорівнює вхідній {Sum@_/=_2}&_. Це трохи дослівно, оскільки такі підкреслені частини коду є "просто для того, щоб він працював":

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]
          ^           ^^^^^        ^^^^

І я відкинув ідею.

Вибір цікавіший. Основна концепція полягає у використанні BaseBelow[b, n]вбудованого, який формує перелік усіх базових bцілих чисел ширини n(як цифрові масиви) від 0до b^n-1. Наприклад, BaseBelow[3, 2]генерує всі потрійні цілі числа шириною 2:

A> BaseBelow[3, 2]
 0 0
 0 1
 0 2
 1 0
 1 1
 1 2
 2 0
 2 1
 2 2

Ми спеціально використовуємо BaseBelow[2, 8] для всіх двійкових цілих чисел шириною 8. Вони представляють усі можливі мінні поля різної довжини. Це перший крок.

Другий крок - вибір усіх таких масивів з лише N1s, де Nвхід. Моя перша ідея полягала в тому, щоб перекласти цю англійську заяву безпосередньо в Attache:

Chunk[SortBy[Sum,BaseBelow[2,8]],Sum]@N@1

Однак це не тільки на 1 байт довше, ніж у вищезгаданому підході, він також є дуже повторюваним - і це ще не рандомізоване! Звичайно, я міг би зберегти 1 байт шляхом реорганізації, як BaseBelowвикликається, але використовувати підхід просто не варто.

Тому я вирішив вбити двох птахів одним каменем і застосувати Shuffleпідхід, заснований на основі. Далі наведено всі дійсні мінні поля довжини Nу випадковому порядку:

{Sum@_=_2}&N\Shuffle[BaseBelow&8!2]

Тоді, все, що потрібно зробити, це вибрати перший. Але я можу зробити краще - напевно, було б краще просто Sampleвідфільтрований масив? Цей підхід виглядає приблизно так:

Sample[{Sum@_=_2}&_\BaseBelow[2,8]]

Мені довелося повернути BaseBelow&8!2гольф, оскільки \пріоритет надто високий. Інакше задоволений, я перейшов до відсікання цього байта:

Sample[{Sum@_=_2}&_\2&BaseBelow@8]

(Я виявив інший спосіб, як тут швидко викликати діадичну функцію: x&f@yце вираз з високим пріоритетом, який оцінює f[x, y].)

Однак, незважаючи на це, я згадав , що, все разом, псевдонім 2&BaseBelowіснує: BinBelow. Тому я використав це:

Sample[{Sum@_=_2}&_\BinBelow@8]

Це генерує бажане мінне поле. Переконаний, це майже оптимально.

Частина 2: Формування масиву

Як було сказано раніше, використовувана методика формування аналогічна відповіді J / APL, тому я не буду надто детально описуватись. Припустимо, MINEFIELDце результат з останнього розділу. Потім функція стає:

{[3,3]&Rotate[MINEFIELD'_,4]}

MINEFIELD'_з'єднує мінне поле з оригінальним входом _, даючи нам щось подібне:

[1, 0, 0, 0, 1, 0, 0, 1, 3]

Потім Rotate[MINEFIELD'_,4]повертає цей список 4разів ліворуч, розміщуючи центр:

[1, 0, 0, 1, 3, 1, 0, 0, 0]

Останній крок використовується [3,3]&для перестановки списку в матрицю 3x3:

 1 0 0
 1 3 1
 0 0 0

Java 10, 165 157 141 байт

n->{var r="___\n_"+n+"_\n___";for(int i;n>0;r=r.charAt(i*=Math.random())>58?r.substring(0*n--,i)+(i>9?0:0+r.substring(i+1)):r)i=11;return r;}

Порожні плитки є _(будь-який символ із значенням Unicode вище 58 - це добре), а міни є 0.

Спробуйте в Інтернеті.

Пояснення:

n->{                           // Method with integer parameter and String return-type
  var r="___\n_"+n+"_\n___";   //  Result-String, starting at:
                               //   "___
                               //    _n_
                               //    ___"
  for(int i;n>0                //  Loop as long as `n` isn't 0 yet:
      ;                        //    After every iteration:
       r=r.charAt(i*=Math.random())
                               //     Select a random integer in the range [0,11)
         >58?                  //     And if the character at this random index is a '_':
          r.substring(0*n--,i) //      Set `r` to the first part excluding character `i`,
                               //      (and decrease `n` by 1 in the process)
          +(i>9?0:0+           //      appended with a '0',
           r.substring(i+1))   //      appended with the second part
         :                     //     Else:
          r)                   //      Leave `r` unchanged
     i=11;                     //   Set `i` to 11 so a new random integer can be chosen
  return r;}                   //  Return the result

PowerShell , 77 байт

param($n)-join(0..7|random -c 8|%{'X_'[$_-ge$n]
$n[++$i-ne4]
'
'*($i-in3,5)})

Спробуйте в Інтернеті!

PHP , 135 134 123 117 122 121 байт

Переведення на str для друку замість цього зберігає 1 байт

str_split і попросити вставити номер центру економить 11 байт

Більше не потрібно призначати рядок до $ s, зберігаючи 6 байт
Так. Інакше рядок перетасовується після кожного відлуння ...

Видалення пробілів після відлуння економить 1 байт

Заміна "\ n" на розрив віртуальної лінії зберігає 1 байт

$n=$argv[1];$s=implode($n,str_split(str_shuffle(str_pad(str_repeat(m,$n),8,n)),4));for(;$i<9;)echo$s[$i].(++$i%3?"":"
");

Спробуйте в Інтернеті!

Аліса , 24 байти

a8E/be?SZ!@
~E-\ita*.o/a

Спробуйте в Інтернеті!

Порожні прорізи є 9, а міни є0 .

Я також зробив 27-байтну програму 1для мін та 0порожніх слотів:

a8Ea8/be?SZ!@
-E-9:\ita*.o/

Спробуйте в Інтернеті!

PowerShell , 91 86 байт

^{-5 байт завдяки маззі}

param($n)$x=,'X'*$n+,'_'*(8-$n)|random -c 8
-join$x[0..2]
$x[3,4]-join$n
-join$x[5..7]

Спробуйте в Інтернеті!

Shuffles генерується рядка в діапазоні від ________до XXXXXXXX(заміни зліва). Потім він прорізається через нього кілька разів, вставляючи $nпосередині, щоб побудувати вихідний рядок. Ця остання частина, ймовірно, може бути значно оптимізована, оскільки кожен індекс коштує як мінімум 5 байт.

Ruby, 59 bytes

Returns a list of strings (one for each line).

->n{a=([0]*(8-n)+[1]*n).shuffle;a[4,0]=n;a.join.scan /.../}

Try it online!

C (gcc), 81 bytes

f(n,i,j,k){for(j=i=8,k=n;--i+5;putchar(i%4?i-2?rand()%j--<k?k--,88:95:48+n:10));}

Try it online!

Perl 5 -pa, 105 101 bytes

@o=grep!/^....1/&&y/1//=="@F",map{sprintf"%09b",$_}0..2**9-1;$_=$o[rand@o];s/....\K./@F/;s/...\K/\n/g

Try it online!

05AB1E, 12 bytes

$×8j.r2äIý3ô

Uses 0 for mines, spaces for blank squares. Outputs a list of lines, which is pretty printed in the TIOs below by joining with newline delimiter (»).

Try it online or verify a few more test cases at once.

Explanation:

$             # Push 0 and the input-digit
 ×            # Repeat the 0 the input-digit amount of times as string
              #  i.e. 4 → "0000"
  8j          # Prepend spaces to make the size 8
              #  → "    0000"
    .r        # Randomly shuffle the characters in this string
              #  i.e. "    0000" → " 00 0  0"
      2ä      # Split it into two equal halves (of 4 characters)
              #  → [" 00 ","0  0"]
        Iý    # Join it with the input-digit
              #  → " 00 40  0"
          3ô  # And then split it into (three) parts of 3 characters
              #  → [" 00"," 40","  0"]
              # (which is output implicitly as result)

12 bytes alternative:

8L@.rIš5._3ô

Uses 1 for mines, 0 for blank squares. Outputs a matrix of digits, which is pretty printed in the TIOs below by joining each row, and then these rows with newline delimiter (J»).

Try it online or verify a few more test cases at once.

Explanation:

8L            # Push the list [1,2,3,4,5,6,7,8]
  @           # Check for each if the (implicit) input-integer is >= it
              # (1 if truthy; 0 if falsey)
              #  i.e. 4 → [1,1,1,1,0,0,0,0]
   .r         # Randomly shuffle this list
              #  i.e. [1,1,1,1,0,0,0,0] → [0,1,1,0,1,0,0,1]
     Iš       # Prepend the input-digit to the list
              #  → [4,0,1,1,0,1,0,0,1]
       5._    # Rotate the list five times towards the left
              #  → [1,0,0,1,4,0,1,1,0]
          3ô  # And then split it into (three) parts of 3 digits each
              #  → [[1,0,0],[1,4,0],[1,1,0]]
              # (which is output implicitly as result)