Repeat question mark({@code ?}) {@code n} times with delimiter {@code ", "}.
<br />
It's designed for batch SQL builder.

@param n
@return
543084
public static String repeatQM(int n) {
        N.checkArgNotNegative(n, "count");

        String result = QM_CACHE.get(n);

        if (result == null) {
            result = StringUtil.repeat("?", n, ", ");
        }

        return result;
    }
196111
public static String generateMixPassword(final int n) {
		final char[] pw = new char[n];
		int c = 'A';
		int r1 = 0;
		for (int i = 0; i < n; i++) {
			r1 = (int) (Math.random() * 3);
			switch (r1) {
			case 0:
				c = '0' + (int) (Math.random() * 10);
				break;
			case 1:
				c = 'a' + (int) (Math.random() * 26);
				break;
			case 2:
				c = 'A' + (int) (Math.random() * 26);
				break;
			}
			pw[i] = (char) c;
		}
		return new String(pw);
	}
331907
public long markNode(Object n) {
        long oid = 0;
        if(this.markers == null) {
            this.markers = new IdentityHashMap<Object, Long>();
        }

        if(!this.markers.containsKey(n)) {
            oid = this.markers.size() + 1;
            markers.put(n, oid);
        } else {
            oid = this.markers.get(n);
            if(this.anchors == null) {
                this.anchors = new HashMap<Long, String>();
            }
            if(!anchors.containsKey(oid)) {
                int idx = 0;
                String anc = this.anchor_format == null ? YAML.DEFAULT_ANCHOR_FORMAT : this.anchor_format;
                idx = anchors.size() + 1;
                String anchor_name = String.format(anc, idx);
                anchors.put(oid, anchor_name);
            }
        }

        return oid;
    }
1112259
private void setRepeat(final boolean repeat)
	{
		final boolean flag = mc == MC_LDATA_IND ? !repeat : repeat;
		if (flag)
			ctrl1 |= 0x20;
		else
			ctrl1 &= 0xDF;
	}
1002120
public static Pattern repeat(int n, CharPredicate predicate) {
    Checks.checkNonNegative(n, "n < 0");
    return new RepeatCharPredicatePattern(n, predicate);
  }
608561
public FastqBuilder withSequence(final String sequence)
	{
		if (sequence == null)
		{
			throw new IllegalArgumentException("sequence must not be null");
		}
		if (this.sequence == null)
		{
			this.sequence = new StringBuilder(sequence.length());
		}
		this.sequence.replace(0, this.sequence.length(), sequence);
		return this;
	}
1110987
public static double[] repeat (double value, int n) {
        // Initialize the return array:
        double[] retval = new double[n];

        // Fill the array:
        Arrays.fill(retval, value);

        // Done, return the filled array:
        return retval;
    }
910528
public long skip(long n) throws IllegalArgumentException, IOException {

        if (lookaheadChar == UNDEFINED) {
            lookaheadChar = super.read();
        }

        // illegal argument
        if (n < 0) {
            throw new IllegalArgumentException("negative argument not supported");
        }

        // no skipping
        if (n == 0 || lookaheadChar == END_OF_STREAM) {
            return 0;
        }

        // skip and reread the lookahead-char
        long skiped = 0;
        if (n > 1) {
            skiped = super.skip(n - 1);
        }
        lookaheadChar = super.read();
        // fixme uh: we should check the skiped sequence for line-terminations...
        lineCounter = Integer.MIN_VALUE;
        return skiped + 1;
    }
200422
@Override
    public T get(int n) {
        checkUnsupportedOperationForIterationOnlyMode("get(int n)");
        
        while ( allResults.size() <= n && nextResultsAvailable() ) {
            moveNextResults(false);
        }

        return allResults.get(n);
    }
584351
public List<T> pollN(int n) {
    if (n >= size) {
      // if we need to remove all elements then do fast polling
      return pollAll();
    }
    List<T> retList = new ArrayList<T>(n);
    pollNToList(n, retList);
    return retList;
  }
415251
public static String repeat(char source, int times) {
        dbc.precondition(times > -1, "times must be non negative");
        final char[] array = new char[times];
        Arrays.fill(array, source);
        return new String(array);
    }
1252968
public JcString right(int n) {
		JcNumber right = new JcNumber(n, this, OPERATOR.Common.COMMA_SEPARATOR);
		SubString ret = new SubString(null, right,
				new FunctionInstance(FUNCTION.String.RIGHT, 2));
		QueryRecorder.recordInvocationConditional(this, "right", ret, QueryRecorder.literal(n));
		return ret;
	}
1083413
@Override
	public long skip(long n) throws IOException {
		if (n < 0L) {
			throw new IllegalArgumentException("skip value is negative");
		}
		synchronized (lock) {
			ensureOpen();
			long r = n;
			while (r > 0) {
				if (nextChar >= nChars) {
					fill();
				}
				if (nextChar >= nChars) /* EOF */ {
					break;
				}
				if (skipLF) {
					skipLF = false;
					if (cb[nextChar] == '\n') {
						nextChar++;
					}
				}
				long d = nChars - nextChar;
				if (r <= d) {
					nextChar += r;
					r = 0;
					break;
				} else {
					r -= d;
					nextChar = nChars;
				}
			}
			bytesRead = bytesRead + (n - r);
			return n - r;
		}
	}
1368585
static String repeat(final String toBeRepeated, final int numTimes) {
        final StringBuilder builder = new StringBuilder();

        for (int i = 0; i < numTimes; i++) {
            builder.append(toBeRepeated);
        }
        return builder.toString();
    }
940548
function repeat(input, n) {

    var times = ~~n;

    return (!isString(input) || !times) ? input : strRepeat(input, n);
}
801889
def repeat(col, n):
    
    sc = SparkContext._active_spark_context
    return Column(sc._jvm.functions.repeat(_to_java_column(col), n))
902667
function repeat( str, n ) {
	var rpt;
	var cnt;
	if ( !isString( str ) ) {
		throw new TypeError( 'invalid input argument. First argument must be a string. Value: `' + str + '`.' );
	}
	if ( !isNonNegativeInteger( n ) ) {
		throw new TypeError( 'invalid input argument. Second argument must be a nonnegative integer. Value: `' + n + '`.' );
	}
	if ( str.length === 0 || n === 0 ) {
		return '';
	}
	// Check that output string will not exceed the maximum string length:
	if ( str.length * n > MAX_SAFE_INTEGER ) {
		throw new RangeError( 'invalid input argument. Output string length exceeds maximum allowed string length.' );
	}
	rpt = '';
	cnt = n;
	for( ; ; ) {
		// If the count is odd, append the current concatenated string:
		if ( (cnt&1) === 1 ) {
			rpt += str;
		}
		// Right-shift the bits:
		cnt >>>= 1;
		if ( cnt === 0 ) {
			break;
		}
		// Double the string:
		str += str;
	}
	return rpt;
}