RPG attributes generator: Difference between revisions

From Rosetta Code
Content added Content deleted
m (→‎Python: Functional composition: (Edited type comments))
(→‎Functional JS: Updated in translation of the Python version)
Line 459: Line 459:


===Functional===
===Functional===
{{Trans|Python}} (Functional composition version)
{{Trans|Haskell}}
<lang javascript>(() => {
<lang javascript>(() => {
'use strict';
'use strict';


// main :: IO ()
// main :: IO ()
const main = () =>
const main = () =>
// 10 random heroes drawn from
console.log(
// a non-finite series.
unlines(
map(
unlines(map(
() => {
xs => show(sum(xs)) +
const xs = character();
' -> [' + show(xs) + ']',
return showJSON([sum(xs), xs]);
},
enumFromTo(1, 10)
)
)
);


take(10, heroes(
// character :: ([Int] -> Bool) -> [Int]
seventyFivePlusWithTwo15s
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]
// seventyFivePlusWithTwo15s :: [Int] -> Bool
const seventyFivePlusWithTwo15s = xs =>
const discardUntil = p => f => {
const go = () => {
// Total score over 75,
// with two or more qualities scoring 15.
const xs = f();
return p(xs) ? xs : go();
75 < sum(xs) && 1 < length(filter(
x => 15 === x, xs
));


function* heroes(p) {
// Non-finite list of heroes matching
// the requirements of predicate p.
while (true) {
yield hero(p)
}
}
}
return go();
};


// hero :: (Int -> Bool) -> IO (Int, Int, Int, Int, Int, Int)
const hero = p =>
// A random character matching the
// requirements of predicate p.
until(p, character, []);

// character :: () -> [Int]
const character = () =>
// A random character with six
// integral attributes.
map(() => sum(tail(sort(map(
randomRInt(1, 6),
enumFromTo(1, 4)
)))),
enumFromTo(1, 6)
);


// GENERIC FUNCTIONS ----------------------------------

// enumFromTo :: (Int, Int) -> [Int]
const enumFromTo = (m, n) =>
Array.from({
length: 1 + n - m
}, (_, i) => m + i);


// filter :: (a -> Bool) -> [a] -> [a]
// GENERIC FUNCTIONS ------------------------------------
const filter = (f, xs) => xs.filter(f);


// Returns Infinity over objects without finite length.
// composeList :: [(a -> a)] -> (a -> a)
// This enables zip and zipWith to choose the shorter
const composeList = fs =>
// argument when one is non-finite, like cycle, repeat etc
x => fs.reduceRight((a, f) => f(a), x, fs);


// enumFromTo :: Int -> Int -> [Int]
// length :: [a] -> Int
const enumFromTo = (m, n) =>
const length = xs =>
(Array.isArray(xs) || 'string' === typeof xs) ? (
Array.from({
length: 1 + n - m
xs.length
}, (_, i) => m + i)
) : Infinity;


// filter :: (a -> Bool) -> [a] -> [a]
// map :: (a -> b) -> [a] -> [b]
const filter = (f, xs) => xs.filter(f);
const map = (f, xs) =>
(Array.isArray(xs) ? (
xs
) : xs.split('')).map(f);


// e.g. map(randomRInt(1, 10), enumFromTo(1, 20))
// 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
// randomRInt :: Int -> Int -> IO () -> Int
const length = xs => xs.length || Infinity;
const randomRInt = (low, high) => () =>
low + Math.floor(
(Math.random() * ((high - low) + 1))
);


// map :: (a -> b) -> [a] -> [b]
// show :: a -> String
const map = (f, xs) => xs.map(f);
const show = x => x.toString()


// randomRInt :: Int -> Int -> Int
// sort :: Ord a => [a] -> [a]
const randomRInt = (low, high) =>
const sort = xs => xs.slice()
.sort((a, b) => a < b ? -1 : (a > b ? 1 : 0));
low + Math.floor(
(Math.random() * ((high - low) + 1))
);


// showJSON :: a -> String
// sum :: [Num] -> Num
const showJSON = x => JSON.stringify(x);
const sum = xs => xs.reduce((a, x) => a + x, 0);


// sort :: Ord a => [a] -> [a]
// tail :: [a] -> [a]
const sort = xs => xs.slice()
const tail = xs => 0 < xs.length ? xs.slice(1) : [];
.sort((a, b) => a < b ? -1 : (a > b ? 1 : 0));


// sum :: [Num] -> Num
// take :: Int -> [a] -> [a]
// take :: Int -> String -> String
const sum = xs => xs.reduce((a, x) => a + x, 0);
const take = (n, xs) =>
'GeneratorFunction' !== xs.constructor.constructor.name ? (
xs.slice(0, n)
) : [].concat.apply([], Array.from({
length: n
}, () => {
const x = xs.next();
return x.done ? [] : [x.value];
}));


// tail :: [a] -> [a]
// unlines :: [String] -> String
const tail = xs => 0 < xs.length ? xs.slice(1) : [];
const unlines = xs => xs.join('\n');


// unlines :: [String] -> String
// until :: (a -> Bool) -> (a -> a) -> a -> a
const unlines = xs => xs.join('\n');
const until = (p, f, x) => {
let v = x;
while (!p(v)) v = f(v);
return v;
};


// MAIN ---
// MAIN ---
main();
return main();
})();</lang>
})();</lang>
{{Out}}
{{Out}}
A sample of 10 character attribute sets:
A sample of 10 character attribute sets:
<pre>[83,[9,13,16,17,12,16]]
<pre>79 -> [12,15,12,15,13,12]
[79,[13,16,12,10,16,12]]
92 -> [17,16,15,15,17,12]
[78,[15,11,13,14,15,10]]
82 -> [12,14,13,13,15,15]
[76,[16,13,11,15,10,11]]
84 -> [15,16,18,10,15,10]
[82,[13,7,16,15,16,15]]
83 -> [15,12,17,14,10,15]
[79,[14,14,14,14,13,10]]
83 -> [14,15,10,15,14,15]
[77,[9,9,15,16,16,12]]
77 -> [12,13,15,11,15,11]
[85,[16,15,16,11,12,15]]
81 -> [15,8,16,15,15,12]
[77,[15,12,12,9,14,15]]
79 -> [15,15,11,17,12,9]
[83,[17,15,14,14,11,12]]</pre>
76 -> [14,12,9,15,15,11]</pre>


=={{header|Julia}}==
=={{header|Julia}}==

Revision as of 17:48, 28 March 2019

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

Task

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

<lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. 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;

}</lang>

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. <lang cpp>#include <algorithm>

  1. include <ctime>
  2. include <iostream>
  3. include <cstdlib>
  4. 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;

}</lang>

Output:

Sample run: 

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

C#

Translation of: Visual Basic .NET

<lang csharp>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);
   }

}</lang>

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

<lang Ruby>def roll_stat 

 dices = Array(Int32).new(4) { rand(1..6) }
 dices.sum - dices.min

end

def roll_character 

 loop do
   stats = Array(Int32).new(6) { roll_stat }
   return stats if stats.sum >= 75 && stats.count(&.>=(15)) >= 2
 end

end

10.times do 

 stats = roll_character
 puts "stats: #{stats}, sum is #{stats.sum}"

end</lang>

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

<lang factor>USING: combinators.short-circuit dice formatting io kernel math math.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</lang>

Output:
Str: 9
Dex: 13
Con: 14
Int: 17
Wis: 17
Cha: 11

Total: 81
# of attributes >= 15: 2

Go

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

}</lang>

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

Haskell

<lang haskell>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 >>= (,)))</lang>

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

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

</lang>

Output:
sum: 79
10
16
14
16
8
15

JavaScript

Imperative

<lang javascript>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`);</lang>

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

Translation of: Python

(Functional composition version)

<lang javascript>(() => { 

   'use strict';

   // main :: IO ()
   const main = () =>
       // 10 random heroes drawn from
       // a non-finite series.
       unlines(map(
           xs => show(sum(xs)) +
           ' -> [' + show(xs) + ']',

           take(10, heroes(
               seventyFivePlusWithTwo15s
           ))
       ));

   // seventyFivePlusWithTwo15s :: [Int] -> Bool
   const seventyFivePlusWithTwo15s = xs =>
       // Total score over 75,
       // with two or more qualities scoring 15.
       75 < sum(xs) && 1 < length(filter(
           x => 15 === x, xs
       ));



   function* heroes(p) {
       // Non-finite list of heroes matching
       // the requirements of predicate p.
       while (true) {
           yield hero(p)
       }
   }

   // hero :: (Int -> Bool) -> IO (Int, Int, Int, Int, Int, Int)
   const hero = p =>
       // A random character matching the
       // requirements of predicate p.
       until(p, character, []);

   // character :: () -> [Int]
   const character = () =>
       // A random character with six
       // integral attributes.
       map(() => sum(tail(sort(map(
               randomRInt(1, 6),
               enumFromTo(1, 4)
           )))),
           enumFromTo(1, 6)
       );



   // GENERIC FUNCTIONS ----------------------------------

   // 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 =>
       (Array.isArray(xs) || 'string' === typeof xs) ? (
           xs.length
       ) : Infinity;

   // map :: (a -> b) -> [a] -> [b]
   const map = (f, xs) =>
       (Array.isArray(xs) ? (
           xs
       ) : xs.split()).map(f);

   // e.g. map(randomRInt(1, 10), enumFromTo(1, 20))

   // randomRInt :: Int -> Int -> IO () -> Int
   const randomRInt = (low, high) => () =>
       low + Math.floor(
           (Math.random() * ((high - low) + 1))
       );

   // show :: a -> String
   const show = x => x.toString()

   // 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) : [];

   // take :: Int -> [a] -> [a]
   // take :: Int -> String -> String
   const take = (n, xs) =>
       'GeneratorFunction' !== xs.constructor.constructor.name ? (
           xs.slice(0, n)
       ) : [].concat.apply([], Array.from({
           length: n
       }, () => {
           const x = xs.next();
           return x.done ? [] : [x.value];
       }));

   // unlines :: [String] -> String
   const unlines = xs => xs.join('\n');

   // until :: (a -> Bool) -> (a -> a) -> a -> a
   const until = (p, f, x) => {
       let v = x;
       while (!p(v)) v = f(v);
       return v;
   };

   // MAIN ---
   return main();

})();</lang>

Output:

A sample of 10 character attribute sets: 

79 -> [12,15,12,15,13,12]
92 -> [17,16,15,15,17,12]
82 -> [12,14,13,13,15,15]
84 -> [15,16,18,10,15,10]
83 -> [15,12,17,14,10,15]
83 -> [14,15,10,15,14,15]
77 -> [12,13,15,11,15,11]
81 -> [15,8,16,15,15,12]
79 -> [15,15,11,17,12,9]
76 -> [14,12,9,15,15,11]

Julia

<lang 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()

</lang>

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

<lang scala>// 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
   }

}</lang>

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

<lang 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. </lang>

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

<lang perl>use strict; use List::Util 'sum';

my ($min_sum, $hero_attr_min, $hero_count_min) = <75 15 3>; my @attr_names = <Str Int Wis Dex Con Cha>;

sub heroic { scalar grep { $_ >= $hero_attr_min } @_ }

sub roll_skip_lowest { 

   my($dice, $sides) = @_;
   sum( (sort map { 1 + int rand($sides) } 1..$dice)[1..$dice-1] );

}

my @attr; do { 

   @attr = map { roll_skip_lowest(6,4) } @attr_names;

} until sum(@attr) >= $min_sum and heroic(@attr) >= $hero_count_min;

printf "%s = %2d\n", $attr_names[$_], $attr[$_] for 0..$#attr; printf "Sum = %d, with %d attributes >= $hero_attr_min\n", sum(@attr), heroic(@attr);</lang>

Output:
Str = 13
Int = 15
Wis =  9
Dex = 19
Con = 17
Cha = 10
Sum = 83, with 3 attributes >= 15

Perl 6

Works with: Rakudo Star version 2018.04.1

<lang perl6>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";</lang>

Output:
(Str => 15 Int => 16 Wis => 13 Dex => 11 Con => 15 Cha => 6)
Sum: 76, with 3 attributes >= 15

Phix

<lang Phix>sequence numbers = repeat(0,6) integer t,n while 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 while printf(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})</lang>

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

<lang 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);</lang>

PureBasic

<lang purebasic>#heroicAttributeMinimum = 15

  1. heroicAttributeCountMinimum = 2
  2. attributeSumMinimum = 75
  3. 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 sum

EndProcedure

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</lang> Sample output: 

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

Python

Python: Simple

<lang python>import random random.seed() attributes_total = 0 count = 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)</lang>

Output:

Sample run: 

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

Python: Nested Comprehensions #1

<lang python>import random random.seed() total = 0 count = 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)</lang>

Output:

Sample run: 

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

Python: Nested Comprehensions #2

With comprehensions for checking candidate values in the while expression. <lang python>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())

</lang>

Output:
81 [12, 17, 9, 9, 17, 17]
75 [16, 7, 13, 12, 15, 12]
81 [15, 11, 15, 16, 10, 14]

Python: Functional composition

Composing a hero-generator from reusable functions: <lang python>RPG Attributes Generator

from itertools import islice from operator import eq import random


  1. heroes :: Gen IO [(Int, Int, Int, Int, Int, Int)]

def heroes(p): 

   Non-finite list of heroes matching
      the requirements of predicate p.
   while True:
       yield hero(p)


  1. hero :: ([Int] -> Bool) -> IO (Int, Int, Int, Int, Int, Int)

def hero(p): 

   A random character matching the
      requirements of predicate p.
   return tuple(
       until(p)(character)([])
   )


  1. character :: () -> IO [Int]

def character(_): 

   A random character with six
      integral attributes.
   return [
       sum(sorted(map(
           randomRInt(1)(6),
           enumFromTo(1)(4)
       ))[1:])
       for _ in enumFromTo(1)(6)
   ]


  1. TEST -------------------------------------------------
  2. main :: IO ()

def main(): 

   Test :: Sample of 10

   # seventyFivePlusWithTwo15s :: [Int] -> Bool
   def seventyFivePlusIncTwo15s(xs):
       Sums to 75 or more,
          and includes at least two 15s.
       return 75 <= sum(xs) and (
           1 < len(list(filter(curry(eq)(15), xs)))
       )

   print('A sample of 10:\n')
   print(unlines(
       str(sum(x)) + ' -> ' + str(x) for x
       in take(10)(heroes(
           seventyFivePlusIncTwo15s
       ))
   ))


  1. GENERIC -------------------------------------------------
  1. curry :: ((a, b) -> c) -> a -> b -> c

def curry(f): 

   A curried function derived
      from an uncurried function.
   return lambda a: lambda b: f(a, b)


  1. enumFromTo :: (Int, Int) -> [Int]

def enumFromTo(m): 

   Integer enumeration from m to n.
   return lambda n: list(range(m, 1 + n))


  1. randomRInt :: Int -> Int -> IO () -> Int

def randomRInt(m): 

   Returns a generator function
      which can be applied to any argument,
      always returning some integer in
      the range m to n.
   return lambda n: lambda _: random.randint(m, n)


  1. take :: Int -> [a] -> [a]
  2. take :: Int -> String -> String

def take(n): 

   The prefix of xs of length n,
      or xs itself if n > length xs.
   return lambda xs: (
       xs[0:n]
       if isinstance(xs, list)
       else list(islice(xs, n))
   )


  1. unlines :: [String] -> String

def unlines(xs): 

   A single string derived by the intercalation
      of a list of strings with the newline character.
   return '\n'.join(xs)


  1. until :: (a -> Bool) -> (a -> a) -> a -> a

def until(p): 

   The result of repeatedly applying f until p holds.
      The initial seed value is x.
   def go(f, x):
       v = x
       while not p(v):
           v = f(v)
       return v
   return lambda f: lambda x: go(f, x)


if __name__ == '__main__': 

   main()</lang>

A sample of 10:

76 -> (15, 14, 12, 9, 15, 11)
85 -> (12, 11, 16, 15, 15, 16)
80 -> (15, 11, 15, 9, 13, 17)
81 -> (15, 14, 12, 13, 15, 12)
82 -> (10, 12, 13, 15, 15, 17)
77 -> (9, 15, 11, 15, 15, 12)
83 -> (15, 13, 13, 15, 15, 12)
84 -> (10, 16, 15, 14, 14, 15)
79 -> (17, 15, 10, 11, 15, 11)
75 -> (15, 13, 7, 11, 14, 15)

Racket

<lang 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))</lang>
Output:
Rolls:	(11 16 10 13 12 15)
Total:	77

REXX

version 1

<lang rexx>/* REXX Generates 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
 End

Say try 'iterations' Say ol '=>' sum Exit

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)</lang>
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. <lang rexx>/*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."</lang>

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 <lang rexx>/*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.'
 end

Say 'Solution found with' n 'iterations'</lang>

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

<lang ring>

  1. Project  : RPG Attributes Generator

load "stdlib.ring" attributestotal = 0 count = 0 while 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)

end showline()

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

</lang> Output: 

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

Scala

<lang scala> import scala.util.Random Random.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("[", ",", "]")) </lang> 

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 <lang vbnet>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 Sub

End Module</lang>

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

<lang 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));</lang>
Output:
Random numbers: 15,15,7,17,10,13
Sums to 77 with 3 >= 15
Retrieved from "https://rosettacode.org/wiki/RPG_attributes_generator?oldid=283203"