टिक-टैक-टो विजेता निर्धारित करें (राउंड आधारित)

26

चलो कुछ कोड-गोल्फ खेलते हैं!

चुनौती टिक-टैक-टो के खेल के विजेता को खोजने की है।

ऐसा बोर्ड द्वारा कई बार किया गया है जिसमें एक स्पष्ट विजेता है लेकिन यहाँ ट्विस्ट है:

कोशिकाओं को इस तरह गिना जाता है:

1|2|3
-+-+-
4|5|6
-+-+-
7|8|9

आपको उस तरह की 9 चालों की एक सरणी मिलती है:

{3, 5, 6, 7, 9, 8, 1, 2, 3}

यह इस प्रकार है:

  • खिलाड़ी 1 अंक सेल 3
  • खिलाड़ी 2 अंक सेल 5
  • खिलाड़ी 1 अंक सेल 6
  • खिलाड़ी 2 अंक सेल 7
  • खिलाड़ी 1 अंक सेल 9
  • खिलाड़ी 1 जीता है

नोट: खेल एक खिलाड़ी के जीतने के बाद नहीं रुकता, ऐसा हो सकता है कि हारने वाला खिलाड़ी विजेता खिलाड़ी के बाद एक पंक्ति में तीन पाने का प्रबंधन करता है, लेकिन केवल पहली जीत मायने रखती है।

आपका काम अब इनपुट के रूप में 9 नंबर प्राप्त करना है और विजेता खिलाड़ी को आउटपुट देना है और वह दौर जिसमें जीत हासिल हुई है। यदि कोई नहीं जीतता है, तो अपनी पसंद के कुछ स्थिर उत्पादन करें। आप इनपुट प्राप्त कर सकते हैं और किसी भी मानक माध्य / प्रारूप के माध्यम से आउटपुट प्रदान कर सकते हैं।

मज़े करो!

अनुरोध के रूप में कुछ और उदाहरण:

{2,3,4,5,6,7,1,8,9} => Player 2 wins in round 6
{1,2,4,5,6,7,3,8,9} => Player 2 wins in round 8
{1,2,3,5,4,7,6,8,9} => Player 2 wins in round 8
code-golf  tic-tac-toe 
— Grunzwanzling
स्रोत
11
PPCG में आपका स्वागत है! यह एक अच्छा पहला पोस्ट है, लेकिन आमतौर पर हम बहुत प्रतिबंधात्मक इनपुट / आउटपुट प्रारूपों को पसंद नहीं करते हैं । क्या आप "राउंड वाई में प्लेयर एक्स जीत" को हटाने पर विचार करेंगे और हमें सूची की तरह किसी भी उचित प्रारूप में आउटपुट देंगे [X, Y]? एक टाई के मामले में, क्या हम इसके बजाय किसी अन्य सुसंगत मूल्य का उत्पादन कर सकते हैं? मैं ऐसा करने की सलाह देता हूं, क्योंकि उन सटीक तारों को मुद्रित करना वास्तव में गोल्फिंग का हिस्सा नहीं है। भविष्य के चुनौती विचारों के लिए, मैं सैंडबॉक्स का उपयोग करने की सलाह देता हूं । :-)
— श्री एक्सकोडर
माफ करना मेरा बुरा। मुझे लगता है कि अब यह सही है।
— ग्रुंज़वान्ज़लिंग
चुनौती को अंत तक पढ़ें, मैं कहता हूं कि एक ड्रा हो सकता है और ऐसा होने पर आप अपनी पसंद का कुछ उत्पादन कर सकते हैं। मैं {2,6} वापस आता हूं जब खिलाड़ी 2 राउंड 6 में जीतता है और {0,0} जब कोई जीतता है।
— ग्रुंजवान्ज़लिंग
क्या हम 0-अनुक्रमित सब कुछ का उपयोग कर सकते हैं? (सेल, खिलाड़ी, राउंड)
— अर्नुलड
1
"आपको इस तरह की 9 चालों की एक सरणी मिलती है: {3, 5, 6, 7, 9, 8, 1, 2, 3}" - 3वास्तव में दो बार दिखना चाहिए ?
— जोनाथन एलन

जवाबों:

8

रेटिना , 114 बाइट्स

(.)(.)
$1O$2X
^
123;;456;;789¶X
{`(.)(.*¶)(.)\1
$3$2
}`.*(.)(.)*\1(?<-2>.)*(?(2)(?!))\1.*¶(..)*
$1$#3
.*¶
T
T`d`Rd

इसे ऑनलाइन आज़माएं! टिक-टैक-टू - एक्स या ओ के मेरे उत्तर के आधार पर ? । X<N>यदि पहला खिलाड़ी जीतता Nहै, O<N>तो दूसरा खिलाड़ी जीतता है, Tअगर न तो जीतता है, तो आउटपुट । स्पष्टीकरण:

(.)(.)
$1O$2X
^
123;;456;;789¶X

एक आंतरिक बोर्ड बनाता है, और उस खिलाड़ी के साथ प्रत्येक चाल को भी चिह्नित करता है जिसकी चाल है।

{`(.)(.*¶)(.)\1
$3$2

एक चाल लागू करता है।

}`.*(.)(.)*\1(?<-2>.)*(?(2)(?!))\1.*¶(..)*
$1$#3

एक जीत के लिए खोज करता है, और यदि कोई पाया जाता है, तो बोर्ड को विजेता और शेष चालों की संख्या के साथ बदलें।

.*¶
T

यदि चालें समाप्त हो जाती हैं और कोई नहीं जीता है तो खेल एक टाई है।

T`d`Rd

शेष चालों की संख्या से गोल की संख्या की गणना करें।

— नील
स्रोत
4
यह अधिक में से एक है .... ज्वालामुखी उत्तर मैंने यहां देखा है।
— लॉर्ड फ़रक्वाड 21
6

MATL , 39 बाइट्स

3:g&+XIx"IX@oXK@(XIt!yXdyPXd&hK=Aa?KX@.

आउटपुट है

  • 1और R, अलग-अलग लाइनों में, यदि उपयोगकर्ता 1 आर में जीतता है ;
  • 0और R, अलग-अलग लाइनों में, यदि उपयोगकर्ता 2 आर में जीतता है ;
  • खाली अगर कोई नहीं जीतता।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

3:       % Push [1 2 3]
g        % Convert to logical. Gives [true true true]
&+       % Matrix of all pairs of additions. Gives a 3×3 matrix, which represents
         % the board in its initial state, namely all cells contain 2. This value
         % means "cell not used yet". 1 will represent "cell marked by user 1",
         % and 0 will represent "cell marked by user 2"
XI       % Copy into clipboard I
x        % Delete
"        % Implicit input: array with moves. For each move
  I      %   Push current board state
  X@     %   Push iteration index (starting at 1), that is, current round number
  o      %   Modulo 2: gives 1 or 0. This represents the current user
  XK     %   Copy into clipboard K
  @      %   Push current move ((that is, cell index)
  (      %   Write user identifier (1 or 0) into that cell. Cells are indexed
         %   linearly in column-major order. So the board is transposed compared
         %   to that in the challenge, but that is unimportant
  XI     %   Copy updated board into clipboard I
  t!     %   Duplicate and transpose
  y      %   Duplicate from below: push copy of board
  Xd     %   Extract main diagonal as a 3×1 vector
  y      %   Duplicate from below: push copy of transposed board
  PXd    %   Flip vertically and extract main diagonal. This is the anti-diagonal
         %   of the board
  &h     %   Concatenate stack horizontally. This concatenates the board (3×3),
         %   transposed board (3×3), main diagonal (3×1 vector) and anti-diagonal
         %   (3×1) into an 3×8 matrix
  K=     %   Push current user identifier. Test for equality with each entry of the
         %   3×8 matrix
  A      %   For each column, this gives true if all its entries are true. Note 
         %   that the first three columns in the 3×8 matrix are the board columns;
         %   the next three are the board rows; and the last two columns are the
         %   main diagonal and anti-diagonal. The result is a 1×8 vector
  a      %   True if any entry is true, meaning the current user has won
  ?      %   If true
    K    %     Push current user identifier
    X@   %     Push current round number
    .    %     Break for loop
         %   Implicit end
         % Implicit end
         % Implicit display
— लुइस मेंडो
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 130 बाइट्स

m=>m.reduce((l,n,i)=>l||(b[n-1]=p=i%2+1,"012,345,678,036,147,258,048,246".replace(/\d/g,m=>b[m]).match(""+p+p+p)&&[p,i+1]),0,b=[])

f=m=>m.reduce((l,n,i)=>l||(b[n-1]=p=i%2+1,"012,345,678,036,147,258,048,246".replace(/\d/g,m=>b[m]).match(""+p+p+p)&&[p,i+1]),0,b=[])
console.log(JSON.stringify(f([3,5,6,7,9,8,1,2,3])))
console.log(JSON.stringify(f([2,3,4,5,6,7,1,8,9])))
console.log(JSON.stringify(f([1,2,4,5,6,7,3,8,9])))
console.log(JSON.stringify(f([1,2,3,5,4,7,6,8,9])))
स्निपेट का विस्तार करें

व्याख्या

m=>m.reduce((l,n,i)=>               // Reduce the input array with n as the current move
  l||(                              //  If there is already a winner, return it
  b[n-1]=p=i%2+1,                   //  Set the cell at b[n-1] to the current player p
  "012,345,678,036,147,258,048,246" //  For every digit in the list of possible rows:
    .replace(/\d/g,m=>b[m])         //   Replace it with the player at the cell
    .match(""+p+p+p)                //  If any of the rows is filled with p:
      &&[p,i+1]                     //   Return [p, current move]
),0,b=[])
— हरमन एल
स्रोत
क्या आप कृपया एक स्पष्टीकरण या एक अनगुल्ड संस्करण प्रदान करना चाहेंगे? मुझे आपके समाधान को समझने में दिलचस्पी है।
— जैक
4

जावा (ओपनजेडके 8) , 445 बाइट्स

int[] t(int[]m){int[][]f=new int[3][3];boolean z=false;for(int i=0;i<9;i++){f[m[i]%3][m[i]/3]=z?2:1;if(f[m[i]%3][0]==(z?2:1)&&f[m[i]%3][1]==(z?2:1)&&f[m[i]%3][2]==(z?2:1)||f[0][m[i]/3]==(z?2:1)&&f[1][m[i]/3]==(z?2:1)&&f[2][m[i]/3]==(z?2:1)||m[i]%3+m[i]/3==2&&f[0][2]==(z?2:1)&&f[1][1]==(z?2:1)&&f[2][0]==(z?2:1)||m[i]%3==m[i]/3&&f[0][0]==(z?2:1)&&f[1][1]==(z?2:1)&&f[2][2]==(z?2:1)){return(new int[]{(z?2:1),++i});}z=!z;}return(new int[]{0,0});}

इसे ऑनलाइन आज़माएं!

रिटर्न वैल्यू {1,8} का मतलब है कि खिलाड़ी 1 राउंड में जीता है। रिटर्न वैल्यू {0,0} का मतलब ड्रा है।

— Grunzwanzling
स्रोत
5
जब तक आप सभी अनावश्यक रिक्ति को नहीं हटाते हैं, गोल्फिंग प्रयास की कमी के कारण यह उत्तर अमान्य माना जाता है। इसके अलावा, यह वास्तव में तेजी से अपनी खुद की चुनौती का जवाब देने के लिए अनुशंसित नहीं है, और आप एक TIO लिंक जोड़ना चाह सकते हैं जैसे कि हम आपके कोड का परीक्षण कर सकते हैं।
— श्री एक्सकोडर
— user202729
मुझे क्षमा करें, मैंने गलत चीज़ की नकल की। यह वास्तव में छोटा है
— ग्रुंज़वान्ज़लिंग
कुछ बाइट्स को हटाने के लिए आप जावा प्रश्न में गोल्फिंग के लिए टिप्स देख सकते हैं । उदाहरण के लिए , falseद्वारा प्रतिस्थापित किया जा सकता है 1<0और पहले ]हटाए जाने के बाद का स्थान ।
— user202729
442 बाइट्स । यह भी कारण है कि "हैडर" और "पाद" खंड टीआईओ पर मौजूद है, इसलिए आपको टिप्पणी करने की आवश्यकता नहीं है //Code that was submittedऔर //End of code।
— user202729
2

कोटलिन , 236 बाइट्स

i.foldIndexed(l()to l()){o,(a,b),p->fun f(i:(Int)->Int)=b.groupBy(i).any{(_,v)->v.size>2}
if(f{(it-1)/3}|| f{it%3}|| listOf(l(1,5,9),l(3,5,7)).any{b.containsAll(it)}){return p%2+1 to o}
b to a+p}.let{null}
fun l(vararg l:Int)=l.toList()

सजा हुआ

    i.foldIndexed(l() to l()) { o, (a, b), p ->
        fun f(i: (Int) -> Int) = b.groupBy(i).any { (_, v) -> v.size > 2 }
        if (f { (it - 1) / 3 } || f { it % 3 } || listOf(l(1, 5, 9), l(3, 5, 7)).any { b.containsAll(it) }) {
            return p % 2 + 1 to o
        }
        b to a + p
    }.let { null }
fun l(vararg l:Int)= l.toList()

परीक्षा

fun f(i: List<Int>): Pair<Int, Int>? =
i.foldIndexed(l()to l()){o,(a,b),p->fun f(i:(Int)->Int)=b.groupBy(i).any{(_,v)->v.size>2}
if(f{(it-1)/3}|| f{it%3}|| listOf(l(1,5,9),l(3,5,7)).any{b.containsAll(it)}){return p%2+1 to o}
b to a+p}.let{null}
fun l(vararg l:Int)=l.toList()

data class Test(val moves: List<Int>, val winner: Int, val move: Int)

val tests = listOf(
        Test(listOf(3, 5, 6, 7, 9, 8, 1, 2, 3), 1, 5),
        Test(listOf(2, 3, 4, 5, 6, 7, 1, 8, 9), 2, 6),
        Test(listOf(1, 2, 4, 5, 6, 7, 3, 8, 9), 2, 8),
        Test(listOf(1, 2, 3, 5, 4, 7, 6, 8, 9), 2, 8)
)

fun main(args: Array<String>) {
    tests.forEach { (input, winner, move) ->
        val result = f(input)
        if (result != winner to move) {
            throw AssertionError("$input ${winner to move} $result")
        }
    }
}

TIO

TryItOnline

— jrtapsell
स्रोत
1

पायथन 2 , 170 बाइट्स

q=map(input().index,range(1,10))
z=zip(*[iter(q)]*3)
o='',
for l in[q[2:7:2],q[::4]]+z+zip(*z):
 r=[n%2for n in l];y=all(r)*2+1-any(r)
 if y:o+=[max(l)+1,y],
print min(o)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों का प्रयास करें

#swap cell number / turn
q=map(input().index,range(1,10))
#split in 3 parts (rows)
z=zip(*[iter(q)]*3)
#starting value for the list with the results
#since string are "greater" than lists, this will
#be the output value when there is a draw
o='',
#iterate over diagonals, rows and columns
for l in[q[2:7:2],q[::4]]+z+zip(*z):
 #use %2 to separate between player 1 and 2
 r=[n%2 for n in l]
 #store in y the value of the player if the trio is a valid win, 0 otherwise
 #it's a win if all moves are from the same player
 y=all(r)*2+1-any(r)
 #if y has a valid player, add the highest turn of the trio, and the player to o
 if y:o+=[max(l)+1,y],
#output the smaller turn of the valid winning trios
print min(o)
— छड़ी
स्रोत
1

पायथन 3.6+, 137 बाइट्स

n=m=c=z=0
for a in input():m+=1<<~-int(a);c+=1;z=z or f'{c&1}:{c}'*any(m&t==t for t in[7,56,448,73,146,292,273,84]);n,m=m,n
print(z or-1)

आउटपुट स्वरूप है winner number:roundया -1एक टाई के लिए। प्लेयर 2 है 0प्लेयर 1 है 1। 1-अनुक्रमित वर्ग संख्याओं के एक अनछुए स्ट्रिंग के रूप में इनपुट।

— mypetlion
स्रोत
1

जेली , 35 बाइट्स

9s3,ZU$$;ŒD$€Ẏf€⁸L€3e
s2ZÇƤ€ZFTḢ;Ḃ$

चालों की एक सूची लेने और एक सूची वापस करने के लिए एक विवादास्पद लिंक, [move, player]जहां खिलाड़ियों की पहचान की जाती है 1(पहले कार्य करने के लिए) और 0(अभिनय करने के लिए दूसरा)।

इसे ऑनलाइन आज़माएं!

कैसे?

9s3,ZU$$;ŒD$€Ẏf€⁸L€3e - Link 1: any winning play?: list of player's moves:
9s3                   - (range of) nine split into threes = [[1,2,3],[4,5,6],[7,8,9]]
       $              - last two links as a monad:
      $               -   last two links as a monad:
    Z                 -     transpose = [[1,4,7],[2,5,8],[3,6,9]]
     U                -     upend     = [[7,4,1],[8,5,2],[9,6,3]]
   ,                  -  pair = [[[1,2,3],[4,5,6],[7,8,9]],[[7,4,1],[8,5,2],[9,6,3]]]
           $€         - last two links as a monad for €ach:
         ŒD           -   diagonals = [[1,5,9],[2,6],[3],[7],[4,8]] or [[7,5,3],[4,2],[1],[9],[8,6]]
        ;             -  concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,5,9],[2,6],[3],[7],[4,8]] or [[7,4,1],[8,5,2],[9,6,3],[7,5,3],[4,2],[1],[9],[8,6]]
             Ẏ        - tighten = [[1,2,3],[4,5,6],[7,8,9],[1,5,9],[2,6],[3],[7],[4,8],[7,4,1],[8,5,2],[9,6,3],[7,5,3],[4,2],[1],[9],[8,6]]
                      -    i.e.:    row1    row2    row3    diag\   x     x   x   x     col1    col2    col3    diag/   x     x   x   x
                      -    where x's are not long enough to matter for the rest...
                ⁸     - chain's left argument, list of player's moves
              f€      - filter to keep those moves for €ach of those lists to the left
                 L€   - length of €ach result
                   3e - 3 exists in that? (i.e. were any length 3 when filtered down to only moves made?)

s2ZÇƤ€ZFTḢ;Ḃ$ - Main link: list of the moves  e.g. [2,3,4,5,6,7,1,8,9]
s2            - split into twos                    [[2,3],[4,5],[6,7],[1,8],[9]]
  Z           - transpose                          [[2,4,6,1,9],[3,5,7,8]]
    Ƥ€        - for Ƥrefixes of €ach:
   Ç          -   call last link (1) as a monad     [0,0,0,0,0] [0,0,1,1]
      Z       - transpose                          [[0,0],[0,0],[0,1],[0,1],[0]]
       F      - flatten                            [0,0,0,0,0,1,0,1,0]
        T     - truthy indices                     [          6   8  ]
         Ḣ    - head (if empty yields 0)           6
            $ - last two links as a monad:
           Ḃ  -   modulo by 2 (evens are player 2) 0
          ;   -   concatenate                      [6,0]
— जोनाथन एलन
स्रोत
0

पायथन 2, 168 बाइट्स

import itertools as z
f=lambda g:next(([i%2+1,i+1]for i in range(9) if any(c for c in z.combinations([[0,6,1,8,7,5,3,2,9,4][j]for j in g[i%2:i+1:2]],3)if sum(c)==15)),0)

एक टाई के लिए आउटपुट (खिलाड़ी, गोल) या 0।

3-बाय -3 मैजिक स्क्वायर पर गेम को मैप करता है और 3 ओएस या एक्स के सेट की तलाश करता है जो कि 15 तक होता है।

— aPaulT
स्रोत
0

साफ , 244 ... 220 बाइट्स

import StdEnv
f[a,b]i#k= \l=or[and[isMember(c+n)(take i l)\\c<-:"123147159357"%(j,j+2)]\\j<-[0,3..9]&h<-:"\0\0",n<-[h-h,h,h+h]]
|k a=(1,i*2-1)|i>4=(0,0)|k b=(2,i*2)=f[a,b](i+1)
@l=f(map(map((!!)l))[[0,2..8],[1,3..7]])1

इसे ऑनलाइन आज़माएं!

स्ट्रिंग hमें गैर- चिह्न शामिल हैं, और इसके बराबर है "\003\001\000\000"।

— Οurous
स्रोत
0

पायथन 2 , 140 136 134 बाइट्स

lambda a,i=0:i<9and(any(set(a[i%2:i+1:2])>=set(map(int,t))for t in'123 456 789 147 258 369 159 357'.split())and(i%2+1,i+1)or f(a,i+1))

इसे ऑनलाइन आज़माएं!

EDIT: 4 बाइट्स + 2 बाइट्स थेक्स टू द एरिक द आउटगोलर।

अगर कोई विजेता नहीं है तो एक ट्यूपल (प्लेयरनंबर, राउंडनंबर) या गलत आउटपुट करता है।

— चास ब्राउन
स्रोत
— निकली आउटगॉल्फ
@ एरिक - याह, मुझे पहले से ही ऐसा करना चाहिए था; लेकिन मैं फ्लू से लड़ रहा हूं और मेरी आंखें दुख रही हैं :)। धन्यवाद!
— चास ब्राउन
अच्छा, जल्दी ठीक हो जाओ। :)
— ३38 बजे आउटगॉल्फ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.