Bulls and cows: Difference between revisions

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

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

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:

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>

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

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

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

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

for i range 4

h = i + random (9 - i)

until bulls = 4

.

=={{header|Eiffel}}==

class

BULLS_AND_COWS

end

{{out}}

<pre>

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

console.readChar()

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

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

=={{header|Euphoria}}==

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

include std\os.e

include std\sequence.e

Output :

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

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

=={{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|F Sharp|F#}}==

open System

shouldEnd <- false

0

=={{Header|FreeBASIC}}==

return (num mod 10^(ps+1))\10^ps

end function

wend

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

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

=={{header|JavaScript}}==

=== Spidermonkey version ===

function main() {

main();

Example game (cheating!):

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

import java.util.Random

}

}

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

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

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

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

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

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

=={{header|Nim}}==

{{trans|Python}}

randomize()

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

elif guess[i] in chosen: inc cows

{{out}}

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

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

=={{header|PHP}}==

$size = 4;

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

}

=={{header|Picat}}==

{{trans|Python}}

Digits = to_array("123456789"),

Size = 4,

random_sample(N,I,Chosen0,Chosen)

).

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

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.

=={{header|QB64}}==

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

Dim As String NumberToGuess, NumberToTest, Newdigit, Result

End If

Loop

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

{{works with|Rakudo|2015.12}}

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

}

=={{header|Red}}==

Red[]

a: "0123456789"

]

print "You won!"

=={{header|REXX}}==

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

=={{header|Seed7}}==

const proc: main is func

until guess = chosen;

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

{{out}}

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

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