Bulls and cows: Difference between revisions

[[Category:Puzzles]]

[[Category:Games]]

 

[[wp:Bulls and Cows|Bulls and Cows]]   is an old game played with pencil and paper that was later implemented using computers.

*   [[Mastermind]]

<br><br>

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

end;

end loop;

=={{header|ALGOL 68}}==

{{trans|Python}}

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

[4]CHAR chosen;

print((" ",D bulls," Bulls",new line," ",D cows," Cows"))

OD;

Output:

<pre>

Next guess [1]:

</pre>

 

=={{header|AppleScript}}==

 

GUI implementation; the prompt for a guess includes a list of all past guesses and their scores.

 

set theNumber to ""

repeat 4 times

end if

end repeat

 

=={{header|AutoHotkey}}==

 

While StrLen(Code) < length {

Cows++

Return Bulls "," Cows

=={{header|AWK}}==

BEGIN {

srand()

}

return bulls == 4

{{out}}

<pre>

Congratulations, you win!

</pre>

=={{header|BASIC}}==

{{works with|QBasic}}

 

DIM secret AS STRING

END IF

looper:

 

==={{header|Applesoft BASIC}}===

110 FOR I = 1 TO 4

120 P = INT(RND(1) * LEN(D$)) + 1

380 PRINT B " BULLS, " C " COWS"

390 Q = G$ = N$

 

 

@echo off

setlocal enabledelayedexpansion

 

:begin

)

 

cls

 

)

 

:score

)

 

 

 

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

REPEAT

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

UNTIL FALSE

 

=={{header|Brat}}==

 

secret = [1 2 3 4 5 6 7 8 9].shuffle.pop secret_length

guesses = guesses + 1

}

=={{header|C}}==

{{libheader|ncurses}}

#include <stdarg.h>

#include <stdlib.h>

}

}

 

The following function contains the code to check how many bulls and cows there are.

 

{

int i;

nocbreak(); echo(); endwin();

return EXIT_SUCCESS;

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

 

namespace BullsnCows

}

}

 

=={{header|Ceylon}}==

DefaultRandom

}

}

}

=={{header|Clojure}}==

(ns bulls-and-cows)

(bulls-and-cows)

 

=={{header|Coco}}==

 

To handle I/O, we use functions named <code>say</code> (which simply outputs a string) and <code>prompt</code> (which takes a prompt string to display to the user and returns a line of input, without a trailing newline). These require platform-specific implementations. Here's how they can be implemented for the SpiderMonkey shell:

 

prompt = (str) ->

putstr str

 

We can now solve the task using <code>say</code> and <code>prompt</code>:

 

 

secret = _.sample ['1' to '9'], SIZE

say "#bulls bull#{[if bulls !== 1 then 's']}, #cows cow#{[if cows !== 1 then 's']}."

 

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

(do ((digits '()))

((>= (length digits) 4) digits)

(format stream "~&Correct, you win!")

(format stream "~&Score: ~a cows, ~a bulls."

=={{header|Crystal}}==

{{trans|Ruby}}

secret = ('1'..'9').to_a.sample(size)

guess = [] of Char

 

puts "Bulls: #{bulls}; Cows: #{cows}"

=={{header|D}}==

import std.stdio, std.random, std.string, std.algorithm,

std.range, std.ascii;

" Bad guess! (4 unique digits, 1-9)".writeln;

}

{{out}}

<pre>Next guess: 6548

Next guess: 5814

You guessed it!</pre>

 

=={{header|E}}==

Note: This example was deliberately written in an abstracted style, separating out the algorithms, game logic, and UI.

 

def Number := Tuple[Digit,Digit,Digit,Digit]

 

return gameTurn()

 

===REPL user interface===

{{works with|E-on-Java}} (Java Swing)

 

var lastGuess := ""

def op := <unsafe:javax.swing.makeJOptionPane>

op.showMessageDialog(null, msg)

}, entropy)

 

=={{header|EasyLang}}==

.

# print dig[]

attempts = 0

repeat

.

.

.

 

=={{header|Eiffel}}==

class

BULLS_AND_COWS

 

end

{{out}}

<pre>

Congratulations! You won with 6 guesses.

</pre>

=={{header|Elena}}==

import extensions;

 

class GameMaster

{

 

 

 

 

 

}

 

}

 

public program()

{

 

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def play(size \\ 4) do

secret = Enum.take_random(1..9, size) |> Enum.map(&to_string/1)

end

 

 

{{out}}

You win!

</pre>

=={{header|Erlang}}==

Module:

-export([generate_secret/0, score_guess/2, play/0]).

 

read_guess() ->

lists:map(fun(D)->D-48 end,

 

Script:

% Play Bulls and Cows

 

Sample play:<pre>Enter your 4-digit guess: 8376

Correct!

</pre>

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.3, 4.0.0 RC1 and later}}

include std\os.e

include std\sequence.e

 

 

Output :

<pre>

Press Any Key to continue...

</pre>

 

=={{header|Factor}}==

locals math math.parser math.ranges random sequences strings

io ascii ;

[ main-loop ] [ drop win ] if ;

 

=={{header|Fan}}==

** Bulls and cows. A game pre-dating, and similar to, Mastermind.

**

}

}

 

=={{header|Forth}}==

{{works with|GNU Forth}}

 

create hidden 4 allot

: guess: ( "1234" -- )

bl parse 2dup ok? 0= if 2drop ." Bad guess! (4 unique digits, 1-9)" exit then

guess: 1234 1 bulls, 0 cows ok

guess: 1567 1 bulls, 1 cows ok

guess: 1895 2 bulls, 1 cows ok

guess: 1879 4 bulls, 0 cows

=={{header|Fortran}}==

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

implicit none

 

write(*,"(a,i0,a)") "Congratulations! You correctly guessed the correct number in ", tries, " attempts"

 

 

=={{header|Go}}==

 

import (

}

}

=={{header|Golo}}==

----

This module is the Bulls and Cows game.

 

function main = |args| {

while true {

let secret = create4RandomNumbers()

println("(with only the digits 1 to 9 and no repeated digits, for example 2537)")

let guess = readln("guess: ")

if bulls is 4 {

println("You win!")

println("cows: " + cows)

} else {

}

}

}

 

Valid = { digits }

Invalid = { message }

digits = number: digits()

if digits: exists(|d| -> d is 0) {

}

if digits: size() isnt 4 {

}

let digitSet = set[ digit foreach digit in digits ]

if digitSet: size() < digits: size() {

}

} catch(e) {

}

}

 

 

function digits = |this| {

var remaining = this

let digits = vector[]

return digits

}

 

=={{header|Haskell}}==

import Control.Monad

import System.Random (StdGen, getStdRandom, randomR)

f (n - 1) (left ++ right) g' (max - 1) (picked : ps)

where (i, g') = randomR (0, max) g

=={{header|Hy}}==

 

 

(def +size+ 4)

cows (if (= cows 1) "" "s"))))

=={{header|Icon}} and {{header|Unicon}}==

 

The following works in both Icon and Unicon.

 

digits := "123456789"

every !digits :=: ?digits

write("\t",bulls," bulls and ",cows," cows")

return (bulls = *num)

=={{header|J}}==

plural=: conjunction define

end.

smoutput 'you win'

 

For example:

 

Guess my number: 1234

0 bulls and 1 cow.

Guess my number: 5178

4 bulls and 0 cows.

=={{header|Java}}==

import java.util.Random;

import java.util.Scanner;

public static void main(String[] args){

Random gen= new Random();

while(hasDupes(target= (gen.nextInt(9000) + 1000)));

String targetStr = target +"";

return false;

}

Output:

<pre>Guess a 4-digit number with no duplicate digits: 5834

Guess a 4-digit number with no duplicate digits: 3957

You won after 10 guesses!</pre>

=={{header|JavaScript}}==

=== Spidermonkey version ===

 

function main() {

 

main();

 

Example game (cheating!):

Bulls: 4, cows: 0

You win! Guesses needed: 8

 

=={{header|Julia}}==

print("Welcome to Cows & Bulls! I've picked a number with unique digits between 1 and 9, go ahead and type your guess.\n

You get one bull for every right number in the right position.\n

end

end

The following version checks thoroughly that the input of the player is constituted of four distincts digits.

bulls = cows = turns = 0

result = (s = [] ; while length(unique(s))<4 push!(s,rand('1':'9')) end; unique(s))

end

println("You win! You succeeded in $turns guesses.")

{{Out}}

<pre>julia> bullsandcows()

 

=={{header|Kotlin}}==

 

const val MAX_GUESSES = 20 // say

 

 

println("All guesses should have exactly 4 distinct digits excluding zero.")

while (true) {

print("Enter your guess : ")

if (guess == num) {

println("You've won with ${++guesses} valid guesses!")

}

val n = guess.toIntOrNull()

}

}

Sample input/output:

{{out}}

=={{header|Lasso}}==

This game uses an HTML form to submit the answer. The random number and history are stored in a session using Lasso's built in session management.

define randomizer() => {

local(n = string)

'<a href="?restart">Restart</a>'

^}]

 

{{out}}

5493: Bulls: 4, Cows: 0 - YOU WIN!

Restart</pre>

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

 

do while len( secret$) <4

close #w

end

=={{header|Logo}}==

{{works with|UCB Logo}}

output (and [number? :n] [4 = count :n] [4 = count remdup :n] [not member? 0 :n])

end

(print :bulls "bulls, :cows "cows)

if :bulls = 4 [print [You guessed it!]]

=={{header|Lua}}==

for i=1,#array-1 do

local t = math.random(i, #array)

print("\nGoodbye!")

end

 

=={{header|M2000 Interpreter}}==

Module Game {

Malformed=lambda (a$)->{

}

Game

=={{header|Maple}}==

local target, win, numGuesses, guess, bulls, cows, i, err;

target := [0, 0, 0, 0]:

end if;

return NULL;

{{out}}

<pre>

...

</pre>

codes=ToCharacterCode[StringJoin[ToString/@digits]];

Module[{r,bulls,cows},

bulls=Count[userCodes-codes,0];cows=Length@Intersection[codes,userCodes]-bulls;

Print[r<>": "<>ToString[bulls]<>"bull(s), "<>ToString@cows<>"cow(s)."],

Output:

3432: 0 bull(s), 1 cow(s).

Illegal input.

=={{header|MATLAB}}==

% Plays the game Bulls and Cows as the "game master"

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

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

{{out}}

<pre>Welcome to Bulls and Cows!

You win! Bully for you! Only 8 guesses.</pre>

=={{header|MAXScript}}==

numCount = 4 -- number of digits to use

 

format "\nBulls: % Cows: %\n" bulls cows

)

{{out}}

OK

Rules:

Enter your number: 1357

Bulls: 0 Cows: 1

 

=={{header|MUMPS}}==

Set number="",x=1234567890

For ii=1:1:4 Do

Your guess: 2907

You guessed 2907. That earns you 4 bulls.

 

=={{header|Nim}}==

{{trans|Python}}

randomize()

 

const

 

 

 

 

var guesses = 0

var guess = ""

while true:

break

if guess == chosen:

break

var bulls, cows = 0

if guess[i] == chosen[i]: inc bulls

Sample output:

<pre>I have chosen a number from 4 unique digits from 1 to 9 arranged in a random order.

 

2 Bulls

 

3 Cows

 

 

=={{header|OCaml}}==

let s = read_line () in

try

done;

print_endline "Congratulations you guessed correctly";

=={{header|Oforth}}==

 

| numbers guess digits bulls cows |

 

guess filter(#[numbers include]) size bulls - ->cows

System.Out "Bulls = " << bulls << ", cows = " << cows << cr

=={{header|ooRexx}}==

The solution at [[#Version_2|Rexx Version 2]] is a valid ooRexx program.

=={{header|Oz}}==

proc {Main}

Solution = {PickNUnique 4 {List.number 1 9 1}}

fun {Id X} X end

in

=={{header|PARI/GP}}==

This simple implementation expects guesses in the form [a,b,c,d].

my(u,v,bulls,cows);

while(#vecsort(v=vector(4,i,random(9)+1),,8)<4,);

print("You have "bulls" bulls and "cows" cows")

)

=={{header|Pascal}}==

 

{$mode objFPC}

end.

=={{header|Perl}}==

use List::MoreUtils qw(uniq);

 

my $g = shift;

return uniq(split //, $g) == $size && $g =~ /^[1-9]{$size}$/;

=={{header|Phix}}==

{{out}}

<pre>

Well done!

</pre>

=={{header|PHP}}==

$size = 4;

 

preg_match("/^[1-9]{{$size}}$/", $g);

}

 

=={{header|PicoLisp}}==

(let D (mapcar 'format (chop N))

(and (num? N)

(pack Bulls " bulls, " Cows " cows") ) ) )

" Bad guess! (4 unique digits, 1-9)" ) ) )

=={{header|PowerShell}}==

[int]$guesses = $bulls = $cows = 0

[string]$guess = "none"

 

Write-Host "`nYou won after $($guesses - 1) guesses." -ForegroundColor Cyan

{{Out}}

<pre>

You won after 7 guesses.

</pre>

=={{header|Processing}}==

Produces both a console transcript and a GUI interface to the game.

Creates a new game each time the guess is correct; tracks number of games won.

StringList choices;

StringList guess;

}

return result;

=={{header|Prolog}}==

Works with SWI-Prolog 6.1.8 (for predicate '''foldl'''), module lambda, written by '''Ulrich Neumerkel''' found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl and module clpfd written by '''Markus Triska'''.

:- use_module(library(clpfd)).

 

Solution, 0, TT),

Cows is TT - Bulls.

=={{header|PureBasic}}==

Define.i bulls, cows, guesses, i

 

Input()

CloseConsole()

=={{header|Python}}==

Bulls and cows. A game pre-dating, and similar to, Mastermind.

'''

elif guess[i] in chosen:

cows += 1

Sample output:

<pre>I have chosen a number from 4 unique digits from 1 to 9 arranged in a random order.

 

Congratulations you guessed correctly in 2 attempts</pre>

 

=={{header|R}}==

{{works with|R|2.8.1}}

bulls <- 0

cows <- 0

} else {print("Malformed input!")}

}

=={{header|Racket}}==

 

#lang racket

 

(main-loop state (add1 step))))))))))

 

 

Output:

You won after 8 guesses.

</pre>

 

=={{header|Red}}==

Red[]

a: "0123456789"

]

print "You won!"

=={{header|REXX}}==

This game is also known as:

:::::::* Master Mind

===version 1===

This REXX version of Bulls and Cows doesn't allow repeated digits (in the computer-generated number),

<br>nor the use of the zero digit.

<br>and also change the prompt message.

<br>The REXX statement that contains the &nbsp; '''translate''' &nbsp; statement can be removed if repeated digits aren't allowed.

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

===Version 2===

/*REXX program to play the game of "Bulls & Cows". *******************

* Changes from Version 1:

 

ser: Say '*** error ***' arg(1); Return

 

=={{header|Ring}}==

# Project : Bulls and cows

 

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

end

 

=={{header|Ruby}}==

Inspired by Tcl

{{works with|Ruby|1.8.7+}}

[*"1".."9"].shuffle.first(len) # [*"1".."9"].sample(len) ver 1.9+

end

puts "that guess has %d bulls and %d cows" % score(word, guess)

end

 

Inspired by Python

{{works with|Ruby|2.0+}}

secret = [*'1' .. '9'].sample(size)

guess = nil

puts "Bulls: #{bulls}; Cows: #{cows}"

 

=={{header|Rust}}==

{{libheader|rand}}

use rand::{Rng,thread_rng};

 

}

}

=={{header|Scala}}==

 

object BullCow {

 

def hasDups(input:List[Int])=input.size!=input.distinct.size

=={{header|Scheme}}==

{{works with|any R6RS Scheme}}

 

 

;generate a random non-repeating list of 4 digits, 1-9 inclusive

 

(bull-cow (get-num))

 

=== Sample game play ===

You win!

</pre>

=={{header|Seed7}}==

 

const proc: main is func

until guess = chosen;

writeln("Congratulations you guessed correctly in " <& guesses <& " attempts");

 

{{out}}

Congratulations you guessed correctly in 4 attempts

</pre>

 

=={{header|Sidef}}==

var num = @(1..9).shuffle.first(size)

 

 

"Bulls: %d; Cows: %d\n".printf(bulls, cows)

{{out}}

<pre>

You did it in 4 attempts!

</pre>

=={{header|Smalltalk}}==