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

bufdef: db 4,0 ; User input buffer

buf: ds 4</syntaxhighlight>

 

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

 

TYPE Score=[BYTE bulls,cows,err]

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

end loop;

end Bulls_And_Cows;</syntaxhighlight>

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

Next guess [1]:

</pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

Bulls and Cows in the APL session.

 

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

isdigits← ∧/⎕D∊⍨⊢

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 repeat

end run</syntaxhighlight>

=={{header|Arturo}}==

 

bulls: 0

 

]

print color #green "** Well done! You made the right guess!!"</syntaxhighlight>

=={{header|AutoHotkey}}==

 

While StrLen(Code) < length {

Return Bulls "," Cows

}</syntaxhighlight>

=={{header|AWK}}==

BEGIN {

srand()

Congratulations, you win!

</pre>

=={{header|BASIC}}==

{{works with|QBasic}}

 

DIM secret AS STRING

 

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

110 FOR I = 1 TO 4

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

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

 

110 FOR I=1 TO 4

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

 

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

110 RANDOMIZE

120 STRING C$*4

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

{{trans|QBasic}}

20 FOR i=1 TO 4

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

190 GO TO 90

</syntaxhighlight>

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

:: Batch File Implementation

 

Play again? </pre>

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

REPEAT

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

UNTIL FALSE

</syntaxhighlight>

=={{header|BCPL}}==

 

static $( randstate = ? $)

You win in 9 tries.</pre>

=={{header|Brat}}==

 

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

}

}</syntaxhighlight>

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

return EXIT_SUCCESS;

}</syntaxhighlight>

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

 

namespace BullsnCows

}

</syntaxhighlight>

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

#include <string>

#include <algorithm>

}

}</syntaxhighlight>

=={{header|Ceylon}}==

DefaultRandom

}

}

}</syntaxhighlight>

=={{header|Clojure}}==

(ns bulls-and-cows)

(bulls-and-cows)

</syntaxhighlight>

=={{header|CLU}}==

% to use the random number generator.

%

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 'A winner is you!'</syntaxhighlight>

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

(do ((digits '()))

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

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

cows bulls)))))))</syntaxhighlight>

=={{header|Crystal}}==

{{trans|Ruby}}

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

guess = [] of Char

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

end</syntaxhighlight>

=={{header|D}}==

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

std.range, std.ascii;

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

 

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

 

var lastGuess := ""

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

 

=={{header|EasyLang}}==

.

# print dig[]

attempts = 0

repeat

.

.

.

print "Well done! " & attempts & " attempts needed."</syntaxhighlight>

 

=={{header|Eiffel}}==

class

BULLS_AND_COWS

Congratulations! You won with 6 guesses.

</pre>

=={{header|Elena}}==

import extensions;

 

class GameMaster

{

 

 

 

 

 

}

 

}

 

public program()

{

 

}</syntaxhighlight>

{{out}}

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def play(size \\ 4) do

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

You win!

</pre>

=={{header|Erlang}}==

Module:

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

 

 

Script:

% Play Bulls and Cows

main(_) -> random:seed(now()), bulls_and_cows:play().</syntaxhighlight>

Correct!

</pre>

=={{header|Euphoria}}==

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

include std\os.e

include std\sequence.e

Press Any Key to continue...

</pre>

 

=={{header|Factor}}==

locals math math.parser math.ranges random sequences strings

io ascii ;

 

: main ( -- ) new-number drop narr>nhash main-loop ;</syntaxhighlight>

=={{header|Fan}}==

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

**

}

}</syntaxhighlight>

=={{header|FOCAL}}==

01.20 S T=0;D 3

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

 

YOU WON! GUESSES= 8</pre>

=={{header|Forth}}==

{{works with|GNU Forth}}

 

create hidden 4 allot

guess: 1879 4 bulls, 0 cows

You guessed it! ok</pre>

=={{header|Fortran}}==

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

implicit none

 

 

end program Bulls_and_Cows</syntaxhighlight>

=={{header|Frink}}==

// Bulls and Cows - Written in Frink

println["Welcome to Bulls and Cows!"]

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

</pre>

 

=={{header|Go}}==

 

import (

}

}</syntaxhighlight>

=={{header|Golo}}==

----

This module is the Bulls and Cows game.

}

</syntaxhighlight>

=={{header|Groovy}}==

static void main(args) {

def inputReader = System.in.newReader()

 

</syntaxhighlight>

=={{header|Haskell}}==

import Control.Monad

import System.Random (StdGen, getStdRandom, randomR)

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

(left, picked : right) = splitAt i l</syntaxhighlight>

=={{header|Hy}}==

 

 

(def +size+ 4)

(print "A winner is you!")</syntaxhighlight>

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

 

The following works in both Icon and Unicon.

 

digits := "123456789"

every !digits :=: ?digits

return (bulls = *num)

end</syntaxhighlight>

=={{header|J}}==

plural=: conjunction define

For example:

 

Guess my number: 1234

0 bulls and 1 cow.

4 bulls and 0 cows.

you win</syntaxhighlight>

=={{header|Java}}==

import java.util.Random;

import java.util.Scanner;

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

You won after 10 guesses!</pre>

=={{header|JavaScript}}==

=== Spidermonkey version ===

 

function main() {

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</syntaxhighlight>

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

 

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

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

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

Restart</pre>

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

 

do while len( secret$) <4

end

</syntaxhighlight>

=={{header|Logo}}==

{{works with|UCB Logo}}

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

end

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

end</syntaxhighlight>

=={{header|Lua}}==

for i=1,#array-1 do

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

 

Another version:

math.randomseed(os.time())

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

end

end</syntaxhighlight>

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

Module Game {

Malformed=lambda (a$)->{

Game

</syntaxhighlight>

=={{header|Maple}}==

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

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

...

</pre>

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

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

Module[{r,bulls,cows},

Illegal input.

8261: You got it!</pre>

=={{header|MATLAB}}==

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

Try again: 4368

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

=={{header|MAXScript}}==

numCount = 4 -- number of digits to use

 

)</syntaxhighlight>

{{out}}

OK

Rules:

Bulls: 0 Cows: 1

</syntaxhighlight>

=={{header|MiniScript}}==

secret.shuffle

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

Your guess? 8642

You got it! Great job!</pre>

=={{header|MUMPS}}==

Set number="",x=1234567890

For ii=1:1:4 Do

You guessed 2907. That earns you 4 bulls.

That's a perfect score.</syntaxhighlight>

=={{header|Nanoquery}}==

{{trans|Python}}

 

// a function to verify the user's input

 

Congratulations you guess correctly in 11 attempts</pre>

=={{header|Nim}}==

{{trans|Python}}

randomize()

 

 

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

=={{header|OCaml}}==

let s = read_line () in

try

print_endline "Congratulations you guessed correctly";

;;</syntaxhighlight>

=={{header|Oforth}}==

 

| numbers guess digits bulls cows |

 

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

] ;</syntaxhighlight>

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

in

{Main}</syntaxhighlight>

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

)

};</syntaxhighlight>

=={{header|Pascal}}==

 

{$mode objFPC}

end.

</syntaxhighlight>

=={{header|Perl}}==

use List::MoreUtils qw(uniq);

 

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

}</syntaxhighlight>

=={{header|Phix}}==

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

-- demo\rosetta\BullsAndCows.exw

Well done!

</pre>

=={{header|PHP}}==

$size = 4;

 

}

?></syntaxhighlight>

=={{header|Picat}}==

{{trans|Python}}

Digits = to_array("123456789"),

Size = 4,

).

</syntaxhighlight>

=={{header|PicoLisp}}==

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

(and (num? N)

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

</syntaxhighlight>

=={{header|PowerShell}}==

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

[string]$guess = "none"

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;

}</syntaxhighlight>

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

 

Cows is TT - Bulls.

</syntaxhighlight>

=={{header|PureBasic}}==

Define.i bulls, cows, guesses, i

 

CloseConsole()

EndIf</syntaxhighlight>

=={{header|Python}}==

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

'''

 

Congratulations you guessed correctly in 2 attempts</pre>

=={{header|QB64}}==

Const MaxDigit = 4, Min = 1, Max = 9

Dim As String NumberToGuess, NumberToTest, Newdigit, Result

</syntaxhighlight>

 

 

=={{header|R}}==

{{works with|R|2.8.1}}

bulls <- 0

cows <- 0

}

print(paste("You won in",attempts,"attempt(s)!"))</syntaxhighlight>

=={{header|Racket}}==

 

#lang racket

 

You won after 8 guesses.

</pre>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

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

 

 

say 'A winner is you!';</syntaxhighlight>

=={{header|Red}}==

Red[]

a: "0123456789"

print "You won!"

</syntaxhighlight>

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

 

===Version 2===

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

* Changes from Version 1:

 

=={{header|Ring}}==

# Project : Bulls and cows

 

end

</syntaxhighlight>

 

=={{header|Ruby}}==

Inspired by Tcl

{{works with|Ruby|1.8.7+}}

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

end

Inspired by Python

{{works with|Ruby|2.0+}}

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

guess = nil

=={{header|Rust}}==

{{libheader|rand}}

use rand::{Rng,thread_rng};

 

}

}</syntaxhighlight>

=={{header|Scala}}==

 

object BullCow {

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

}</syntaxhighlight>

=={{header|Scheme}}==

{{works with|any R6RS Scheme}}

 

 

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

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

Congratulations you guessed correctly in 4 attempts

</pre>

=={{header|SenseTalk}}==

repeat forever

put random(1111,9999) into num

end repeat

end repeat</syntaxhighlight>

 

=={{header|Shale}}==

 

 

maths library

 

=={{header|Sidef}}==

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

 

You did it in 4 attempts!

</pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

|number|

BullsCows class >> new: secretNum [ |i|

( (stdin nextLine) = 'y' )

] whileTrue: [ Character nl displayNl ].</syntaxhighlight>

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

'by rbytes, January 2017

OPTION BASE 1

END

</syntaxhighlight>

=={{header|Swift}}==

 

 

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

 

=={{header|Tcl}}==

fconfigure stdout -buffering none

set length 4

 

main</syntaxhighlight>

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

BINGO

</pre>

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

 

Proc _Initialize ' Get our secret number

Return (c@) ' Return number of valid digits</syntaxhighlight>

The addition of strings allows for much simpler code.

s = Str(1234 + RND(8643))

Until FUNC(_Check(s))

Next

Return (1)</syntaxhighlight>

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

{{works with|bash|3}}

 

 

rand() {

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

done</syntaxhighlight>

=={{header|VBA}}==

 

Option Explicit

 

End Function

</syntaxhighlight>

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

fail=array("Wrong number of chars","Only figures 0 to 9 allowed","Two or more figures are the same")

end function

</syntaxhighlight>

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

#90 = Time_Tick // seed for random number generator

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

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

Return ((#90 & 0xffff) * #91 / 0x10000)</syntaxhighlight>

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

 

Imports System.Text.RegularExpressions

 

End Sub

End Module</syntaxhighlight>

 

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

Enter your guess : 8253

You've won with 9 valid guesses!

</pre>

 

=={{header|zkl}}==

Play one game:

abcd:=d.keys.shuffle();

while(1){