Bulls and cows/Player: Difference between revisions

 

bulls_player.adb:

with Ada.Containers.Vectors;

with Ada.Numerics.Discrete_Random;

-- solve the puzzle

Solve;

 

output:

 

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

 

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

#include <iostream>

#include <sstream>

}

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

Output:

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

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

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def player(size \\ 4) do

possibility = permute(size) |> Enum.shuffle

end

 

 

{{out}}

{{trans|C}}

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

 

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

sequence secret = get_digits(n)

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

 

Output:

 

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

=={{header|Fortran}}==

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

implicit none

 

end if

end do

Output

<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=: ' ' -.~ ":

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

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

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

 

 

=={{header|Lua}}==

{{Trans|Phix}}

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

 

print (line..'\nSecret '.. #secret.. ' | '..table.concat(secret) .. ' | Bulls | Cows |' .. '\n' .. line)

 

 

{{out}}

 

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

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

While[True,

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

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

Output:

<pre>120 candidates remaining.

 

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

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

{{works with|Perl 5.10.0 and above}}

 

use warnings;

use strict;

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">" +---------+-----------------------------+-------+------+\n"</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s | Secret | %9s | BULLS | COWS |\n%s"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">line</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">secret</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">line</span><span style="color: #0000FF;">})</span>

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

{{out}}

N=4:

 

=={{header|PicoLisp}}==

 

(de bullsAndCows ()

Choices ) )

(NIL Choices "No matching solution")

Output:

<pre>: (bullsAndCows)

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.

 

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

 

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

{

guesses <- 1234:9876

}

}

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

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

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

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

 

=={{header|Scala}}==

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

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

play(allCombinations)

}

{{out}}

<pre>

 

=={{header|SenseTalk}}==

repeat forever

repeat forever

end if

end repeat

 

=={{header|Shale}}==

 

 

maths library

{ true } {

solve()

 

{{out}}

 

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

{{tcllib|struct::list}}

{{tcllib|struct::set}}

package require struct::set

 

break

}

'''Sample Output'''

<pre>

=={{header|VBA}}==

 

Option Explicit

Next

End Sub

{{out}}

<pre>TOSS : 9 2 4 7

=={{header|Wren}}==

{{trans|Kotlin}}

 

var countBullsAndCows = Fn.new { |guess, answer|

System.print("Something went wrong as no choices left! Aborting program")

}

 

{{out}}

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