# RPG Attributes Generator

RPG Attributes Generator
You are encouraged to solve this task according to the task description, using any language you may know.

You're running a tabletop RPG, and your players are creating characters.

Each character has six core attributes: strength, dexterity, constitution, intelligence, wisdom, and charisma.

One way of generating values for these attributes is to roll four, 6-sided dice (d6) and sum the three highest rolls, discarding the lowest roll.

Some players like to assign values to their attributes in the order they're rolled.

To ensure generated characters don't put players at a disadvantage, the following requirements must be satisfied:

• The total of all character attributes must be at least 75.
• At least two of the attributes must be at least 15.

However, this can require a lot of manual dice rolling. A programatic solution would be much faster.

Write a program that:

1. Generates 4 random, whole values between 1 and 6.
2. Saves the sum of the 3 largest values.
3. Generates a total of 6 values this way.
4. Displays the total, and all 6 values once finished.

• The order in which each value was generated must be preserved.
• The total of all 6 values must be at least 75.
• At least 2 of the values must be 15 or more.

## C

Translation of: Go
`#include <stdio.h>#include <stdlib.h>#include <time.h> int compareInts(const void *i1, const void *i2) {    int a = *((int *)i1);    int b = *((int *)i2);    return a - b;} int main() {    int i, j, nsum, vsum, vcount, values[6], numbers[4];    srand(time(NULL));    for (;;) {        vsum = 0;        for (i = 0; i < 6; ++i) {            for (j = 0; j < 4; ++j) {                numbers[j] = 1 + rand() % 6;            }            qsort(numbers, 4, sizeof(int), compareInts);            nsum = 0;            for (j = 1; j < 4; ++j) {                nsum += numbers[j];            }            values[i] = nsum;            vsum += values[i];        }        if (vsum < 75) continue;        vcount = 0;        for (j = 0; j < 6; ++j) {            if (values[j] >= 15) vcount++;        }        if (vcount < 2) continue;        printf("The 6 random numbers generated are:\n");        printf("[");        for (j = 0; j < 6; ++j) printf("%d ", values[j]);        printf("\b]\n");        printf("\nTheir sum is %d and %d of them are >= 15\n", vsum, vcount);        break;    }    return 0;}`
Output:

Sample run:

```The 6 random numbers generated are:
[9 15 15 17 13 8]

Their sum is 77 and 3 of them are >= 15
```

## C++

GCC 4.9.2, unoptimised.

`#include <algorithm>#include <ctime>#include <iostream>#include <cstdlib>#include <string> using namespace std; int main(){    srand(time(0));     unsigned int attributes_total = 0;    unsigned int count = 0;    int attributes[6] = {};    int rolls[4] = {};     while(attributes_total < 75 || count < 2)    {        attributes_total = 0;        count = 0;         for(int attrib = 0; attrib < 6; attrib++)        {                        for(int roll = 0; roll < 4; roll++)            {                rolls[roll] = 1 + (rand() % 6);            }             sort(rolls, rolls + 4);            int roll_total = rolls[1] + rolls[2] + rolls[3];                         attributes[attrib] = roll_total;            attributes_total += roll_total;             if(roll_total >= 15) count++;        }    }     cout << "Attributes generated : [";    cout << attributes[0] << ", ";    cout << attributes[1] << ", ";    cout << attributes[2] << ", ";    cout << attributes[3] << ", ";    cout << attributes[4] << ", ";    cout << attributes[5];     cout << "]\nTotal: " << attributes_total;    cout << ", Values above 15 : " << count;     return 0;}`
Output:

Sample run:

```Attributes generated : [13, 13, 17, 14, 10, 16]
Total: 83, Values above 15 : 2
```

## C#

Translation of: Visual Basic .NET
`using System;using System.Collections.Generic;using System.Linq; static class Module1{    static Random r = new Random();     static List<int> getThree(int n)    {        List<int> g3 = new List<int>();        for (int i = 0; i < 4; i++) g3.Add(r.Next(n) + 1);        g3.Sort(); g3.RemoveAt(0); return g3;    }     static List<int> getSix()    {        List<int> g6 = new List<int>();        for (int i = 0; i < 6; i++) g6.Add(getThree(6).Sum());        return g6;    }     static void Main(string[] args)    {        bool good = false; do {            List<int> gs = getSix(); int gss = gs.Sum(); int hvc = gs.FindAll(x => x > 14).Count;            Console.Write("attribs: {0}, sum={1}, ({2} sum, high vals={3})",                          string.Join(", ", gs), gss, gss >= 75 ? "good" : "low", hvc);            Console.WriteLine(" - {0}", (good = gs.Sum() >= 75 && hvc > 1) ? "success" : "failure");        } while (!good);    }}`
Output:

sample outputs:

```attribs: 10, 11, 11, 11, 11, 14, sum=68, (low sum, high vals=0) - failure
attribs: 16, 13, 12, 10, 15, 16, sum=82, (good sum, high vals=3) - success```
`attribs: 16, 8, 9, 15, 16, 12, sum=76, (good sum, high vals=3) - success`

## Crystal

`def roll_stat  dices = Array(Int32).new(4) { rand(1..6) }  dices.sum - dices.minend def roll_character  loop do    stats = Array(Int32).new(6) { roll_stat }    return stats if stats.sum >= 75 && stats.count(&.>=(15)) >= 2  endend 10.times do  stats = roll_character  puts "stats: #{stats}, sum is #{stats.sum}"end`

sample output:

```stats: [14, 11, 18, 14, 12, 16], sum is 85
stats: [10, 12, 13, 16, 17, 16], sum is 84
stats: [12, 17, 13, 11, 17, 13], sum is 83
stats: [16, 12, 11, 9, 16, 12], sum is 76
stats: [14, 17, 12, 15, 16, 14], sum is 88
stats: [9, 17, 17, 7, 9, 16], sum is 75
stats: [17, 14, 17, 12, 12, 13], sum is 85
stats: [16, 8, 14, 12, 11, 16], sum is 77
stats: [17, 13, 11, 10, 14, 16], sum is 81
stats: [11, 16, 11, 13, 15, 16], sum is 82```

## Factor

Works with: Factor version 0.98
`USING: combinators.short-circuit dice formatting io kernel mathmath.statistics qw sequences ;IN: rosetta-code.rpg-attributes-generator CONSTANT: stat-names qw{ Str Dex Con Int Wis Cha } : attribute ( -- n )    4 [ ROLL: 1d6 ] replicate 3 <iota> kth-largests sum ; : stats ( -- seq ) 6 [ attribute ] replicate ; : valid-stats? ( seq -- ? )    { [ [ 15 >= ] count 2 >= ] [ sum 75 >= ] } 1&& ; : generate-valid-stats ( -- seq )    f [ dup valid-stats? ] [ drop stats ] do until ; : stats-info ( seq -- )    [ sum ] [ [ 15 >= ] count ] bi    "Total: %d\n# of attributes >= 15: %d\n" printf ; : main ( -- )    generate-valid-stats dup stat-names swap    [ "%s: %d\n" printf ] 2each nl stats-info ; MAIN: main`
Output:
```Str: 9
Dex: 13
Con: 14
Int: 17
Wis: 17
Cha: 11

Total: 81
# of attributes >= 15: 2
```

## Go

`package main import (    "fmt"    "math/rand"    "sort"    "time") func main() {    s := rand.NewSource(time.Now().UnixNano())    r := rand.New(s)    for {        var values [6]int        vsum := 0        for i := range values {            var numbers [4]int            for j := range numbers {                numbers[j] = 1 + r.Intn(6)            }            sort.Ints(numbers[:])            nsum := 0            for _, n := range numbers[1:] {                nsum += n            }            values[i] = nsum            vsum += values[i]        }        if vsum < 75 {            continue        }        vcount := 0        for _, v := range values {            if v >= 15 {                vcount++            }        }        if vcount < 2 {            continue        }        fmt.Println("The 6 random numbers generated are:")        fmt.Println(values)        fmt.Println("\nTheir sum is", vsum, "and", vcount, "of them are >= 15")        break    }}`
Output:

Sample run:

```The 6 random numbers generated are:
[16 15 7 14 9 15]

Their sum is 76 and 3 of them are >= 15
```

`import Control.Monad (replicateM)import System.Random (randomRIO)import Data.List (sort) character :: IO [Int]character =  discardUntil    (((&&) . (75 <) . sum) <*> ((2 <=) . length . filter (15 <=)))    (replicateM 6 \$     (sum . tail . sort) <\$> replicateM 4 (randomRIO (1, 6 :: Int))) discardUntil :: ([Int] -> Bool) -> IO [Int] -> IO [Int]discardUntil p throw =  let go =        throw >>=        \x ->           if p x             then return x             else go  in go -- TEST -----------------------------------------------------------main :: IO ()main = replicateM 10 character >>= mapM_ (print . (sum >>= (,)))`
Output:
```Sample computation:

(86,[15,13,17,17,13,11])
(80,[16,11,15,13,11,14])
(77,[15,8,15,11,15,13])
(76,[12,11,17,11,7,18])
(76,[11,16,8,15,15,11])
(87,[14,15,12,16,15,15])
(84,[11,11,16,15,15,16])
(77,[14,13,15,8,11,16])
(80,[12,15,11,17,15,10])
(89,[15,12,16,17,12,17])```

## Java

`     static boolean goodRoll = false;     public static int genAttribute(){        // Create a new Random object to populate our array with. We use nextInt(6)+1 because 6 is exclusive and 0 is inclusive        Random dice = new Random();        int[] sumArray = {dice.nextInt(6)+1, dice.nextInt(6)+1, dice.nextInt(6)+1, dice.nextInt(6)+1};         // Sort the array ascending, last 3 dice will always be the highest, return sum.        java.util.Arrays.sort(sumArray);        return (sumArray[1] + sumArray[2] + sumArray[3]);    }     public static boolean checkFinalArray(int[] checkArray){        int fifteenCount = 0;         // First check for how many 15+'s        for (int z : checkArray){            if (z >= 15){                fifteenCount++;            }        }         return (fifteenCount >= 2 && Arrays.stream(checkArray).sum() >= 75);    }     public static void main(String[] args) {        // Here we use a while loop to make sure that while the conditions aren't met, we reroll.        while (!goodRoll){            int[] finalArray;            finalArray = new int[6];             // Generate 6 attributes using above method genAttributes()            for (int i = 0; i<6;++i){                finalArray[i] = genAttribute();            }            // Pass finalArray to be checked            if (checkFinalArray(finalArray)){                System.out.println("sum: " + Arrays.stream(finalArray).sum());                // Enhanced for to print each die                for (int x : finalArray){                    System.out.println(x);                }                goodRoll = true; // Exit the loop if conditions are met.            }              }    } `
Output:
```sum: 79
10
16
14
16
8
15
```

## JavaScript

### Imperative

`function roll() {  const stats = {    total: 0,    rolls: []  }  let count = 0;   for(let i=0;i<=5;i++) {    let d6s = [];     for(let j=0;j<=3;j++) {      d6s.push(Math.ceil(Math.random() * 6))    }         d6s.sort().splice(0, 1);    rollTotal = d6s.reduce((a, b) => a+b, 0);     stats.rolls.push(rollTotal);    stats.total += rollTotal;   }   return stats;} let rolledCharacter = roll(); while(rolledCharacter.total < 75 || rolledCharacter.rolls.filter(a => a >= 15).length < 2){  rolledCharacter = roll();} console.log(`The 6 random numbers generated are:\${rolledCharacter.rolls.join(', ')} Their sum is \${rolledCharacter.total} and \${rolledCharacter.rolls.filter(a => a >= 15).length} of them are >= 15`);`
Output:

Sample run:

```The 6 random numbers generated are:
11, 17, 12, 12, 9, 16

Their sum is 77 and 2 of them are >= 15
```

### Functional

`(() => {  'use strict';   // main :: IO ()  const main = () =>    console.log(      unlines(        map(          () => {            const xs = character();            return showJSON([sum(xs), xs]);          },          enumFromTo(1, 10)        )      )    );   // character :: ([Int] -> Bool) -> [Int]  const character = () =>    discardUntil(      xs => 75 <= sum(xs) && 2 <= length(filter(x => 15 <= x, xs))    )(      () => map(        () => composeList([sum, tail, sort])(          map(x => randomRInt(1, 6), enumFromTo(1, 4))        ),        enumFromTo(1, 6)      )    );   // discardUntil :: ([Int] -> Bool) -> (() -> [Int]) -> [Int]  const discardUntil = p => f => {    const go = () => {      const xs = f();      return p(xs) ? xs : go();    }    return go();  };    // GENERIC FUNCTIONS ------------------------------------   // composeList :: [(a -> a)] -> (a -> a)  const composeList = fs =>    x => fs.reduceRight((a, f) => f(a), x, fs);   // enumFromTo :: Int -> Int -> [Int]  const enumFromTo = (m, n) =>    Array.from({      length: 1 + n - m    }, (_, i) => m + i)   // filter :: (a -> Bool) -> [a] -> [a]  const filter = (f, xs) => xs.filter(f);   // Returns Infinity over objects without finite length  // this enables zip and zipWith to choose the shorter  // argument when one is non-finite, like cycle, repeat etc   // length :: [a] -> Int  const length = xs => xs.length || Infinity;   // map :: (a -> b) -> [a] -> [b]  const map = (f, xs) => xs.map(f);   // randomRInt :: Int -> Int -> Int  const randomRInt = (low, high) =>    low + Math.floor(      (Math.random() * ((high - low) + 1))    );   // showJSON :: a -> String  const showJSON = x => JSON.stringify(x);   // sort :: Ord a => [a] -> [a]  const sort = xs => xs.slice()    .sort((a, b) => a < b ? -1 : (a > b ? 1 : 0));   // sum :: [Num] -> Num  const sum = xs => xs.reduce((a, x) => a + x, 0);   // tail :: [a] -> [a]  const tail = xs => 0 < xs.length ? xs.slice(1) : [];   // unlines :: [String] -> String  const unlines = xs => xs.join('\n');   // MAIN ---  main();})();`
Output:

A sample of 10 character attribute sets:

```[83,[9,13,16,17,12,16]]
[79,[13,16,12,10,16,12]]
[78,[15,11,13,14,15,10]]
[76,[16,13,11,15,10,11]]
[82,[13,7,16,15,16,15]]
[79,[14,14,14,14,13,10]]
[77,[9,9,15,16,16,12]]
[85,[16,15,16,11,12,15]]
[77,[15,12,12,9,14,15]]
[83,[17,15,14,14,11,12]]```

## Julia

`roll_skip_lowest(dice, sides) = (r = rand(collect(1:sides), dice); sum(r) - minimum(r)) function rollRPGtoon()    attributes = zeros(Int, 6)    attsum = 0    gte15 = 0     while attsum < 75 || gte15 < 2        for i in 1:6            attributes[i] = roll_skip_lowest(4, 6)        end        attsum = sum(attributes)        gte15 = mapreduce(x -> x >= 15, +, attributes)    end     println("New RPG character roll: \$attributes. Sum is \$attsum, and \$gte15 are >= 15.")end rollRPGtoon()rollRPGtoon()rollRPGtoon() `
Output:
```
New RPG character roll: [15, 16, 15, 11, 9, 15]. Sum is 81, and 4 are >= 15.
New RPG character roll: [12, 14, 15, 12, 10, 16]. Sum is 79, and 2 are >= 15.
New RPG character roll: [10, 12, 13, 13, 15, 17]. Sum is 80, and 2 are >= 15.

```

## Kotlin

`// Version 1.2.51 import java.util.Random fun main(args: Array<String>) {    val r = Random()    while (true) {        val values = IntArray(6)        for (i in 0..5) {            val numbers = IntArray(4) { 1 + r.nextInt(6) }            numbers.sort()            values[i] = numbers.drop(1).sum()        }        val vsum = values.sum()        val vcount = values.count { it >= 15 }        if (vsum < 75 || vcount < 2) continue        println("The 6 random numbers generated are:")        println(values.asList())        println("\nTheir sum is \$vsum and \$vcount of them are >= 15")        break    }}`
Output:

Sample run:

```The 6 random numbers generated are:
[13, 14, 13, 15, 17, 8]

Their sum is 80 and 2 of them are >= 15
```

## Pascal

` program attributes; var   total, roll,score, count: integer;   atribs : array [1..6] of integer; begin     randomize; {Initalise the random number genertor}    repeat        count:=0;        total:=0;        for score :=1 to 6 do begin           {roll:=random(18)+1;   produce a number up to 18, pretty much the same results}           for diceroll:=1 to 4 do dice[diceroll]:=random(6)+1; {roll 4 six sided die}            {find lowest rolled dice. If we roll two or more equal low rolls then we	    eliminate the first of them, change '<' to '<=' to eliminate last low die}           lowroll:=7;	   lowdie:=0;	   for diceroll:=1 to 4 do if (dice[diceroll] < lowroll) then begin	       lowroll := dice[diceroll];	       lowdie := diceroll; 	   end;           {add up higest three dice}	   roll:=0;	   for diceroll:=1 to 4 do if (diceroll <> lowdie) then roll := roll + dice[diceroll];           atribs[score]:=roll;           total := total + roll;           if (roll>15) then count:=count+1;        end;   until ((total>74) and (count>1)); {this evens out different rolling methods }   { Prettily print the attributes out }   writeln('Attributes :');   for count:=1 to 6 do      writeln(count,'.......',atribs[count]:2);   writeln('       ---');   writeln('Total  ',total:3);   writeln('       ---');end. `
Output:
```Attributes :
1....... 5
2.......13
3....... 8
4.......17
5.......15
6.......18
---
Total   76
---
Attributes :
1.......17
2.......13
3.......17
4.......12
5.......12
6.......16
---
Total   87
---
Attributes :
1.......16
2....... 9
3.......10
4.......17
5.......15
6....... 9
---
Total   76
```

## Perl 6

Works with: Rakudo Star version 2018.04.1
`my ( \$min_sum, \$hero_attr_min, \$hero_count_min ) = 75, 15, 2;my @attr-names = <Str Int Wis Dex Con Cha>; sub heroic { + @^a.grep: * >= \$hero_attr_min } my @attr;repeat until @attr.sum     >= \$min_sum         and heroic(@attr) >= \$hero_count_min {     @attr = @attr-names.map: { (1..6).roll(4).sort(+*).skip(1).sum };} say @attr-names Z=> @attr;say "Sum: {@attr.sum}, with {heroic(@attr)} attributes >= \$hero_attr_min";`
Output:
```(Str => 15 Int => 16 Wis => 13 Dex => 11 Con => 15 Cha => 6)
Sum: 76, with 3 attributes >= 15
```

## Phix

`sequence numbers = repeat(0,6)integer t,nwhile true do    for i=1 to length(numbers) do        sequence ni = sq_rand(repeat(6,4))        numbers[i] = sum(ni)-min(ni)    end for    t = sum(numbers)    n = sum(sq_ge(numbers,15))    if t>=75 and n>=2 then exit end if    ?"re-rolling..."  -- (occasionally >20)end whileprintf(1,"The 6 attributes generated are:\n")printf(1,"strength %d, dexterity %d, constitution %d, "&         "intelligence %d, wisdom %d, and charisma %d.\n",         numbers)printf(1,"\nTheir sum is %d and %d of them are >=15\n",{t,n})`
Output:
```"re-rolling..."
"re-rolling..."
The 6 attributes generated are:
strength 14, dexterity 15, constitution 17, intelligence 9, wisdom 13, and charisma 18.

Their sum is 86 and 3 of them are >=15
```

## PHP

`<?php \$attributesTotal = 0;\$count = 0; while(\$attributesTotal < 75 || \$count < 2) {    \$attributes = [];     foreach(range(0, 5) as \$attribute) {        \$rolls = [];         foreach(range(0, 3) as \$roll) {            \$rolls[] = rand(1, 6);        }         sort(\$rolls);        array_shift(\$rolls);         \$total = array_sum(\$rolls);         if(\$total >= 15) {            \$count += 1;        }         \$attributes[] = \$total;    }     \$attributesTotal = array_sum(\$attributes);} print_r(\$attributes);`

## PureBasic

`#heroicAttributeMinimum = 15#heroicAttributeCountMinimum = 2#attributeSumMinimum = 75#attributeCount = 6 Procedure roll_attribute()  Protected i, sum  Dim rolls(3)   For i = 0 To 3    rolls(i) = Random(6, 1)  Next i   ;sum the highest three rolls  SortArray(rolls(), #PB_Sort_Descending)  For i = 0 To 2    sum + rolls(i)  Next  ProcedureReturn sumEndProcedure Procedure displayAttributes(List attributes(), sum, heroicCount)  Protected output\$   output\$ = "Attributes generated: ["  ForEach attributes()    output\$ + attributes()    If ListIndex(attributes()) <> #attributeCount - 1: output\$ + ", ": EndIf  Next  output\$ + "]"  PrintN(output\$)  PrintN("Total: " + sum + ", Values " + #heroicAttributeMinimum + " or above: " + heroicCount)EndProcedure Procedure Gen_attributes()  Protected i, attributesSum, heroicAttributesCount   NewList attributes()  Repeat    ClearList(attributes())    attributesSum = 0: heroicAttributesCount = 0    For i = 1 To #attributeCount      AddElement(attributes())      attributes() = roll_attribute()      attributesSum + attributes()      heroicAttributesCount + Bool(attributes() >= #heroicAttributeMinimum)    Next  Until attributesSum >= #attributeSumMinimum And heroicAttributesCount >= #heroicAttributeCountMinimum   displayAttributes(attributes(), attributesSum, heroicAttributesCount)EndProcedure If OpenConsole("RPG Attributes Generator")  Gen_attributes()  Print(#CRLF\$ + #CRLF\$ + "Press ENTER to exit"): Input()  CloseConsole()EndIf`

Sample output:

```Attributes generated: [13, 17, 17, 11, 9, 17]
Total: 84, Values 15 or above: 3```

## Python

### Python: Simple

`import randomrandom.seed()attributes_total = 0count = 0 while attributes_total < 75 or count < 2:    attributes = []     for attribute in range(0, 6):        rolls = []         for roll in range(0, 4):            result = random.randint(1, 6)            rolls.append(result)         sorted_rolls = sorted(rolls)        largest_3 = sorted_rolls[1:]        rolls_total = sum(largest_3)         if rolls_total >= 15:            count += 1         attributes.append(rolls_total)     attributes_total = sum(attributes) print(attributes_total, attributes)`
Output:

Sample run:

`(74, [16, 10, 12, 9, 16, 11])`

### Python: Nested Comprehensions #1

`import randomrandom.seed()total = 0count = 0 while total < 75 or count < 2:    attributes = [(sum(sorted([random.randint(1, 6) for roll in range(0, 4)])[1:])) for attribute in range(0, 6)]         for attribute in attributes:        if attribute >= 15:            count += 1     total = sum(attributes) print(total, attributes)`
Output:

Sample run:

`(77, [17, 8, 15, 13, 12, 12])`

### Python: Nested Comprehensions #2

With comprehensions for checking candidate values in the while expression.

`import random def compute():    values = []    while (sum(values) < 75                            # Total must be >= 75           or sum(1 for v in values if v >= 15) < 2):  # Two must be >= 15        values = [sum(sorted(random.randint(1, 6) for _ in range(4))[1:]) for _ in range(6)]    return sum(values), values for i in range(3):    print(*compute()) `
Output:
```81 [12, 17, 9, 9, 17, 17]
75 [16, 7, 13, 12, 15, 12]
81 [15, 11, 15, 16, 10, 14]```

## Racket

`#lang racket (define (d6 . _)  (+ (random 6) 1)) (define (best-3-of-4d6 . _)  (apply + (rest (sort (build-list 4 d6) <)))) (define (generate-character)  (let* ((rolls (build-list 6 best-3-of-4d6))         (total (apply + rolls)))    (if (or (< total 75) (< (length (filter (curryr >= 15) rolls)) 2))        (generate-character)        (values rolls total)))) (module+ main  (define-values (rolled-stats total) (generate-character))  (printf "Rolls:\t~a~%Total:\t~a" rolled-stats total))`
Output:
```Rolls:	(11 16 10 13 12 15)
Total:	77```

## REXX

### version 1

`/* REXXGenerates 4 random, whole values between 1 and 6.Saves the sum of the 3 largest values.Generates a total of 6 values this way.Displays the total, and all 6 values once finished.*/Do try=1 By 1  ge15=0  sum=0  ol=''  Do i=1 To 6    rl=''    Do j=1 To 4      rl=rl (random(5)+1)      End    rl=wordsort(rl)    rsum.i=maxsum()    If rsum.i>=15 Then ge15=ge15+1    sum=sum+rsum.i    ol=ol right(rsum.i,2)    End  Say ol '->' ge15 sum  If ge15>=2 & sum>=75 Then Leave  EndSay try 'iterations'Say ol '=>' sumExit maxsum: procedure Expose rl/*********************************************************************** Comute the sum of the 3 largest values**********************************************************************/  m=0  Do i=2 To 4    m=m+word(rl,i)    End  Return m wordsort: Procedure/*********************************************************************** Sort the list of words supplied as argument. Return the sorted list**********************************************************************/  Parse Arg wl  wa.=''  wa.0=0  Do While wl<>''    Parse Var wl w wl    Do i=1 To wa.0      If wa.i>w Then Leave      End    If i<=wa.0 Then Do      Do j=wa.0 To i By -1        ii=j+1        wa.ii=wa.j        End      End    wa.i=w    wa.0=wa.0+1    End  swl=''  Do i=1 To wa.0    swl=swl wa.i    End  Return strip(swl)`
Output:
```I:\>rexx cast
13 13  8 15 14 11 -> 1 74
10  9 13  7 15  9 -> 1 63
15 15 14 13 17 14 -> 3 88
3 iterations
15 15 14 13 17 14 => 88```

### version 2

This REXX version doesn't need a sort to compute the sum of the largest three (of four) values.

`/*REXX program generates values for six core attributes for a  RPG  (Role Playing Game).*/   do  until  m>=2 & \$\$>=75;   \$\$= 0;     list=  /*do rolls until requirements are met. */   m= 0                                          /*the number of values ≥ 15   (so far).*/        do 6;                  \$= 0              /*6 values (meet criteria); attrib. sum*/             do d=1  for 4;    @.d= random(1, 6) /*roll four random dice (six sided die)*/             \$= \$ + @.d                          /*also obtain their sum  (of die pips).*/             end   /*d*/                         /* [↓]  use of MIN  BIF avoids sorting.*/        \$= \$  -  min(@.1, @.2, @.3, @.4)         /*obtain the sum of the highest 3 rolls*/        list= list  \$;         \$\$= \$\$ + \$        /*append \$──►list; add \$ to overall \$\$.*/        \$\$= \$\$ + \$                               /*add the  \$  sum  to the overall sum. */        m= m + (\$>=15)                           /*get # of rolls that meet the minimum.*/        end       /*do 6*/                       /* [↑]  gen six core attribute values. */   end            /*until*/                      /*stick a fork in it,  we're all done. */say 'The total for '     list      "  is ──► "       \$\$', '     m     " entries are ≥ 15."`
output   when using the default (internal) inputs:
```The total for   14 12 15 16 14 15   is ──►  86,  3  entries are ≥ 15.
```

### version 3

A variation of version 2

`/*REXX program generates values for six core attributes for an RPG (Role Playing Game).*/Do n=1 By 1 until m>=2 & tot>=75;  slist=''  tot=0  m=0  Do 6    sum=0    Do d=1 To 4;      cast.d=random(1,6)      sum=sum+cast.d      End    min=min(cast.1,cast.2,cast.3,cast.4)    sum=sum-min    slist=slist sum    tot=tot+sum    m=m+(sum>=15)    end  Say 'the total for' space(slist) 'is -->' tot', 'm' entries are >= 15.'  endSay 'Solution found with' n 'iterations'`
Output:
```I:\>rexx rpg
the total for 12 14 14 13 12 9 is --> 74, 0 entries are >= 15.
the total for 15 11 13 14 10 10 is --> 73, 1 entries are >= 15.
the total for 18 12 12 11 16 10 is --> 79, 2 entries are >= 15.
Solution found with 3 iterations```

## Ring

` # Project  : RPG Attributes Generator load "stdlib.ring"attributestotal = 0count = 0while attributestotal < 75 or count < 2        attributes = []         for attribute = 0 to 6             rolls = []              largest3 = []              for roll = 0 to 4                  result = random(5)+1                  add(rolls,result)             next              sortedrolls = sort(rolls)             sortedrolls = reverse(sortedrolls)             for n = 1 to 3                  add(largest3,sortedrolls[n])             next             rollstotal = sum(largest3)              if rollstotal >= 15                count = count + 1             ok              add(attributes,rollstotal)        next        attributestotal = sum(attributes)endshowline()  func sum(aList)       num = 0       for n = 1 to len(aList)            num = num + aList[n]       next       return num func showline()        line = "(" + attributestotal + ", ["        for n = 1 to len(attributes)             line = line + attributes[n] + ", "        next        line = left(line,len(line)-2)        line = line + "])"        see line + nl `

Output:

```(95, [14, 11, 14, 13, 16, 11, 16])
```

## Scala

` import scala.util.RandomRandom.setSeed(1) def rollDice():Int = {  val v4 = Stream.continually(Random.nextInt(6)+1).take(4)  v4.sum - v4.min} def getAttributes():Seq[Int] = Stream.continually(rollDice()).take(6) def getCharacter():Seq[Int] = {  val attrs = getAttributes()  println("generated => " + attrs.mkString("[",",", "]"))  (attrs.sum, attrs.filter(_>15).size) match {    case (a, b)  if (a < 75 || b < 2) => getCharacter    case _ => attrs  }} println("picked => " + getCharacter.mkString("[", ",", "]")) `
```generated => [13,13,12,11,10,14]
generated => [17,12,15,11,9,6]
generated => [16,9,9,11,13,14]
generated => [11,12,10,18,7,17]
picked => [11,12,10,18,7,17]
```

## Visual Basic .NET

repeats until a successful outcome occurs

`Module Module1     Dim r As New Random     Function getThree(n As Integer) As List(Of Integer)        getThree = New List(Of Integer)        For i As Integer = 1 To 4 : getThree.Add(r.Next(n) + 1) : Next        getThree.Sort() : getThree.RemoveAt(0)    End Function     Function getSix() As List(Of Integer)        getSix = New List(Of Integer)        For i As Integer = 1 To 6 : getSix.Add(getThree(6).Sum) : Next    End Function     Sub Main(args As String())        Dim good As Boolean = False : Do            Dim gs As List(Of Integer) = getSix(), gss As Integer = gs.Sum,                hvc As Integer = gs.FindAll(Function(x) x > 14).Count            Console.Write("attribs: {0}, sum={1}, ({2} sum, high vals={3})",                          String.Join(", ", gs), gss, If(gss >= 75, "good", "low"), hvc)            good = gs.Sum >= 75 AndAlso hvc > 1            Console.WriteLine(" - {0}", If(good, "success", "failure"))        Loop Until good    End SubEnd Module`
Output:

sample outputs:

```attribs: 8, 15, 10, 13, 12, 8, sum=66, (low sum, high vals=1) - failure
attribs: 9, 11, 7, 10, 17, 12, sum=66, (low sum, high vals=1) - failure
attribs: 18, 14, 12, 11, 16, 9, sum=80, (good sum, high vals=2) - success```
```attribs: 10, 12, 9, 13, 17, 6, sum=67, (low sum, high vals=1) - failure
attribs: 14, 11, 17, 12, 8, 11, sum=73, (low sum, high vals=1) - failure
attribs: 13, 9, 12, 14, 10, 13, sum=71, (low sum, high vals=0) - failure
attribs: 13, 9, 14, 14, 14, 12, sum=76, (good sum, high vals=0) - failure
attribs: 11, 12, 7, 8, 10, 11, sum=59, (low sum, high vals=0) - failure
attribs: 15, 4, 9, 18, 9, 12, sum=67, (low sum, high vals=2) - failure
attribs: 17, 16, 14, 8, 8, 9, sum=72, (low sum, high vals=2) - failure
attribs: 18, 16, 13, 9, 9, 10, sum=75, (good sum, high vals=2) - success```

## zkl

`reg attrs=List(), S,N;do{   attrs.clear();   do(6){      abcd:=(4).pump(List,(0).random.fp(1,7));   // list of 4 [1..6] randoms      attrs.append(abcd.sum(0) - (0).min(abcd)); // sum and substract min   }}while((S=attrs.sum(0))<75 or (N=attrs.filter('>=(15)).len())<2);println("Random numbers: %s\nSums to %d, with %d >= 15"        .fmt(attrs.concat(","),S,N));`
Output:
```Random numbers: 15,15,7,17,10,13
Sums to 77 with 3 >= 15
```