Data commit

2023-07-01 11:58:00 -04:00 · 2023-07-01 11:58:00 -04:00 · cb5bb5e222
commit cb5bb5e222
parent 7387c8f97b
199093 changed files with 3378972 additions and 0 deletions
--- a/Task/Bulls-and-cows/00-META.yaml
+++ b/Task/Bulls-and-cows/00-META.yaml
@ -0,0 +1,6 @@
+---
+category:
+- Puzzles
+- Games
+from: http://rosettacode.org/wiki/Bulls_and_cows
+note: Games
--- a/Task/Bulls-and-cows/00-TASK.txt
+++ b/Task/Bulls-and-cows/00-TASK.txt
@ -0,0 +1,24 @@
+[[wp:Bulls and Cows|Bulls and Cows]] &nbsp; is an old game played with pencil and paper that was later implemented using computers.
+
+
+;Task:
+Create a four digit random number from the digits &nbsp; '''1''' &nbsp; to &nbsp; '''9''', &nbsp; without duplication.
+
+The program should: 
+::::::* &nbsp; ask for guesses to this number
+::::::* &nbsp; reject guesses that are malformed
+::::::* &nbsp; print the score for the guess
+
+
+The score is computed as:
+# The player wins if the guess is the same as the randomly chosen number, and the program ends.
+# A score of one '''bull''' is accumulated for each digit in the guess that equals the corresponding digit in the randomly chosen initial number.
+# A score of one '''cow''' is accumulated for each digit in the guess that also appears in the randomly chosen number, but in the wrong position.
+
+
+;Related tasks:
+* &nbsp; [[Bulls and cows/Player]]
+* &nbsp; [[Guess the number]]
+* &nbsp; [[Guess the number/With Feedback]]
+* &nbsp; [[Mastermind]]
+<br><br>
--- a/Task/Bulls-and-cows/8080-Assembly/bulls-and-cows.8080
+++ b/Task/Bulls-and-cows/8080-Assembly/bulls-and-cows.8080
@ -0,0 +1,206 @@
+bdos		equ	5
+putchar		equ	2
+rawio		equ	6
+puts		equ	9
+cstat		equ	11
+reads		equ	10
+
+		org	100h
+		mvi	c,puts
+		lxi	d,signon	; Print name
+		call	bdos
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Initialize the RNG with keyboard input
+		mvi	c,puts
+		lxi	d,entropy	; Ask for randomness
+		call	bdos
+		mvi	b,9		; 9 times,
+randloop:	mvi	c,3		; read 3 keys.
+		lxi	h,xabcdat + 1
+randkey:	push	b		; Read a key
+		push	h
+randkeywait:	mvi	c,rawio
+		mvi	e,0FFh
+		call	bdos
+		ana	a
+		jz	randkeywait
+		pop	h
+		pop	b
+		xra	m		; XOR it with the random memory
+		mov	m,a
+		inx	h
+		dcr	c
+		jnz	randkey		; Go get more characters
+		dcr	b
+		jnz	randloop
+		mvi	c,puts
+		lxi 	d,done		; Tell the user we're done
+		call	bdos
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Generate 4-digit secret code
+		lxi	h,secret
+		mvi	b,4
+gencode:	push	h
+		push	b
+		call	randcode
+		pop	b
+		pop	h
+		mov	m,a
+		inx	h
+		dcr	b
+		jnz	gencode
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; User makes a guess		
+readguess:	mvi	c,puts		; Ask for guess
+		lxi	d,guess
+		call	bdos
+		mvi	c,reads		; Read guess
+		lxi	d,bufdef
+		call	bdos
+		call	newline		; Print newline
+		mvi	b,4		; Check input
+		lxi	h,buf
+validate:	mov	a,m
+		cpi	'9' + 1		; >9?
+		jnc	inval		; = invalid
+		cpi	'1'		; <1?
+		jc	inval		; = invalid
+		sui	'0'		; Make ASCII digit into number
+		mov	m,a
+		inx	h
+		dcr	b
+		jnz	validate
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Count bulls
+		mvi	c,puts		
+		lxi	d,bulls		; Output "Bulls:"
+		call	bdos
+		lxi	d,secret
+		lxi	h,buf
+		lxi	b,4		; No bulls, counter = 4
+bullloop:	ldax	d		; Get secret digit
+		cmp	m		; Match to buffer digit
+		cz	countmatch
+		inx	h
+		inx	d
+		dcr	c
+		jnz	bullloop
+		push	b		; Keep bulls for cow count,
+		push	b		; and for final check.
+		call	printcount
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Count cows
+		mvi	c,puts
+		lxi	d,cows		; Output ", Cows:"
+		call	bdos
+		pop	psw		; Retrieve the bulls (into A reg)
+		cma			; Negate amount of bulls
+		inr	a
+		mov	b,a		; Use it as start of cow count
+		mvi	d,4		; For all 4 secret digits..
+		lxi	h,secret	
+cowouter:	mov	a,m		; Grab secret digit to test
+		push	h		; Store secret position
+		mvi	e,4		; For all 4 input digits...
+		lxi	h,buf
+cowinner:	cmp	m		; Compare to current secret digit
+		cz	countmatch
+		inx	h
+		dcr	e		; While there are more digits in buf
+		jnz	cowinner	; Test next digit
+		pop	h		; Restore secret position
+		inx	h		; Look at next secret digit
+		dcr	d		; While there are digits left
+		jnz	cowouter
+		push	b		; Keep cow count
+		call	printcount
+		call	newline
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Check win condition
+		pop	psw		; Cow count (in A)
+		pop	b		; Bull count (in B)
+		ana	a		; To win, there must be 0 cows...
+		jnz	readguess
+		mvi	a,4		; And 4 bulls.
+		cmp	b
+		jnz	readguess
+		mvi	c,puts
+		lxi	d,win
+		jmp	bdos
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Increment bull/cow counter
+countmatch:	inr	b
+		ret
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Print a newline
+newline:	mvi	c,puts
+		lxi	d,nl
+		jmp 	bdos
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Output counter as ASCII
+printcount:	mvi	a,'0'
+		add	b
+		mvi	c,putchar
+		mov	e,a
+		jmp	bdos
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; User entered invalid input
+inval:		mvi	c,puts
+		lxi	d,invalid
+		call	bdos
+		jmp	readguess
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Generate random number 1-9 that isn't in key
+randcode:	call	xabcrand
+		ani	0fh	; Low nybble
+		ana	a	; 0 = invalid
+		jz	randcode
+		cpi	10	; >9 = invalid
+		jnc	randcode
+		;; Check if it is a duplicate
+		mvi	b,4
+		lxi	h,secret
+checkdup:	cmp	m
+		jz	randcode
+		inx	h
+		dcr	b
+		jnz	checkdup
+		ret
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; The "X ABC" 8-bit random number generator
+		;; (Google that to find where it came from)
+xabcrand:       lxi     h,xabcdat
+                inr     m       ; X++
+                mov     a,m     ; X,
+                inx     h       ;
+                xra     m       ; ^ C,
+                inx     h       ;
+                xra     m       ; ^ A,
+                mov     m,a     ; -> A
+                inx     h
+                add     m       ; + B,
+                mov     m,a     ; -> B
+                rar             ; >>1
+                dcx     h
+                xra     m       ; ^ A,
+                dcx     h
+                add     m       ; + C
+                mov     m,a     ; -> C
+                ret
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Strings
+signon:		db	'Bulls and Cows',13,10,'$'
+entropy:	db	'Please mash the keyboard to generate entropy...$'
+done:		db	'done.',13,10,13,10,'$'
+bulls:		db	'Bulls: $'
+cows:		db	', Cows: $'
+guess:		db	'Guess: $'
+invalid: 	db	'Invalid input.',13,10,'$'
+win:		db	'You win!',13,10,'$'
+nl:		db	13,10,'$'
+		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+		;; Variables
+xabcdat:	ds	4	; RNG state
+secret:		ds	4	; Holds the secret code
+bufdef:		db	4,0	; User input buffer
+buf:		ds	4
--- a/Task/Bulls-and-cows/ALGOL-68/bulls-and-cows.alg
+++ b/Task/Bulls-and-cows/ALGOL-68/bulls-and-cows.alg
@ -0,0 +1,55 @@
+STRING digits = "123456789";
+
+[4]CHAR chosen;
+STRING available := digits;
+FOR i TO UPB chosen DO
+    INT c = ENTIER(random*UPB available)+1;
+    chosen[i] := available[c];
+    available := available[:c-1]+available[c+1:]
+OD;
+
+COMMENT print((chosen, new line)); # Debug # END COMMENT
+
+OP D = (INT d)STRING: whole(d,0); # for formatting an integer #
+
+print (("I have chosen a number from ",D UPB chosen," unique digits from 1 to 9 arranged in a random order.", new line,
+"You need to input a ",D UPB chosen," digit, unique digit number as a guess at what I have chosen", new line));
+
+PRIO WITHIN = 5, NOTWITHIN = 5;
+OP WITHIN = (CHAR c, []CHAR s)BOOL: char in string(c,LOC INT,s);
+OP NOTWITHIN = (CHAR c, []CHAR s)BOOL: NOT ( c WITHIN s );
+
+INT guesses := 0, bulls, cows;
+WHILE
+    STRING guess;
+    guesses +:= 1;
+    WHILE
+        # get a good guess #
+        print((new line,"Next guess [",D guesses,"]: "));
+        read((guess, new line));
+        IF UPB guess NE UPB chosen THEN
+            FALSE
+        ELSE
+            BOOL ok;
+            FOR i TO UPB guess WHILE
+                ok := guess[i] WITHIN digits AND guess[i] NOTWITHIN guess[i+1:]
+            DO SKIP OD;
+            NOT ok
+        FI
+    DO
+        print(("Problem, try again. You need to enter ",D UPB chosen," unique digits from 1 to 9", new line))
+    OD;
+# WHILE #
+    guess NE chosen
+DO
+    bulls := cows := 0;
+    FOR i TO UPB chosen DO
+        IF guess[i] = chosen[i] THEN
+            bulls +:= 1
+        ELIF guess[i] WITHIN chosen THEN
+            cows +:= 1
+        FI
+    OD;
+    print(("  ",D bulls," Bulls",new line,"  ",D cows," Cows"))
+OD;
+print((new line, "Congratulations you guessed correctly in ",D guesses," attempts.",new line))
--- a/Task/Bulls-and-cows/APL/bulls-and-cows-1.apl
+++ b/Task/Bulls-and-cows/APL/bulls-and-cows-1.apl
@ -0,0 +1,10 @@
+input   ← {⍞←'Guess: ' ⋄ 7↓⍞}
+output  ← {⎕←(↑'Bulls: ' 'Cows: '),⍕⍪⍵ ⋄ ⍵}
+isdigits← ∧/⎕D∊⍨⊢
+valid   ← isdigits∧4=≢
+guess   ← ⍎¨input⍣(valid⊣)
+bulls   ← +/=
+cows    ← +/∊∧≠
+game    ← (output ⊣(bulls,cows) guess)⍣(4 0≡⊣)
+random  ← 4∘⊣?9∘⊣
+moo     ← 'You win!'⊣(random game⊢)
--- a/Task/Bulls-and-cows/APL/bulls-and-cows-2.apl
+++ b/Task/Bulls-and-cows/APL/bulls-and-cows-2.apl
@ -0,0 +1 @@
+moo←'You win!'⊣((4∘⊣?9∘⊣)(({⎕←(↑'Bulls: ' 'Cows: '),⍕⍪⍵⋄⍵}⊣((+/=),(+/∊∧≠))(⍎¨{⍞←'Guess: '⋄7↓⍞}⍣(((∧/⎕D∊⍨⊢)∧4=≢)⊣)))⍣(4 0≡⊣))⊢)
--- a/Task/Bulls-and-cows/AWK/bulls-and-cows.awk
+++ b/Task/Bulls-and-cows/AWK/bulls-and-cows.awk
@ -0,0 +1,54 @@
+# Usage: GAWK -f BULLS_AND_COWS.AWK
+BEGIN {
+    srand()
+    secret = ""
+    for (i = 1; i <= 4; ) {
+        digit = int(9 * rand()) + 1
+        if (index(secret, digit) == 0) {
+            secret = secret digit
+            i++
+        }
+    }
+    print "Welcome to 'Bulls and Cows'!"
+    print "I thought of a 4-digit number."
+    print "Please enter your guess."
+}
+iswellformed($0) {
+    if (calcscore($0, secret)) {
+        exit
+    }
+}
+function iswellformed(number,    i, digit) {
+    if (number !~ /[1-9][1-9][1-9][1-9]/) {
+        print "Your guess should contain 4 digits, each from 1 to 9. Try again!"
+        return 0
+    }
+    for (i = 1; i <= 3; i++) {
+        digit = substr(number, 1, 1)
+        number = substr(number, 2)
+        if (index(number, digit) != 0) {
+            print "Your guess contains a digit twice. Try again!"
+            return 0
+        }
+    }
+    return 1
+}
+function calcscore(guess, secret,    bulls, cows, i, idx) {
+    # Bulls = correct digits at the right position
+    # Cows = correct digits at the wrong position
+    for (i = 1; i <= 4; i++) {
+        idx = index(secret, substr(guess, i, 1))
+        if (idx == i) {
+            bulls++
+        } else if (idx > 0) {
+            cows++
+        }
+    }
+    printf("Your score for this guess: Bulls = %d, Cows = %d.", bulls, cows)
+    if (bulls < 4) {
+        printf(" Try again!\n")
+    } else {
+        printf("\nCongratulations, you win!\n")
+    }
+    return bulls == 4
+}
--- a/Task/Bulls-and-cows/Action-/bulls-and-cows.action
+++ b/Task/Bulls-and-cows/Action-/bulls-and-cows.action
@ -0,0 +1,78 @@
+DEFINE DIGNUM="4"
+
+TYPE Score=[BYTE bulls,cows,err]
+
+PROC Generate(CHAR ARRAY secret)
+  DEFINE DIGCOUNT="9"
+  CHAR ARRAY digits(DIGCOUNT)
+  BYTE i,j,d,tmp,count
+
+  FOR i=0 TO DIGCOUNT-1
+  DO
+    digits(i)=i+'1
+  OD
+
+  secret(0)=DIGNUM
+  count=DIGCOUNT
+  FOR i=1 TO DIGNUM
+  DO
+    d=Rand(count)
+    secret(i)=digits(d)
+    count==-1
+    digits(d)=digits(count)
+  OD
+RETURN
+
+PROC CheckScore(CHAR ARRAY code,guess Score POINTER res)
+  BYTE i,j
+
+  res.bulls=0
+  res.cows=0
+  IF guess(0)#DIGNUM THEN
+    res.err=1
+    RETURN
+  FI
+  res.err=0
+  FOR i=1 TO DIGNUM
+  DO
+    IF guess(i)=code(i) THEN
+      res.bulls==+1
+    ELSE
+      FOR j=1 TO DIGNUM
+      DO
+        IF j#i AND guess(j)=code(i) THEN
+          res.cows==+1
+          EXIT
+        FI
+      OD
+    FI
+  OD
+RETURN
+
+PROC Main()
+  CHAR ARRAY code(DIGNUM+1),guess(255)
+  Score res
+
+  Generate(code)
+  PrintE("Bull and cows game.") PutE()
+  Print("I choose a 4-digit number from digits 1 to 9 without repetition. ")
+  PrintE("Your goal is to guess it.") PutE()
+  PrintE("Enter your guess:")
+  DO
+    InputS(guess)
+    CheckScore(code,guess,res)
+    Put(28) ;cursor up
+    PrintF("%S -> ",guess)
+    IF res.err THEN
+      Print("Wrong input")
+    ELSE
+      PrintF("Bulls=%B Cows=%B",res.bulls,res.cows)
+      IF res.bulls=DIGNUM THEN
+        PutE() PutE()
+        PrintE("You win!")
+        EXIT
+      FI
+    FI
+    PrintE(", try again:")
+  OD
+RETURN
--- a/Task/Bulls-and-cows/Ada/bulls-and-cows.ada
+++ b/Task/Bulls-and-cows/Ada/bulls-and-cows.ada
@ -0,0 +1,53 @@
+with Ada.Text_IO;  use Ada.Text_IO;
+with Ada.Numerics.Discrete_Random;
+
+procedure Bulls_And_Cows is
+   package Random_Natural is new Ada.Numerics.Discrete_Random (Natural);
+   Number : String (1..4);
+begin
+   declare -- Generation of number
+      use Random_Natural;
+      Digit    : String   := "123456789";
+      Size     : Positive := 9;
+      Dice     : Generator;
+      Position : Natural;
+   begin
+      Reset (Dice);
+      for I in Number'Range loop
+         Position := Random (Dice) mod Size + 1;
+         Number (I) := Digit (Position);
+         Digit (Position..Size - 1) := Digit (Position + 1..Size);
+         Size := Size - 1;
+      end loop;
+   end;
+   loop -- Guessing loop
+      Put ("Enter four digits:");
+      declare
+         Guess : String  := Get_Line;
+         Bulls : Natural := 0;
+         Cows  : Natural := 0;
+      begin
+         if Guess'Length /= 4 then
+            raise Data_Error;
+         end if;
+         for I in Guess'Range loop
+            for J in Number'Range loop
+               if Guess (I) not in '1'..'9' or else (I < J and then Guess (I) = Guess (J)) then
+                  raise Data_Error;
+               end if;
+               if Number (I) = Guess (J) then
+                  if I = J then
+                     Bulls := Bulls + 1;
+                  else
+                     Cows := Cows + 1;
+                  end if;
+               end if;
+            end loop;
+         end loop;
+         exit when Bulls = 4;
+         Put_Line (Integer'Image (Bulls) & " bulls," & Integer'Image (Cows) & " cows");
+      exception
+         when Data_Error => Put_Line ("You should enter four different digits 1..9");
+      end;
+   end loop;
+end Bulls_And_Cows;
--- a/Task/Bulls-and-cows/AppleScript/bulls-and-cows.applescript
+++ b/Task/Bulls-and-cows/AppleScript/bulls-and-cows.applescript
@ -0,0 +1,58 @@
+on pickNumber()
+	set theNumber to ""
+	repeat 4 times
+		set theDigit to (random number from 1 to 9) as string
+		repeat while (offset of theDigit in theNumber) > 0
+			set theDigit to (random number from 1 to 9) as string
+		end repeat
+		set theNumber to theNumber & theDigit
+	end repeat
+end pickNumber
+
+to bulls of theGuess given key:theKey
+	set bullCount to 0
+	repeat with theIndex from 1 to 4
+		if text theIndex of theGuess = text theIndex of theKey then
+			set bullCount to bullCount + 1
+		end if
+	end repeat
+	return bullCount
+end bulls
+
+to cows of theGuess given key:theKey, bulls:bullCount
+	set cowCount to -bullCount
+	repeat with theIndex from 1 to 4
+		if (offset of (text theIndex of theKey) in theGuess) > 0 then
+			set cowCount to cowCount + 1
+		end if
+	end repeat
+	
+	return cowCount
+end cows
+
+to score of theGuess given key:theKey
+	set bullCount to bulls of theGuess given key:theKey
+	set cowCount to cows of theGuess given key:theKey, bulls:bullCount
+	return {bulls:bullCount, cows:cowCount}
+end score
+
+on run
+	set theNumber to pickNumber()
+	set pastGuesses to {}
+	repeat
+		set theMessage to ""
+		repeat with aGuess in pastGuesses
+			set {theGuess, theResult} to aGuess
+			set theMessage to theMessage & theGuess & ":" & bulls of theResult & "B, " & cows of theResult & "C" & linefeed
+		end repeat
+		set theMessage to theMessage & linefeed & "Enter guess:"
+		set theGuess to text returned of (display dialog theMessage with title "Bulls and Cows" default answer "")
+		set theScore to score of theGuess given key:theNumber
+		if bulls of theScore is 4 then
+			display dialog "Correct!  Found the secret in " & ((length of pastGuesses) + 1) & " guesses!"
+			exit repeat
+		else
+			set end of pastGuesses to {theGuess, theScore}
+		end if
+	end repeat
+end run
--- a/Task/Bulls-and-cows/Applesoft-BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/Applesoft-BASIC/bulls-and-cows.basic
@ -0,0 +1,28 @@
+100 D$ = "123456789"
+110 FOR I = 1 TO 4
+120    P = INT(RND(1) * LEN(D$)) + 1
+130    N$ = N$ + MID$(D$, P, 1)
+140    D$ = MID$(D$, 1, P - 1) + MID$(D$, P + 1, 8)
+150 NEXT
+160 PRINT "A RANDOM NUMBER HAS BEEN CREATED.
+170 PRINT "THE NUMBER HAS FOUR DIGITS FROM 1 TO 9, WITHOUT DUPLICATION."
+200 FOR Q = 0 TO 1 STEP 0
+210     INPUT "GUESS THE NUMBER: "; G%
+220     G$ = STR$(G%)
+230     M = LEN(G$) <> 4 OR G% = 0
+240     IF NOT M THEN FOR I = 2 TO 4 : M = MID$(G$, I, 1) = "0" : IF NOT M THEN NEXT I
+250     IF NOT M THEN FOR I = 1 TO 3 : FOR J = I + 1 TO 4 : M = MID$(G$, I, 1) = MID$(G$, J, 1) : IF NOT M THEN NEXT J, I
+260     IF M THEN PRINT "THE GUESS IS MALFORMED." : NEXT Q
+270     B = 0
+280     C = 0
+300     FOR I = 1 TO 4
+310         C$ = MID$(N$, I, 1)
+320         BULL = MID$(G$, I, 1) = C$
+330         COW = 0
+340         IF NOT BULL THEN FOR J = 1 TO 4 : COW = MID$(G$, J, 1) = C$ : IF NOT COW THEN NEXT J
+350         B = B + BULL
+360         C = C + COW
+370     NEXT I
+380     PRINT B " BULLS, " C " COWS"
+390     Q = G$ = N$
+400 NEXT Q
--- a/Task/Bulls-and-cows/Arturo/bulls-and-cows.arturo
+++ b/Task/Bulls-and-cows/Arturo/bulls-and-cows.arturo
@ -0,0 +1,21 @@
+rand: first.n: 4 unique map 1..10 => [sample 0..9]
+bulls: 0
+
+while [bulls <> 4][
+    bulls: new 0
+	cows: new 0
+
+    got: strip input "make a guess: "
+    if? or? not? numeric? got
+            4 <> size got -> print "Malformed answer. Try again!"
+    else [
+        loop.with:'i split got 'digit [
+            if? (to :integer digit) = rand\[i] -> inc 'bulls
+            else [
+                if contains? rand to :integer digit -> inc 'cows
+            ]
+        ]
+        print ["Bulls:" bulls "Cows:" cows "\n"]
+    ]
+]
+print color #green "** Well done! You made the right guess!!"
--- a/Task/Bulls-and-cows/AutoHotkey/bulls-and-cows.ahk
+++ b/Task/Bulls-and-cows/AutoHotkey/bulls-and-cows.ahk
@ -0,0 +1,52 @@
+length:=4, Code:="" ; settings
+
+While StrLen(Code) < length {
+	Random, num, 1, 9
+	If !InStr(Code, num)
+		Code .= num
+}
+Gui, Add, Text, w83 vInfo, I'm thinking of a %length%-digit number with no duplicate digits.
+Gui, Add, Edit, wp vGuess, Enter a guess...
+Gui, Add, Button, wp Default vDefault, Submit
+Gui, Add, Edit, ym w130 r8 vHistory ReadOnly
+Gui, Show
+Return
+
+ButtonSubmit:
+	If Default = Restart
+		Reload
+	Gui, Submit, NoHide
+	If (StrLen(Guess) != length)
+		GuiControl, , Info, Enter a %length%-digit number.
+	Else If Guess is not digit
+		GuiControl, , Info, Enter a %length%-digit number.
+	Else
+	{
+		GuiControl, , Info
+		GuiControl, , Guess
+		If (Guess = Code)
+		{
+			GuiControl, , Info, Correct!
+			GuiControl, , Default, Restart
+			Default = Restart
+		}
+		response := Response(Guess, Code)
+		Bulls := SubStr(response, 1, InStr(response,",")-1)
+		Cows := SubStr(response, InStr(response,",")+1)
+		GuiControl, , History, % History . Guess ": " Bulls " Bulls " Cows " Cows`n"
+	}
+Return
+
+GuiEscape:
+GuiClose:
+	ExitApp
+
+Response(Guess,Code) {
+	Bulls := 0, Cows := 0
+	Loop, % StrLen(Code)
+		If (SubStr(Guess, A_Index, 1) = SubStr(Code, A_Index, 1))
+			Bulls++
+		Else If (InStr(Code, SubStr(Guess, A_Index, 1)))
+			Cows++
+	Return Bulls "," Cows
+}
--- a/Task/Bulls-and-cows/BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/BASIC/bulls-and-cows.basic
@ -0,0 +1,41 @@
+DEFINT A-Z
+
+DIM secret AS STRING
+DIM guess  AS STRING
+DIM c      AS STRING
+DIM bulls, cows, guesses, i
+
+RANDOMIZE TIMER
+DO WHILE LEN(secret) < 4
+    c = CHR$(INT(RND * 10) + 48)
+    IF INSTR(secret, c) = 0 THEN secret = secret + c
+LOOP
+
+guesses = 0
+DO
+    INPUT "Guess a 4-digit number with no duplicate digits: "; guess
+    guess = LTRIM$(RTRIM$(guess))
+    IF LEN(guess) = 0 THEN EXIT DO
+
+    IF LEN(guess) <> 4 OR VAL(guess) = 0 THEN
+        PRINT "** You should enter 4 numeric digits!"
+        GOTO looper
+    END IF
+
+    bulls = 0: cows = 0: guesses = guesses + 1
+    FOR i = 1 TO 4
+        c = MID$(secret, i, 1)
+        IF MID$(guess, i, 1) = c THEN
+            bulls = bulls + 1
+        ELSEIF INSTR(guess, c) THEN
+            cows = cows + 1
+        END IF
+    NEXT i
+    PRINT bulls; " bulls, "; cows; " cows"
+
+    IF guess = secret THEN
+        PRINT "You won after "; guesses; " guesses!"
+        EXIT DO
+    END IF
+looper:
+LOOP
--- a/Task/Bulls-and-cows/BBC-BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/BBC-BASIC/bulls-and-cows.basic
@ -0,0 +1,32 @@
+      secret$ = ""
+      REPEAT
+        c$ = CHR$(&30 + RND(9))
+        IF INSTR(secret$, c$) = 0 secret$ += c$
+      UNTIL LEN(secret$) = 4
+
+      PRINT "Guess a four-digit number with no digit used twice."'
+      guesses% = 0
+      REPEAT
+
+        REPEAT
+          INPUT "Enter your guess: " guess$
+          IF LEN(guess$) <> 4 PRINT "Must be a four-digit number"
+        UNTIL LEN(guess$) = 4
+        guesses% += 1
+
+        IF guess$ = secret$ PRINT "You won after "; guesses% " guesses!" : END
+
+        bulls% = 0
+        cows% = 0
+        FOR i% = 1 TO 4
+          c$ = MID$(secret$, i%, 1)
+          IF MID$(guess$, i%, 1) = c$ THEN
+            bulls% += 1
+          ELSE IF INSTR(guess$, c$) THEN
+              cows% += 1
+            ENDIF
+          ENDIF
+        NEXT i%
+        PRINT "You got " ;bulls% " bull(s) and " ;cows% " cow(s)."
+
+      UNTIL FALSE
--- a/Task/Bulls-and-cows/BCPL/bulls-and-cows.bcpl
+++ b/Task/Bulls-and-cows/BCPL/bulls-and-cows.bcpl
@ -0,0 +1,70 @@
+get "libhdr"
+
+static $( randstate = ? $)
+
+let randdigit() = valof
+$(  let x = ?
+    $(  randstate := random(randstate)
+        x := (randstate >> 7) & 15
+    $) repeatuntil 0 < x <= 9
+    resultis x
+$)
+
+let gensecret(s) be
+    for i=0 to 3
+        s!i := randdigit() repeatuntil valof
+        $(  for j=0 to i-1 if s!i = s!j then resultis false
+            resultis true
+        $)
+
+let bulls(secret, guess) = valof
+$(  let x = 0
+    for i=0 to 3 if secret!i = guess!i then x := x + 1
+    resultis x
+$)
+
+let cows(secret, guess) = valof
+$(  let x = 0
+    for i=0 to 3
+        for j=0 to 3
+            unless i=j
+                if secret!i = guess!j then x := x + 1
+    resultis x
+$)
+
+let readguess(guess) be
+$(  let g, v = ?, true
+    writes("Enter a guess, or 0 to quit: ")
+    g := readn()
+    if g=0 then finish
+    for i=3 to 0 by -1
+    $(  guess!i := g rem 10
+        g := g / 10
+    $)
+    for i=0 to 2 for j = i+1 to 3
+        v := v & guess!i ~= 0 & guess!j ~= 0 & guess!i ~= guess!j
+    if v then return
+    writes("Invalid guess.*N")
+$) repeat
+
+let play(secret) be
+$(  let tries, b, c = 0, ?, ?
+    let guess = vec 3
+    $(  readguess(guess)
+        b := bulls(secret, guess)
+        c := cows(secret, guess)
+        writef("Bulls: %N, cows: %N*N", b, c);
+        tries := tries + 1
+    $) repeatuntil b = 4
+    writef("You win in %N tries.*N", tries)
+$)
+
+let start() be
+$(  let secret = vec 3
+    writes("Bulls and cows*N----- --- ----*N")
+    writes("Please enter a random seed: ")
+    randstate := readn()
+    wrch('*N')
+    gensecret(secret)
+    play(secret)
+$)
--- a/Task/Bulls-and-cows/Batch-File/bulls-and-cows.bat
+++ b/Task/Bulls-and-cows/Batch-File/bulls-and-cows.bat
@ -0,0 +1,101 @@
+:: Bulls and Cows Task from Rosetta Code
+:: Batch File Implementation
+
+@echo off
+setlocal enabledelayedexpansion
+
+:: initialization
+:begin
+set "list_chars=123456789"
+set "list_length=9"
+set "code="
+set "code_length=4"   %== this should be less than 10 ==%
+set "tries=0"   %== number of tries ==%
+
+:: generate the code to be guessed by player
+set "chars_left=%list_chars%"
+for /l %%c in (1, 1, %code_length%) do (
+    set /a "rnd=!random! %% (%list_length% + 1 - %%c)"
+    for %%? in (!rnd!) do set "pick_char=!chars_left:~%%?,1!"
+    set "code=!code!!pick_char!"
+    for %%? in (!pick_char!) do set "chars_left=!chars_left:%%?=!"
+)
+
+:: get the min and max allowable guess for input validation
+set "min=!list_chars:~0,%code_length%!"
+set "max="
+for /l %%c in (1, 1, %code_length%) do set "max=!max!!list_chars:~-%%c,1!"
+
+:: display game
+:display
+cls
+echo(
+echo(Bulls and Cows Game
+echo(Batch File Implementation
+echo(
+echo(Gameplay:
+echo(
+echo(I have generated a %code_length%-digit code from digits 1-9 without duplication.
+echo(Your objective is to guess it. If your guess is equal to my code,
+echo(then you WIN. If not, I will score your guess:
+echo(
+echo(** A score of one BULL is accumulated for each digit in your guess
+echo(that equals the corresponding digit in my code.
+echo(
+echo(** A score of one COW is accumulated for each digit in your guess
+echo(that also appears in my code, but in the WRONG position.
+echo(
+echo(Now, start guessing^^!
+
+:: input guess
+:guess
+echo(
+set "guess="   %== clear input ==%
+set /p "guess=Your Guess: "
+
+:: validate input
+if "!guess!" gtr "%max%" goto invalid
+if "!guess!" lss "%min%" goto invalid
+set /a "last_idx=%code_length% - 1"
+for /l %%i in (0, 1, %last_idx%) do (
+    set /a "next_idx=%%i + 1"
+    for /l %%j in (!next_idx!, 1, %last_idx%) do (
+        if "!guess:~%%i,1!" equ "!guess:~%%j,1!" goto invalid
+    )
+)
+goto score
+
+:: display that input is invalid
+:invalid
+echo(Please input a valid guess.
+goto guess
+
+:: scoring section
+:score
+set /a "tries+=1"
+if "%guess%" equ "%code%" goto win
+set "cow=0"
+set "bull=0"
+for /l %%i in (0, 1, %last_idx%) do (
+    for /l %%j in (0, 1, %last_idx%) do (
+        if "!guess:~%%i,1!" equ "!code:~%%j,1!" (
+            if "%%i" equ "%%j" (
+                set /a "bull+=1"
+            ) else (
+                set /a "cow+=1"
+            )
+        )
+    )
+)
+:: display score and go back to user input
+echo(BULLS = %bull%; COWS = %cow%.
+goto guess
+
+:: player wins!
+:win
+echo(
+echo(After %tries% tries, YOU CRACKED IT^^! My code is %code%.
+echo(
+set /p "opt=Play again? "
+if /i "!opt!" equ "y" goto begin
+exit /b 0
--- a/Task/Bulls-and-cows/Brat/bulls-and-cows.brat
+++ b/Task/Bulls-and-cows/Brat/bulls-and-cows.brat
@ -0,0 +1,39 @@
+secret_length = 4
+
+secret = [1 2 3 4 5 6 7 8 9].shuffle.pop secret_length
+
+score = { guess |
+  cows = 0
+  bulls = 0
+
+  guess.each_with_index { digit, index |
+    true? digit == secret[index]
+      { bulls = bulls + 1 }
+      { true? secret.include?(digit)
+        { cows = cows + 1 }
+      }
+  }
+
+  [cows: cows, bulls: bulls]
+}
+
+won = false
+guesses = 1
+
+p "I have chosen a number with four unique digits from 1 through 9. Can you guess it?"
+
+while { not won }
+  {
+    print "Guess #{guesses}: "
+    guess = g.strip.dice.map { d | d.to_i }
+
+    when { guess == secret }  { p "You won in #{guesses} guesses!"; won = true }
+      { guess.include?(0) || guess.include?(null) } { p "Your guess should only include digits 1 through 9." }
+      { guess.length != secret.length } { p "Your guess was not the correct length. The number has exactly #{secret.length} digits." }
+      { guess.unique.length != secret.length } { p "Each digit should only appear once in your guess." }
+      { true } {
+        result = score guess
+        p "Score: #{result[:bulls]} bulls, #{result[:cows]} cows."
+        guesses = guesses + 1
+      }
+  }
--- a/Task/Bulls-and-cows/C++/bulls-and-cows.cpp
+++ b/Task/Bulls-and-cows/C++/bulls-and-cows.cpp
@ -0,0 +1,78 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cstdlib>
+
+bool contains_duplicates(std::string s)
+{
+  std::sort(s.begin(), s.end());
+  return std::adjacent_find(s.begin(), s.end()) != s.end();
+}
+
+void game()
+{
+  typedef std::string::size_type index;
+
+  std::string symbols = "0123456789";
+  unsigned int const selection_length = 4;
+
+  std::random_shuffle(symbols.begin(), symbols.end());
+  std::string selection = symbols.substr(0, selection_length);
+  std::string guess;
+  while (std::cout << "Your guess? ", std::getline(std::cin, guess))
+  {
+    if (guess.length() != selection_length
+        || guess.find_first_not_of(symbols) != std::string::npos
+        || contains_duplicates(guess))
+    {
+      std::cout << guess << " is not a valid guess!";
+      continue;
+    }
+
+    unsigned int bulls = 0;
+    unsigned int cows = 0;
+    for (index i = 0; i != selection_length; ++i)
+    {
+      index pos = selection.find(guess[i]);
+      if (pos == i)
+        ++bulls;
+      else if (pos != std::string::npos)
+        ++cows;
+    }
+    std::cout << bulls << " bulls, " << cows << " cows.\n";
+    if (bulls == selection_length)
+    {
+      std::cout << "Congratulations! You have won!\n";
+      return;
+    }
+  }
+  std::cerr << "Oops! Something went wrong with input, or you've entered end-of-file!\nExiting ...\n";
+  std::exit(EXIT_FAILURE);
+}
+
+int main()
+{
+  std::cout << "Welcome to bulls and cows!\nDo you want to play? ";
+  std::string answer;
+  while (true)
+  {
+    while (true)
+    {
+      if (!std::getline(std::cin, answer))
+      {
+        std::cout << "I can't get an answer. Exiting.\n";
+        return EXIT_FAILURE;
+      }
+      if (answer == "yes" || answer == "Yes" || answer == "y" || answer == "Y")
+        break;
+      if (answer == "no" || answer == "No" || answer == "n" || answer == "N")
+      {
+        std::cout << "Ok. Goodbye.\n";
+        return EXIT_SUCCESS;
+      }
+      std::cout << "Please answer yes or no: ";
+    }
+    game();
+    std::cout << "Another game? ";
+  }
+}
--- a/Task/Bulls-and-cows/C-sharp/bulls-and-cows.cs
+++ b/Task/Bulls-and-cows/C-sharp/bulls-and-cows.cs
@ -0,0 +1,79 @@
+using System;
+
+namespace BullsnCows
+{
+    class Program
+    {
+
+        static void Main(string[] args)
+        {
+            int[] nums = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+            KnuthShuffle<int>(ref nums);
+            int[] chosenNum = new int[4];
+            Array.Copy(nums, chosenNum, 4);
+
+            Console.WriteLine("Your Guess ?");
+            while (!game(Console.ReadLine(), chosenNum))
+            {
+                Console.WriteLine("Your next Guess ?");
+            }
+
+            Console.ReadKey();
+        }
+
+        public static void KnuthShuffle<T>(ref T[] array)
+        {
+            System.Random random = new System.Random();
+            for (int i = 0; i < array.Length; i++)
+            {
+                int j = random.Next(array.Length);
+                T temp = array[i]; array[i] = array[j]; array[j] = temp;
+            }
+        }
+
+        public static bool game(string guess, int[] num)
+        {
+            char[] guessed = guess.ToCharArray();
+            int bullsCount = 0, cowsCount = 0;
+
+            if (guessed.Length != 4)
+            {
+                Console.WriteLine("Not a valid guess.");
+                return false;
+            }
+
+            for (int i = 0; i < 4; i++)
+            {
+                int curguess = (int) char.GetNumericValue(guessed[i]);
+                if (curguess < 1 || curguess > 9)
+                {
+                    Console.WriteLine("Digit must be ge greater 0 and lower 10.");
+                    return false;
+                }
+                if (curguess == num[i])
+                {
+                    bullsCount++;
+                }
+                else
+                {
+                    for (int j = 0; j < 4; j++)
+                    {
+                        if (curguess == num[j])
+                            cowsCount++;
+                    }
+                }
+            }
+
+            if (bullsCount == 4)
+            {
+                Console.WriteLine("Congratulations! You have won!");
+                return true;
+            }
+            else
+            {
+                Console.WriteLine("Your Score is {0} bulls and {1} cows", bullsCount, cowsCount);
+                return false;
+            }
+        }
+    }
+}
--- a/Task/Bulls-and-cows/C/bulls-and-cows-1.c
+++ b/Task/Bulls-and-cows/C/bulls-and-cows-1.c
@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <curses.h>
+#include <string.h>
+
+#define MAX_NUM_TRIES 72
+#define LINE_BEGIN 7
+#define LAST_LINE 18
+
+int yp=LINE_BEGIN, xp=0;
+
+char number[5];
+char guess[5];
+
+#define MAX_STR 256
+void mvaddstrf(int y, int x, const char *fmt, ...)
+{
+  va_list args;
+  char buf[MAX_STR];
+
+  va_start(args, fmt);
+  vsprintf(buf, fmt, args);
+  move(y, x);
+  clrtoeol();
+  addstr(buf);
+  va_end(args);
+}
+
+void ask_for_a_number()
+{
+  int i=0;
+  char symbols[] = "123456789";
+
+  move(5,0); clrtoeol();
+  addstr("Enter four digits: ");
+  while(i<4) {
+    int c = getch();
+    if ( (c >= '1') && (c <= '9') && (symbols[c-'1']!=0) ) {
+      addch(c);
+      symbols[c-'1'] = 0;
+      guess[i++] = c;
+    }
+  }
+}
+
+void choose_the_number()
+{
+  int i=0, j;
+  char symbols[] = "123456789";
+
+  while(i<4) {
+    j = rand() % 9;
+    if ( symbols[j] != 0 ) {
+      number[i++] = symbols[j];
+      symbols[j] = 0;
+    }
+  }
+}
--- a/Task/Bulls-and-cows/C/bulls-and-cows-2.c
+++ b/Task/Bulls-and-cows/C/bulls-and-cows-2.c
@ -0,0 +1,85 @@
+bool take_it_or_not()
+{
+  int i;
+  int cows=0, bulls=0;
+
+  for(i=0; i < 4; i++) {
+    if ( number[i] == guess[i] ) {
+      bulls++;
+    } else if ( strchr(number, guess[i]) != NULL ) {
+      cows++;
+    }
+  }
+  move(yp, xp);
+  addstr(guess); addch(' ');
+  if ( bulls == 4 ) { yp++; return true; }
+  if ( (cows==0) && (bulls==0) ) addch('-');
+  while( cows-- > 0 ) addstr("O");
+  while( bulls-- > 0 ) addstr("X");
+  yp++;
+  if ( yp > LAST_LINE ) {
+    yp = LINE_BEGIN;
+    xp += 10;
+  }
+  return false;
+}
+
+bool ask_play_again()
+{
+  int i;
+
+  while(yp-- >= LINE_BEGIN) {
+    move(yp, 0); clrtoeol();
+  }
+  yp = LINE_BEGIN; xp = 0;
+
+  move(21,0); clrtoeol();
+  addstr("Do you want to play again? [y/n]");
+  while(true) {
+    int a = getch();
+    switch(a) {
+    case 'y':
+    case 'Y':
+      return true;
+    case 'n':
+    case 'N':
+      return false;
+    }
+  }
+}
+
+
+int main()
+{
+  bool bingo, again;
+  int tries = 0;
+
+  initscr(); cbreak(); noecho();
+  clear();
+
+  number[4] = guess[4] = 0;
+
+  mvaddstr(0,0, "I choose a number made of 4 digits (from 1 to 9) without repetitions\n"
+                "You enter a number of 4 digits, and I say you how many of them are\n"
+                "in my secret number but in wrong position (cows or O), and how many\n"
+                "are in the right position (bulls or X)");
+  do {
+    move(20,0); clrtoeol(); move(21, 0); clrtoeol();
+    srand(time(NULL));
+    choose_the_number();
+    do {
+      ask_for_a_number();
+      bingo = take_it_or_not();
+      tries++;
+    } while(!bingo && (tries < MAX_NUM_TRIES));
+    if ( bingo )
+      mvaddstrf(20, 0, "You guessed %s correctly in %d attempts!", number, tries);
+    else
+      mvaddstrf(20,0, "Sorry, you had only %d tries...; the number was %s",
+		MAX_NUM_TRIES, number);
+    again = ask_play_again();
+    tries = 0;
+  } while(again);
+  nocbreak(); echo(); endwin();
+  return EXIT_SUCCESS;
+}
--- a/Task/Bulls-and-cows/CLU/bulls-and-cows.clu
+++ b/Task/Bulls-and-cows/CLU/bulls-and-cows.clu
@ -0,0 +1,132 @@
+% This program needs to be merged with PCLU's "misc" library
+% to use the random number generator.
+%
+% pclu -merge $CLUHOME/lib/misc.lib -compile bulls_cows.clu
+
+% Seed the random number generator with the current time
+init_rng = proc ()
+    d: date := now()
+    seed: int := ((d.hour*60) + d.minute)*60 + d.second
+    random$seed(seed)
+end init_rng
+
+% Generate a secret
+make_secret = proc () returns (sequence[int])
+    secret: array[int] := array[int]$[0,0,0,0]
+    for i: int in int$from_to(1,4) do
+        digit: int
+        valid: bool := false
+        while ~valid do
+            digit := 1+random$next(9)
+            valid := true
+            for j: int in int$from_to(1, i-1) do
+                if secret[i] = digit then
+                    valid := false
+                    break
+                end
+            end
+        end
+        secret[i] := digit
+    end
+    return(sequence[int]$a2s(secret))
+end make_secret
+
+% Count the bulls
+bulls = proc (secret, input: sequence[int]) returns (int)
+    n_bulls: int := 0
+    for i: int in int$from_to(1,4) do
+        if secret[i] = input[i] then n_bulls := n_bulls + 1 end
+    end
+    return(n_bulls)
+end bulls
+
+% Count the cows
+cows = proc (secret, input: sequence[int]) returns (int)
+    n_cows: int := 0
+    for i: int in int$from_to(1,4) do
+        for j: int in int$from_to(1,4) do
+            if i ~= j cand secret[i] = input[j] then
+                n_cows := n_cows + 1
+            end
+        end
+    end
+    return(n_cows)
+end cows
+
+% Read a guess
+player_guess = proc () returns (sequence[int])
+    pi: stream := stream$primary_input()
+    po: stream := stream$primary_output()
+
+    while true do       % we will keep reading until the guess is valid
+        stream$puts(po, "Guess? ")
+        guess: string := stream$getl(pi)
+
+        % check length
+        if string$size(guess) ~= 4 then
+            stream$putl(po, "Invalid guess: need four digits.")
+            continue
+        end
+
+        % get and check digits
+        valid: bool := true
+        digits: sequence[int] := sequence[int]$[]
+        for c: char in string$chars(guess) do
+            i: int := char$c2i(c) - 48
+            if ~(i>=1 & i<=9) then
+                valid := false
+                break
+            end
+            digits := sequence[int]$addh(digits,i)
+        end
+        if ~valid then
+            stream$putl(po, "Invalid guess: each position needs to be a digit 1-9.")
+            continue
+        end
+
+        % check that there are no duplicates
+        valid := true
+        for i: int in int$from_to(1,4) do
+            for j: int in int$from_to(i+1,4) do
+                if digits[i] = digits[j] then
+                    valid := false
+                    break
+                end
+            end
+        end
+        if ~valid then
+            stream$putl(po, "Invalid guess: there must be no duplicate digits.")
+            continue
+        end
+
+        return(digits)
+    end
+end player_guess
+
+% Play a game
+play_game = proc (secret: sequence[int])
+    po: stream := stream$primary_output()
+    n_guesses: int := 0
+    while true do
+        n_guesses := n_guesses + 1
+        guess: sequence[int] := player_guess()
+
+        n_bulls: int := bulls(secret, guess)
+        n_cows: int := cows(secret, guess)
+
+        stream$putl(po, "Bulls: " || int$unparse(n_bulls)
+                    || ", cows: " || int$unparse(n_cows))
+        if n_bulls = 4 then
+            stream$putl(po, "Congratulations! You won in "
+                     || int$unparse(n_guesses) || " tries.")
+            break
+        end
+    end
+end play_game
+
+start_up = proc ()
+    po: stream := stream$primary_output()
+    init_rng()
+    stream$putl(po, "Bulls and cows\n----- --- ----\n")
+    play_game(make_secret())
+end start_up
--- a/Task/Bulls-and-cows/Ceylon/bulls-and-cows.ceylon
+++ b/Task/Bulls-and-cows/Ceylon/bulls-and-cows.ceylon
@ -0,0 +1,70 @@
+import ceylon.random {
+    DefaultRandom
+}
+
+shared void run() {
+
+    value random = DefaultRandom();
+
+    function generateDigits() =>
+            random.elements(1..9).distinct.take(4).sequence();
+
+    function validate(String guess) {
+        variable value ok = true;
+        if (!guess.every((Character element) => element.digit)) {
+            print("numbers only, please");
+            ok = false;
+        }
+        if ('0' in guess) {
+            print("only 1 to 9, please");
+            ok = false;
+        }
+        if (guess.distinct.shorterThan(guess.size)) {
+            print("no duplicates, please");
+            ok = false;
+        }
+        if (guess.size != 4) {
+            print("4 digits please");
+            ok = false;
+        }
+        return ok;
+    }
+
+    function score({Integer*} target, {Integer*} guess) {
+        variable value bulls = 0;
+        variable value cows = 0;
+        for ([a, b] in zipPairs(target, guess)) {
+            if (a == b) {
+                bulls++;
+            } else if (target.contains(b)) {
+                cows++;
+            }
+        }
+        return [bulls, cows];
+    }
+
+    while (true) {
+        value digits = generateDigits();
+        print("I have chosen my four digits, please guess what they are.
+               Use only the digits 1 to 9 with no duplicates and enter them with no spaces. eg 1234
+               Enter q or Q to quit.");
+        while (true) {
+            if (exists line = process.readLine()) {
+                if (line.uppercased == "Q") {
+                    return;
+                }
+                if (validate(line)) {
+                    value guessDigits = line.map((Character element) => Integer.parse(element.string)).narrow<Integer>();
+                    value [bulls, cows] = score(digits, guessDigits);
+                    if (bulls == 4) {
+                        print("You win!");
+                        break;
+                    }
+                    else {
+                        print("Bulls: ``bulls``, Cows:  ``cows``");
+                    }
+                }
+            }
+        }
+    }
+}
--- a/Task/Bulls-and-cows/Clojure/bulls-and-cows.clj
+++ b/Task/Bulls-and-cows/Clojure/bulls-and-cows.clj
@ -0,0 +1,38 @@
+(ns bulls-and-cows)
+
+(defn bulls [guess solution]
+  (count (filter true? (map = guess solution))))
+
+(defn cows [guess solution]
+  (-
+   (count (filter (set solution) guess))
+   (bulls guess solution)))
+
+(defn valid-input?
+  "checks whether the string is a 4 digit number with unique digits"
+  [user-input]
+  (if (re-seq #"^(?!.*(\d).*\1)\d{4}$" user-input)
+    true
+    false))
+
+(defn enter-guess []
+  "Let the user enter a guess. Verify the input. Repeat until valid.
+returns a list of digits enters by the user (# # # #)"
+    (println "Enter your guess: ")
+    (let [guess (read-line)]
+      (if (valid-input? guess)
+        (map #(Character/digit % 10) guess)
+        (recur))))
+
+(defn bulls-and-cows []
+  "generate a random 4 digit number from the list of (1 ... 9): no repeating digits
+player tries to guess the number with bull and cows rules gameplay"
+  (let [solution ( take 4 (shuffle (range 1 10)))]
+    (println "lets play some bulls and cows!")
+    (loop [guess (enter-guess)]
+      (println (bulls guess solution) " bulls and " (cows guess solution) " cows.")
+      (if (not= guess solution)
+        (recur (enter-guess))
+        (println "You have won!")))))
+
+(bulls-and-cows)
--- a/Task/Bulls-and-cows/Coco/bulls-and-cows-1.coco
+++ b/Task/Bulls-and-cows/Coco/bulls-and-cows-1.coco
@ -0,0 +1,4 @@
+say = print
+prompt = (str) ->
+    putstr str
+    readline! ? quit!
--- a/Task/Bulls-and-cows/Coco/bulls-and-cows-2.coco
+++ b/Task/Bulls-and-cows/Coco/bulls-and-cows-2.coco
@ -0,0 +1,22 @@
+const SIZE = 4
+
+secret = _.sample ['1' to '9'], SIZE
+
+for ever
+    var guess
+    for ever
+        guess := _.uniq prompt 'Enter a guess: '
+        if guess.length === SIZE and not _.difference guess, ['1' to '9'] .length
+            break
+        say 'Malformed guess; try again.'
+    bulls = cows = 0
+    for i til SIZE
+        if guess[i] === secret[i]
+            ++bulls
+        else if _.contains secret, guess[i]
+            ++cows
+    if bulls === SIZE
+        break
+    say "#bulls bull#{[if bulls !== 1 then 's']}, #cows cow#{[if cows !== 1 then 's']}."
+
+say 'A winner is you!'
--- a/Task/Bulls-and-cows/Commodore-BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/Commodore-BASIC/bulls-and-cows.basic
@ -0,0 +1,38 @@
+100 D$="123456789"
+110 FOR I=1 TO 4
+120 P=INT(RND(1)*LEN(D$))+1
+130 N$=N$+MID$(D$,P,1)
+140 D$=MID$(D$,1,P - 1)+MID$(D$,P+1,8)
+150 NEXT
+160 PRINT CHR$(147);"A RANDOM NUMBER HAS BEEN CREATED."
+170 PRINT "THE NUMBER HAS FOUR DIGITS FROM 1 TO 9, WITHOUT DUPLICATION."
+200 FOR Q=0 TO 1 STEP 0
+210 INPUT "GUESS THE NUMBER: "; G%
+219 REM CONVERT TO STRING AND TRIM LEADING SPACE
+220 G$=RIGHT$(STR$(G%),4)
+230 M=LEN(G$)<>4 OR G%=0
+240 IF NOT M THEN GOSUB 600
+250 IF NOT M THEN GOSUB 700
+260 IF M THEN PRINT "THE GUESS IS MALFORMED.":NEXT Q
+270 B=0
+280 C=0
+300 FOR I=1 TO 4
+310 C$=MID$(N$,I,1)
+320 BULL=MID$(G$,I,1)=C$
+330 COW=0
+340 IF NOT BULL THEN FOR J=1 TO 4:COW=MID$(G$,J,1)=C$:IF NOT COW THEN NEXT J
+350 B=B+ABS(BULL)
+360 C=C+ABS(COW)
+370 NEXT I
+380 PRINT "BULLS:";B:PRINT "COWS:";C
+390 Q=ABS(G$=N$)
+400 NEXT Q
+500 PRINT "GOOD JOB!":END
+600 FOR I=2 TO 4:M=MID$(G$,I,1)="0"
+610 IF NOT M THEN NEXT I
+620 RETURN
+700 FOR I=1 TO 3
+710 FOR J=I+1 TO 4
+720 M=MID$(G$,I,1)=MID$(G$,J,1)
+730 IF NOT M THEN NEXT J,I
+740 RETURN
--- a/Task/Bulls-and-cows/Common-Lisp/bulls-and-cows.lisp
+++ b/Task/Bulls-and-cows/Common-Lisp/bulls-and-cows.lisp
@ -0,0 +1,42 @@
+(defun get-number ()
+  (do ((digits '()))
+      ((>= (length digits) 4) digits)
+    (pushnew (1+ (random 9)) digits)))
+
+(defun compute-score (guess number)
+  (let ((cows  0)
+        (bulls 0))
+    (map nil (lambda (guess-digit number-digit)
+               (cond ((= guess-digit number-digit) (incf bulls))
+                     ((member guess-digit number)  (incf cows))))
+         guess number)
+    (values cows bulls)))
+
+(defun number->guess (number)
+  (when (integerp number)
+    (do ((digits '()))
+        ((zerop number) digits)
+      (multiple-value-bind (quotient remainder) (floor number 10)
+        (push remainder digits)
+        (setf number quotient)))))
+
+(defun valid-guess-p (guess)
+  (and (= 4 (length guess))
+       (every (lambda (digit) (<= 1 digit 9)) guess)
+       (equal guess (remove-duplicates guess))))
+
+(defun play-game (&optional (stream *query-io*))
+  (do ((number (get-number))
+       (cows   0)
+       (bulls  0))
+      ((= 4 bulls))
+    (format stream "~&Guess a 4-digit number: ")
+    (let ((guess (number->guess (read stream))))
+      (cond ((not (valid-guess-p guess))
+             (format stream "~&Malformed guess."))
+            (t
+             (setf (values cows bulls) (compute-score guess number))
+             (if (= 4 bulls)
+               (format stream "~&Correct, you win!")
+               (format stream "~&Score: ~a cows, ~a bulls."
+                       cows bulls)))))))
--- a/Task/Bulls-and-cows/Crystal/bulls-and-cows.crystal
+++ b/Task/Bulls-and-cows/Crystal/bulls-and-cows.crystal
@ -0,0 +1,35 @@
+size = 4
+secret = ('1'..'9').to_a.sample(size)
+guess = [] of Char
+
+i = 0
+loop do
+  i += 1
+  loop do
+    print "Guess #{i}: "
+    guess = gets.not_nil!.chomp.chars
+    exit if guess.empty?
+
+    break if guess.size == size &&
+             guess.all? { |x| ('1'..'9').includes? x } &&
+             guess.uniq.size == size
+
+    puts "Problem, try again. You need to enter #{size} unique digits from 1 to 9"
+  end
+
+  if guess == secret
+    puts "Congratulations you guessed correctly in #{i} attempts"
+    break
+  end
+
+  bulls = cows = 0
+  size.times do |j|
+    if guess[j] == secret[j]
+      bulls += 1
+    elsif secret.includes? guess[j]
+      cows += 1
+    end
+  end
+
+  puts "Bulls: #{bulls}; Cows: #{cows}"
+end
--- a/Task/Bulls-and-cows/D/bulls-and-cows.d
+++ b/Task/Bulls-and-cows/D/bulls-and-cows.d
@ -0,0 +1,18 @@
+void main() {
+    import std.stdio, std.random, std.string, std.algorithm,
+           std.range, std.ascii;
+
+    immutable hidden = "123456789"d.randomCover.take(4).array;
+    while (true) {
+        "Next guess: ".write;
+        const d = readln.strip.array.sort().release;
+        if (d.count == 4 && d.all!isDigit && d.uniq.count == 4) {
+            immutable bulls = d.zip(hidden).count!q{ a[0] == a[1] },
+                      cows = d.count!(g => hidden.canFind(g)) - bulls;
+            if (bulls == 4)
+                return " You guessed it!".writeln;
+            writefln("bulls %d, cows %d", bulls, cows);
+        }
+        " Bad guess! (4 unique digits, 1-9)".writeln;
+    }
+}
--- a/Task/Bulls-and-cows/Draco/bulls-and-cows.draco
+++ b/Task/Bulls-and-cows/Draco/bulls-and-cows.draco
@ -0,0 +1,108 @@
+union {
+    ulong state;
+    struct {
+        byte x;
+        byte a;
+        byte b;
+        byte c;
+    } fields;
+} rng;
+
+proc rand() byte:
+    rng.fields.x := rng.fields.x + 1;
+    rng.fields.a := rng.fields.a >< rng.fields.c >< rng.fields.x;
+    rng.fields.b := rng.fields.b + rng.fields.a;
+    rng.fields.c := rng.fields.c + (rng.fields.b >> 1) >< rng.fields.a;
+    rng.fields.c
+corp
+
+proc rand_digit() byte:
+    byte digit;
+    while
+        digit := rand() & 15;
+        digit < 1 or digit >= 10
+    do od;
+    digit
+corp
+
+proc make_secret([4]byte secret) void:
+    int i, j;
+    bool ok;
+    for i from 0 upto 3 do
+        while
+            secret[i] := rand_digit();
+            ok := true;
+            for j from 0 upto i-1 do
+                ok := ok and secret[i] /= secret[j]
+            od;
+            not ok
+        do od
+    od
+corp
+
+proc bulls([4]byte secret, guess) byte:
+    byte i, count;
+    count := 0;
+    for i from 0 upto 3 do
+        if secret[i] = guess[i] then count := count + 1 fi
+    od;
+    count
+corp
+
+proc cows([4]byte secret, guess) byte:
+    byte i, j, count;
+    count := 0;
+    for i from 0 upto 3 do
+        for j from 0 upto 3 do
+            if i /= j and secret[i] = guess[j] then count := count + 1 fi
+        od
+    od;
+    count
+corp
+
+proc read_guess([4]byte guess) void:
+    word guessNo;
+    byte i;
+
+    while
+        write("Guess? ");
+        readln(guessNo);
+        if guessNo<1111 or guessNo>9999 then true
+        else
+            for i from 3 downto 0 do
+                guess[i] := guessNo % 10;
+                guessNo := guessNo / 10;
+            od;
+            guess[0]*guess[1]*guess[2]*guess[3] = 0
+        fi
+    do
+        writeln("A guess must be a four-digit number not containing zeroes.")
+    od
+corp
+
+proc play_game([4]byte secret) word:
+    [4]byte guess;
+    word tries;
+    tries := 1;
+
+    while
+        read_guess(guess);
+        writeln("Bulls: ", bulls(secret, guess), ", cows: ", cows(secret, guess));
+        bulls(secret, guess) /= 4
+    do
+        tries := tries + 1
+    od;
+    tries
+corp
+
+proc main() void:
+    [4]byte secret;
+    word tries;
+
+    write("Please enter a random seed: ");
+    readln(rng.state);
+    make_secret(secret);
+    tries := play_game(secret);
+    writeln();
+    writeln("You got it in ", tries, " tries.")
+corp
--- a/Task/Bulls-and-cows/E/bulls-and-cows-1.e
+++ b/Task/Bulls-and-cows/E/bulls-and-cows-1.e
@ -0,0 +1,82 @@
+def Digit := 1..9
+def Number := Tuple[Digit,Digit,Digit,Digit]
+
+/** Choose a random number to be guessed. */
+def pick4(entropy) {
+    def digits := [1,2,3,4,5,6,7,8,9].diverge()
+
+    # Partial Fisher-Yates shuffle
+    for i in 0..!4 {
+        def other := entropy.nextInt(digits.size() - i) + i
+        def t := digits[other]
+        digits[other] := digits[i]
+        digits[i] := t
+    }
+    return digits(0, 4)
+}
+
+/** Compute the score of a guess. */
+def scoreGuess(actual :Number, guess :Number) {
+    var bulls := 0
+    var cows := 0
+    for i => digit in guess {
+        if (digit == actual[i]) {
+            bulls += 1
+        } else if (actual.indexOf1(digit) != -1) {
+            cows += 1
+        }
+    }
+    return [bulls, cows]
+}
+
+/** Parse a guess string into a list of digits (Number). */
+def parseGuess(guessString, fail) :Number {
+    if (guessString.size() != 4) {
+        return fail(`I need four digits, not ${guessString.size()} digits.`)
+    } else {
+        var digits := []
+        for c in guessString {
+            if (('1'..'9')(c)) {
+                digits with= c - '0'
+            } else {
+                return fail(`I need a digit from 1 to 9, not "$c".`)
+            }
+        }
+        return digits
+    }
+}
+
+/** The game loop: asking for guesses and reporting scores and win conditions.
+    The return value is null or a broken reference if there was a problem. */
+def bullsAndCows(askUserForGuess, tellUser, entropy) {
+    def actual := pick4(entropy)
+
+    def gameTurn() {
+        return when (def guessString := askUserForGuess <- ()) -> {
+            escape tellAndContinue {
+
+                def guess := parseGuess(guessString, tellAndContinue)
+                def [bulls, cows] := scoreGuess(actual, guess)
+
+                if (bulls == 4) {
+                    tellUser <- (`You got it! The number is $actual!`)
+                    null
+                } else {
+                    tellAndContinue(`Your score for $guessString is $bulls bulls and $cows cows.`)
+                }
+
+            } catch message {
+                # The parser or scorer has something to say, and the game continues afterward
+                when (tellUser <- (message)) -> {
+                    gameTurn()
+                }
+            }
+        } catch p {
+            # Unexpected problem of some sort
+            tellUser <- ("Sorry, game crashed.")
+            throw(p)
+        }
+    }
+
+    return gameTurn()
+}
--- a/Task/Bulls-and-cows/E/bulls-and-cows-2.e
+++ b/Task/Bulls-and-cows/E/bulls-and-cows-2.e
@ -0,0 +1,15 @@
+def guiBullsAndCows() {
+    var lastGuess := ""
+    def op := <unsafe:javax.swing.makeJOptionPane>
+    return bullsAndCows(fn {
+      lastGuess := op.showInputDialog(null, "Enter your guess:", lastGuess)
+      if (lastGuess == null) {
+        # canceled, so just fail to return an answer and let the game logic get GCed
+        Ref.promise()[0]
+      } else {
+        lastGuess
+      }
+    }, fn msg {
+      op.showMessageDialog(null, msg)
+    }, entropy)
+}
--- a/Task/Bulls-and-cows/EasyLang/bulls-and-cows.easy
+++ b/Task/Bulls-and-cows/EasyLang/bulls-and-cows.easy
@ -0,0 +1,42 @@
+dig[] = [ 1 2 3 4 5 6 7 8 9 ]
+for i = 1 to 4
+  h = i - 1 + random (10 - i)
+  swap dig[i] dig[h]
+.
+# print dig[]
+len g[] 4
+attempts = 0
+repeat
+  repeat
+    ok = 0
+    s$[] = strchars input
+    if len s$[] = 4
+      ok = 1
+      for i = 1 to 4
+        g[i] = number s$[i]
+        if g[i] = 0
+          ok = 0
+        .
+      .
+    .
+    until ok = 1
+  .
+  print g[]
+  attempts += 1
+  bulls = 0
+  cows = 0
+  for i = 1 to 4
+    if g[i] = dig[i]
+      bulls += 1
+    else
+      for j = 1 to 4
+        if dig[j] = g[i]
+          cows += 1
+        .
+      .
+    .
+  .
+  print "bulls:" & bulls & " cows:" & cows
+  until bulls = 4
+.
+print "Well done! " & attempts & " attempts needed."
--- a/Task/Bulls-and-cows/Eiffel/bulls-and-cows.e
+++ b/Task/Bulls-and-cows/Eiffel/bulls-and-cows.e
@ -0,0 +1,112 @@
+class
+	BULLS_AND_COWS
+
+create
+	execute
+
+feature
+
+	execute
+			-- Initiate game.
+		do
+			io.put_string ("Let's play bulls and cows.%N")
+			create answer.make_empty
+			play
+		end
+
+feature {NONE}
+
+	play
+			-- Plays bulls ans cows.
+		local
+			count, seed: INTEGER
+			guess: STRING
+		do
+			from
+			until
+				seed > 0
+			loop
+				io.put_string ("Enter a positive integer.%NYour play will be generated from it.%N")
+				io.read_integer
+				seed := io.last_integer
+			end
+			generate_answer (seed)
+			io.put_string ("Your game has been created.%N Try to guess the four digit number.%N")
+			create guess.make_empty
+			from
+			until
+				guess ~ answer
+			loop
+				io.put_string ("Guess: ")
+				io.read_line
+				guess := io.last_string
+				if guess.count = 4 and guess.is_natural and not guess.has ('0') then
+					io.put_string (score (guess) + "%N")
+					count := count + 1
+				else
+					io.put_string ("Your input does not have the correct format.")
+				end
+			end
+			io.put_string ("Congratulations! You won with " + count.out + " guesses.")
+		end
+
+	answer: STRING
+
+	generate_answer (s: INTEGER)
+			-- Answer with 4-digits between 1 and 9 stored in 'answer'.
+		require
+			positive_seed: s > 0
+		local
+			random: RANDOM
+			ran: INTEGER
+		do
+			create random.set_seed (s)
+			from
+			until
+				answer.count = 4
+			loop
+				ran := (random.double_item * 10).floor
+				if ran > 0 and not answer.has_substring (ran.out) then
+					answer.append (ran.out)
+				end
+				random.forth
+			end
+		ensure
+			answer_not_void: answer /= Void
+			correct_length: answer.count = 4
+		end
+
+	score (g: STRING): STRING
+			-- Score for the guess 'g' depending on 'answer'.
+		require
+			same_length: answer.count = g.count
+		local
+			k: INTEGER
+			a, ge: STRING
+		do
+			Result := ""
+			a := answer.twin
+			ge := g.twin
+			across
+				1 |..| a.count as c
+			loop
+				if a [c.item] ~ ge [c.item] then
+					Result := Result + "BULL "
+					a [c.item] := ' '
+					ge [c.item] := ' '
+				end
+			end
+			across
+				1 |..| a.count as c
+			loop
+				if a [c.item] /= ' ' then
+					k := ge.index_of (a [c.item], 1)
+					if k > 0 then
+						Result := Result + "COW "
+						ge [k] := ' '
+					end
+				end
+			end
+		end
+
+end
--- a/Task/Bulls-and-cows/Elena/bulls-and-cows.elena
+++ b/Task/Bulls-and-cows/Elena/bulls-and-cows.elena
@ -0,0 +1,90 @@
+import system'routines;
+import extensions;
+
+class GameMaster
+{
+    object theNumbers;
+    object theAttempt;
+
+    constructor()
+    {
+        // generate secret number
+        var randomNumbers := new int[]{1,2,3,4,5,6,7,8,9}.randomize(9);
+
+        theNumbers := randomNumbers.Subarray(0, 4);
+        theAttempt := new Integer(1);
+    }
+
+    ask()
+    {
+        var row := console.print("Your Guess #",theAttempt," ?").readLine();
+
+        ^ row.toArray()
+    }
+
+    proceed(guess)
+    {
+        int cows := 0;
+        int bulls := 0;
+
+        if (guess.Length != 4)
+        {
+            bulls := -1
+        }
+        else
+        {
+            try
+            {
+                for (int i := 0, i < 4, i+=1) {
+                    var ch := guess[i];
+                    var number := ch.toString().toInt();
+
+                    // check range
+                    ifnot (number > 0 && number < 10)
+                        { InvalidArgumentException.raise() };
+
+                    // check duplicates
+                    var duplicate := guess.seekEach:(x => (x == ch)&&(x.equalReference(ch).Inverted));
+                    if (nil != duplicate)
+                    {
+                        InvalidArgumentException.raise()
+                    };
+
+                    if (number == theNumbers[i])
+                    {
+                        bulls += 1
+                    }
+                    else
+                    {
+                        if (theNumbers.ifExists(number))
+                            { cows += 1 }
+                    }
+                }
+            }
+            catch(Exception e)
+            {
+                bulls := -1
+            }
+        };
+
+        bulls =>
+            -1 { console.printLine:"Not a valid guess."; ^ true }
+             4 { console.printLine:"Congratulations! You have won!"; ^ false }
+             : {
+                 theAttempt.append(1);
+
+                 console.printLine("Your Score is ",bulls," bulls and ",cows," cows");
+
+                 ^ true
+             }
+    }
+}
+
+public program()
+{
+    var gameMaster := new GameMaster();
+
+    (lazy:gameMaster.proceed(gameMaster.ask())).doWhile();
+
+    console.readChar()
+}
--- a/Task/Bulls-and-cows/Elixir/bulls-and-cows.elixir
+++ b/Task/Bulls-and-cows/Elixir/bulls-and-cows.elixir
@ -0,0 +1,42 @@
+defmodule Bulls_and_cows do
+  def play(size \\ 4) do
+    secret = Enum.take_random(1..9, size) |> Enum.map(&to_string/1)
+    play(size, secret)
+  end
+
+  defp play(size, secret) do
+    guess = input(size)
+    if guess == secret do
+      IO.puts "You win!"
+    else
+      {bulls, cows} = count(guess, secret)
+      IO.puts "  Bulls: #{bulls}; Cows: #{cows}"
+      play(size, secret)
+    end
+  end
+
+  defp input(size) do
+    guess = IO.gets("Enter your #{size}-digit guess: ") |> String.strip
+    cond do
+      guess == "" ->
+        IO.puts "Give up"
+        exit(:normal)
+      String.length(guess)==size and String.match?(guess, ~r/^[1-9]+$/) ->
+        String.codepoints(guess)
+      true -> input(size)
+    end
+  end
+
+  defp count(guess, secret) do
+    Enum.zip(guess, secret) |>
+    Enum.reduce({0,0}, fn {g,s},{bulls,cows} ->
+      cond do
+        g == s      -> {bulls + 1, cows}
+        g in secret -> {bulls, cows + 1}
+        true        -> {bulls, cows}
+      end
+    end)
+  end
+end
+
+Bulls_and_cows.play
--- a/Task/Bulls-and-cows/Erlang/bulls-and-cows-1.erl
+++ b/Task/Bulls-and-cows/Erlang/bulls-and-cows-1.erl
@ -0,0 +1,45 @@
+-module(bulls_and_cows).
+-export([generate_secret/0, score_guess/2, play/0]).
+
+% generate the secret code
+generate_secret() -> generate_secret([], 4, lists:seq(1,9)).
+generate_secret(Secret, 0, _) -> Secret;
+generate_secret(Secret, N, Digits) ->
+  Next = lists:nth(random:uniform(length(Digits)), Digits),
+  generate_secret(Secret ++ [Next], N - 1, Digits -- [Next]).
+
+% evaluate a guess
+score_guess(Secret, Guess)
+  when length(Secret) =/= length(Guess) -> throw(badguess);
+score_guess(Secret, Guess) ->
+  Bulls = count_bulls(Secret,Guess),
+  Cows = count_cows(Secret, Guess, Bulls),
+  [Bulls, Cows].
+
+% count bulls (exact matches)
+count_bulls(Secret, Guess) ->
+  length(lists:filter(fun(I) -> lists:nth(I,Secret) == lists:nth(I,Guess) end,
+                      lists:seq(1, length(Secret)))).
+
+% count cows (digits present but out of place)
+count_cows(Secret, Guess, Bulls) ->
+   length(lists:filter(fun(I) -> lists:member(I, Guess) end, Secret)) - Bulls.
+
+% play a game
+play() -> play_round(generate_secret()).
+
+play_round(Secret) -> play_round(Secret, read_guess()).
+
+play_round(Secret, Guess) ->
+  play_round(Secret, Guess, score_guess(Secret,Guess)).
+
+play_round(_, _, [4,0]) ->
+  io:put_chars("Correct!\n");
+
+play_round(Secret, _, Score) ->
+  io:put_chars("\tbulls:"), io:write(hd(Score)), io:put_chars(", cows:"),
+  io:write(hd(tl(Score))), io:put_chars("\n"), play_round(Secret).
+
+read_guess() ->
+  lists:map(fun(D)->D-48 end,
+    lists:sublist(io:get_line("Enter your 4-digit guess: "), 4)).
--- a/Task/Bulls-and-cows/Erlang/bulls-and-cows-2.erl
+++ b/Task/Bulls-and-cows/Erlang/bulls-and-cows-2.erl
@ -0,0 +1,3 @@
+#!/usr/bin/escript
+% Play Bulls and Cows
+main(_) -> random:seed(now()), bulls_and_cows:play().
--- a/Task/Bulls-and-cows/Euphoria/bulls-and-cows.euphoria
+++ b/Task/Bulls-and-cows/Euphoria/bulls-and-cows.euphoria
@ -0,0 +1,103 @@
+include std\text.e
+include std\os.e
+include std\sequence.e
+include std\console.e
+
+sequence bcData = {0,0} --bull,cow score for the player
+sequence goalNum = { {0,0,0,0}, {0,0,0,0}, 0} --computer's secret number digits (element 1), marked as bull/cow
+--indexes in element 2, integer value of it in element 3
+sequence currentGuess = { {0,0,0,0}, {0,0,0,0}, 0} --player's guess, same format as goalNum
+sequence removeChars = 0 & " 0\r\t\n" --characters to trim (remove) from user's input. \r, \t are single escaped characters,
+--0 is ascii 0x0 and number zero is ascii 48, or 0x30. The rest are wysiwyg
+integer tries = 0 --track number of tries to guess the number
+sequence bcStrings ={"bull", "cow"} --stores singular and/or plural strings depending on score in bcData
+
+goalNum[1] = rand( {9,9,9,9} ) --rand function works on objects. here it outputs into each sequence element.
+goalNum[3] = goalNum[1][1] * 1000 + goalNum[1][2] * 100 + goalNum[1][3] * 10 + goalNum[1][4] --convert digits to an integer
+--and store it
+
+procedure getInputAndProcess(integer stage = 1)  --object = 1 sets default value for the parameter if it isn't specified
+
+    goalNum[2][1..4] = 0 --{0,0,0,0} --set these to unscaned (0) since the scanning will start over.
+    currentGuess[1][1..4] = 0 --{0,0,0,0} --these too, or they will contain old marks
+    currentGuess[2][1..4] = 0
+    tries += 1 --equivalent to tries = tries + 1, but faster and shorter to write
+    bcData[1..2] = 0 -- {0,0}
+
+    if stage <= 1 then --if this process was run for the first time or with no parameters, then..
+        puts(1,"The program has thought of a four digit number using only digits 1 to 9.\nType your guess and press enter.\n")
+    end if
+
+    while 1 label "guesscheck" do --labels can be used to specify a jump point from exit or retry, and help readability
+        currentGuess[1] = trim(gets(0), removeChars) --get user input, trim unwanted characters from it, store it in currentGuess[1]
+        currentGuess[1] = mapping( currentGuess[1], {49,50,51,52,53,54,55,56,57}, {1,2,3,4,5,6,7,8,9} ) --convert ascii codes to
+        -- integer digits they represent
+        integer tempF = find('0',currentGuess[1])
+        if length(currentGuess[1]) != 4 or tempF != 0 then --if the input string is now more than 4 characters/integers,
+            --the input won't be used.
+            puts(1,"You probably typed too many digits or a 0. Try typing a new 4 digit number with only numbers 1 through 9.\n")
+            retry "guesscheck"
+            else
+                exit "guesscheck"
+        end if
+    end while
+    --convert separate digits to the one integer they represent and store it, like with goalNum[3]
+    currentGuess[3] = currentGuess[1][1] * 1000 + currentGuess[1][2] * 100 + currentGuess[1][3] * 10 + currentGuess[1][4]
+--convert digits to the integer they represent, to print to a string later
+
+    --check for bulls
+    for i = 1 to 4 do
+        if goalNum[1][i] = currentGuess[1][i] then
+            goalNum[2][i] = 1
+            currentGuess[2][i] = 1
+            bcData[1] += 1
+        end if
+    end for
+
+    --check for cows, but not slots marked as bulls or cows already.
+    for i = 1 to 4 label "iGuessElem"do --loop through each guessed digit
+        for j = 1 to 4 label "jGoalElem" do --but first go through each goal digit, comparing the first guessed digit,
+            --and then the other guessed digits 2 through 4
+
+            if currentGuess[2][i] = 1 then --if the guessed digit we're comparing right now has been marked as bull or cow already
+                continue "iGuessElem" --skip to the next guess digit without comparing this guess digit to the other goal digits
+            end if
+
+            if goalNum[2][j] = 1 then --if the goal digit we're comparing to right now has been marked as a bull or cow already
+                continue "jGoalElem" --skip to the next goal digit
+            end if
+
+            if currentGuess[1][i] = goalNum[1][j] then --if the guessed digit is the same as the goal one,
+                --it won't be a bull, so it's a cow
+                bcData[2] += 1 --score one more cow
+                goalNum[2][j] = 1 --mark this digit as a found cow in the subsequence that stores 0's or 1's as flags
+                continue "iGuessElem" --skip to the next guess digit, so that this digit won't try to check for
+                --matches(cow) with other goal digits
+            end if
+
+        end for --this guess digit was compared to one goal digit , try comparing this guess digit with the next goal digit
+    end for --this guess digit was compared with all goal digits, compare the next guess digit to all the goal digits
+
+    if bcData[1] = 1 then --uses singular noun when there is score of 1, else plural
+        bcStrings[1] = "bull"
+        else
+            bcStrings[1] = "bulls"
+    end if
+
+    if bcData[2] = 1 then --the same kind of thing as above block
+        bcStrings[2] = "cow"
+        else
+            bcStrings[2] = "cows"
+    end if
+
+    if bcData[1] < 4 then --if less than 4 bulls were found, the player hasn't won, else they have...
+        printf(1, "Guess #%d : You guessed %d . You found %d %s, %d %s. Type new guess.\n", {tries, currentGuess[3], bcData[1], bcStrings[1], bcData[2], bcStrings[2]} )
+        getInputAndProcess(2)
+    else --else they have won and the procedure ends
+        printf(1, "The number was %d. You guessed %d in %d tries.\n", {goalNum[3], currentGuess[3], tries} )
+        any_key()--wait for keypress before closing console window.
+    end if
+
+end procedure
+--run the procedure
+getInputAndProcess(1)
--- a/Task/Bulls-and-cows/F-Sharp/bulls-and-cows-1.fs
+++ b/Task/Bulls-and-cows/F-Sharp/bulls-and-cows-1.fs
@ -0,0 +1,68 @@
+open System
+
+let generate_number targetSize =
+    let rnd = Random()
+    let initial = Seq.initInfinite (fun _ -> rnd.Next(1,9))
+    initial |> Seq.distinct |> Seq.take(targetSize) |> Seq.toList
+
+let countBulls guess target =
+    let hits = List.map2 (fun g t -> if g = t then true else false) guess target
+    List.filter (fun x -> x = true) hits |> List.length
+
+let countCows guess target =
+    let mutable score = 0
+    for g in guess do
+        for t in target do
+            if g = t then
+                score <- score + 1
+            else
+                score <- score
+    score
+
+let countScore guess target =
+    let bulls = countBulls guess target
+    let cows = countCows guess target
+    (bulls, cows)
+
+let playRound guess target =
+    countScore guess target
+
+let inline ctoi c : int =
+    int c - int '0'
+
+let lineToList (line: string) =
+    let listc = Seq.map(fun c -> c |> string) line |> Seq.toList
+    let conv = List.map(fun x -> Int32.Parse x) listc
+    conv
+
+let readLine() =
+    let line = Console.ReadLine()
+    if line <> null then
+        if line.Length = 4 then
+            Ok (lineToList line)
+        else
+            Error("Input guess must be 4 characters!")
+    else
+        Error("Input guess cannot be empty!")
+
+let rec handleInput() =
+    let line = readLine()
+    match line with
+    | Ok x -> x
+    | Error s ->
+        printfn "%A" s
+        handleInput()
+
+[<EntryPoint>]
+let main argv =
+    let target = generate_number 4
+    let mutable shouldEnd = false
+    while shouldEnd = false do
+        let guess = handleInput()
+        let (b, c) = playRound guess target
+        printfn "Bulls: %i | Cows: %i" b c
+        if b = 4 then
+            shouldEnd <- true
+        else
+            shouldEnd <- false
+    0
--- a/Task/Bulls-and-cows/F-Sharp/bulls-and-cows-2.fs
+++ b/Task/Bulls-and-cows/F-Sharp/bulls-and-cows-2.fs
@ -0,0 +1,50 @@
+function get_digit( num as uinteger, ps as uinteger ) as uinteger
+    return (num mod 10^(ps+1))\10^ps
+end function
+
+function is_malformed( num as uinteger ) as boolean
+    if num > 9876 then return true
+    dim as uinteger i, j
+    for i = 0 to 2
+        for j = i+1 to 3
+            if get_digit( num, j ) = get_digit( num, i ) then return true
+        next j
+    next i
+    return false
+end function
+
+function make_number() as uinteger
+    dim as uinteger num = 0
+    while is_malformed(num)
+        num = int(rnd*9877)
+    wend
+    return num
+end function
+
+randomize timer
+
+dim as uinteger count=0, num=make_number(), guess=0
+dim as uinteger cows, bulls, i, j
+
+while guess <> num
+    count += 1
+    do
+        print "Guess a number. "
+        input guess
+    loop while is_malformed(guess)
+
+    cows = 0
+    bulls = 0
+
+    for i = 0 to 3
+        for j = 0 to 3
+            if get_digit( num, i ) = get_digit( guess, j ) then
+                if i= j then bulls += 1
+                if i<>j then cows  += 1
+            end if
+        next j
+    next i
+    print using "You scored # bulls and # cows."; bulls; cows
+wend
+
+print using "Correct. That took you ### guesses."; count
--- a/Task/Bulls-and-cows/FOCAL/bulls-and-cows.focal
+++ b/Task/Bulls-and-cows/FOCAL/bulls-and-cows.focal
@ -0,0 +1,34 @@
+01.10 T %1,"BULLS AND COWS"!"----- --- ----"!!
+01.20 S T=0;D 3
+01.30 D 2;D 5;S T=T+1;T "BULLS",B," COWS",C,!!
+01.40 I (B-4)1.3
+01.50 T "YOU WON! GUESSES",%4,T,!!
+01.60 Q
+
+02.10 A "GUESS",A
+02.20 F X=0,3;S B=FITR(A/10);S G(3-X)=A-B*10;S A=B
+02.30 S A=1
+02.40 F X=0,3;S A=A*G(X)
+02.50 I (-A)2.6;T "NEED FOUR NONZERO DIGITS"!;G 2.1
+02.60 F X=0,2;F Y=X+1,3;S A=A*(FABS(G(X)-G(Y)))
+02.70 I (-A)2.8;T "NO DUPLICATES ALLOWED"!;G 2.1
+02.80 R
+
+03.10 F X=0,3;S S(X)=0
+03.20 F X=0,3;D 4;S S(X)=A
+
+04.10 S A=10*FRAN();S A=FITR(1+9*(A-FITR(A)))
+04.20 S Z=1
+04.30 F Y=0,3;S Z=Z*(FABS(A-S(Y)))
+04.40 I (-Z)4.5,4.1
+04.50 R
+
+05.10 S B=0
+05.20 F X=0,3;D 5.6
+05.30 S C=-B
+05.40 F X=0,3;F Y=0,3;D 5.7
+05.50 R
+05.60 I (-FABS(S(X)-G(X)))5.5,5.8
+05.70 I (-FABS(S(X)-G(Y)))5.5,5.9
+05.80 S B=B+1
+05.90 S C=C+1
--- a/Task/Bulls-and-cows/Factor/bulls-and-cows.factor
+++ b/Task/Bulls-and-cows/Factor/bulls-and-cows.factor
@ -0,0 +1,64 @@
+USING: accessors assocs combinators fry grouping hashtables kernel
+       locals math math.parser math.ranges random sequences strings
+       io ascii ;
+
+IN: bullsncows
+
+TUPLE: score bulls cows ;
+: <score> ( -- score ) 0 0 score boa ;
+
+TUPLE: cow ;
+: <cow> ( -- cow ) cow new ;
+
+TUPLE: bull ;
+: <bull> ( -- bull ) bull new ;
+
+: inc-bulls ( score -- score ) dup bulls>> 1 + >>bulls ;
+: inc-cows ( score -- score ) dup cows>> 1 + >>cows ;
+
+: random-nums ( -- seq ) 9 [1,b] 4 sample ;
+
+: add-digits ( seq -- n ) 0 [ swap 10 * + ] reduce number>string ;
+
+: new-number ( -- n narr ) random-nums dup add-digits ;
+
+: narr>nhash ( narr -- nhash ) { 1 2 3 4 } swap zip ;
+
+: num>hash ( n -- hash )
+    [ 1string string>number ] { } map-as narr>nhash ;
+
+:: cow-or-bull ( n g -- arr )
+    {
+        { [ n first g at n second = ] [ <bull> ] }
+        { [ n second g value? ] [ <cow> ] }
+        [ f ]
+    } cond ;
+
+: add-to-score ( arr -- score )
+   <score> [ bull? [ inc-bulls ] [ inc-cows ] if ] reduce ;
+
+: check-win ( score -- ? ) bulls>> 4 = ;
+
+: sum-score ( n g -- score ? )
+    '[ _ cow-or-bull ] map sift add-to-score dup check-win ;
+
+: print-sum ( score -- str )
+    dup bulls>> number>string "Bulls: " swap append swap cows>> number>string
+    " Cows: " swap 3append "\n" append ;
+
+: (validate-readln) ( str -- ? ) dup length 4 = not swap [ letter? ] all? or ;
+
+: validate-readln ( -- str )
+    readln dup (validate-readln)
+    [ "Invalid input.\nPlease enter a valid 4 digit number: "
+      write flush drop validate-readln ]
+    when ;
+
+: win ( -- ) "\nYou've won! Good job. You're so smart." print flush ;
+
+: main-loop ( x -- )
+    "Enter a 4 digit number: " write flush validate-readln num>hash swap
+    [ sum-score swap print-sum print flush ] keep swap not
+    [ main-loop ] [ drop win ] if ;
+
+: main ( -- ) new-number drop narr>nhash main-loop ;
--- a/Task/Bulls-and-cows/Fan/bulls-and-cows.fan
+++ b/Task/Bulls-and-cows/Fan/bulls-and-cows.fan
@ -0,0 +1,50 @@
+**
+** Bulls and cows. A game pre-dating, and similar to, Mastermind.
+**
+class BullsAndCows
+{
+
+  Void main()
+  {
+    digits := [1,2,3,4,5,6,7,8,9]
+    size := 4
+    chosen := [,]
+    size.times { chosen.add(digits.removeAt(Int.random(0..<digits.size))) }
+
+    echo("I've chosen $size unique digits from 1 to 9 at random.
+          Try to guess my number!")
+    guesses := 0
+    while (true) // game loop
+    {
+      guesses += 1
+      guess := Int[,]
+      while (true) // input loop
+      {
+        // get a good guess
+        Sys.out.print("\nNext guess [$guesses]: ")
+        Sys.out.flush
+        inString := Sys.in.readLine?.trim ?: ""
+        inString.each |ch|
+        { if (ch >= '1' && ch <= '9' && !guess.contains(ch)) guess.add(ch-'0') }
+        if (guess.size == 4)
+          break // input loop
+        echo("Oops, try again. You need to enter $size unique digits from 1 to 9")
+      }
+      if (guess.all |v, i->Bool| { return v == chosen[i] })
+      {
+        echo("\nCongratulations! You guessed correctly in $guesses guesses")
+        break // game loop
+      }
+      bulls := 0
+      cows  := 0
+      (0 ..< size).each |i|
+      {
+        if (guess[i] == chosen[i])
+          bulls += 1
+        else if (chosen.contains(guess[i]))
+          cows += 1
+      }
+      echo("\n  $bulls Bulls\n  $cows Cows")
+    }
+  }
+}
--- a/Task/Bulls-and-cows/Forth/bulls-and-cows.fth
+++ b/Task/Bulls-and-cows/Forth/bulls-and-cows.fth
@ -0,0 +1,37 @@
+include random.fs
+
+create hidden 4 allot
+
+: ok? ( str -- ? )
+  dup 4 <> if 2drop false exit then
+  1 9 lshift 1- -rot
+  bounds do
+    i c@ '1 -
+    dup 0 9 within 0= if 2drop false leave then
+    1 swap lshift over and
+    dup 0= if nip leave then
+    xor
+  loop 0<> ;
+
+: init
+  begin
+    hidden 4 bounds do 9 random '1 + i c! loop
+    hidden 4 ok?
+  until ;
+
+: check? ( addr -- solved? )
+  0
+  4 0 do
+    over i + c@
+    4 0 do
+      dup hidden i + c@ = if     swap
+        i j = if 8 else 1 then + swap
+      then
+    loop drop
+  loop nip
+  8 /mod tuck . ." bulls, " . ." cows"
+  4 = ;
+
+: guess: ( "1234" -- )
+  bl parse 2dup ok? 0= if 2drop ." Bad guess! (4 unique digits, 1-9)" exit then
+  drop check? if cr ." You guessed it!" then ;
--- a/Task/Bulls-and-cows/Fortran/bulls-and-cows.f
+++ b/Task/Bulls-and-cows/Fortran/bulls-and-cows.f
@ -0,0 +1,84 @@
+module bac
+  implicit none
+
+contains
+
+  subroutine Gennum(n)
+    integer, intent(out) :: n(4)
+    integer :: i, j
+    real :: r
+
+    call random_number(r)
+    n(1) = int(r * 9.0) + 1
+    i = 2
+
+outer: do while (i <= 4)
+         call random_number(r)
+         n(i) = int(r * 9.0) + 1
+inner:   do j = i-1 , 1, -1
+           if (n(j) == n(i)) cycle outer
+         end do inner
+         i = i + 1
+       end do outer
+
+  end subroutine Gennum
+
+  subroutine Score(n, guess, b, c)
+    character(*), intent(in) :: guess
+    integer, intent(in) :: n(0:3)
+    integer, intent(out) :: b, c
+    integer :: digit, i, j, ind
+
+    b = 0; c = 0
+    do i = 1, 4
+      read(guess(i:i), "(i1)") digit
+      if (digit == n(i-1)) then
+        b = b + 1
+      else
+        do j = i, i+2
+          ind = mod(j, 4)
+          if (digit == n(ind)) then
+            c = c + 1
+            exit
+          end if
+        end do
+      end if
+    end do
+
+ end subroutine Score
+
+end module bac
+
+program Bulls_and_Cows
+   use bac
+   implicit none
+
+   integer :: n(4)
+   integer :: bulls=0, cows=0, tries=0
+   character(4) :: guess
+
+   call random_seed
+   call Gennum(n)
+
+   write(*,*) "I have selected a number made up of 4 digits (1-9) without repetitions."
+   write(*,*) "You attempt to guess this number."
+   write(*,*) "Every digit in your guess that is in the correct position scores 1 Bull"
+   write(*,*) "Every digit in your guess that is in an incorrect position scores 1 Cow"
+   write(*,*)
+
+   do while (bulls /= 4)
+     write(*,*) "Enter a 4 digit number"
+     read*, guess
+     if (verify(guess, "123456789") /= 0) then
+       write(*,*) "That is an invalid entry. Please try again."
+       cycle
+     end if
+     tries = tries + 1
+     call Score (n, guess, bulls, cows)
+     write(*, "(a, i1, a, i1, a)") "You scored ", bulls, " bulls and ", cows, " cows"
+     write(*,*)
+   end do
+
+   write(*,"(a,i0,a)") "Congratulations! You correctly guessed the correct number in ", tries, " attempts"
+
+end program Bulls_and_Cows
--- a/Task/Bulls-and-cows/Frink/bulls-and-cows.frink
+++ b/Task/Bulls-and-cows/Frink/bulls-and-cows.frink
@ -0,0 +1,83 @@
+// Bulls and Cows - Written in Frink
+println["Welcome to Bulls and Cows!"]
+
+// Put 4 random digits into target array
+digits = array[1 to 9]
+target = new array
+for i = 0 to 3
+{
+   target@i = digits.removeRandom[]
+}
+
+// Game variables
+guessCount = 0
+solved = 0
+
+while solved == 0
+{
+   // Round variables
+   bulls = 0
+   cows = 0
+
+   // Input guess from player
+   guess = input["Guess a 4 digit number with numbers 1 to 9: "]
+
+   // Valid Guess Tests. Set validGuess to 1. If any test fails it will be set to 0
+   validGuess = 1
+   // Test for exactly 4 digits
+   if length[guess] != 4
+   {
+      println["$guess is invalid. Your guess must be 4 digits."]
+      validGuess = 0
+   }
+   // Test for any characters not in 1 - 9 using regex
+   if guess =~ %r/[^1-9]/
+   {
+      println["$guess is invalid. Your guess can only contain the digits 1 through 9."]
+      validGuess = 0
+   }
+   // Check for duplicate digits in guess
+   comboCheck = 1
+   guessArr = charList[guess] // Split guess string into array of characters.
+   guessArrCombos = guessArr.combinations[2] // Divide the array into all possible 2 digits combinations.
+   for geussCombo = guessArrCombos
+   {
+      if geussCombo@0 == geussCombo@1 // If the two digits in the combinations are the same mark the comboCheck as failed.
+         comboCheck = 0
+   }
+   if comboCheck == 0
+   {
+      println["$guess is invalid. Each digit in your guess should be unique."]
+      validGuess = 0
+   }
+
+   // If all tests pass, continue with the game.
+   if validGuess == 1
+   {
+      guessCount = guessCount + 1
+      for i = 0 to 3
+      {
+         if parseInt[guessArr@i] == target@i // Convert guess from string to int. Frink imports all input as strings.
+         {
+            bulls = bulls + 1
+            next // If bull is found, skip the contains check.
+         }
+         if target.contains[parseInt[guessArr@i]]
+         {
+            cows = cows + 1
+         }
+      }
+      if bulls == 4
+      {
+         solved = 1 // Exit from While loop.
+      } else
+      {
+         // Print the results of the guess. Formatting for plurals.
+         bullsPlural = bulls == 1 ? "bull" : "bulls"
+         cowsPlural = cows == 1 ? "cow" : "cows"
+         println["Your guess of $guess had $bulls $bullsPlural and $cows $cowsPlural."]
+      }
+   }
+}
+guessPlural = guessCount == 1 ? "guess" : "guesses"
+println["Congratulations! Your guess of $guess was correct! You solved this in $guessCount $guessPlural."]
--- a/Task/Bulls-and-cows/Go/bulls-and-cows.go
+++ b/Task/Bulls-and-cows/Go/bulls-and-cows.go
@ -0,0 +1,68 @@
+package main
+
+import (
+    "bufio"
+    "bytes"
+    "fmt"
+    "math/rand"
+    "os"
+    "strings"
+    "time"
+)
+
+func main() {
+    fmt.Println(`Cows and Bulls
+Guess four digit number of unique digits in the range 1 to 9.
+A correct digit but not in the correct place is a cow.
+A correct digit in the correct place is a bull.`)
+    // generate pattern
+    pat := make([]byte, 4)
+    rand.Seed(time.Now().Unix())
+    r := rand.Perm(9)
+    for i := range pat {
+        pat[i] = '1' + byte(r[i])
+    }
+
+    // accept and score guesses
+    valid := []byte("123456789")
+guess:
+    for in := bufio.NewReader(os.Stdin); ; {
+        fmt.Print("Guess: ")
+        guess, err := in.ReadString('\n')
+        if err != nil {
+            fmt.Println("\nSo, bye.")
+            return
+        }
+        guess = strings.TrimSpace(guess)
+        if len(guess) != 4 {
+            // malformed:  not four characters
+            fmt.Println("Please guess a four digit number.")
+            continue
+        }
+        var cows, bulls int
+        for ig, cg := range guess {
+            if strings.IndexRune(guess[:ig], cg) >= 0 {
+                // malformed:  repeated digit
+                fmt.Printf("Repeated digit: %c\n", cg)
+                continue guess
+            }
+            switch bytes.IndexByte(pat, byte(cg)) {
+            case -1:
+                if bytes.IndexByte(valid, byte(cg)) == -1 {
+                    // malformed:  not a digit
+                    fmt.Printf("Invalid digit: %c\n", cg)
+                    continue guess
+                }
+            default: // I just think cows should go first
+                cows++
+            case ig:
+                bulls++
+            }
+        }
+        fmt.Printf("Cows: %d, bulls: %d\n", cows, bulls)
+        if bulls == 4 {
+            fmt.Println("You got it.")
+            return
+        }
+    }
+}
--- a/Task/Bulls-and-cows/Golo/bulls-and-cows.golo
+++ b/Task/Bulls-and-cows/Golo/bulls-and-cows.golo
@ -0,0 +1,99 @@
+#!/usr/bin/env golosh
+----
+This module is the Bulls and Cows game.
+----
+module Bullsandcows
+
+import gololang.Decorators
+import gololang.Functions
+import gololang.IO
+import java.util
+
+function main = |args| {
+  while true {
+    let secret = create4RandomNumbers()
+    println("Welcome to Bulls And Cows")
+    while true {
+      println("Please enter a 4 digit number")
+      println("(with only the digits 1 to 9 and no repeated digits, for example 2537)")
+      let guess = readln("guess: ")
+      let result = validateGuess(guess)
+      if result: isValid() {
+        let bulls, cows = bullsAndOrCows(result: digits(), secret)
+        if bulls is 4 {
+          println("You win!")
+          break
+        }
+        println("bulls: " + bulls)
+        println("cows:  " + cows)
+      } else {
+        println(result: message())
+      }
+    }
+  }
+}
+
+function create4RandomNumbers = {
+  let numbers = vector[1, 2, 3, 4, 5, 6, 7, 8, 9]
+  Collections.shuffle(numbers)
+  let shuffled = numbers: subList(0, 4)
+  return shuffled
+}
+
+union Result = {
+  Valid = { digits }
+  Invalid = { message }
+}
+
+@checkArguments(isString())
+function validateGuess = |guess| {
+  var digits = []
+  try {
+    let number = guess: toInt()
+    digits = number: digits()
+    if digits: exists(|d| -> d is 0) {
+      return Result.Invalid("No zeroes please")
+    }
+    if digits: size() isnt 4  {
+      return Result.Invalid("Four digits please")
+    }
+    let digitSet = set[ digit foreach digit in digits ]
+    if digitSet: size() < digits: size() {
+      return Result.Invalid("No duplicate numbers please")
+    }
+  } catch(e) {
+    return Result.Invalid("Numbers only please")
+  }
+  return Result.Valid(digits)
+}
+
+let is4Vector = |arg| -> arg oftype java.util.List.class and arg: size() is 4
+
+@checkArguments(is4Vector, is4Vector)
+function bullsAndOrCows = |guess, secret| {
+  var bulls = 0
+  var cows = 0
+  foreach i in [0..4] {
+    let guessNum = guess: get(i)
+    let secretNum = secret: get(i)
+    if guessNum is secretNum {
+      bulls = bulls + 1
+    } else if secret: exists(|num| -> guessNum is num) {
+      cows = cows + 1
+    }
+  }
+  return [bulls, cows]
+}
+
+augment java.lang.Integer {
+
+  function digits = |this| {
+    var remaining = this
+    let digits = vector[]
+    while remaining > 0 {
+      digits: prepend(remaining % 10)
+      remaining = remaining / 10
+    }
+    return digits
+  }
+}
--- a/Task/Bulls-and-cows/Groovy/bulls-and-cows.groovy
+++ b/Task/Bulls-and-cows/Groovy/bulls-and-cows.groovy
@ -0,0 +1,45 @@
+class BullsAndCows {
+    static void main(args) {
+        def inputReader = System.in.newReader()
+        def numberGenerator = new Random()
+        def targetValue
+        while (targetValueIsInvalid(targetValue = numberGenerator.nextInt(9000) + 1000)) continue
+        def targetStr = targetValue.toString()
+        def guessed = false
+        def guesses = 0
+        while (!guessed) {
+            def bulls = 0, cows = 0
+            print 'Guess a 4-digit number with no duplicate digits: '
+            def guess = inputReader.readLine()
+            if (guess.length() != 4 || !guess.isInteger() || targetValueIsInvalid(guess.toInteger())) {
+                continue
+            }
+            guesses++
+            4.times {
+                if (targetStr[it] == guess[it]) {
+                    bulls++
+                } else if (targetStr.contains(guess[it])) {
+                    cows++
+                }
+            }
+            if (bulls == 4) {
+                guessed = true
+            } else {
+                println "$cows Cows and $bulls Bulls."
+            }
+        }
+        println "You won after $guesses guesses!"
+    }
+
+    static targetValueIsInvalid(value) {
+        def digitList = []
+        while (value > 0) {
+            if (digitList[value % 10] == 0 || digitList[value % 10]) {
+                return true
+            }
+            digitList[value % 10] = true
+            value = value.intdiv(10)
+        }
+        false
+    }
+}
--- a/Task/Bulls-and-cows/Haskell/bulls-and-cows.hs
+++ b/Task/Bulls-and-cows/Haskell/bulls-and-cows.hs
@ -0,0 +1,50 @@
+import Data.List (partition, intersect, nub)
+import Control.Monad
+import System.Random (StdGen, getStdRandom, randomR)
+import Text.Printf
+
+numberOfDigits = 4 :: Int
+
+main = bullsAndCows
+
+bullsAndCows :: IO ()
+bullsAndCows = do
+    digits <- getStdRandom $ pick numberOfDigits ['1' .. '9']
+    putStrLn "Guess away!"
+    loop digits
+
+  where loop digits = do
+            input <- getLine
+            if okay input
+              then
+                  let (bulls, cows) = score digits input in
+                  if bulls == numberOfDigits then
+                      putStrLn "You win!"
+                  else do
+                      printf "%d bulls, %d cows.\n" bulls cows
+                      loop digits
+              else do
+                  putStrLn "Malformed guess; try again."
+                  loop digits
+
+        okay :: String -> Bool
+        okay input =
+            length input == numberOfDigits &&
+            input == nub input &&
+            all legalchar input
+          where legalchar c = '1' <= c && c <= '9'
+
+        score :: String -> String -> (Int, Int)
+        score secret guess = (length bulls, cows)
+          where (bulls, nonbulls) = partition (uncurry (==)) $
+                    zip secret guess
+                cows = length $ uncurry intersect $ unzip nonbulls
+
+pick :: Int -> [a] -> StdGen -> ([a], StdGen)
+{- Randomly selects items from a list without replacement. -}
+pick n l g = f n l g (length l - 1) []
+  where  f 0 _ g _   ps = (ps, g)
+         f n l g max ps =
+             f (n - 1) (left ++ right) g' (max - 1) (picked : ps)
+          where (i, g') = randomR (0, max) g
+                (left, picked : right) = splitAt i l
--- a/Task/Bulls-and-cows/Hy/bulls-and-cows.hy
+++ b/Task/Bulls-and-cows/Hy/bulls-and-cows.hy
@ -0,0 +1,26 @@
+(import random)
+
+(def +size+ 4)
+(def +digits+ "123456789")
+(def +secret+ (random.sample +digits+ +size+))
+
+(while True
+  (while True
+    (setv guess (list (distinct (raw-input "Enter a guess: "))))
+    (when (and
+        (= (len guess) +size+)
+        (all (map (fn [c] (in c +digits+)) guess)))
+      (break))
+    (print "Malformed guess; try again"))
+  (setv bulls 0)
+  (setv cows 0)
+  (for [i (range +size+)] (cond
+    [(= (get guess i) (get +secret+ i)) (setv bulls (inc bulls))]
+    [(in (get guess i) +secret+) (setv cows (inc cows))]))
+  (when (= bulls +size+)
+    (break))
+  (print (.format "{} bull{}, {} cows"
+    bulls (if (= bulls 1) "" "s")
+    cows (if (= cows 1) "" "s"))))
+
+(print "A winner is you!")
--- a/Task/Bulls-and-cows/IS-BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/IS-BASIC/bulls-and-cows.basic
@ -0,0 +1,31 @@
+100 PROGRAM "Bulls.bas"
+110 RANDOMIZE
+120 STRING C$*4
+130 LET GUESS=0
+140 DO
+150   LET C$=STR$(RND(8701)+1199)
+160 LOOP UNTIL CHECK$(C$)=C$
+170 CLEAR SCREEN:PRINT "Welcome to 'Bulls and Cows!'"
+180 DO
+190   DO
+200     PRINT :INPUT PROMPT "Guess a 4-digit number with no duplicate digits: ":G$
+210     IF CHECK$(G$)="" THEN PRINT "You should enter 4-digit number with no duplicate digits."
+220   LOOP UNTIL CHECK$(G$)=G$ AND G$<>""
+230   LET GUESS=GUESS+1:LET BULLS,COWS=0
+240   FOR I=1 TO 4
+250     IF C$(I)=G$(I) THEN
+260       LET BULLS=BULLS+1
+270     ELSE IF POS(C$,G$(I))<>0 THEN
+280       LET COWS=COWS+1
+290     END IF
+300   NEXT
+310   PRINT BULLS;"bulls,";COWS;"cows"
+320 LOOP UNTIL C$=G$
+330 PRINT "You won after";GUESS;"guesses!"
+340 DEF CHECK$(S$)
+350   LET CHECK$=""
+360   IF LEN(STR$(VAL(S$)))=4 AND POS(S$,"0")=0 THEN LET CHECK$=S$
+370   FOR I=1 TO 4
+380     IF POS(S$(:I-1),S$(I)) OR POS(S$(I+1:),S$(I)) THEN LET CHECK$=""
+390   NEXT
+400 END DEF
--- a/Task/Bulls-and-cows/Icon/bulls-and-cows.icon
+++ b/Task/Bulls-and-cows/Icon/bulls-and-cows.icon
@ -0,0 +1,24 @@
+procedure main()
+    digits := "123456789"
+    every !digits :=: ?digits
+    num := digits[1+:4]
+    repeat if score(num, getGuess(num)) then break
+    write("Good job.")
+end
+
+procedure getGuess(num)
+    repeat {
+        writes("Enter a guess: ")
+        guess := read() | stop("Quitter!")
+        if *(guess ** '123456789') == *num then return guess
+        write("Malformed guess: ",guess,". Try again.")
+        }
+end
+
+procedure score(num, guess)
+    bulls := 0
+    cows := *(num ** guess)
+    every (num[i := 1 to *num] == guess[i], bulls +:= 1, cows -:= 1)
+    write("\t",bulls," bulls and ",cows," cows")
+    return (bulls = *num)
+end
--- a/Task/Bulls-and-cows/J/bulls-and-cows-1.j
+++ b/Task/Bulls-and-cows/J/bulls-and-cows-1.j
@ -0,0 +1,24 @@
+require 'misc'
+
+plural=: conjunction define
+ (":m),' ',n,'s'#~1~:m
+)
+
+bullcow=:monad define
+  number=. 1+4?9
+  whilst. -.guess-:number do.
+    guess=. 0 "."0 prompt 'Guess my number: '
+    if. (4~:#guess)+.(4~:#~.guess)+.0 e.guess e.1+i.9 do.
+      if. 0=#guess do.
+        smoutput 'Giving up.'
+        return.
+      end.
+      smoutput 'Guesses must be four different non-zero digits'
+      continue.
+    end.
+    bulls=. +/guess=number
+    cows=. (+/guess e.number)-bulls
+    smoutput bulls plural 'bull',' and ',cows plural 'cow','.'
+  end.
+  smoutput 'you win'
+)
--- a/Task/Bulls-and-cows/J/bulls-and-cows-2.j
+++ b/Task/Bulls-and-cows/J/bulls-and-cows-2.j
@ -0,0 +1,16 @@
+   bullcow''
+Guess my number: 1234
+0 bulls and 1 cow.
+Guess my number: 5678
+3 bulls and 0 cows.
+Guess my number: 2349
+0 bulls and 0 cows.
+Guess my number: 1567
+0 bulls and 3 cows.
+Guess my number: 6178
+3 bulls and 0 cows.
+Guess my number: 6157
+1 bull and 2 cows.
+Guess my number: 5178
+4 bulls and 0 cows.
+you win
--- a/Task/Bulls-and-cows/Java/bulls-and-cows.java
+++ b/Task/Bulls-and-cows/Java/bulls-and-cows.java
@ -0,0 +1,52 @@
+import java.util.InputMismatchException;
+import java.util.Random;
+import java.util.Scanner;
+
+public class BullsAndCows{
+	public static void main(String[] args){
+		Random gen= new Random();
+		int target;
+		while(hasDupes(target= (gen.nextInt(9000) + 1000)));
+		String targetStr = target +"";
+		boolean guessed = false;
+		Scanner input = new Scanner(System.in);
+		int guesses = 0;
+		do{
+			int bulls = 0;
+			int cows = 0;
+			System.out.print("Guess a 4-digit number with no duplicate digits: ");
+			int guess;
+			try{
+				guess = input.nextInt();
+				if(hasDupes(guess) || guess < 1000) continue;
+			}catch(InputMismatchException e){
+				continue;
+			}
+			guesses++;
+			String guessStr = guess + "";
+			for(int i= 0;i < 4;i++){
+				if(guessStr.charAt(i) == targetStr.charAt(i)){
+					bulls++;
+				}else if(targetStr.contains(guessStr.charAt(i)+"")){
+					cows++;
+				}
+			}
+			if(bulls == 4){
+				guessed = true;
+			}else{
+				System.out.println(cows+" Cows and "+bulls+" Bulls.");
+			}
+		}while(!guessed);
+		System.out.println("You won after "+guesses+" guesses!");
+	}
+
+	public static boolean hasDupes(int num){
+		boolean[] digs = new boolean[10];
+		while(num > 0){
+			if(digs[num%10]) return true;
+			digs[num%10] = true;
+			num/= 10;
+		}
+		return false;
+	}
+}
--- a/Task/Bulls-and-cows/JavaScript/bulls-and-cows.js
+++ b/Task/Bulls-and-cows/JavaScript/bulls-and-cows.js
@ -0,0 +1,88 @@
+#!/usr/bin/env js
+
+function main() {
+    var len = 4;
+    playBullsAndCows(len);
+}
+
+function playBullsAndCows(len) {
+    var num = pickNum(len);
+    // print('The secret number is:\n  ' + num.join('\n  '));
+    showInstructions(len);
+    var nGuesses = 0;
+    while (true) {
+        nGuesses++;
+        var guess = getGuess(nGuesses, len);
+        var census = countBovine(num, guess);
+        showScore(census.bulls, census.cows);
+        if (census.bulls == len) {
+            showFinalResult(nGuesses);
+            return;
+        }
+    }
+}
+
+function showScore(nBulls, nCows) {
+    print('    Bulls: ' + nBulls + ', cows: ' + nCows);
+}
+
+function showFinalResult(guesses) {
+    print('You win!!! Guesses needed: ' + guesses);
+}
+
+function countBovine(num, guess) {
+    var count = {bulls:0, cows:0};
+    var g = guess.join('');
+    for (var i = 0; i < num.length; i++) {
+        var digPresent = g.search(num[i]) != -1;
+        if (num[i] == guess[i]) count.bulls++;
+        else if (digPresent) count.cows++;
+    }
+    return count;
+}
+
+function getGuess(nGuesses, len) {
+    while (true) {
+        putstr('Your guess #' + nGuesses + ': ');
+        var guess = readline();
+        guess = String(parseInt(guess)).split('');
+        if (guess.length != len) {
+            print('  You must enter a ' + len + ' digit number.');
+            continue;
+        }
+        if (hasDups(guess)) {
+            print('  No digits can be duplicated.');
+            continue;
+        }
+        return guess;
+    }
+}
+
+function hasDups(ary) {
+    var t = ary.concat().sort();
+    for (var i = 1; i < t.length; i++) {
+        if (t[i] == t[i-1]) return true;
+    }
+    return false;
+}
+
+function showInstructions(len) {
+    print();
+    print('Bulls and Cows Game');
+    print('-------------------');
+    print('  You must guess the ' + len + ' digit number I am thinking of.');
+    print('  The number is composed of the digits 1-9.');
+    print('  No digit appears more than once.');
+    print('  After each of your guesses, I will tell you:');
+    print('    The number of bulls (digits in right place)');
+    print('    The number of cows (correct digits, but in the wrong place)');
+    print();
+}
+
+function pickNum(len) {
+    var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    nums.sort(function(){return Math.random() - 0.5});
+    return nums.slice(0, len);
+}
+
+main();
--- a/Task/Bulls-and-cows/Jq/bulls-and-cows.jq
+++ b/Task/Bulls-and-cows/Jq/bulls-and-cows.jq
@ -0,0 +1,72 @@
+# A PRNG for generating a pseudo-random integer in range(0; .).
+# $array must be a sufficiently large array of pseudo-random integers in range(0;10).
+# $start specifies the position in $array to begin searching.
+# Output: {prn, start) where .prn is a PRN in range(0; .) and .start is the corresponding position in $array.
+def prn($array; $start):
+  def a2n: map(tostring) | join("") | tonumber;
+  if . == 1 then 0
+  else . as $n
+  | (($n-1)|tostring|length) as $w
+  | {$start}
+  | until( $array[.start: .start + $w] | a2n < $n; .start+=1 )
+  | {start, prn: ($raw[.start: .start + $w] | a2n)}
+  end;
+
+# Generate a 4-digit PRN from 1234 to 9876 inclusive, with no zeros or repeated digits.
+# Global variable: $raw (see documentation for $array above)
+def num:
+  def _num($start):
+    (8643|prn($raw; $start)) as $prn
+    | (1234 + $prn.prn)
+    | . as $n
+    | tostring
+    | if (test("0")|not) and ((explode|unique|length) == 4)
+      then $n
+      else _num($prn.start+4)
+    end;
+  _num(0);
+
+def MAX_GUESSES: 20;  # say
+
+def instructions:
+ "All guesses should have exactly 4 distinct digits excluding zero.",
+ "Keep guessing until you guess the chosen number (maximum \(MAX_GUESSES) valid guesses).\n";
+
+def play:
+  num as $num
+  | ($num|tostring|explode) as $numArray
+  | { guesses: 0 }
+  | instructions, "Enter your guess:",
+    (label $out
+     | foreach range(0; infinite) as $i (.;
+         if .bulls == 4 or .guesses == MAX_GUESSES then break $out
+         else .guess = input
+         | if .guess == $num then .emit = "You have won with \(.guesses+1) valid guesses!"
+           else .n = (.guess | try tonumber catch null)
+           | if .n == null               then .emit = "Not a valid number"
+             elif .guess|test("[+-.]")   then .emit = "The guess should not contain a sign or decimal point."
+             elif .guess|test("0")       then .emit = "The guess cannot contain zero."
+             elif .guess|length != 4     then .emit = "The guess must have exactly 4 digits."
+             else .guessArray = (.guess | explode )
+             | if .guessArray | unique | length < 4 then .emit = "All digits must be distinct."
+               else . + {bulls: 0, cows: 0 }
+               | reduce range(0; .guessArray|length) as $i ( .;
+                   if $numArray[$i] == .guessArray[$i]      then .bulls += 1
+                   elif (.guessArray[$i] | IN($numArray[])) then .cows  += 1
+                   else .
+                   end)
+               | .emit = "Your score for this guess:  Bulls = \(.bulls)  Cows = \(.cows)"
+               | .guesses += 1
+               end
+             end
+           end
+         end;
+
+         select(.emit).emit,
+         if .bulls == 4 then "Congratulations!"
+         elif .guesses == MAX_GUESSES
+         then "\nYou have now had \(.guesses) valid guesses, the maximum allowed. Bye!"
+         else "Enter your next guess:"
+         end ) );
+
+play
--- a/Task/Bulls-and-cows/Julia/bulls-and-cows-1.julia
+++ b/Task/Bulls-and-cows/Julia/bulls-and-cows-1.julia
@ -0,0 +1,32 @@
+function cowsbulls()
+	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
+		You get one cow for every right number, but in the wrong position.\n
+		Enter 'n' to pick a new number and 'q' to quit.\n>")
+	function new_number()
+		s = [1:9]
+		n = ""
+		for i = 9:-1:6
+			n *= string(delete!(s,rand(1:i)))
+		end
+		return n
+	end
+	answer = new_number()
+	while true
+		input = chomp(readline(STDIN))
+		input == "q" && break
+		if input == "n"
+			answer = new_number()
+			print("\nI've picked a new number, go ahead and guess\n>")
+			continue
+		end
+		!ismatch(r"^[1-9]{4}$",input) && (print("Invalid guess: Please enter a 4-digit number\n>"); continue)
+		if input == answer
+			print("\nYou're right! Good guessing!\nEnter 'n' for a new number or 'q' to quit\n>")
+		else
+			bulls = sum(answer.data .== input.data)
+			cows = sum([answer[x] != input[x] && contains(input.data,answer[x]) for x = 1:4])
+			print("\nNot quite! Your guess is worth:\n$bulls Bulls\n$cows Cows\nPlease guess again\n\n>")
+		end
+	end
+end
--- a/Task/Bulls-and-cows/Julia/bulls-and-cows-2.julia
+++ b/Task/Bulls-and-cows/Julia/bulls-and-cows-2.julia
@ -0,0 +1,17 @@
+function bullsandcows ()
+    bulls = cows = turns = 0
+    result = (s = [] ; while length(unique(s))<4 push!(s,rand('1':'9')) end; unique(s))
+    println("A game of bulls and cows!")
+    while (bulls != 4)
+      print("Your guess? ")
+      guess = collect(chomp(readline(STDIN)))
+      if ! (length(unique(guess)) == length(guess) == 4 && all(isdigit,guess))
+         println("please, enter four distincts digits")
+         continue
+      end
+      bulls = sum(map(==, guess, result))
+      cows = length(intersect(guess,result)) - bulls
+      println("$bulls bulls and $cows cows!") ; turns += 1
+    end
+    println("You win! You succeeded in $turns guesses.")
+  end
--- a/Task/Bulls-and-cows/Kotlin/bulls-and-cows.kotlin
+++ b/Task/Bulls-and-cows/Kotlin/bulls-and-cows.kotlin
@ -0,0 +1,49 @@
+// version 1.1.2
+
+import java.util.Random
+
+const val MAX_GUESSES = 20  // say
+
+fun main(args: Array<String>) {
+    val r = Random()
+    var num: String
+    // generate a 4 digit random number from 1234 to 9876 with no zeros or repeated digits
+    do {
+        num = (1234 + r.nextInt(8643)).toString()
+    } while ('0' in num || num.toSet().size < 4)
+
+    println("All guesses should have exactly 4 distinct digits excluding zero.")
+    println("Keep guessing until you guess the chosen number (maximum $MAX_GUESSES valid guesses).\n")
+    var guesses = 0
+    while (true) {
+        print("Enter your guess : ")
+        val guess = readLine()!!
+        if (guess == num) {
+            println("You've won with ${++guesses} valid guesses!")
+            return
+        }
+        val n = guess.toIntOrNull()
+        if (n == null)
+            println("Not a valid number")
+        else if ('-' in guess || '+' in guess)
+            println("Can't contain a sign")
+        else if ('0' in guess)
+            println("Can't contain zero")
+        else if (guess.length != 4)
+            println("Must have exactly 4 digits")
+        else if (guess.toSet().size < 4)
+            println("All digits must be distinct")
+        else {
+            var bulls = 0
+            var cows  = 0
+            for ((i, c) in guess.withIndex()) {
+                if (num[i] == c) bulls++
+                else if (c in num) cows++
+            }
+            println("Your score for this guess:  Bulls = $bulls  Cows = $cows")
+            guesses++
+            if (guesses == MAX_GUESSES)
+                println("You've now had $guesses valid guesses, the maximum allowed")
+        }
+    }
+}
--- a/Task/Bulls-and-cows/Lasso/bulls-and-cows.lasso
+++ b/Task/Bulls-and-cows/Lasso/bulls-and-cows.lasso
@ -0,0 +1,70 @@
+[
+define randomizer() => {
+	local(n = string)
+	while(#n->size < 4) => {
+		local(r = integer_random(1,9)->asString)
+		#n !>> #r ? #n->append(#r)
+	}
+	return #n
+}
+define cowbullchecker(n::string,a::string) => {
+	integer(#n) == integer(#a) ? return (:true,map('cows'=0,'bulls'=4,'choice'=#a))
+	local(cowbull = map('cows'=0,'bulls'=0,'choice'=#a),'checked' = array)
+	loop(4) => {
+		if(#checked !>> integer(#a->values->get(loop_count))) => {
+			#checked->insert(integer(#a->values->get(loop_count)))
+			if(integer(#n->values->get(loop_count)) == integer(#a->values->get(loop_count))) => {
+				#cowbull->find('bulls') += 1
+			else(#n->values >> #a->values->get(loop_count))
+				#cowbull->find('cows') += 1
+			}
+		}
+	}
+	#cowbull->find('bulls') == 4 ? return (:true,map('cows'=0,'bulls'=4,'choice'=#a))
+	return (:true,#cowbull)
+}
+session_start('user')
+session_addvar('user', 'num')
+session_addvar('user', 'historic_choices')
+// set up rand
+var(num)->isNotA(::string) ? var(num = randomizer)
+var(historic_choices)->isNotA(::array) ? var(historic_choices = array)
+local(success = false)
+// check answer
+if(web_request->param('a')->asString->size) => {
+	local(success,result) = cowbullchecker($num,web_request->param('a')->asString)
+	$historic_choices->insert(#result)
+}
+if(web_request->params->asStaticArray >> 'restart') => {
+	$num = randomizer
+	$historic_choices = array
+}
+]
+<h1>Bulls and Cows</h1>
+<p>Guess the 4-digit number...</p>
+<p>Your win if the guess is the same as the randomly chosen number.<br>
+- A score of one bull is accumulated for each digit in your guess that equals the corresponding digit in the randomly chosen initial number.<br>
+- A score of one cow is accumulated for each digit in your guess that also appears in the randomly chosen number, but in the wrong position.
+</p>
+[
+local(win = false)
+if($historic_choices->size) => {
+	with c in $historic_choices do => {^
+		'<p>'+#c->find('choice')+': Bulls: '+#c->find('bulls')+', Cows: '+#c->find('cows')
+		if(#c->find('bulls') == 4) => {^
+			' - YOU WIN!'
+			#win = true
+		^}
+		'</p>'
+	^}
+}
+if(not #win) => {^
+]
+<form action="?" method="post">
+	<input name="a" value="[web_request->param('a')->asString]" size="5">
+	<input type="submit" name="guess">
+	<a href="?restart">Restart</a>
+</form>
+[else
+	'<a href="?restart">Restart</a>'
+^}]
--- a/Task/Bulls-and-cows/Liberty-BASIC/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/Liberty-BASIC/bulls-and-cows.basic
@ -0,0 +1,61 @@
+    do while len( secret$) <4
+        c$ =chr$( int( rnd( 1) *9) +49)
+        if not( instr( secret$, c$)) then secret$ =secret$ +c$
+    loop
+
+    print " Secret number has been guessed....                                                                                 "; secret$
+
+    guesses  =   0
+
+[loop]
+    print " Your guess ";
+    input " "; guess$
+
+    guesses  = guesses +1
+
+    r$       =score$( guess$, secret$)
+
+    bulls    =val( word$( r$, 1, ","))
+    cows     =val( word$( r$, 2, ","))
+
+    print "   Result: "; bulls; " bulls, and "; cows; " cows"
+    print
+
+    if guess$ =secret$ then
+        print "  You won after "; guesses; " guesses!"
+        print "  You guessed it in "; guesses
+        print "  Thanks for playing!"
+        wait
+    end if
+
+    goto [loop]
+
+end '   _____________________________________________________________
+
+function check( i$) '   check =0 if no digit repeats, else =1
+    check =0
+    for i =1 to 3
+        for j =i +1 to 4
+            if mid$( i$, i, 1) =mid$( i$, j, 1) then check =1
+        next j
+    next i
+end function
+
+function score$( a$, b$)    '   return as a csv string the number of bulls & cows.
+    bulls    = 0:  cows     = 0
+    for i = 1 to 4
+        c$ = mid$( a$, i, 1)
+        if mid$( b$, i, 1) = c$ then
+            bulls = bulls + 1
+        else
+            if instr( b$, c$) <>0 and instr( b$, c$) <>i then
+                cows = cows + 1
+            end if
+        end if
+    next i
+    score$ =str$( bulls); ","; str$( cows)
+end function
+
+[quit]
+close #w
+end
--- a/Task/Bulls-and-cows/Logo/bulls-and-cows.logo
+++ b/Task/Bulls-and-cows/Logo/bulls-and-cows.logo
@ -0,0 +1,19 @@
+to ok? :n
+  output (and [number? :n] [4 = count :n] [4 = count remdup :n] [not member? 0 :n])
+end
+
+to init
+  do.until [make "hidden random 10000] [ok? :hidden]
+end
+
+to guess :n
+  if not ok? :n [print [Bad guess! (4 unique digits, 1-9)]  stop]
+  localmake "bulls 0
+  localmake "cows  0
+  foreach :n [cond [
+    [[? = item # :hidden] make "bulls 1 + :bulls]
+    [[member?  ? :hidden] make "cows  1 + :cows ]
+  ]]
+  (print :bulls "bulls, :cows "cows)
+  if :bulls = 4 [print [You guessed it!]]
+end
--- a/Task/Bulls-and-cows/Lua/bulls-and-cows-1.lua
+++ b/Task/Bulls-and-cows/Lua/bulls-and-cows-1.lua
@ -0,0 +1,101 @@
+function ShuffleArray(array)
+   for i=1,#array-1 do
+      local t = math.random(i, #array)
+      array[i], array[t] = array[t], array[i]
+   end
+end
+
+function GenerateNumber()
+   local digits = {1,2,3,4,5,6,7,8,9}
+
+   ShuffleArray(digits)
+
+   return digits[1] * 1000 +
+          digits[2] *  100 +
+          digits[3] *   10 +
+          digits[4]
+end
+
+function IsMalformed(input)
+   local malformed = false
+
+   if #input == 4 then
+      local already_used = {}
+      for i=1,4 do
+         local digit = input:byte(i) - string.byte('0')
+         if digit < 1 or digit > 9 or already_used[digit] then
+            malformed = true
+            break
+         end
+         already_used[digit] = true
+      end
+   else
+      malformed = true
+   end
+
+   return malformed
+end
+
+math.randomseed(os.time())
+math.randomseed(math.random(2^31-1)) -- since os.time() only returns seconds
+
+print("\nWelcome to Bulls and Cows!")
+print("")
+print("The object of this game is to guess the random 4-digit number that the")
+print("computer has chosen. The number is generated using only the digits 1-9,")
+print("with no repeated digits. Each time you enter a guess, you will score one")
+print("\"bull\" for each digit in your guess that matches the corresponding digit")
+print("in the computer-generated number, and you will score one \"cow\" for each")
+print("digit in your guess that appears in the computer-generated number, but is")
+print("in the wrong position. Use this information to refine your guesses. When")
+print("you guess the correct number, you win.");
+print("")
+
+quit = false
+
+repeat
+   magic_number = GenerateNumber()
+   magic_string = tostring(magic_number) -- Easier to do scoring with a string
+   repeat
+      io.write("\nEnter your guess (or 'Q' to quit): ")
+      user_input = io.read()
+      if user_input == 'Q' or user_input == 'q' then
+         quit = true
+         break
+      end
+
+      if not IsMalformed(user_input) then
+         if user_input == magic_string then
+            print("YOU WIN!!!")
+         else
+            local bulls, cows = 0, 0
+            for i=1,#user_input do
+               local find_result = magic_string:find(user_input:sub(i,i))
+
+               if find_result and find_result == i then
+                  bulls = bulls + 1
+               elseif find_result then
+                  cows = cows + 1
+               end
+            end
+            print(string.format("You scored %d bulls, %d cows", bulls, cows))
+         end
+      else
+         print("Malformed input. You must enter a 4-digit number with")
+         print("no repeated digits, using only the digits 1-9.")
+      end
+
+   until user_input == magic_string
+
+   if not quit then
+      io.write("\nPress <Enter> to play again or 'Q' to quit: ")
+      user_input = io.read()
+      if user_input == 'Q' or user_input == 'q' then
+         quit = true
+      end
+   end
+
+   if quit then
+      print("\nGoodbye!")
+   end
+until quit
--- a/Task/Bulls-and-cows/Lua/bulls-and-cows-2.lua
+++ b/Task/Bulls-and-cows/Lua/bulls-and-cows-2.lua
@ -0,0 +1,63 @@
+function createNewNumber ()
+	math.randomseed(os.time())
+	local numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9}
+	local tNumb = {} -- list of numbers
+	for i = 1, 4 do
+		table.insert(tNumb, math.random(#tNumb+1), table.remove(numbers, math.random(#numbers)))
+	end
+	return tNumb
+end
+
+TNumber = createNewNumber ()
+print ('(right number: ' .. table.concat (TNumber) .. ')')
+
+function isValueInList (value, list)
+	for i, v in ipairs (list) do
+		if v == value then return true end
+	end
+	return false
+end
+
+local nGuesses = 0
+
+while not GameOver do
+	nGuesses = nGuesses + 1
+	print("Enter your guess (or 'q' to quit): ")
+	local input
+	while not input do
+		input = io.read()
+	end
+	if input == "q" then
+		GameOver = true
+		return
+	end
+	local tInput = {}
+	for i=1, string.len(input) do
+		local number = tonumber(string.sub(input,i,i))
+		if number and not isValueInList (number, tInput) then
+			table.insert (tInput, number)
+		end
+	end
+	local malformed = false
+	if not (string.len(input) == 4) or not (#tInput == 4) then
+		print (nGuesses, 'bad input: too short or too long')
+		malformed = true
+	end
+	
+	if not malformed then
+		print (nGuesses, 'parsed input:', table.concat(tInput, ', '))
+		local nBulls, nCows = 0, 0
+		for i, number in ipairs (tInput) do
+			if TNumber[i] == number then
+				nBulls = nBulls + 1
+			elseif isValueInList (number, TNumber) then
+				nCows = nCows + 1
+			end
+		end
+		print (nGuesses, 'Bulls: '.. nBulls .. ' Cows: ' .. nCows)
+		if nBulls == 4 then
+			print (nGuesses, 'Win!')
+			GameOver = true
+		end
+	end
+end
--- a/Task/Bulls-and-cows/M2000-Interpreter/bulls-and-cows.m2000
+++ b/Task/Bulls-and-cows/M2000-Interpreter/bulls-and-cows.m2000
@ -0,0 +1,48 @@
+Module Game {
+      Malformed=lambda (a$)->{
+            =true
+            if len(a$)<>4 then exit
+            n=0 : dummy=val(a$,"int",n)
+            if n<>5 or dummy=0 then exit
+            for i=1 to 9
+                  if len(filter$(a$,str$(i,0)))<3 then break
+            next i
+            =false
+      }
+      BullsAndCows$=lambda$ (a$, b$, &ok) ->{
+            Def b, c
+            for i=1 to 4
+            if mid$(a$,i,1)=mid$(b$,i,1) then
+                  b++
+            else.if instr(b$,mid$(a$,i,1))>0 then
+                  c++
+            end if
+            next i
+            ok=b=4
+            =format$("bulls {0}, cows {1}", b, c)
+      }
+      Random$=lambda$ ->{
+            def repl$, bank$, c$
+            bank$="123456789"
+            for i=1 to 4
+                  c$=mid$(bank$,random(1,len(bank$)),1)
+                  bank$=filter$(bank$, c$)
+                  repl$+=c$
+            next i
+            =repl$
+      }
+      target$=Random$()
+      def boolean win=false, a$
+      do
+            do
+                  Input "Next guess ";a%
+                  a$=str$(a%,0)
+                  if Malformed(a$) then Print "Malformed input, try again" else exit
+            always
+            Print BullsAndCows$(a$, target$, &win)
+            if win then exit
+            Print "Bad guess! (4 unique digits, 1-9)"
+      always
+      Print "You guess it"
+}
+Game
--- a/Task/Bulls-and-cows/MATLAB/bulls-and-cows.m
+++ b/Task/Bulls-and-cows/MATLAB/bulls-and-cows.m
@ -0,0 +1,62 @@
+function BullsAndCows
+% Plays the game Bulls and Cows as the "game master"
+
+    % Create a secret number
+    nDigits = 4;
+    lowVal = 1;
+    highVal = 9;
+    digitList = lowVal:highVal;
+    secret = zeros(1, 4);
+    for k = 1:nDigits
+        idx = randi(length(digitList));
+        secret(k) = digitList(idx);
+        digitList(idx) = [];
+    end
+
+    % Give game information
+    fprintf('Welcome to Bulls and Cows!\n')
+    fprintf('Try to guess the %d-digit number (no repeated digits).\n', nDigits)
+    fprintf('Digits are between %d and %d (inclusive).\n', lowVal, highVal)
+    fprintf('Score: 1 Bull per correct digit in correct place.\n')
+    fprintf('       1 Cow per correct digit in incorrect place.\n')
+    fprintf('The number has been chosen. Now it''s your moooooove!\n')
+    gs = input('Guess: ', 's');
+
+    % Loop until user guesses right or quits (no guess)
+    nGuesses = 1;
+    while gs
+        gn = str2double(gs);
+        if isnan(gn) || length(gn) > 1  % Not a scalar
+            fprintf('Malformed guess. Keep to valid scalars.\n')
+            gs = input('Try again: ', 's');
+        else
+            g = sprintf('%d', gn) - '0';
+            if length(g) ~= nDigits || any(g < lowVal) || any(g > highVal) || ...
+                    length(unique(g)) ~= nDigits    % Invalid number for game
+                fprintf('Malformed guess. Remember:\n')
+                fprintf('  %d digits\n', nDigits)
+                fprintf('  Between %d and %d inclusive\n', lowVal, highVal)
+                fprintf('  No repeated digits\n')
+                gs = input('Try again: ', 's');
+            else
+                score = CountBullsCows(g, secret);
+                if score(1) == nDigits
+                    fprintf('You win! Bully for you! Only %d guesses.\n', nGuesses)
+                    gs = '';
+                else
+                    fprintf('Score: %d Bulls, %d Cows\n', score)
+                    gs = input('Guess: ', 's');
+                end
+            end
+        end
+        nGuesses = nGuesses+1;  % Counts malformed guesses
+    end
+end
+
+function score = CountBullsCows(guess, correct)
+% Checks the guessed array of digits against the correct array to find the score
+% Assumes arrays of same length and valid numbers
+    bulls = guess == correct;
+    cows = ismember(guess(~bulls), correct);
+    score = [sum(bulls) sum(cows)];
+end
--- a/Task/Bulls-and-cows/MAXScript/bulls-and-cows-1.max
+++ b/Task/Bulls-and-cows/MAXScript/bulls-and-cows-1.max
@ -0,0 +1,69 @@
+numCount = 4 -- number of digits to use
+
+digits = #(1, 2, 3, 4, 5, 6, 7, 8, 9)
+num = ""
+while num.count < numCount and digits.count > 0 do
+(
+	local r = random 1 digits.count
+	append num (digits[r] as string)
+	deleteitem digits r
+)
+digits = undefined
+numGuesses = 0
+inf = "Rules: \n1. Choose only % unique digits in any combination"+\
+		" (0 can't be used).\n2. Only positive integers are allowed."+\
+		"\n3. For each digit that is in it's place, you get a bull,\n"+\
+		"\tand for each digit that is not in it's place, you get a cow."+\
+		"\n4. The game is won when your number matches the number I chose."+\
+		"\n\nPress [esc] to quit the game.\n\n"
+clearlistener()
+format inf num.count
+while not keyboard.escpressed do
+(
+	local userVal = getkbvalue prompt:"\nEnter your number: "
+	if (userVal as string) == num do
+	(
+		format "\nCorrect! The number is %. It took you % moves.\n" num numGuesses
+		exit with OK
+	)
+	local bulls = 0
+	local cows = 0
+	local badInput = false
+	case of
+	(
+		(classof userVal != integer):
+			(
+			format "\nThe number must be a positive integer.\n"
+			badInput = true
+			)
+		((userVal as string).count != num.count):
+			(
+			format "\nThe number must have % digits.\n" num.count
+			badInput = true
+			)
+		((makeuniquearray (for i in 1 to (userVal as string).count \
+			collect (userVal as string)[i])).count != (userVal as string).count):
+			(
+				format "\nThe number can only have unique digits.\n"
+				badInput = true
+			)
+	)
+	if not badInput do
+	(
+		userVal = userVal as string
+		i = 1
+		while i <= userVal.count do
+		(
+			for j = 1 to num.count do
+			(
+				if userVal[i] == num[j] do
+				(
+					if i == j then bulls += 1 else cows += 1
+				)
+			)
+			i += 1
+		)
+		numGuesses += 1
+		format "\nBulls: % Cows: %\n" bulls cows
+	)
+)
--- a/Task/Bulls-and-cows/MAXScript/bulls-and-cows-2.max
+++ b/Task/Bulls-and-cows/MAXScript/bulls-and-cows-2.max
@ -0,0 +1,20 @@
+OK
+Rules:
+1. Choose only 4 unique digits in any combination (0 can't be used).
+2. Only positive integers are allowed.
+3. For each digit that is in it's place, you get a bull,
+	and for each digit that is not in it's place, you get a cow.
+4. The game is won when your number matches the number I chose.
+
+Press [esc] to quit the game.
+
+OK
+
+Enter your number:  2468
+Bulls: 0 Cows: 2
+
+Enter your number:  2448
+The number can only have unique digits.
+
+Enter your number:  1357
+Bulls: 0 Cows: 1
--- a/Task/Bulls-and-cows/MUMPS/bulls-and-cows.mumps
+++ b/Task/Bulls-and-cows/MUMPS/bulls-and-cows.mumps
@ -0,0 +1,65 @@
+BullCow	New bull,cow,guess,guessed,ii,number,pos,x
+	Set number="",x=1234567890
+	For ii=1:1:4 Do
+	. Set pos=$Random($Length(x))+1
+	. Set number=number_$Extract(x,pos)
+	. Set $Extract(x,pos)=""
+	. Quit
+	Write !,"The computer has selected a number that consists"
+	Write !,"of four different digits."
+	Write !!,"As you are guessing the number, ""bulls"" and ""cows"""
+	Write !,"will be awarded: a ""bull"" for each digit that is"
+	Write !,"placed in the correct position, and a ""cow"" for each"
+	Write !,"digit that occurs in the number, but in a different place.",!
+	Write !,"For a guess, enter 4 digits."
+	Write !,"Any other input is interpreted as ""I give up"".",!
+	Set guessed=0 For  Do  Quit:guessed
+	. Write !,"Your guess: " Read guess If guess'?4n Set guessed=-1 Quit
+	. Set (bull,cow)=0,x=guess
+	. For ii=4:-1:1 If $Extract(x,ii)=$Extract(number,ii) Do
+	. . Set bull=bull+1,$Extract(x,ii)=""
+	. . Quit
+	. For ii=1:1:$Length(x) Set:number[$Extract(x,ii) cow=cow+1
+	. Write !,"You guessed ",guess,". That earns you "
+	. If 'bull,'cow Write "neither bulls nor cows..." Quit
+	. If bull Write bull," bull" Write:bull>1 "s"
+	. If cow Write:bull " and " Write cow," cow" Write:cow>1 "s"
+	. Write "."
+	. If bull=4 Set guessed=1 Write !,"That's a perfect score."
+	. Quit
+	If guessed<0 Write !!,"The number was ",number,".",!
+	Quit
+Do BullCow
+
+The computer has selected a number that consists
+of four different digits.
+
+As you are guessing the number, "bulls" and "cows"
+will be awarded: a "bull" for each digit that is
+placed in the correct position, and a "cow" for each
+digit that occurs in the number, but in a different place.
+
+For a guess, enter 4 digits.
+Any other input is interpreted as "I give up".
+
+Your guess: 1234
+You guessed 1234. That earns you 1 cow.
+Your guess: 5678
+You guessed 5678. That earns you 1 cow.
+Your guess: 9815
+You guessed 9815. That earns you 1 cow.
+Your guess: 9824
+You guessed 9824. That earns you 2 cows.
+Your guess: 9037
+You guessed 9037. That earns you 1 bull and 2 cows.
+Your guess: 9048
+You guessed 2789. That earns you 1 bull and 2 cows.
+Your guess: 2079
+You guessed 2079. That earns you 1 bull and 3 cows.
+Your guess: 2709
+You guessed 2709. That earns you 2 bulls and 2 cows.
+Your guess: 0729
+You guessed 0729. That earns you 4 cows.
+Your guess: 2907
+You guessed 2907. That earns you 4 bulls.
+That's a perfect score.
--- a/Task/Bulls-and-cows/Maple/bulls-and-cows.maple
+++ b/Task/Bulls-and-cows/Maple/bulls-and-cows.maple
@ -0,0 +1,55 @@
+BC := proc(n) #where n is the number of turns the user wishes to play before they quit
+	local target, win, numGuesses, guess, bulls, cows, i, err;
+    	target := [0, 0, 0, 0]:
+    	randomize(); #This is a command that makes sure that the numbers are truly randomized each time, otherwise your first time will always give the same result.
+	while member(0, target) or numelems({op(target)}) < 4 do #loop continues to generate random numbers until you get one with no repeating digits or 0s
+		target := [seq(parse(i), i in convert(rand(1234..9876)(), string))]: #a list of random numbers
+	end do:
+
+	win := false:
+	numGuesses := 0:
+	while win = false and numGuesses < n do #loop allows the user to play until they win or until a set amount of turns have passed
+		err := true;
+		while err do #loop asks for values until user enters a valid number
+			printf("Please enter a 4 digit integer with no repeating digits\n");
+			try#catches any errors in user input
+				guess := [seq(parse(i), i in readline())];
+				if hastype(guess, 'Not(numeric)', 'exclude_container') then
+					printf("Postive integers only! Please guess again.\n\n");
+				elif numelems(guess) <> 4 then
+					printf("4 digit numbers only! Please guess again.\n\n");
+				elif numelems({op(guess)}) < 4 then
+					printf("No repeating digits! Please guess again.\n\n");
+				elif member(0, guess) then
+					printf("No 0s! Please guess again.\n\n");
+				else
+					err := false;
+				end if;
+			catch:
+				printf("Invalid input. Please guess again.\n\n");
+			end try;
+		end do:
+		numGuesses := numGuesses + 1;
+		printf("Guess %a: %a\n", numGuesses, guess);
+		bulls := 0;
+		cows := 0;
+		for i to 4 do #loop checks for bulls and cows in the user's guess
+			if target[i] = guess[i] then
+				bulls := bulls + 1;
+			elif member(target[i], guess) then
+				cows := cows + 1;
+			end if;
+		end do;
+		if bulls = 4 then
+			win := true;
+			printf("The number was %a.\n", target);
+			printf(StringTools[FormatMessage]("You won with %1 %{1|guesses|guess|guesses}.", numGuesses));
+		else
+			printf(StringTools[FormatMessage]("%1 %{1|Cows|Cow|Cows}, %2 %{2|Bulls|Bull|Bulls}.\n\n", cows, bulls));
+		end if;
+	end do:
+	if win = false and numGuesses >= n then
+        printf("You lost! The number was %a.\n", target);
+     end if;
+	return NULL;
+end proc:
--- a/Task/Bulls-and-cows/Mathematica/bulls-and-cows.math
+++ b/Task/Bulls-and-cows/Mathematica/bulls-and-cows.math
@ -0,0 +1,12 @@
+digits=Last@FixedPointList[If[Length@Union@#==4,#,Table[Random[Integer,{1,9}],{4}]]&,{}]
+codes=ToCharacterCode[StringJoin[ToString/@digits]];
+Module[{r,bulls,cows},
+	While[True,
+	r=InputString[];
+	If[r===$Canceled,Break[],
+		With[{userCodes=ToCharacterCode@r},
+		If[userCodes===codes,Print[r<>": You got it!"];Break[],
+			If[Length@userCodes==Length@codes,
+				bulls=Count[userCodes-codes,0];cows=Length@Intersection[codes,userCodes]-bulls;
+				Print[r<>": "<>ToString[bulls]<>"bull(s), "<>ToString@cows<>"cow(s)."],
+				Print["Guess four digits."]]]]]]]
--- a/Task/Bulls-and-cows/MiniScript/bulls-and-cows.mini
+++ b/Task/Bulls-and-cows/MiniScript/bulls-and-cows.mini
@ -0,0 +1,26 @@
+secret = range(1,9)
+secret.shuffle
+secret = secret[:4].join("")
+
+while true
+    guess = input("Your guess? ").split("")
+    if guess.len != 4 then
+        print "Please enter 4 numbers, with no spaces."
+        continue
+    end if
+    bulls = 0
+    cows = 0
+    for i in guess.indexes
+        if secret[i] == guess[i] then
+            bulls = bulls + 1
+        else if secret.indexOf(guess[i]) != null then
+            cows = cows + 1
+        end if
+    end for
+    if bulls == 4 then
+        print "You got it!  Great job!"
+        break
+    end if
+    print "You score " + bulls + " bull" + "s"*(bulls!=1) +
+    " and " + cows + " cow" + "s"*(cows!=1) + "."
+end while
--- a/Task/Bulls-and-cows/Nanoquery/bulls-and-cows.nanoquery
+++ b/Task/Bulls-and-cows/Nanoquery/bulls-and-cows.nanoquery
@ -0,0 +1,66 @@
+import Nanoquery.Util; random = new(Random)
+
+// a function to verify the user's input
+def verify_digits(input)
+	global size
+	seen = ""
+
+	if len(input) != size
+		return false
+	else
+		for char in input
+			if not char in "0123456789"
+				return false
+			else if char in seen
+				return false
+			end
+
+			seen += char
+		end
+	end
+
+	return true
+end
+
+size = 4
+chosen = ""
+while len(chosen) < size
+	digit = random.getInt(8) + 1
+
+	if not str(digit) in chosen
+		chosen += str(digit)
+	end
+end
+
+println "I have chosen a number from 4 unique digits from 1 to 9 arranged in a random order."
+println "You need to input a 4 digit, unique digit number as a guess at what I have chosen."
+
+guesses = 1
+won = false
+while !won
+	print "\nNext guess [" + str(guesses) + "]: "
+	guess = input()
+
+	if !verify_digits(guess)
+		println "Problem, try again. You need to enter 4 unique digits from 1 to 9"
+	else
+		if guess = chosen
+			won = true
+		else
+			bulls = 0
+			cows = 0
+			for i in range(0, size - 1)
+				if guess[i] = chosen[i]
+					bulls += 1
+				else if guess[i] in chosen
+					cows += 1
+				end
+			end
+
+			println format("  %d Bulls\n  %d Cows", bulls, cows)
+			guesses += 1
+		end
+	end
+end
+
+println "\nCongratulations you guess correctly in " + guesses + " attempts"
--- a/Task/Bulls-and-cows/Nim/bulls-and-cows.nim
+++ b/Task/Bulls-and-cows/Nim/bulls-and-cows.nim
@ -0,0 +1,40 @@
+import random, strutils, strformat, sequtils
+randomize()
+
+const
+  Digits = "123456789"
+  DigitSet = {Digits[0]..Digits[^1]}
+  Size = 4
+
+proc sample(s: string; n: Positive): string =
+  ## Return a random sample of "n" characters extracted from string "s".
+  var s = s
+  s.shuffle()
+  result = s[0..<n]
+
+proc plural(n: int): string =
+  if n > 1: "s" else: ""
+
+let chosen = Digits.sample(Size)
+
+echo &"I have chosen a number from {Size} unique digits from 1 to 9 arranged in a random order."
+echo &"You need to input a {Size} digit, unique digit number as a guess at what I have chosen."
+
+var guesses = 0
+while true:
+  inc guesses
+  var guess = ""
+  while true:
+    stdout.write(&"\nNext guess {guesses}: ")
+    guess = stdin.readLine().strip()
+    if guess.len == Size and allCharsInSet(guess, DigitSet) and guess.deduplicate.len == Size:
+      break
+    echo &"Problem, try again. You need to enter {Size} unique digits from 1 to 9."
+  if guess == chosen:
+    echo &"\nCongratulations! You guessed correctly in {guesses} attempts."
+    break
+  var bulls, cows = 0
+  for i in 0..<Size:
+    if guess[i] == chosen[i]: inc bulls
+    elif guess[i] in chosen: inc cows
+  echo &"  {bulls} Bull{plural(bulls)}\n  {cows} Cow{plural(cows)}"
--- a/Task/Bulls-and-cows/OCaml/bulls-and-cows.ocaml
+++ b/Task/Bulls-and-cows/OCaml/bulls-and-cows.ocaml
@ -0,0 +1,50 @@
+let rec input () =
+  let s = read_line () in
+  try
+    if String.length s <> 4 then raise Exit;
+    String.iter (function
+      | '1'..'9' -> ()
+      | _ -> raise Exit
+    ) s;
+    let t = [ s.[0]; s.[1]; s.[2]; s.[3] ] in
+    let _ = List.fold_left  (* reject entry with duplication *)
+              (fun ac b -> if List.mem b ac then raise Exit; (b::ac))
+              [] t in
+    List.map (fun c -> int_of_string (String.make 1 c)) t
+  with Exit ->
+    prerr_endline "That is an invalid entry. Please try again.";
+    input ()
+;;
+
+let print_score g t =
+  let bull = ref 0 in
+  List.iter2 (fun x y ->
+    if x = y then incr bull
+  ) g t;
+  let cow = ref 0 in
+  List.iter (fun x ->
+    if List.mem x t then incr cow
+  ) g;
+  cow := !cow - !bull;
+  Printf.printf "%d bulls, %d cows\n%!" !bull !cow
+;;
+
+let () =
+  Random.self_init ();
+  let rec mkgoal acc = function 4 -> acc
+  | i ->
+      let n = succ(Random.int 9) in
+      if List.mem n acc
+      then mkgoal acc i
+      else mkgoal (n::acc) (succ i)
+  in
+  let g = mkgoal [] 0 in
+  let found = ref false in
+  while not !found do
+    let t = input () in
+    if t = g
+    then found := true
+    else print_score g t
+  done;
+  print_endline "Congratulations you guessed correctly";
+;;
--- a/Task/Bulls-and-cows/Oforth/bulls-and-cows.fth
+++ b/Task/Bulls-and-cows/Oforth/bulls-and-cows.fth
@ -0,0 +1,18 @@
+: bullsAndCows
+| numbers guess digits bulls cows |
+
+   ListBuffer new ->numbers
+   while(numbers size 4 <>) [ 9 rand dup numbers include ifFalse: [ numbers add ] else: [ drop ] ]
+
+   while(true) [
+      "Enter a number of 4 different digits between 1 and 9 : " print
+      System.Console askln ->digits
+      digits asInteger isNull digits size 4 <> or ifTrue: [ "Number of four digits needed" println continue ]
+      digits map(#asDigit) ->guess
+
+      guess numbers zipWith(#==) occurrences(true) ->bulls
+      bulls 4 == ifTrue: [ "You won !" println return ]
+
+      guess filter(#[numbers include]) size bulls - ->cows
+      System.Out "Bulls = " << bulls << ", cows = " << cows << cr
+      ] ;
--- a/Task/Bulls-and-cows/Oz/bulls-and-cows.oz
+++ b/Task/Bulls-and-cows/Oz/bulls-and-cows.oz
@ -0,0 +1,69 @@
+declare
+  proc {Main}
+     Solution = {PickNUnique 4 {List.number 1 9 1}}
+
+     proc {Loop}
+        Guess = {EnterGuess}
+     in
+        {System.showInfo
+         {Bulls Guess Solution}#" bulls and "#
+         {Cows Guess Solution}#" cows"}
+        if Guess \= Solution then {Loop} end
+     end
+  in
+     {Loop}
+     {System.showInfo "You have won!"}
+  end
+
+  fun {Bulls Xs Sol}
+     {Length {Filter {List.zip Xs Sol Value.'=='} Id}}
+  end
+
+  fun {Cows Xs Sol}
+     {Length {Intersection Xs Sol}}
+  end
+
+  local
+     class TextFile from Open.file Open.text end
+     StdIn = {New TextFile init(name:stdin)}
+  in
+     fun {EnterGuess}
+        try
+           {System.printInfo "Enter your guess (e.g. \"1234\"): "}
+           S = {StdIn getS($)}
+        in
+           %% verify
+           {Length S} = 4
+           {All S Char.isDigit} = true
+           {FD.distinct S} %% assert there is no duplicate digit
+           %% convert from digits to numbers
+           {Map S fun {$ D} D-&0 end}
+        catch _ then
+           {EnterGuess}
+        end
+     end
+  end
+
+  fun {PickNUnique N Xs}
+     {FoldL {MakeList N}
+      fun {$ Z _}
+         {Pick {Diff Xs Z}}|Z
+      end
+      nil}
+  end
+
+  fun {Pick Xs}
+     {Nth Xs {OS.rand} mod {Length Xs} + 1}
+  end
+
+  fun {Diff Xs Ys}
+     {FoldL Ys List.subtract Xs}
+  end
+
+  fun {Intersection Xs Ys}
+     {Filter Xs fun {$ X} {Member X Ys} end}
+  end
+
+  fun {Id X} X end
+in
+  {Main}
--- a/Task/Bulls-and-cows/PARI-GP/bulls-and-cows.parigp
+++ b/Task/Bulls-and-cows/PARI-GP/bulls-and-cows.parigp
@ -0,0 +1,11 @@
+bc()={
+  my(u,v,bulls,cows);
+  while(#vecsort(v=vector(4,i,random(9)+1),,8)<4,);
+  while(bulls<4,
+    u=input();
+    if(type(u)!="t_VEC"|#u!=4,next);
+    bulls=sum(i=1,4,u[i]==v[i]);
+    cows=sum(i=1,4,sum(j=1,4,i!=j&v[i]==u[j]));
+    print("You have "bulls" bulls and "cows" cows")
+  )
+};
--- a/Task/Bulls-and-cows/PHP/bulls-and-cows.php
+++ b/Task/Bulls-and-cows/PHP/bulls-and-cows.php
@ -0,0 +1,40 @@
+<?php
+$size = 4;
+
+$chosen = implode(array_rand(array_flip(range(1,9)), $size));
+
+echo "I've chosen a number from $size unique digits from 1 to 9; you need
+to input $size unique digits to guess my number\n";
+
+for ($guesses = 1; ; $guesses++) {
+    while (true) {
+        echo "\nNext guess [$guesses]: ";
+        $guess = rtrim(fgets(STDIN));
+        if (!checkguess($guess))
+            echo "$size digits, no repetition, no 0... retry\n";
+        else
+            break;
+    }
+    if ($guess == $chosen) {
+        echo "You did it in $guesses attempts!\n";
+        break;
+    } else {
+        $bulls = 0;
+        $cows = 0;
+        foreach (range(0, $size-1) as $i) {
+            if ($guess[$i] == $chosen[$i])
+                $bulls++;
+            else if (strpos($chosen, $guess[$i]) !== FALSE)
+                $cows++;
+        }
+        echo "$cows cows, $bulls bulls\n";
+    }
+}
+
+function checkguess($g)
+{
+  global $size;
+  return count(array_unique(str_split($g))) == $size &&
+    preg_match("/^[1-9]{{$size}}$/", $g);
+}
+?>
--- a/Task/Bulls-and-cows/Pascal/bulls-and-cows.pas
+++ b/Task/Bulls-and-cows/Pascal/bulls-and-cows.pas
@ -0,0 +1,188 @@
+Program BullCow;
+
+{$mode objFPC}
+
+uses Math, SysUtils;
+
+type
+   TFourDigit = array[1..4] of integer;
+
+Procedure WriteFourDigit(fd: TFourDigit);
+{ Write out a TFourDigit with no line break following. }
+var
+   i: integer;
+begin
+   for i := 1 to 4 do
+   begin
+      Write(fd[i]);
+   end;
+end;
+
+Function WellFormed(Tentative: TFourDigit): Boolean;
+{ Does the TFourDigit avoid repeating digits? }
+var
+   current, check: integer;
+begin
+
+   Result := True;
+
+   for current := 1 to 4 do
+   begin
+      for check := current + 1 to 4 do
+      begin
+         if Tentative[check] = Tentative[current] then
+         begin
+            Result := False;
+         end;
+      end;
+   end;
+
+end;
+
+Function MakeNumber(): TFourDigit;
+{ Make a random TFourDigit, keeping trying until it is well-formed. }
+var
+   i: integer;
+begin
+   for i := 1 to 4 do
+   begin
+      Result[i] := RandomRange(1, 9);
+   end;
+   if not WellFormed(Result) then
+   begin
+      Result := MakeNumber();
+   end;
+end;
+
+Function StrToFourDigit(s: string): TFourDigit;
+{ Convert an (input) string to a TFourDigit. }
+var
+   i: integer;
+begin
+   for i := 1 to Length(s) do
+   begin
+      StrToFourDigit[i] := StrToInt(s[i]);
+   end;
+end;
+
+Function Wins(Num, Guess: TFourDigit): Boolean;
+{ Does the guess win? }
+var
+   i: integer;
+begin
+   Result := True;
+   for i := 1 to 4 do
+   begin
+      if Num[i] <> Guess[i] then
+      begin
+         Result := False;
+         Exit;
+      end;
+   end;
+end;
+
+Function GuessScore(Num, Guess: TFourDigit): string;
+{ Represent the score of the current guess as a string. }
+var
+   i, j, bulls, cows: integer;
+begin
+
+   bulls := 0;
+   cows := 0;
+
+   { Count the cows and bulls. }
+   for i := 1 to 4 do
+   begin
+      for j := 1 to 4 do
+      begin
+         if  (Num[i] = Guess[j]) then
+         begin
+            { If the indices are the same, that would be a bull. }
+            if (i = j) then
+            begin
+               bulls := bulls + 1;
+            end
+            else
+            begin
+               cows := cows + 1;
+            end;
+         end;
+      end;
+   end;
+
+   { Format the result as a sentence. }
+   Result := IntToStr(bulls) + ' bulls, ' + IntToStr(cows) + ' cows.';
+
+end;
+
+Function GetGuess(): TFourDigit;
+{ Get a well-formed user-supplied TFourDigit guess. }
+var
+   input: string;
+begin
+
+   WriteLn('Enter a guess:');
+   ReadLn(input);
+
+   { Must be 4 digits. }
+   if Length(input) = 4 then
+   begin
+
+      Result := StrToFourDigit(input);
+
+      if not WellFormed(Result) then
+      begin
+         WriteLn('Four unique digits, please.');
+         Result := GetGuess();
+      end;
+
+   end
+   else
+   begin
+      WriteLn('Please guess a four-digit number.');
+      Result := GetGuess();
+   end;
+
+end;
+
+var
+   Num, Guess: TFourDigit;
+   Turns: integer;
+begin
+
+   { Initialize the randymnity. }
+   Randomize();
+
+   { Make the secred number. }
+   Num := MakeNumber();
+
+   WriteLn('I have a secret number. Guess it!');
+
+   Turns := 0;
+
+   { Guess until the user gets it. }
+   While True do
+   begin
+
+      Guess := GetGuess();
+
+      { Count each guess as a turn. }
+      Turns := Turns + 1;
+
+      { If the user won, tell them and ditch. }
+      if Wins(Num, Guess) then
+      begin
+         WriteLn('You won in ' + IntToStr(Turns) + ' tries.');
+         Write('The number was ');
+         WriteFourDigit(Num);
+         WriteLn('!');
+         Exit;
+      end
+      else { Otherwise, score it and get a new guess. }
+      begin
+         WriteLn(GuessScore(Num, Guess));
+      end;
+
+   end;
+
+end.
--- a/Task/Bulls-and-cows/Perl/bulls-and-cows.pl
+++ b/Task/Bulls-and-cows/Perl/bulls-and-cows.pl
@ -0,0 +1,39 @@
+use Data::Random qw(rand_set);
+use List::MoreUtils qw(uniq);
+
+my $size = 4;
+my $chosen = join "", rand_set set => ["1".."9"], size => $size;
+
+print "I've chosen a number from $size unique digits from 1 to 9; you need
+to input $size unique digits to guess my number\n";
+
+for ( my $guesses = 1; ; $guesses++ ) {
+    my $guess;
+    while (1) {
+        print "\nNext guess [$guesses]: ";
+        $guess = <STDIN>;
+        chomp $guess;
+        checkguess($guess) and last;
+        print "$size digits, no repetition, no 0... retry\n";
+    }
+    if ( $guess eq $chosen ) {
+        print "You did it in $guesses attempts!\n";
+        last;
+    }
+    my $bulls = 0;
+    my $cows = 0;
+    for my $i (0 .. $size-1) {
+        if ( substr($guess, $i, 1) eq substr($chosen, $i, 1) ) {
+            $bulls++;
+        } elsif ( index($chosen, substr($guess, $i, 1)) >= 0 ) {
+            $cows++;
+        }
+    }
+    print "$cows cows, $bulls bulls\n";
+}
+
+sub checkguess
+{
+    my $g = shift;
+    return uniq(split //, $g) == $size && $g =~ /^[1-9]{$size}$/;
+}
--- a/Task/Bulls-and-cows/Phix/bulls-and-cows.phix
+++ b/Task/Bulls-and-cows/Phix/bulls-and-cows.phix
@ -0,0 +1,76 @@
+(phixonline)-->
+ <span style="color: #000080;font-style:italic;">--
+ -- demo\rosetta\BullsAndCows.exw
+ -- =============================
+ --</span>
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (DEV lots of resizing issues)</span>
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">N</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">4</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">mask</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">return</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">-</span><span style="color: #008000;">'1'</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">score</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">goal</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">bits</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">bulls</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cows</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">N</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">goal</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">guess</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">b</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">bulls</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #008080;">else</span>
+             <span style="color: #000000;">bits</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">mask</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">N</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mask</span><span style="color: #0000FF;">(</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
+         <span style="color: #008080;">if</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bits</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">cows</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+             <span style="color: #000000;">bits</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">b</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">bulls</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cows</span><span style="color: #0000FF;">}</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+
+ <span style="color: #004080;">Ihandle</span> <span style="color: #000000;">label</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dlg</span>
+
+ <span style="color: #004080;">string</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"   Guess %-2d  (%s)  bulls:%d  cows:%d\n"</span><span style="color: #0000FF;">,</span>
+        <span style="color: #000000;">tgt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"123456789"</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">N</span><span style="color: #0000FF;">]</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">attempt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">valuechanged_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*guess*/</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">string</span> <span style="color: #000000;">g</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"VALUE"</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">4</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">))=</span><span style="color: #000000;">4</span> <span style="color: #008080;">then</span>
+         <span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">bulls</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cows</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">score</span><span style="color: #0000FF;">(</span><span style="color: #000000;">g</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tgt</span><span style="color: #0000FF;">)</span>
+         <span style="color: #004080;">string</span> <span style="color: #000000;">title</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"TITLE"</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">&</span>
+                        <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">attempt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">g</span><span style="color: #0000FF;">,</span><span style="color: #000000;">bulls</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cows</span><span style="color: #0000FF;">})</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">bulls</span><span style="color: #0000FF;">=</span><span style="color: #000000;">N</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">title</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">"\nWell done!"</span>
+             <span style="color: #7060A8;">IupSetInt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ACTIVE"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">else</span>
+             <span style="color: #7060A8;">IupSetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"VALUE"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #7060A8;">IupSetStrAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"TITLE"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">title</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">attempt</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #7060A8;">IupSetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"SIZE"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">NULL</span><span style="color: #0000FF;">)</span>
+         <span style="color: #7060A8;">IupRefresh</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
+     <span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span>
+     <span style="color: #000000;">label</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupLabel</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter %d digits 1 to 9 without duplication"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">N</span><span style="color: #0000FF;">}))</span>
+     <span style="color: #000000;">guess</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupText</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"VALUECHANGED_CB"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"valuechanged_cb"</span><span style="color: #0000FF;">))</span>
+     <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupLabel</span><span style="color: #0000FF;">(</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">dlg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">IupVbox</span><span style="color: #0000FF;">({</span><span style="color: #7060A8;">IupHbox</span><span style="color: #0000FF;">({</span><span style="color: #000000;">label</span><span style="color: #0000FF;">,</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">},</span><span style="color: #008000;">"GAP=10,NORMALIZESIZE=VERTICAL"</span><span style="color: #0000FF;">),</span>
+                              <span style="color: #7060A8;">IupHbox</span><span style="color: #0000FF;">({</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})},</span><span style="color: #008000;">"MARGIN=5x5"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">`TITLE="Bulls and Cows"`</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
+         <span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>
+         <span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+
+ <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
+<!--
--- a/Task/Bulls-and-cows/Picat/bulls-and-cows.picat
+++ b/Task/Bulls-and-cows/Picat/bulls-and-cows.picat
@ -0,0 +1,32 @@
+main =>
+    Digits = to_array("123456789"),
+    Size = 4,
+    random_sample(Size,Size,[],ChosenIndecies),
+    Chosen = {Digits[I] : I in ChosenIndecies},
+    printf("I have chosen a number from %d unique digits from 1 to 9 arranged in a random order.\n", Size),
+    printf("You need to input a %d digit, unique digit number as a guess at what I have chosen.\n", Size),
+    guess(Chosen,Size,1).
+
+guess(Chosen,Size,NGuess) =>
+    Input = read_line(),
+    Guess = Input.to_array(),
+    if len(Guess) != Size || len(sort_remove_dups(Input)) != Size || (member(D, Input), (D @< '1' || D @> '9'))  then
+        printf("Problem, try again. You need to enter %d unique digits from 1 to 9\n", Size),
+        guess(Chosen,Size,NGuess)
+    elseif Guess == Chosen then
+        printf("\nCongratulations you guessed correctly in %d attempts\n", NGuess)
+    else
+        Bulls = sum([cond(Chosen[I] == Guess[I], 1, 0) : I in 1..Size]),
+        Cows = sum([cond(member(Chosen[I], Input), 1, 0) : I in 1..Size]),
+        printf("%d Bulls\n%d Cows\n", Bulls, Cows),
+        guess(Chosen, Size, NGuess+1)
+    end.
+
+random_sample(_N,0,Chosen0,Chosen) => Chosen = Chosen0.
+random_sample(N,I,Chosen0,Chosen) =>
+    R = random() mod N + 1,
+    (not member(R, Chosen0) ->
+        random_sample(N,I-1,[R|Chosen0],Chosen)
+    ;
+        random_sample(N,I,Chosen0,Chosen)
+    ).
--- a/Task/Bulls-and-cows/PicoLisp/bulls-and-cows.l
+++ b/Task/Bulls-and-cows/PicoLisp/bulls-and-cows.l
@ -0,0 +1,20 @@
+(de ok? (N)
+   (let D (mapcar 'format (chop N))
+      (and (num? N)
+           (not (member 0 D))
+           (= 4 (length D))
+           (= D (uniq D))
+           D )) )
+
+(de init-cows ()
+   (until (setq *Hidden (ok? (rand 1234 9876)))) )
+
+(de guess (N)
+   (let D (ok? N)
+      (if D
+         (let Bulls (cnt '= D *Hidden)
+            (if (= 4 Bulls)
+               " You guessed it!"
+               (let Cows (- (cnt '((N) (member N *Hidden)) D) Bulls)
+                  (pack Bulls " bulls, " Cows " cows") ) ) )
+         " Bad guess! (4 unique digits, 1-9)" ) ) )
--- a/Task/Bulls-and-cows/PowerShell/bulls-and-cows.psh
+++ b/Task/Bulls-and-cows/PowerShell/bulls-and-cows.psh
@ -0,0 +1,47 @@
+[int]$guesses = $bulls = $cows = 0
+[string]$guess = "none"
+[string]$digits = ""
+
+while ($digits.Length -lt 4)
+{
+    $character = [char](49..57 | Get-Random)
+
+    if ($digits.IndexOf($character) -eq -1) {$digits += $character}
+}
+
+Write-Host "`nGuess four digits (1-9) using no digit twice.`n" -ForegroundColor Cyan
+
+while ($bulls -lt 4)
+{
+    do
+    {
+        $prompt = "Guesses={0:0#}, Last='{1,4}', Bulls={2}, Cows={3}; Enter your guess" -f $guesses, $guess, $bulls, $cows
+        $guess = Read-Host $prompt
+
+        if ($guess.Length -ne 4)                     {Write-Host "`nMust be a four-digit number`n" -ForegroundColor Red}
+        if ($guess -notmatch "[1-9][1-9][1-9][1-9]") {Write-Host "`nMust be numbers 1-9`n"         -ForegroundColor Red}
+    }
+    until ($guess.Length -eq 4)
+
+    $guesses += 1
+    $bulls = $cows = 0
+
+    for ($i = 0; $i -lt 4; $i++)
+    {
+        $character = $digits.Substring($i,1)
+
+        if ($guess.Substring($i,1) -eq $character)
+        {
+            $bulls += 1
+        }
+        else
+        {
+            if ($guess.IndexOf($character) -ge 0)
+            {
+                $cows += 1
+            }
+        }
+    }
+}
+
+Write-Host "`nYou won after $($guesses - 1) guesses." -ForegroundColor Cyan
--- a/Task/Bulls-and-cows/Processing/bulls-and-cows.processing
+++ b/Task/Bulls-and-cows/Processing/bulls-and-cows.processing
@ -0,0 +1,62 @@
+IntDict score;
+StringList choices;
+StringList guess;
+StringList secret;
+int gamesWon = -1;
+
+void setup() {
+  choices = new StringList("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
+  newGame();
+}
+
+void newGame() {
+  gamesWon++;
+  choices.shuffle();
+  secret = new StringList();
+  for (int i=0; i<4; i++) { // selections
+    secret.append(choices.get(i));
+  }
+  newGuess();
+  println("\nsecret:", secret, "\n");
+}
+
+void newGuess() {
+  guess = new StringList();
+  score = null;
+}
+
+void draw() {
+  background(0);
+  text("Bulls & Cows " + gamesWon, 5, 20);
+  for (int i=0; i<guess.size(); i++) {
+    text(guess.get(i), 20*i+10, height/2);
+  }
+  if (score!=null) {
+    text("bulls:" + score.get("bulls") + " cows:" + score.get("cows"), 10, height-20);
+  }
+}
+
+void keyReleased() {
+  if (score!=null && score.get("bulls")==4) newGame();
+  if (guess.size()==secret.size()) newGuess();
+  if (guess.hasValue(str(key))) newGuess();
+  if (key>=48 && key<=57) guess.append(str(key));
+  if (guess.size()==secret.size()) {
+    score = checkScore(secret, guess);
+    println("guess: ", guess, "\n", score, "wins:", gamesWon);
+  }
+}
+
+IntDict checkScore(StringList secret, StringList guess) {
+  IntDict result = new IntDict();
+  result.set("bulls", 0);
+  result.set("cows", 0);
+  for (int i=0; i<guess.size(); i++) {
+    if (guess.get(i).equals(secret.get(i))) {
+      result.add("bulls", 1);
+    } else if (secret.hasValue(guess.get(i))) {
+      result.add("cows", 1);
+    }
+  }
+  return result;
+}
--- a/Task/Bulls-and-cows/Prolog/bulls-and-cows.pro
+++ b/Task/Bulls-and-cows/Prolog/bulls-and-cows.pro
@ -0,0 +1,56 @@
+:- use_module(library(lambda)).
+:- use_module(library(clpfd)).
+
+% Parameters of the server
+
+% length of the guess
+proposition(4).
+
+% Numbers of digits
+% 0 -> 8
+digits(8).
+
+
+bulls_and_cows_server :-
+	proposition(LenGuess),
+	length(Solution, LenGuess),
+	choose(Solution),
+	repeat,
+	write('Your guess : '),
+	read(Guess),
+	(   study(Solution, Guess, Bulls, Cows)
+	->  format('Bulls : ~w Cows : ~w~n', [Bulls, Cows]),
+	    Bulls = LenGuess
+	;   digits(Digits), Max is Digits + 1,
+	    format('Guess must be of ~w digits between 1 and ~w~n',
+		   [LenGuess, Max]),
+	    fail).
+
+choose(Solution) :-
+	digits(Digits),
+	Max is Digits + 1,
+	repeat,
+	maplist(\X^(X is random(Max) + 1), Solution),
+	all_distinct(Solution),
+	!.
+
+study(Solution, Guess, Bulls, Cows) :-
+	proposition(LenGuess),
+	digits(Digits),
+	
+	% compute the transformation 1234 => [1,2,3,4]
+	atom_chars(Guess, Chars),
+	maplist(\X^Y^(atom_number(X, Y)), Chars, Ms),
+	
+	% check that the guess is well formed
+	length(Ms, LenGuess),
+	maplist(\X^(X > 0, X =< Digits+1), Ms),
+
+	% compute the digit in good place
+	foldl(\X^Y^V0^V1^((X = Y->V1 is V0+1; V1 = V0)),Solution, Ms, 0, Bulls),
+	
+	% compute the digits in bad place
+	foldl(\Y1^V2^V3^(foldl(\X2^Z2^Z3^(X2 = Y1 -> Z3 is Z2+1; Z3 = Z2), Ms, 0, TT1),
+			 V3 is V2+ TT1),
+	      Solution, 0, TT),
+	Cows is TT - Bulls.
--- a/Task/Bulls-and-cows/PureBasic/bulls-and-cows.basic
+++ b/Task/Bulls-and-cows/PureBasic/bulls-and-cows.basic
@ -0,0 +1,70 @@
+Define.s secret, guess, c
+Define.i bulls, cows, guesses, i
+
+If OpenConsole()
+
+  While Len(secret) < 4
+    c = Chr(Random(8) + 49)
+    If FindString(secret, c, 1) = 0
+      secret + c
+    EndIf
+  Wend
+
+  Repeat
+    Print("Guess a 4-digit number with no duplicate digits: ")
+    guess = Input()
+    If Len(guess) = 0
+      Break   ;break from loop
+    EndIf
+
+    isMalformedGuess = #False
+    If Len(guess) <> 4
+      ;guess is too short
+      isMalformedGuess = #True
+    Else
+      For i = 1 To 4
+        c = Mid(guess, i, 1)
+        If Not FindString("123456789", c, 1) Or CountString(guess, c) <> 1
+          ;guess contains either non-digits or duplicate digits
+          isMalformedGuess = #True
+          Break ;break from For/Next loop
+        EndIf
+      Next
+    EndIf
+
+    If isMalformedGuess
+      PrintN("** You should enter 4 different numeric digits that are each from 1 to 9!")
+      Continue ;continue loop
+    EndIf
+
+    bulls = 0: cows = 0: guesses = guesses + 1
+    For i = 1 To 4
+      c = Mid(secret, i, 1)
+      If Mid(guess, i, 1) = c
+        bulls + 1
+      ElseIf FindString(guess, c, 1)
+        cows + 1
+      EndIf
+    Next
+
+    Print( Str(bulls) + " bull")
+    If bulls <> 1
+      Print( "s")
+    EndIf
+    Print( ", " + Str(cows) + " cow")
+    If cows <> 1
+      PrintN( "s")
+    Else
+      PrintN("")
+    EndIf
+
+    If guess = secret
+      PrintN("You won after " + Str(guesses) + " guesses!")
+      Break    ;break from loop
+    EndIf
+  ForEver
+
+  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
+  Input()
+  CloseConsole()
+EndIf
--- a/Task/Bulls-and-cows/Python/bulls-and-cows.py
+++ b/Task/Bulls-and-cows/Python/bulls-and-cows.py
@ -0,0 +1,33 @@
+'''
+ Bulls and cows. A game pre-dating, and similar to, Mastermind.
+'''
+
+import random
+
+digits = '123456789'
+size = 4
+chosen = ''.join(random.sample(digits,size))
+#print chosen # Debug
+print '''I have chosen a number from %s unique digits from 1 to 9 arranged in a random order.
+You need to input a %i digit, unique digit number as a guess at what I have chosen''' % (size, size)
+guesses = 0
+while True:
+    guesses += 1
+    while True:
+        # get a good guess
+        guess = raw_input('\nNext guess [%i]: ' % guesses).strip()
+        if len(guess) == size and \
+           all(char in digits for char in guess) \
+           and len(set(guess)) == size:
+            break
+        print "Problem, try again. You need to enter %i unique digits from 1 to 9" % size
+    if guess == chosen:
+        print '\nCongratulations you guessed correctly in',guesses,'attempts'
+        break
+    bulls = cows = 0
+    for i in range(size):
+        if guess[i] == chosen[i]:
+            bulls += 1
+        elif guess[i] in chosen:
+            cows += 1
+    print '  %i Bulls\n  %i Cows' % (bulls, cows)
--- a/Task/Bulls-and-cows/QB64/bulls-and-cows.qb64
+++ b/Task/Bulls-and-cows/QB64/bulls-and-cows.qb64
@ -0,0 +1,28 @@
+Const MaxDigit = 4, Min = 1, Max = 9
+Dim As String NumberToGuess, NumberToTest, Newdigit, Result
+Dim As Integer Counter, Number
+Randomize Timer
+Do
+    Counter = Counter + 1
+    Newdigit = _Trim$(Str$(Int(Rnd * Max) + Min))
+    If InStr(NumberToGuess, Newdigit) = 0 Then NumberToGuess = NumberToGuess + Newdigit Else Counter = Counter - 1
+Loop While Counter < MaxDigit
+Print NumberToGuess  'debug output
+Do While NumberToGuess <> NumberToTest
+    Input "Please enter your guess of 4 digits... ", Number
+    NumberToTest = _Trim$(Str$(Number))
+    If NumberToGuess <> NumberToTest Then
+        Result = ""
+        For Counter = 1 To 4 Step 1
+            Newdigit = Mid$(NumberToTest, Counter, 1)
+            If InStr(NumberToGuess, Newdigit) - Counter = 0 Then
+                Result = Result + " Bull "
+            ElseIf InStr(NumberToGuess, Newdigit) > 0 Then
+                Result = Result + " Cow "
+            End If
+        Next Counter
+        Print NumberToTest, Result
+    Else
+        Print "You Win!"
+    End If
+Loop
--- a/Task/Bulls-and-cows/R/bulls-and-cows.r
+++ b/Task/Bulls-and-cows/R/bulls-and-cows.r
@ -0,0 +1,19 @@
+target <- sample(1:9,4)
+bulls <- 0
+cows <- 0
+attempts <- 0
+while (bulls != 4)
+  {
+  input <- readline("Guess a 4-digit number with no duplicate digits or 0s: ")
+  if (nchar(input) == 4)
+    {
+    input <- as.integer(strsplit(input,"")[[1]])
+    if ((sum(is.na(input)+sum(input==0))>=1) | (length(table(input)) != 4)) {print("Malformed input!")} else {
+      bulls <- sum(input == target)
+      cows <- sum(input %in% target)-bulls
+      cat("\n",bulls," Bull(s) and ",cows, " Cow(s)\n")
+      attempts <- attempts + 1
+      }
+    } else {print("Malformed input!")}
+  }
+print(paste("You won in",attempts,"attempt(s)!"))
--- a/Task/Bulls-and-cows/REXX/bulls-and-cows-1.rexx
+++ b/Task/Bulls-and-cows/REXX/bulls-and-cows-1.rexx
@ -0,0 +1,27 @@
+/*REXX program scores the   Bulls & Cows   game with  CBLFs  (Carbon Based Life Forms). */
+?=; 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.  */
+    end   /*until length*/                     /* [↑]  builds a unique four-digit number*/
+$= '──────── [Bulls & Cows]  '                 /*a literal that is part of the prompt.  */
+    do  until  bulls==4;      say              /*play until guessed  or  enters  "Quit".*/
+    say $  'Please enter a 4-digit guess (with no zeroes)   [or Quit]:'
+    pull n;  n=space(n, 0);   if abbrev('QUIT', n, 1)  then exit   /*user wants to quit?*/
+    q=?;   L= length(n);   bulls= 0;   cows= 0 /*initialize some REXX variables.        */
+        do j=1  for L;    if substr(n, j, 1)\==substr(q, j, 1)  then iterate  /*is bull?*/
+        bulls= bulls +1;  q= overlay(., q, j)  /*bump the bull count;  disallow for cow.*/
+        end   /*j*/                            /* [↑]  bull count───────────────────────*/
+                                                                              /*is cow? */
+        do k=1  for L;   _= substr(n, k, 1);           if pos(_, q)==0  then iterate
+        cows=cows + 1;   q= translate(q, , _)  /*bump the cow count;  allow mult digits.*/
+        end   /*k*/                            /* [↑]  cow  count───────────────────────*/
+    say;                  @= 'You got'   bulls
+    if L\==0  &  bulls\==4  then say $  @  'bull's(bulls)    "and"    cows   'cow's(cows).
+    end   /*until bulls*/
+                            say "          ┌─────────────────────────────────────────┐"
+                            say "          │                                         │"
+                            say "          │  Congratulations, you've guessed it !!  │"
+                            say "          │                                         │"
+                            say "          └─────────────────────────────────────────┘"
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+s:  if arg(1)==1  then return '';   return "s"   /*this function handles pluralization. */
--- a/Task/Bulls-and-cows/REXX/bulls-and-cows-2.rexx
+++ b/Task/Bulls-and-cows/REXX/bulls-and-cows-2.rexx
@ -0,0 +1,101 @@
+/*REXX program to play the game of  "Bulls & Cows". *******************
+* Changes from Version 1:
+* ?= -> qq='' (righthandside mandatory and I never use ? as symbol -
+*                               although it is available on all Rexxes)
+* implemented singular/plural distinction differently
+* change getRand to avoid invalid digit rejection
+* check user's input for multiple digits
+* add feature MM to ease guessing (MM=Mastermind - a similar game)
+* add feature ? to see the solution (for the impatient player)
+* program runs as is on ooRexx and on TSO (after changing | to !)
+* Made source and output more compact
+* formatted source 'my way'  2 July 2012 Walter Pachl
+**********************************************************************/
+ask='<Bulls & Cows game>   Please enter a four-digit guess  (or QUIT):'
+
+b.='bulls'; b.1='bull'
+c.='cows';  c.1='cow'
+qq=getRand()
+mm=0
+Do Forever
+  If get_guess()==qq Then leave
+  Call scorer
+  Say "You got" bulls b.bulls "and" cows c.cows"."
+  If mm Then
+    Say mms
+  End   /*forever*/
+Say "         *******************************************"
+Say "         *                                         *"
+Say "         *  Congratulations, you've guessed it !!  *"
+Say "         *                                         *"
+Say "         *******************************************"
+Exit
+
+get_guess:                           /*get a guess from the guesser. */
+
+do forever
+  Say ask
+  Parse Pull guessi
+  guess=translate(guessi)
+  bc=verify(guess,987654321)
+  Select
+    When guess='?'       Then Say qq 'is the correct sequence'
+    When guess='QUIT'    Then Exit
+    When guess='MM'      Then Do
+                              Say 'Mastermind output enabled'
+                              mm=1
+                              End
+    When guess=''        Then Call ser 'no argument specified.'
+    When words(guess)>1  Then Call ser 'too many arguments specified.'
+    When verify(0,guess)=0 Then Call ser 'illegal digit: 0'
+    When bc>0 Then Call ser 'illegal character:' substr(guessi,bc,1)
+    When length(guess)<4 Then Call ser 'not enough digits'
+    When length(guess)>4 Then Call ser 'too many digits'
+    When dups(guess)     Then Call ser '4 DIFFERENT digits, please'
+    Otherwise Do
+      /********** Say guess ************/
+      Return guess
+      End
+    End
+  End
+
+getRand:
+digits='123456789'
+qq=''
+Do i=1 To 4
+  d=random(1,length(digits))
+  d=substr(digits,d,1)
+  qq=qq||d
+  digits=space(translate(digits,' ',d),0)
+  /************ Say qq digits ************/
+  End
+Return qq
+
+scorer: g=qq
+mms='----'
+bulls=0
+Do j=1 for 4
+  If substr(guess,j,1)=substr(qq,j,1) Then Do
+    bulls=bulls+1
+    guess=overlay(' ',guess,j)
+    mms=overlay('+',mms,j)
+    End
+  End
+cows=0
+Do j=1 To 4
+  If pos(substr(guess,j,1),qq)>0 Then Do
+    cows=cows+1
+    mms=overlay('.',mms,j)
+    End
+  End
+Return
+
+dups: Procedure
+Parse Arg s
+Do i=1 To 3
+  If pos(substr(s,i,1),substr(s,i+1))>0 Then
+    Return 1
+  End
+Return 0
+
+ser: Say '*** error ***' arg(1); Return
--- a/Task/Bulls-and-cows/Racket/bulls-and-cows.rkt
+++ b/Task/Bulls-and-cows/Racket/bulls-and-cows.rkt
@ -0,0 +1,58 @@
+#lang racket
+
+; secret : (listof exact-nonnegative-integer?)
+(define secret
+  (foldr (λ (n result)
+           (cons n (map (λ (y) (if (>= y n) (add1 y) y))
+                        result)))
+         '()
+         (map random '(10 9 8 7))))
+
+; (count-bulls/cows guess) -> (values exact-nonnegative-integer?
+;                                     exact-nonnegative-integer?)
+; guess : (listof exact-nonnegative-integer?)
+(define (count-bulls/cows guess)
+  (let* ([bulls (map = guess secret)]
+         [cow-candidates (filter-map (λ (x y) (if (false? x) y #f))
+                                      bulls
+                                      secret)]
+         [cows (filter (curryr member cow-candidates) guess)])
+    (values (length (filter ((curry equal?) #t) bulls))
+            (length cows))))
+
+; (valid-guess guess-str) -> (or/c (listof exact-nonnegative-integer?) #f)
+; guess-str : string?
+(define (valid-guess guess-str)
+  (define (char->digit c)
+    (- (char->integer c) (char->integer #\0)))
+  (if (regexp-match-exact? #px"[0-9]{4}" guess-str)
+      (let ([guess (map char->digit (string->list guess-str))])
+        (if (andmap (λ (x) (equal? (count ((curry equal?) x) guess) 1))
+                    guess)
+            guess
+            #f))
+      #f))
+
+; Game states
+(define win #t)
+(define game #f)
+
+; (main-loop state step) -> void?
+; state : boolean?
+; step  : exact-nonnegative-integer?
+(define (main-loop state step)
+  (if (equal? state win)
+      (printf "You won after ~a guesses." step)
+      (begin
+        (let* ([guess-str (read-line)]
+               [guess (valid-guess guess-str)])
+          (if (false? guess)
+              (begin (displayln "Guess should include exactly four different digits")
+                     (main-loop state step))
+              (let-values ([(bulls cows) (count-bulls/cows guess)])
+                (if (= bulls 4)
+                    (main-loop win (add1 step))
+                    (begin (printf "Bulls: ~a Cows: ~a\n" bulls cows)
+                           (main-loop state (add1 step))))))))))
+
+(main-loop game 0)
--- a/Task/Bulls-and-cows/Raku/bulls-and-cows.raku
+++ b/Task/Bulls-and-cows/Raku/bulls-and-cows.raku
@ -0,0 +1,21 @@
+my $size = 4;
+my @secret = pick $size, '1' .. '9';
+
+for 1..* -> $guesses {
+    my @guess;
+    loop {
+        @guess = (prompt("Guess $guesses: ") // exit).comb;
+        last if @guess == $size and
+            all(@guess) eq one(@guess) & any('1' .. '9');
+        say 'Malformed guess; try again.';
+    }
+    my ($bulls, $cows) = 0, 0;
+    for ^$size {
+        when @guess[$_] eq @secret[$_] { ++$bulls; }
+        when @guess[$_] eq any @secret { ++$cows; }
+    }
+    last if $bulls == $size;
+    say "$bulls bulls, $cows cows.";
+}
+
+say 'A winner is you!';
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`moo←'You win!'⊣((4∘⊣?9∘⊣)(({⎕←(↑'Bulls: ' 'Cows: '),⍕⍪⍵⋄⍵}⊣((+/=),(+/∊∧≠))(⍎¨{⍞←'Guess: '⋄7↓⍞}⍣(((∧/⎕D∊⍨⊢)∧4=≢)⊣)))⍣(4 0≡⊣))⊢)`