Bulls and cows/Player: Difference between revisions

*   [[Guess the number/With Feedback (Player)]]

<br><br>

=={{header|Ada}}==

{{works with|Ada 2005}}

 

bulls_player.adb:

with Ada.Containers.Vectors;

with Ada.Numerics.Discrete_Random;

Testant : constant Sequence := V.Element (Position);

Bull_Score : Natural := 0;

begin

for I in Testant'Range loop

-- solve the puzzle

Solve;

 

output:

Cows:2

The sequence you thought has to be: 8 3 9 5</pre>

 

=={{header|AutoHotkey}}==

 

Gui, Add, Text, w83 vInfo, Think of a %length%-digit number with no duplicate digits.

. P(n,k-1,opt,delim,str . A_LoopField . delim)

Return s

=={{header|BBC BASIC}}==

REPEAT

c$ = CHR$(&30 + RND(9))

NEXT i%

ENDPROC

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

Secret | 5437

--------+--------------------

Score | 4 bull, 0 cow

--------+--------------------

Secret | 758214936

--------+--------------------

Guess 11| 758214936 (from: 1)

Score | 9 bull, 0 cow

=={{header|C sharp|C#}}==

{{works with|C#|3.0}}

 

using System;

using System.Collections.Generic;

}

}

Example output:-

<pre>

Hooray! The answer is 5936!

</pre>

=={{header|C++}}==

#include <iostream>

#include <sstream>

}

//--------------------------------------------------------------------------------------------------

Output:

<pre>

It is: 6281

</pre>

=={{header|Common Lisp}}==

(defun random-number ()

(do* ((lst '(1 2 3 4 5 6 7 8 9) (remove d lst))

(setq b (bulls number guess))

(setq c (- (bulls+cows number guess) b)))))

Output:

<pre>

NIL

</pre>

=={{header|Crystal}}==

{{trans|Ruby}}

scores = [] of Tuple(Int32, Int32)

guesses = [] of Array(Char)

break

end

=={{header|D}}==

import std.stdio, std.random, std.algorithm, std.range, std.ascii;

 

return "Nothing fits the scores you gave.".writeln;

writeln("Solution found: ", choices[0]);

{{out|Example output}}

<pre>My guess is 9345. How many bulls and cows? 02

My guess is 7931. How many bulls and cows? 40

Solution found: 7931</pre>

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def player(size \\ 4) do

possibility = permute(size) |> Enum.shuffle

end

 

 

{{out}}

Solved!

</pre>

=={{header|Euphoria}}==

{{trans|C}}

{{works with|Euphoria|4.*}}

 

constant line = "--------+--------------------\n"

sequence secret = get_digits(n)

printf(1,"%sSecret | %s\n%s", {line, secret, line})

 

Output:

Score | 4 bull, 0 cow

--------+--------------------</pre>

=={{header|Factor}}==

math math.combinatorics math.functions math.order math.parser

math.ranges random regexp sequences sets splitting ;

] [ drop "Scoring inconsistency." print ] if* ;

 

{{out}}

<pre>

Success!

</pre>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end if

end do

Output

<pre>

 

Solved!</pre>

 

=={{header|Go}}==

Notes: Strategy per the suggestion in the problem description. Check algorithm lifted from Bulls and cows program. Code here uses Go's built in map type as the container for the list of still-possible numbers; only the map key is used, the value is assigned a dummy of 0.

 

import (

}

}

 

=={{header|Haskell}}==

import Control.Monad

import System.Random (randomRIO)

do putStrLn "Wrong input. Try again"

takeInput

Example:

My guess is 4923

How many bulls and cows?

How many bulls and cows?

4 0

=={{header|J}}==

 

poss=:1+~.4{."1 (i.!9)A.i.9

fmt=: ' ' -.~ ":

while.1<#poss=.poss do.

poss=.poss #~({.bc)=guess+/@:="1 poss

end.

if.#poss do.

'no valid possibilities'

end.

 

For example:

guessing 7461

how many bull and cows? 0 1

guessing 1359

how many bull and cows? 3 0

=={{header|Java}}==

public class BullsAndCowsPlayerGame {

 

}

}

public abstract class AbstractGuessNumber {

 

}

}

public class GameNumber extends AbstractGuessNumber {

 

}

}

public class AutoGuessNumber extends AbstractGuessNumber {

 

}

}

public class GuessResult {

 

}

}

Sample game:

{{out}}

The answer is [0, 5, 3, 6]

</pre>

=={{header|Julia}}==

{{works with|Julia version 0.6.0}}

countbulls(a, b) = sum([a[i] == b[i] for i in 1:length(a)])

countcows(a, b) = sum([a[i] == b[j] for i in 1:length(a), j in 1:length(b) if i != j])

answ = doguess()

println("The winning pick: $(answ[1])$(answ[2])$(answ[3])$(answ[4])")

Example game:

My guess: 9517. How many bulls and cows?

0 1

4 0

The winning pick: 3124

=={{header|Kotlin}}==

 

import java.util.Random

println("Something went wrong as no choices left! Aborting program")

}

Sample game:

{{out}}

You've just found the answer!

</pre>

=={{header|Liberty BASIC}}==

As supplied rhe code shows the remaining pool of numbers after each guess is scored.

guesses =0

 

if instr( i$, "0") then check =1

end function

 

Module[{r,input,candidates=Permutations[Range[9],{4}]},

While[True,

Print[ToString@Length@candidates<>" candidates remaining."];

Print["Can try "<>StringJoin[ToString/@First@candidates]<>"."];

Output:

Can try 1256.

36 candidates remaining.

5 candidates remaining.

Can try 1584.

=={{header|MATLAB}}==

% Plays the game Bulls and Cows as the player

cows = ismember(guess(~bulls), correct);

score = [sum(bulls) sum(cows)];

{{out}}

Secret number: 5612

How many cows? 0

That's bull! You messed up your scoring.</pre>

=={{header|Nim}}==

If there is an impossibility, the program asks the user for the number to guess and indicates where are the errors in scoring.

import random

import sequtils

history.findError()

break

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use strict;

# $+{BULLS} and $+{COWS}.

 

(my $guess) = @_;

 

}

 

my ($a, $b, $bulls, $cows) = @_;

 

"Your secret number is @candidates":

"I think you made a mistake with your scoring");

 

Sample game:

My guess: 1869 (from 3024 possibilities)

1 0

0 3

Your secret number is 1357

 

=={{header|Phix}}==

{{Trans|Euphoria}}

{{out}}

N=4:

+---------+-----------------------------+-------+------+

</pre>

=={{header|PicoLisp}}==

 

(de bullsAndCows ()

Choices ) )

(NIL Choices "No matching solution")

Output:

<pre>: (bullsAndCows)

How many bulls and cows? 0 2

-> "The answer is 2468"</pre>

=={{header|Prolog}}==

Works with SWI-Prolog. Use of library clfd written by '''Markus Triska'''.<br>

There is no algorithm. We explain to Prolog the constraints on the numbers according to the previous guesses and we let Prolog decides of the next guess.<br>

The IA :

:- use_module(library(clpfd)).

 

H #\= H1,

compte_bien_placees(T, T1, MPC, MPF).

The code to play :

retractall('ia.pl':guess(_,_)),

retractall(coups(_)),

add_1(X, Y) :-

Y is X + 1.

A game :

<pre> ?- bulls_and_cows.

true .

</pre>

=={{header|PureBasic}}==

Structure history

answer.s

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>Playing Bulls & Cows with 4 unique digits.

 

Press ENTER to exit</pre>

=={{header|Python}}==

from random import shuffle

 

'\n '.join("%s -> %s" % (''.join(an),sc)

for an,sc in izip(answers, scores)))

 

'''Sample output'''

=={{header|R}}==

As we are picking our guesses randomly from the remaining valid guesses, it is likely that this solution is neither optimal, efficient, or particularly smart. However, it is much shorter than some of the other solutions, is reasonably idiomatic R, and does not break in any way that I know of. I am aware that there exists an optimal method of playing this game, but I neither know the algorithm nor was required by the task to implement it. For comparison, it would be interesting to see the optimal method submitted here as an alternative solution.

{

#The next line is terrible code, but it's the most R way to convert a set of 4-digit numbers to their 4 digits.

repeat

{

#If our guess scores y bulls, then only numbers containing exactly y digits with the same value and position (y "pseudoBulls") as in our guess can be correct.

#Accounting for the positions of cows not being fixed, the same argument also applies for them.

#Finally, the drop=FALSE flag is needed to stop R converting validGuesses to a vector when there is only one guess left.

}

}

{{out}}

<pre>> bullsAndCowsPlayer()

=={{header|Racket}}==

Generate the list of possible choices. Each choice is represented as list of 4 numbers.

(require racket/string

racket/list)

 

(define (listnum->string list)

 

Now define some auxiliary functions to parse the user input (with a minimum error checking) and calculate the score of another possible guess.

(if (string? score)

(let ([splited-score (string-split score ",")])

(let ([bulls (count = guess chosen)]

[cows+bulls (count in-chosen guess)])

 

Main part of the game.

(let loop ([choices all-choices] [num 1])

(begin

(printf "Sorry, I didn't understand that. Please try again.\n")

 

'''Sample Output:'''

Bulls: 1, Cows: 0

Bad scoring! nothing fits those scores you gave.</pre>

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Perl}}

 

# operator X to create the Cartesian Product of four times [1..9] and then get

# all the elements where the number of unique digits is four.

say @candidates

?? "Your secret number is {@candidates[0].join}!"

{{out}}

<pre>My guess: 4235.

2 1

Your secret number is 1234!</pre>

=={{header|Red}}==

ups - this is actually a solver, no input of intermediate results required...

 

digits: charset [#"1" - #"9"] ;; bitset for parse rule in valid function

print [CR "Found *" last k: keys-of results "* in " length? k " attempts" CR] ;; cr - constant for newline / carriage return

] ;; forever loop

'''Sample output'''

<pre>

(halted)

</pre>

=={{header|REXX}}==

About a third of the REXX program deals with presentation and/or validation of answers.

parse arg ? .; if datatype(?,'W') then call random ,,? /*Random seed? Make repeatable*/

L=1234; H=9876; call gen@ /*generate all possibilities. */

if !\=='' then do; call serr; iterate; end /*prompt the user and try again. */

bull=bull/1; cow=cow/1; return /*normalize bulls & cows numbers.*/

=={{header|Ring}}==

# Project : Bulls and cows/Player

 

see "giving " + bulls + " bull(s) and " + cows + " cow(s)." + nl

return [bulls, cows]

=={{header|Ruby}}==

Ruby Version 1.9+

scores = []

guesses = []

break

end

'''Regular output'''

<pre>

6419 => bulls 1 cows 0

</pre>

=={{header|Scala}}==

def allCombinations: Seq[List[Byte]] = {

(0 to 9).map(_.byteValue).toList.combinations(4).toList.flatMap(_.permutations)

play(allCombinations)

}

{{out}}

<pre>

Ye-haw!

</pre>

=={{header|SenseTalk}}==

repeat forever

repeat forever

end if

end repeat

 

=={{header|Sidef}}==

# out numbers containing zeroes or repeated digits.

var candidates = (1234..9876 -> grep {|n| !("#{n}" =~ /0 | (\d) .*? \1 /x) }.map{.digits});

candidates.len == 1 ? ("Your secret number is: %d" % candidates[0].join)

: ("I think you made a mistake with your scoring")

 

'''Output:'''

Your secret number is: 9571

</pre>

=={{header|Tcl}}==

{{trans|Python}}

{{tcllib|struct::list}}

{{tcllib|struct::set}}

package require struct::set

 

break

}

'''Sample Output'''

<pre>

3241 -> (1, 0)

</pre>

=={{header|VBA}}==

 

Option Explicit

Next

End Sub

{{out}}

<pre>TOSS : 9 2 4 7

---------- THE END ------------

TOSS WAS : 9 2 4 7 We found : 9 2 4 7 </pre>

 

=={{header|Yabasic}}==

{{trans|Liberty BASIC}}

clear screen

 

n = token(l$, c$(), d$)

return c$(i)

=={{header|zkl}}==

{{trans|D}}

choices:=Walker.cproduct(d9,d9,d9,d9).pump(List,// lazy,-->3024, order is important

fcn(list){ s:=list.concat(); (s.unique().len()==4) and s or Void.Skip });

 

if(not choices) "Nothing fits the scores you gave.".println();

{{out}}

<pre>

Solution found: 1234

</pre>

{{omit from|GUISS}}