Question

(a) 采取下列行动:

string s1="planets {Sun|Mercury|Venus|Earth|Mars|Jupiter|Saturn|Uranus|Neptune}{?|!|.}"
string s2="some text {morning,night,evening} some text{?|!|.}"

How would I choose randomly N from the set, then join them with comma. The set is defined between {} and options are separated with | pipe The order is maintained. String can have multiple sets {}.

一些产出可以是:

string output1="planets Sun, Venus.";
string output2="planets Neptune!";
string output3="planets Earth, Saturn, Uranus, Neptune.";
string output4="planets Uranus, Saturn.";// bad example, order is not correct
string output5="some text morning!";

Java

Answer 1

将地球划入一个阵列,除去随机元素,直到你有足够的空间。有一些截断的解决办法,从算法的角度讲,但就你重新处理的数据数量而言,这种解决办法是迅速和简单的。

Answer 2

我不相信 j的辛子——但应该如此。

string[] split = s.split("|");
Random r = new Random();
int first = r.nextInt(split.length);
string planets = "planets " + split[first++];
for (; first < split.length; first++)
{
    if (r.nextInt(2) == 1)
         planets += " " + split[first];
}

Answer 3

这是另一种选择。仅从<条码>>>>>>>>>>>>>>>>、<>/代码”中选择1至1项内容,并将其与对应体分开。尼斯方案拟订的挑战。

public static String generateVariant(String s) {
    Pattern p = Pattern.compile("[{]([^}]+)[}]");
    Matcher m = p.matcher(s);
    StringBuilder output = new StringBuilder();

    int offset = 0;
    while (m.find()) {
        output.append(s.substring(offset, m.start()));
        String[] choices = m.group(1).split("[|,]");

        // if  |  used as separator, only echo 1 random choice
        int n = m.group(1).contains("|") ? 1
                : (int) (Math.random() * (choices.length - 1)) + 1;

        // permutation with n random elements
        int[] permutation = new int[choices.length];
        for (int i = 0; i < choices.length; i++) {
            permutation[i] = i;
        }
        for (int i=0; i<n; i++) {
            int r = (int)(Math.random() * (choices.length - i)) + i;
            int aux = permutation[r];
            permutation[r] = permutation[i];
            permutation[i] = aux;
        }

        // sort and echo first n
        Arrays.sort(permutation, 0, n);
        for (int i=0; i<n; i++) {
            output.append((i == 0 ? "" : ", ") + choices[permutation[i]]);
        }
        offset = m.end();
    }
    output.append(s.substring(offset, s.length()));
    return output.toString();
}

public static void main(String[] args) {
    String s1 = "planets {Sun,Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune}{?|!|.}";
    for (int i = 0; i < 10; i++) {
        System.err.println(generateVariant(s1));
    }
}

是的,产生一种变异性超过<代码>>>>>>>>>>>>>>>/代码。这里是一个较短、更简单的版本,选择数目的分配不再统一(由Daniel Trebbien回答):

public static String generateVariant(String s) {
    Pattern p = Pattern.compile("[{]([^}]+)[}]");
    Matcher m = p.matcher(s);
    StringBuilder output = new StringBuilder();
    Random r = new Random();

    int offset = 0;
    while (m.find()) {
        output.append(s.substring(offset, m.start()));
        String[] choices = m.group(1).split("[|,]");
        // if  |  used as separator, only echo 1 random choice
        if (m.group(1).contains("|")) {
            output.append(choices[r.nextInt(choices.length)]);
        } else {
            boolean first = true;
            for (int i=0; i<choices.length; i++) {
                if (r.nextBoolean()) {
                    output.append((first ? "" : ", ") + choices[i]);
                    first = false;
                }
            }                
        }
        offset = m.end();
    }
    output.append(s.substring(offset, s.length()));
    return output.toString();
}

Answer 4

我测试了这一 Java方案,并做了以下工作:

import java.util.R以及om;

/** @author Daniel Trebbien */
// License: Public Domain
public class SO2965185 {
    public static String r以及omFormat(final String templ) {
        int i = templ.indexOf( { );
        if (i < 0) {
            return templ;
        }
        else {
            R以及om r = new R以及om();

            int prevI = 0;
            StringBuilder sb = new StringBuilder();
            do {
                sb.append(templ, prevI, i);
                int j = templ.indexOf( } , i + 1);
                if (j < 0)
                    throw new java.util.MissingFormatArgumentException(templ.substring(i));
                int pipeCount = 0;
                for (int k = templ.indexOf( | , i + 1); i < k && k < j; k = templ.indexOf( | , k + 1))
                    ++pipeCount;
                if (pipeCount == 0) {
                    sb.append(templ, i + 1, j);
                }
                else {
                    String m0Selection;
                    final int m0 = r.nextInt(pipeCount + 1); // must pick one from each set
                    if (m0 >= pipeCount) {
                        m0Selection = templ.substring(templ.lastIndexOf( | , j - 1) + 1, j);
                    }
                    else {
                        int k = i + 1;
                        int m = m0;
                        for(; m > 0; --m)
                            k = templ.indexOf( | , k) + 1;
                        m0Selection = templ.substring(k, templ.indexOf( | , k + 1));
                    }

                    int selectionCount = 0;
                    for (int n = 0; n <= pipeCount; ++n) {
                        if (n == m0) {
                            if (selectionCount != 0)
                                sb.append(", ");
                            sb.append(m0Selection);
                            ++selectionCount;
                        }
                        else if (r.nextBoolean()) {
                            int m = n;
                            if (selectionCount != 0)
                                sb.append(", ");
                            if (m >= pipeCount) {
                                sb.append(templ, templ.lastIndexOf( | , j - 1) + 1, j);
                            }
                            else {
                                int k = i + 1;
                                for(; m > 0; --m)
                                    k = templ.indexOf( | , k) + 1;
                                sb.append(templ, k, templ.indexOf( | , k + 1));
                            }
                            ++selectionCount;
                        }
                    }
                }
                prevI = j + 1;
                i = templ.indexOf( { , j + 1);
            } while(i >= 0);
            return sb.toString();
        }
    }

    public static void main(String[] args) {
        System.out.println(r以及omFormat("test"));
        System.out.println(r以及omFormat("{oneOption}"));
        System.out.println(r以及omFormat("{first|second}"));
        String s1 = "planets {Sun|Mercury|Venus|Earth|Mars|Jupiter|Saturn|Uranus|Neptune}{?|!|.}";
        System.out.println(r以及omFormat(s1));
        //System.out.println(r以及omFormat("jjj{test"));
    }
}

该方案印刷了如下内容:

test
oneOption
first, second
planets Sun, Mercury, Jupiter, Neptune?, !, .

以及

test
oneOption
second
planets Sun, Jupiter, Saturn!, .

以及

test
oneOption
first
planets Venus, Earth, Jupiter, Saturn, Uranus, Neptune.

由于我最初为稍有不同的问题撰写了法典,你不得不宽恕我:

The code picks r以及om combinations of entries having at least one entry from each set. So, for a set with N entries, there are 2^N - 1 combinations that can be generated. Also, keep in mind the probability that there are exactly M entries in the r以及om combination:

P(实际M 生成组合中的条目) = (N 选择M)除以2<<<><><>- 1)

例:N = 9 (>>>{>S.un.Mercury , >enus Homme , « Jupiter Saturn Uranuseptune}"。

http://www.google.com/search?q=%289+2%F%2822%E9+1%29”rel=“nofollow noreferer”

Answer 5

就地球而言,仅写一 lo。

result = empty list
For p in planets
  throw a dice
  If (dice > 3) // 50% probability, adjust as required
    append p to result
If result is empty, start over // do this if you don t want result to be empty

这提供了按顺序排列的随机地球清单。

友情链接