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|8080 Assembly}}==

 

This is written to run under CP/M and includes an RNG to generate the secret.

 

putchar equ 2

rawio equ 6

secret: ds 4 ; Holds the secret code

bufdef: db 4,0 ; User input buffer

 

=={{header|Action!}}==

 

TYPE Score=[BYTE bulls,cows,err]

PrintE(", try again:")

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Bulls_and_cows.png Screenshot from Atari 8-bit computer]

 

=={{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|APL}}==

{{works with|Dyalog APL}}

Bulls and Cows in the APL session.

 

output ← {⎕←(↑'Bulls: ' 'Cows: '),⍕⍪⍵ ⋄ ⍵}

isdigits← ∧/⎕D∊⍨⊢

random ← 4∘⊣?9∘⊣

moo ← 'You win!'⊣(random game⊢)

 

 

referred to twice. The following definition of <code>moo</code> is exactly equivalent to the above:

 

=={{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|Arturo}}==

 

bulls: 0

 

]

]

=={{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$

 

==={{header|Commodore BASIC}}===

* Other formatting (clear screen, etc.) unique to Commodore BASIC.

 

110 FOR I=1 TO 4

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

730 IF NOT M THEN NEXT J,I

740 RETURN

 

==={{header|IS-BASIC}}===

110 RANDOMIZE

120 STRING C$*4

380 IF POS(S$(:I-1),S$(I)) OR POS(S$(I+1:),S$(I)) THEN LET CHECK$=""

390 NEXT

 

==={{header|ZX Spectrum Basic}}===

{{trans|QBasic}}

20 FOR i=1 TO 4

30 LET d=INT (RND*9+1)

180 IF c$=g$ THEN PRINT "You won after ";guesses;" guesses!": GO TO 10

190 GO TO 90

=={{header|Batch File}}==

:: Batch File Implementation

set /p "opt=Play again? "

if /i "!opt!" equ "y" goto begin

{{Out}}

<pre>

 

Play again? </pre>

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

REPEAT

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

UNTIL FALSE

=={{header|BCPL}}==

 

static $( randstate = ? $)

gensecret(secret)

play(secret)

{{out}}

<pre>Bulls and cows

You win in 9 tries.</pre>

=={{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|C++}}==

#include <string>

#include <algorithm>

std::cout << "Another game? ";

}

=={{header|Ceylon}}==

DefaultRandom

}

}

}

=={{header|Clojure}}==

(ns bulls-and-cows)

(bulls-and-cows)

=={{header|CLU}}==

% to use the random number generator.

%

stream$putl(po, "Bulls and cows\n----- --- ----\n")

play_game(make_secret())

{{out}}

<pre>Bulls and cows

Bulls: 4, cows: 0

Congratulations! You won in 5 tries.</pre>

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

=={{header|Delphi}}==

See [[#Pascal]].

=={{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|FOCAL}}==

01.20 S T=0;D 3

01.30 D 2;D 5;S T=T+1;T "BULLS",B," COWS",C,!!

05.70 I (-FABS(S(X)-G(Y)))5.5,5.9

05.80 S B=B+1

 

{{out}}

 

YOU WON! GUESSES= 8</pre>

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

{{out}}

<pre>init ok

guess: 1879 4 bulls, 0 cows

You guessed it! ok</pre>

=={{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|Frink}}==

// Bulls and Cows - Written in Frink

println["Welcome to Bulls and Cows!"]

guessPlural = guessCount == 1 ? "guess" : "guesses"

println["Congratulations! Your guess of $guess was correct! You solved this in $guessCount $guessPlural."]

{{Out}}

<pre>

Congratulations! Your guess of 6431 was correct! You solved this in 9 guesses.

</pre>

 

=={{header|Go}}==

 

import (

}

}

=={{header|Golo}}==

----

This module is the Bulls and Cows game.

}

}

=={{header|Groovy}}==

static void main(args) {

def inputReader = System.in.newReader()

}

 

=={{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;

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

 

 

Another version:

math.randomseed(os.time())

local numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9}

end

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>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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:

<pre>{8, 2, 6, 1}

Illegal input.

8261: You got it!</pre>

=={{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!

Try again: 4368

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|MiniScript}}==

secret.shuffle

secret = secret[:4].join("")

print "You score " + bulls + " bull" + "s"*(bulls!=1) +

" and " + cows + " cow" + "s"*(cows!=1) + "."

{{out}}

<pre>Your guess? 2385

Your guess? 8642

You got it! Great job!</pre>

=={{header|MUMPS}}==

Set number="",x=1234567890

For ii=1:1:4 Do

Your guess: 2907

You guessed 2907. That earns you 4 bulls.

=={{header|Nanoquery}}==

{{trans|Python}}

 

// a function to verify the user's input

end

 

 

{{out}}

 

Congratulations you guess correctly in 11 attempts</pre>

=={{header|Nim}}==

{{trans|Python}}

randomize()

 

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

elif guess[i] in chosen: inc cows

 

{{out}}

 

Congratulations! You guessed correctly in 4 attempts.</pre>

=={{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}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\BullsAndCows.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

<small>(as shown in the res label)</small>

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|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

my @secret = pick $size, '1' .. '9';

 

}

 

=={{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.

?=; do until length(?)==4; r= random(1, 9) /*generate a unique four-digit number. */

if pos(r,?)\==0 then iterate; ?= ? || r /*don't allow a repeated digit/numeral. */

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|Scratch}}==

Scratch is a graphical programming language. Follow the link to see an example solution for Bulls and Cows<br>

<br>

Since Scratch is an educational language, I've included comments in the code to explain what the program is doing.<br>

=={{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|SenseTalk}}==

repeat forever

put random(1111,9999) into num

end if

end repeat

 

=={{header|Shale}}==

 

 

maths library

 

init()

 

{{out}}

 

=={{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}}==

{{works with|GNU Smalltalk}}

|number|

BullsCows class >> new: secretNum [ |i|

'Do you want to play again? [y/n]' display.

( (stdin nextLine) = 'y' )

=={{header|Smart BASIC}}==

'by rbytes, January 2017

OPTION BASE 1

END DEF

END

=={{header|Swift}}==

 

 

func generateRandomNumArray(numDigits: Int = 4) -> [Int] {

exit(0)

}

 

{{out}}

 

=={{header|Tcl}}==

fconfigure stdout -buffering none

set length 4

}

 

=={{header|Transd}}==

{{trans|C++}}

 

MainModule: {

),

 

syms "0123456789"

len 4

(with bulls 0 cows 0 pl 0

(for i in Range(len) do

(if (eq pl i) (+= bulls 1)

elsif (neq pl -1) (+= cows 1))

),

 

(lout "Welcome to \"Bulls and cows\"!")

(while true

(while true

(textout "Do you want to play? (yes|no) : ")

(if (not (size s))

(lout "Didn't receive an answer. Exiting.") (exit)

(play)

(lout "Another game?")

)

 

=={{header|TUSCRIPT}}==

$$ MODE tuscript

SET nr1=RANDOM_NUMBERS (1,9,1)

ENDIF

ENDLOOP

Output:

<pre>

BINGO

</pre>

=={{header|uBasic/4tH}}==

 

Proc _Initialize ' Get our secret number

Next ' Increment with valid digits

Next

 

=={{header|UNIX Shell}}==

{{works with|bash|3}}

 

 

rand() {

[ "${guess}" == "${secret}" ] && echo "You win!" && exit

echo "Score: $( bulls "${secret}" "${guess}" ) Bulls, $( cows "${secret}" "${guess}" ) Cows"

=={{header|VBA}}==

 

Option Explicit

 

AskToUser = strIn

End Function

=={{header|VBScript}}==

VBS functions return variants. I use t to return a single error value or a pair bulls, cows on result<br />

VBS does'nt have a continue so i used the classic do loop inside do loop in the main program

randomize timer

p=dopuzzle()

do

do

wscript.stdout.write vbcrlf & "your move ": s=trim(wscript.stdin.readline)

c=checkinput(s)

bu=c(0)

wscript.stdout.write "bulls: " & c(0) & " | cows: " & c(1)

 

function checkinput(s)

bu=0:co=0

for i=1 to 4

b=mid(s,i,1)

for j=1 to 4

if asc(b)=asc(mid(p,j,1)) then

checkinput=array(bu,co)

end function

=={{header|Vedit macro language}}==

#90 = Time_Tick // seed for random number generator

#91 = 10 // random numbers in range 0 to 9

#93 = 0x7fffffff % 48271

#90 = (48271 * (#90 % #92) - #93 * (#90 / #92)) & 0x7fffffff

=={{header|Visual Basic .NET}}==

 

Imports System.Text.RegularExpressions

 

Console.WriteLine("The number was guessed in {0} attempts. Congratulations!", attempt)

End Sub

 

=={{header|Wren}}==

{{libheader|Wren-set}}

{{libheader|Wren-ioutil}}

 

var MAX_GUESSES = 20 // say

if (!n) {

System.print("Not a valid number")

} else if (guess.contains("0")) {

System.print("Can't contain zero")

}

}

 

{{out}}

Enter your guess : 8253

You've won with 9 valid guesses!

</pre>

 

=={{header|zkl}}==

Play one game:

abcd:=d.keys.shuffle();

while(1){

"%d bull%s and %d cow%s".fmt(bulls,s(bulls),cows,s(cows)).println();

}

{{out}}

<pre>