Evolutionary algorithm: Difference between revisions

To ensure that the new parent is never less fit than the prior parent, both the parent and all of the latest mutations are subjected to the fitness test to select the next parent.

<br><br>

 

=={{header|8080 Assembly}}==

 

COPIES: equ 100 ; Amount of copies to make

fname1: equ 5Dh ; First filename on command line (used for RNG seed)

maxptr: ds 2 ; Pointer to copy with best fitness

parent: equ $ ; Store current parent here

 

{{out}}

=={{header|8086 Assembly}}==

 

cpu 8086

MRATE: equ 26 ; Mutation rate (MRATE/256)

rnddat: resb 4 ; RNG state

parent: resb target.size ; Place to store current parent

 

{{out}}

 

=={{header|8th}}==

\ RosettaCode challenge http://rosettacode.org/wiki/Evolutionary_algorithm

\ Responding to the criticism that the implementation was too directed, this

"METHINKS IT IS LIKE A WEASEL"

 

The output:

Very simple fitness determination. For testing purposes you can add a static seed value to the RNG initializations (sample output uses '12345' for both).

 

with Ada.Numerics.Discrete_Random;

with Ada.Numerics.Float_Random;

-- evolve!

Evolve;

 

sample output:

380: METHINKS ITBIS LIKE A WEASEL, fitness: 27

Final ( 384): METHINKS IT IS LIKE A WEASEL, fitness: 28</pre>

 

=={{header|Aime}}==

{{trans|C}}

fitness(data t, data b)

{

 

return 0;

{{out}}

<pre>23 EAAXIZJROVOHSKREBNSAFHEKF B

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - no extensions to language used.}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

PROC fitness = (STRING tstrg)REAL:

INT iters := 0;

kid[LWB kid] := LOC[UPB target]CHAR;

# initialize #

 

fits := fitness(parent);

INT j;

REAL kf;

FOR j FROM LWB kid TO UPB kid DO

mutate(kid[j], parent, mutate rate)

FI

OD;

iters+:=1

OD;

(

evolve

Sample output:

<pre>

</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

⍺←0.1

target←'METHINKS IT IS LIKE A WEASEL'

}charset[?(⍴target)/⍴charset]

}

 

{{out}}

METHINKS IT IS LIKE A WEASEL

METHINKS IT IS LIKE A WEASEL</pre>

 

=={{header|AutoHotkey}}==

 

target := "METHINKS IT IS LIKE A WEASEL"

targetLen := StrLen(target)

totalFit++

Return totalFit

Output:

<pre>10: DETRNNKR IAQPFLNVKZ AMXEASEL, fitness: 14

=={{header|AWK}}==

I apply the rate to each character in each generated child. The number of generations required seems to be really sensitive to the rate. I used the default seeding in GNU awk to obtain the results below. I suspect the algorithm used to generate the pseudo-random numbers may also influence the rapidity of convergence but I haven't investigated that yet. The output shown was obtained using GNU Awk 3.1.5. BusyBox v1.20.0.git also works but using the same rate generates 88 generations before converging.

#!/bin/awk -f

function randchar(){

}

 

Output:

<pre>

#

</pre>

 

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

@echo off

setlocal enabledelayedexpansion

for /l %%i in (1,1,28) do set %returnarray%=!%returnarray%! !%returnarray%%%i!

exit /b

{{out}}

Sample Output:

Done.

</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

iter 1, score 25: WKVVTFJUHOMQJN YRTEQAGDVSKXC

iter 2, score 25: WKVVTFJUHOMQJN YRTEQAGDVSKXC

iter 221, score 1: METHINKSHIT IS LIKE A WEASEL

iter 222, score 1: METHINKSHIT IS LIKE A WEASEL

 

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

{{works with|C sharp|C#|3+}}

 

using System.Collections.Generic;

using System.Linq;

Console.WriteLine("END: #{0,6} {1,20}", i, parent);

}

 

Example output:

 

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

#include <cstdlib>

#include <iostream>

}

std::cout << "final string: " << parent << "\n";

Example output:

<pre>

 

=={{header|Ceylon}}==

DefaultRandom

print("mutated into target in ``generationCount`` generations!");

 

=={{header|Clojure}}==

Define the evolution parameters (values here per Wikipedia article), with a couple of problem constants.

(def p 0.05) ;mutation probability

 

(def tsize (count target))

 

Now the major functions. ''fitness'' simply counts the number of characters matching the target.

(defn perfectly-fit? [s] (= (fitness s) tsize))

 

(defn randc [] (rand-nth alphabet))

Finally evolve. At each generation, print the generation number, the parent, and the parent's fitness.

(println generation, (apply str parent), (fitness parent))

(if-not (perfectly-fit? parent)

(let [children (repeatedly c #(mutate parent))

fittest (apply max-key fitness parent children)]

 

=={{header|COBOL}}==

For testing purposes, you can comment out the first two sentences in the <tt>CONTROL-PARAGRAPH</tt> and the program will then use the same sequence of pseudo-random numbers on each run.

program-id. evolutionary-program.

data division.

fittest-paragraph.

move fitness to highest-fitness.

{{out}}

<div style="height:50ex;overflow:scroll">

 

=={{header|ColdFusion}}==

<Cfset theString = 'METHINKS IT IS LIKE A WEASEL'>

<cfparam name="parent" default="">

 

</Cfloop>

<pre>

#1 7% fit: VOPJOBSYPTTUNYYSAFHTPJUIAIL

#349 96% fit: METHINKS IT IS LIKE A WEASOL

#360 100% fit: METHINKS IT IS LIKE A WEASEL

</pre>

 

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

"Closeness of string to target; lower number is better"

(loop for c1 across string

(n 0 (1+ n)))

((string= target parent) (format t "Generation ~A: ~S~%" n parent))

Sample output:

<pre>CL-USER> (evolve-gens "METHINKS IT IS LIKE A WEASEL" 100 0.05)

 

Mutates one character at a time, with only on offspring each generation (which competes against the parent):

(loop for a across s1

for b across s2 count(char/= a b)))

(format t "~5d: ~a (~d)~%" gen str fit))))

 

57: DYZTOREXDIL ZCEUCSHRVHBEPGJE (25)

83: DYZTOREX IL ZCEUCSHRVHBEPGJE (24)

1220: METHINKS IT IS LIKE AHBEASEL (2)

1358: METHINKS IT IS LIKE AHWEASEL (1)

 

=={{header|D}}==

 

enum target = "METHINKS IT IS LIKE A WEASEL"d;

writefln("Gen %2d, dist=%2d: %s", gen, parent.fitness, parent);

}

{{out}}

<pre>Generation 0, dist=25: PTJNKPFVJFTDRSDVNUB ESJGU MF

Generation 23, dist= 1: METHINKS IT IS LIKE A WEASEW

Generation 24, dist= 0: METHINKS IT IS LIKE A WEASEL</pre>

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Evolutionary_algorithm#Pascal Pascal].

 

=={{header|E}}==

pragma.enable("accumulator")

 

}

 

 

=={{header|EchoLisp}}==

(require 'sequences)

(define ALPHABET (list->vector ["A" .. "Z"] ))

(set! parent (select parent target rate copies))

))

{{out}}

<pre>

 

=={{header|Elena}}==

import extensions;

import extensions'text;

{

randomString()

fitnessOf(s)

mutate(p)

}

 

class EvoAlgorithm : Enumerator

{

 

constructor new(s,count)

{

}

 

 

bool next()

{

{ ^ false };

^ true

reset()

{

}

}

 

{

var attempt := new Integer();

{

console

console.readChar()

{{out}}

<pre>

Print current gen and most fit offspring if more fit than parent.<br>

Print the target and the total number of generations (iterations) it took to reach it.<br>

def show(offspring,i) do

IO.puts "Generation: #{i}, Offspring: #{offspring}"

end

 

 

{{out}}

 

=={{header|Erlang}}==

-export([run/0]).

 

random_string(N-1,[random_character()|Acc]).

 

 

=={{header|Euphoria}}==

function random_generation(integer len)

sequence s

iter += 1

end while

 

Output:

 

=={{header|F Sharp|F#}}==

//A functional implementation of Evolutionary algorithm

//Nigel Galloway February 7th., 2018

evolution n []

let n = evolution (Array.init 28 (fun _->alphabet.[G.Next()%27]))

Real: 00:00:00.021, CPU: 00:00:00.050, GC gen0: 1, gen1: 0

<br>

 

=={{header|Factor}}==

random sequences strings ;

FROM: math.extras => ... ;

"Finished in %d generations." printf ;

{{out}}

<pre>

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

{{works with|4tH|3.60.0}}

\ target string

s" METHINKS IT IS LIKE A WEASEL" sconstant target

;

 

Output:

<pre>

{{works with|Fortran|2003}}

 

!***************************************************************************************************

module evolve_routines

end program evolve

!***************************************************************************************************

 

The output is:

 

iter best fitness

0 PACQXJB CQPWEYKSVDCIOUPKUOJY 459

70 MESHINKS IT IS LIKE A WEASEL 1

75 METHINKS IT IS LIKE A WEASEL 0

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>iteration best fit Parent

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

I took the liberty to use <code>[]byte</code> for the "strings" mentioned in the task description. Go has a native string type, but in this case it was both easier and more efficient to work with byte slices and just convert to string when there was something to print.

 

import (

}

}

{{out}}

<div style='height: 15em; overflow: scroll'><pre>

{{works with|GHC|7.6.3}}

 

import Control.Monad

import Data.List

genes <- replicateM r $ randomRIO (bounds charSet)

let parent = map (charSet!) genes

Example run in GHCi:

<pre>*Main> main

I find this easier to read.

 

import Data.List

import Data.Ord

where fmtd = parent ++ ": " ++ show (fitness parent) ++ " (" ++ show n ++ ")"

 

Example:

<pre>YUZVNNZ SXPSNGZFRHZKVDOEPIGS: 2 (0)

 

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

 

procedure fitness(s)

write("At generation " || gen || " we found a string with perfect fitness at " || current_fitness || " reading: " || parent)

end

 

=={{header|J}}==

'''Solution:'''<br>

Using sum of differences from the target for fitness, i.e. <code>0</code> is optimal fitness.

NPROG=: 100 NB. number of progeny (C)

MRATE=: 0.05 NB. mutation rate

while =: conjunction def '(] , (u {:))^:(v {:)^:_ ,:'

 

'''Example usage:'''<br>

Returns list of best solutions at each generation until converged.

filter evolve 'METHINKS IT IS LIKE A WEASEL'

XXURVQXKQXDLCGFVICCUA NUQPND

MEFHINVQQXT IW LIKEUA WEAPEL

METHINVS IT IW LIKEUA WEAPEL

 

'''Alternative solution:'''<br>

Using explicit versions of <code>mutate</code> and <code>evolve</code> above.

NPROG=: 100 NB. "C" from specification

 

log iter;val;parent

parent

 

'''Example Usage:'''

#0 fitness: 27 ; YGFDJFTBEDB FAIJJGMFKDPYELOA

#50 fitness: 2 ; MEVHINKS IT IS LIKE ADWEASEL

#76 fitness: 0 ; METHINKS IT IS LIKE A WEASEL

 

=={{header|Java}}==

 

'''(Close)''' {{trans|Python}}

import java.util.Random;

 

}

 

Output:

<pre>100: MEVHIBXSCG TP QIK FZGJ SEL, fitness: 13, rate: 0.4875

Using cross-browser techniques to support Array.reduce and Array.map

 

 

/* Compatibility code to reduce an array

document.write("Generation: " + generation + ", Best: " + fittest.individual.join("") + ", fitness:" + fittest.score + "<br>");

}

Output:

<pre>

Generation: 50, Best: METHINKS IT IS LIKEZA WEASEL, fitness:1

Generation: 52, Best: METHINKS IT IS LIKE A WEASEL, fitness:0

</pre>

 

{{works with|Julia|0.6}}

 

function mutate(str::AbstractString, rate::Float64)

L = collect(Char, " ABCDEFGHIJKLMNOPQRSTUVWXYZ")

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

val target = "METHINKS IT IS LIKE A WEASEL"

}

println("Evolution found target after $i generations")

 

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

'mutaterate has to be greater than 1 or it will not mutate

mutaterate = 2

End If

Next i

 

=={{header|Logo}}==

 

to distance :w

make "trials :trials + 1

]

 

=={{header|Lua}}==

{{works with|Lua|5.1+}}

 

local alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "

local c, p = 100, 0.06

parent, step = bestChild, step + 1

printStep(step, parent, bestFitness)

 

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

===Version 1===

Module WeaselAlgorithm {

Print "Evolutionary Algorithm"

WeaselAlgorithm

 

{{out}}

 

Also here we have one Mutate function which change letters using 5% probability for each place in the parent string.

 

Module WeaselAlgorithm2 {

Print "Evolutionary Algorithm"

}

WeaselAlgorithm2

 

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

alphabet = Append[CharacterRange["A", "Z"], " "];

fitness = HammingDistance[target, #] &;

mutate[target, 1],

fitness@# > 0 &

 

=={{header|MATLAB}}==

To use this code, create a folder in your MATLAB directory titled "@EvolutionaryAlgorithm". Within that folder save this code in a file named "EvolutionaryAlgorithm.m".

 

classdef EvolutionaryAlgorithm

end %methods

Sample Output: (Some evolutionary cycles omitted for brevity)

Target: METHINKS IT IS LIKE A WEASEL

Parent: UVEOCXXFBGDCSFNMJQNWTPJ PCVA

100: METHIXKS YT IS LIKE A WEASEL - Fitness: 26

150: METHINKS YT IS LIKE A WEASEL - Fitness: 27

 

 

 

Presented is very efficient and vectorized version of the genetic algorithm. To run the algorithm simply copy and paste the code into a script and hit run. You can adjust the style of selection and crossover used to learn more about how they effect solutions. The algorithm can also handle any target string that uses ASCII characters and will allow for any phrase to be used regardless of length.

%% Genetic Algorithm -- Solves For A User Input String

 

 

toc % Ends timer and prints elapsed time

 

Sample Output: (The Algorithm was run with 1000 population members, Tournament Selection (with tournament size of 4), 1-Point Crossover, and a mutation rate of 10%).

Gen: 1 | Fitness: 465 | C�I1%G+<%?R�8>9�JU#(E�UO�PHI

Gen: 2 | Fitness: 429 | W=P6>D�I)VU6$T 99,� B�BMP0JH

Gen: 46 | Fitness: 0 | METHINKS IT IS LIKE A WEASEL

Elapsed time is 0.099618 seconds.

 

=={{header|Nanoquery}}==

 

target = "METHINKS IT IS LIKE A WEASEL"

 

iter += 1

 

{{out}}

=={{header|Nim}}==

{{trans|Python}}

 

const

 

echo i, " ", parent

 

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

class Evolutionary {

target : static : String;

}

}

 

Output:

=={{header|OCaml}}==

 

let charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "

let tlen = String.length target

incr i

done;

 

=={{header|Octave}}==

{{trans|R}}

 

target = split("METHINKS IT IS LIKE A WEASEL", "");

charset = ["A":"Z", " "];

endwhile

disp(parent');

 

=={{header|Oforth}}==

 

5 Constant new: RATE

ListBuffer init(C, #[ parent mutate ]) dup add(parent)

maxFor(#[ target fitness ]) dup ->parent . dup println 1+

 

{{out}}

=={{header|OoRexx}}==

Run with Open Object Rexx 4.1.0 by IBM Corporation 1995,2004 Rexx LA 2005-2010. Host OS: Microsoft Windows 7.

/* Weasel.rex - Me thinks thou art a weasel. - G,M.D. - 2/25/2011 */

arg C M

end

return result

Output:

<div style='height: 15em; overflow: scroll'><pre>

=={{header|OxygenBasic}}==

The algorithm pared down to the essentials. It takes around 1200 to 6000 mutations to attain the target. Fitness is measured by the number of beneficial mutations. The cycle ends when this is equal to the string length.

 

'EVOLUTION

end do

print progeny " " gens 'RESULT (range 1200-6000 generations)

 

=={{header|Oz}}==

Target = "METHINKS IT IS LIKE A WEASEL"

C = 100

end

in

 

=={{header|PARI/GP}}==

 

This code is inefficient (tens of milliseconds) since it converts back and forth between string and vector format. A more efficient version would keep the information in a Vecsmall instead.

fitness(s)=-dist(Vec(s),Vec(target));

dist(u,v)=sum(i=1,min(#u,#v),u[i]!=v[i])+abs(#u-#v);

ct;

}

 

=={{header|Pascal}}==

This Pascal version of the program displays the initial random string and every hundredth generation after that. It also displays the final generation count. Mutation happens relatively slowly, about once in every 1000 characters, but this can be changed by altering the RATE constant. Lower values for RATE actually speed up the mutations.

 

 

CONST

WRITE('The string was matched in ');

WRITELN(GENERATIONS, ' generations.')

 

=={{header|Perl}}==

This implementation usually converges in less than 70 iterations.

 

use List::MoreUtils 'false';

 

map {mutate $mutation_rate, $parent}

1 .. $C;

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

define('TARGET','METHINKS IT IS LIKE A WEASEL');

define('TBL','ABCDEFGHIJKLMNOPQRSTUVWXYZ ');

} while($best);

 

Sample Output:

<pre>

Generation 178, score 0: METHINKS IT IS LIKE A WEASEL

</pre>

 

=={{header|PicoLisp}}==

This example uses 'gen', the genetic function in "lib/simul.l"

 

(setq *Target (chop "METHINKS IT IS LIKE A WEASEL"))

C ) ) # return the current char

A ) )

Output:

<pre>RQ ASLWWWI ANSHPNABBAJ ZLTKX

the rate is fixed at 2 as that is the lowest most successful rate still in the spirit of the original proposal (where mutation allows a previously successful change to be undone). if the rate is 1 than every successful character change can not change again (because it would not cause an improvement and thus be rejected.)

 

 

string mutate(string data, int rate)

}

}

 

Output:

=={{header|Pony}}==

{{trans|Java}}

 

actor Main

end

end

Output:

<pre>100: UMMMDNKR IEIIB IIKZ A THAHEL, fitness: 14, rate: 0.455

'''Alternative solution:'''<br>

Using a more OO approach that leverages classes for encapsulation.

use "collections"

 

until best.string == desired.string end

 

 

Output:

=={{header|Prolog}}==

{{works with|SWI Prolog|6.2.6 by Jan Wielemaker, University of Amsterdam}}

 

rndAlpha(64, 32). % Generate a single random character

weasel :- % Chance->probability for a mutation, T=Target, Start=initial text

target(T), length(T, Len), rndTxt(Len, Start), Chance is 1 - (1/(Len+1)),

Output:

<pre> time(weasel).

 

=={{header|PureBasic}}==

Define.s target$ = "METHINKS IT IS LIKE A WEASEL"

Define.s charSet$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "

Wend

 

 

=={{header|Python}}==

Using lists instead of strings for easier manipulation, and a mutation rate that gives more mutations the further the parent is away from the target.

from random import choice, random

parent2 = max(copies[center:], key=fitness)

parent = max(mate(parent1, parent2), key=fitness)

 

Sample output

 

A simpler Python version that converges in less steps:

 

target = list("METHINKS IT IS LIKE A WEASEL")

parent = min(copies, key=neg_fitness)

print "%3d" % i, "".join(parent)

 

=={{header|R}}==

 

 

## Easier if the string is a character vector

}

}

 

output:

Very close to former solution, but a bit easier.

 

set.seed(42)

target= unlist(strsplit("METHINKS IT IS LIKE A WEASEL", ""))

parent= evolve(parent)

cat(paste0(parent, collapse=""), "\n")

 

 

=={{header|Racket}}==

 

#lang racket

 

(printf "~s Total strings: ~s\n" C (for/sum ([n ns]) (* n 50))))

(for ([C (in-range 10 501 10)]) (try-run C 0.001))

 

=={{header|Raku}}==

(formerly Perl 6)

constant @alphabet = flat 'A'..'Z',' ';

 

 

 

=={{header|REXX}}==

::* &nbsp; optimized for speed (only one random number/mutation)

::* &nbsp; supports an alphabet with lowercase letters and other letters and/or punctuation.

parse arg children MR seed . /*get optional arguments from the C.L. */

if children=='' | children=="," then children=10 /*# children produced each generation. */

else $= $ || substr(x , j , 1)

end /*j*/

{{out|output|text=&nbsp; when using the following input: &nbsp; &nbsp; <tt> 20 &nbsp; 4% &nbsp; 11 </tt>}}

<pre>

<br>generating a random character &nbsp; ['''@.n'''] &nbsp; during mutation, &nbsp; thus making it slightly faster &nbsp; (about 10%),

<br>especially for a longer string and/or a low mutation rate.

parse arg children MR seed . /*get optional arguments from the C.L. */

if children=='' | children=="," then children=10 /*# children produced each generation. */

else $= $ || substr(x, m, 1)

end /*m*/

{{out|output|text=&nbsp; is the same as the previous version.}}

<br><br>

 

=={{header|Ring}}==

# Project : Evolutionary algorithm

 

next

return number(str)

Output:

<pre>

 

{{trans|C}}

Charset = [" ", *"A".."Z"]

COPIES = 100

parent = copies.max_by {|c| fitness(c)}

end

 

{{out}}

 

=={{header|Rust}}==

//!

//! A simple evolutionary algorithm written in Rust.

c => c as char,

}

{{out}}

<div style='height: 15em; overflow: scroll'><pre>

{{works with|Scala|2.8.1}}

 

 

case class LearnerParams(target:String,rate:Double,C:Int)

implicit val params = LearnerParams("METHINKS IT IS LIKE A WEASEL",0.01,100)

val initial = (1 to params.target.size) map(x => randchar) mkString

 

=={{header|Scheme}}==

 

(import (scheme base)

(scheme write)

(display (string-append "Found: " parent "\n")))

(display parent) (newline))

 

=={{header|Seed7}}==

 

const string: table is "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";

incr(generation);

until best = 0;

 

=={{header|SequenceL}}==

{{trans|C#}}

'''SequenceL Code:'''<br>

 

AllowedChars := " ABCDEFGHIJKLMNOPQRSTUVWXYZ";

fitnesses := Fitness(target, mutations);

in

 

'''C++ Driver Code:'''<br>

#include <time.h>

#include "SL_Generated.h"

 

return 0;

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

define mutate_chance = 0.08

define alphabet = [('A'..'Z')..., ' ']

parent != target;

parent = C.of{ mutate(parent) }.max_by(fitness)

 

=={{header|Sinclair ZX81 BASIC}}==

Requires at least 2k of RAM. Displaying everything while it's running (generation count, parent, children, and their fitness scores) slows it down somewhat; but it would be very slow anyway, and it's nice to be able to look in on it from time to time and see how the program's getting along.

20 LET T$="METHINKS IT IS LIKE A WEASEL"

30 LET L=LEN T$

410 IF S$(K)=T$(K) THEN LET R=R+1

420 NEXT K

{{out}}

<pre> 349

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

<shape: #character>

 

randomLetter

[^Letters at: (Random between: 1 and: Letters size)]

 

Use example:

QJUUIQHYXEZORSXGJCAHEWACH KG

QJUUIQHYXEZORSXGJCAHEWWCMSKG

METHINKS IW IS LIKE A WEASEL

METHINKS IT IS LIKE A WEASEL

 

=={{header|Swift}}==

{{trans|Rust}}

 

to target: String,

parent: inout String,

print("Gen 0: \(start) with fitness \(fitness(target: target, sentence: start))")

 

 

{{out}}

 

=={{header|Tailspin}}==

def alphabet: [' ABCDEFGHIJKLMNOPQRSTUVWXYZ'...];

def target: ['METHINKS IT IS LIKE A WEASEL'...];

 

sink evolve

$@.parent -> #

when <{fitness: <=$target::length>}> do

otherwise

'Fitness $.fitness; at generation $@.generation;: "$.candidate...;"$#10;' -> !OUT::write

1..$generationSize -> [$@.parent.candidate... -> \(

when <?(100 -> SYS::randomInt <..~$mutationPercent>)> do $randomCharacter!

 

[1..$target::length -> $randomCharacter] -> countFitness -> !evolve

{{out}}

<pre>

{{works with|Tcl|8.5}}

{{trans|Python}}

 

# A function to select a random character from an argument string

}

puts ""

Produces this example output:

<pre>#100 , fitness 42.9%, 'GSTBIGFS ITLSS LMD NNJPESZL'

===Alternate Presentation===

This alternative presentation factors out all assumption of what constitutes a “fit” solution to the <code>fitness</code> command, which is itself just a binding of the <code>fitnessByEquality</code> procedure to a particular target. None of the rest of the code knows anything about what constitutes a solution (and only <code>mutate</code> and <code>fitness</code> really know much about the data being evolved).

proc tcl::mathfunc::randchar {} {

# A function to select a random character

}

 

 

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

This is a bit of a stretch, since uBasic/4tH doesn't support strings. Hence, the array is used to store the data.

L = 28 ' Length of string

P = T + L ' Address of parent

 

Proc _MutateDNA (P/L, P, 100) ' Now mutate the parent DNA

{{out}}

<pre>ZACXCLONTNTEAMJXYYFEP QQMDTA

takes about 500 iterations give or take 100.

 

#import nat

 

#cast %s

 

output:

<pre>

 

=={{header|UTFool}}==

···

http://rosettacode.org/wiki/Evolutionary_algorithm

generation◥

System.out.println "Target reached by generation #⸨generation⸩"

 

=={{header|vbscript}}==

'This is the string we want to "evolve" to. Any string of any length will

'do as long as it consists only of upper case letters and spaces.

Private Function Random ( lower , upper )

Random = Int((upper - lower + 1) * Rnd + lower)

 

Example output:

=={{header|Visual Basic}}==

Adapted from BBC Basic Code in this page. One diference from BBC Basic code is that in this code mutations are always good

 

 

FNfitness = F / Len(Text)

End Function

 

Example output:

</pre>

 

=={{header|Wren}}==

{{trans|Go}}

 

var target = "METHINKS IT IS LIKE A WEASEL"

}

}

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated convention (instead of MSb)

 

Iter:= Iter+1;

until Best = 0;

 

Example output:

=={{header|zkl}}==

{{trans|D}}

const C = 100; // Number of children in each generation.

const P = 0.05; // Mutation probability.

.reduce(fcn(a,b){ if(fitness(a)<fitness(b)) a else b });

println("Gen %2d, dist=%2d: %s".fmt(gen+=1, fitness(parent), parent));

{{out}}

<pre>