지뢰 찾기 는 모든 광산의 위치를 ​​식별하기 위해 설명이없는 타일 보드 주위에 광산이 숨겨져있는 퍼즐 게임입니다. 지뢰를 클릭하면 게임이 사라지지만 다른 타일을 클릭하면 0-8의 숫자가 표시되며, 지뢰를 직접 둘러싸는 지뢰 수를 나타냅니다.

숫자가 주어지면 빈 타일과 주변의 광산을 무작위로 * 가능한 조합으로 표시해야합니다. 이것은 3x3 배열 형식이어야합니다. 중앙 타일은 입력으로 취한 광산의 수 여야합니다.

* 모든 조합이 발생할 가능성이 0이 아닙니다.

예

_ = 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 타일 배열을 표시하는 합리적인 형태의 출력

다른 규칙

• 각 조합이 동일한 기회를 가질 필요는 없습니다. 프로그램을 실행할 때 각 조합이 발생할 가능성이 0이 아니어야합니다.
• 광산 및 빈 타일에 대해 2 개의 문자를 선택할 수 있습니다.
• 이것은 가장 적은 바이트 수를 가진 프로그램 인 코드 골프입니다.

젤리 , 9 바이트

<Ɱ8Ẋs4js3

온라인으로 사용해보십시오!

비어있는 = 1
광산 =0

그 주 1와 0정수입니다.

또 다른 메모 : 이것은 Jonathan Allan의 10 바이트 답변과 다소 유사하지만 실제로 어떤 식 으로든 영향을받지 않으며주의를 기울이면 메커니즘이 실제로는 언뜻보기보다 더 다릅니다.

APL (Dyalog Unicode) , 28 15 바이트

ngn 덕분에 -13 바이트!

{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:

온라인으로 사용해보십시오!

자바 스크립트 (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

반환 된 목록의 목록에는 각각 광산과 공백을 나타내는 0과 1로 둘러싸인 중앙에 정수가 표시됩니다.

온라인으로 사용해보십시오! (바닥 글은 배열을 예쁘게 인쇄합니다)

방법?

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

isaacg 덕분에 2 바이트를 절약했습니다.
안전한 장소를 위해 공백을 사용하고 광산을 인용합니다.
여기 사용해보십시오

설명

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

apt, 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)

DLosc 덕분에 -20 (신규 게시 된 골프 트릭) .

빈 = 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

• PeekSum단순히 배열로 연결된 문자열 배열을 반환하므로 정수로 먼저 캐스팅해야합니다. ( Sum(Sum(PeekAll()))또한 작동합니다.)
• SumNone빈 배열 (첫 번째 루프)을 반환 하므로 유일한 안전한 비교는 Not(Equals(...))입니다.
• 문서에 달리 명시되어 있지만 Nilary는 Random항상을 반환합니다 0.

대체 솔루션은 19 바이트였으며 현재 숯 버그 수정 후 17 바이트입니다.

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 빈 공간에 0광산을 사용 1합니다. 설명:

θ

원래 입력을 인쇄하십시오.

←9

9왼쪽으로 인쇄하십시오 . 이렇게하면 커서가 원래 입력 위로 다시 이동하고 while 루프를 한 번 이상 반복합니다 (그렇지 않으면 입력 8이 아무 것도하지 않음).

Ｗ⁻ΣＩＫＡ⁸

캔버스에있는 모든 숫자의 합과 8 사이의 차이가 0이 아닌 동안 반복하십시오.

ＵＭＫＭＩ‽²

각 주변 문자를 무작위로 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"

파이썬 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]}

온라인으로 사용해보십시오!

설명

Galen의 J / APL answer 와 유사하게 , 기본 기술은 정확한 수의 광산으로 1과 0의 배열을 생성하고, 끝에 입력을 추가하여 입력을 삽입하고, 입력이 중심에 놓 이도록 배열을 회전시키는 것입니다. 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 인 모든 3 진 정수를 생성합니다.

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의 모든 이진 정수에 사용 합니다. 이들은 모든 길이의 가능한 모든 지뢰밭을 나타냅니다. 이것이 첫 번째 단계입니다.

두 번째 단계는 N1이있는 모든 배열을 선택하는 것 N입니다. 여기서는 입력 위치 입니다. 첫 번째 아이디어는이 영어 문장을 직접 Attache로 번역하는 것이 었습니다.

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

그러나이 방법은 앞서 언급 한 방법보다 1 바이트 길어 졌을뿐만 아니라 반복성이 높으며 아직 무작위 화되지도 않았습니다. 물론, BaseBelow호출 방식을 재구성하여 1 바이트를 절약 할 수 는 있지만 접근법을 사용하는 것은 가치가 없습니다.

그래서 나는 하나의 돌로 두 마리의 새를 죽이고 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

자바 (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;}

빈 타일은 _(유니 코드 값이 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 바이트 절약

더 이상 6 바이트를 절약하는 $ s에 문자열을 할당 할 필요가 없습니다
. 예. 그렇지 않으면 매 반향마다 문자열이 섞입니다 ...

에코 후 공백을 제거하면 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?"":"
");

온라인으로 사용해보십시오!

Alice , 24 바이트

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

온라인으로 사용해보십시오!

빈 슬롯은 9이고 광산은 0입니다.

나는 또한 1광산과 0빈 슬롯 을 위해 27 바이트 프로그램을 만들었습니다 .

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]

온라인으로 사용해보십시오!

셔플에서부터 생성 된 문자열 ________로 XXXXXXXX(왼쪽에서 치환). 그런 다음 여러 번 슬라이스 $n하여 중간에 삽입 하여 출력 문자열을 만듭니다. 이 마지막 부분은 각 인덱스의 비용이 최소 5 바이트이므로 크게 최적화 될 수 있습니다.

루비 , 59 바이트

문자열 목록을 반환합니다 (각 줄에 하나씩).

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

온라인으로 사용해보십시오!

C (gcc) , 81 바이트

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));}

온라인으로 사용해보십시오!

펄 5 -pa , 105101 바이트

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

온라인으로 사용해보십시오!

05AB1E , 12 바이트

$×8j.r2äIý3ô

0광산, 빈 사각형을위한 공간에 사용 합니다. 줄 바꿈 문자 ( ») 와 결합하여 아래 TIO에 인쇄 된 줄 목록을 출력합니다 .

온라인으로 시도 하거나 한 번에 몇 가지 테스트 사례를 더 확인하십시오 .

설명:

$             # 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 바이트 대안 :

8L@.rIš5._3ô

사용 1, 광산에 대한 0빈 사각형을 위해. 각 행을 연결 한 다음 줄 바꿈 문자 ( J») 로이 행을 결합하여 아래 TIO에 잘 인쇄 된 숫자 행렬을 출력합니다 .

온라인으로 시도 하거나 한 번에 몇 가지 테스트 사례를 더 확인하십시오 .

설명:

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)