1.
合法的括号匹配序列被定义为:
1. 空串""是合法的括号序列
2. 如果"X"和"Y"是合法的序列,那么"XY"也是一个合法的括号序列
3. 如果"X"是一个合法的序列,那么"(X)"也是一个合法的括号序列
4. 每个合法的括号序列都可以由上面的规则生成
例如"", "()", "()()()", "(()())", "(((())))"都是合法的。 东东现在有一个合法的括号序列s,一次移除操作分为两步:
1. 移除序列s中第一个左括号
2. 移除序列s中任意一个右括号.保证操作之后s还是一个合法的括号序列
东东现在想知道使用上述的移除操作有多少种方案可以把序列s变为空
如果两个方案中有一次移除操作移除的是不同的右括号就认为是不同的方案。
例如: s = "()()()()()",输出1, 因为每次都只能选择被移除的左括号所相邻的右括号.
s = "(((())))",输出24, 第一次有4种情况, 第二次有3种情况, ... ,依次类推, 4 * 3 * 2 * 1 = 24
输入：输入包括一行,一个合法的括号序列s,序列长度length(2 ≤ length ≤ 20).
(((())))
输出：输出一个整数,表示方案数
24var arr = readline().split('');
var count=1;
while(arr.length){
var index = arr.indexOf(')');
count*=index;
arr.splice(index-1,2);
}
print(count);2.
给你两个集合，要求{A} + {B}。 注：同一个集合中不会有两个相同的元素。
输入描述：
每组输入数据分为三行,第一行有两个数字n,m(0 ≤ n,m ≤ 10000)，分别表示集合A和集合B的元素个数。后两行分别表示集合A和集合B。每个元素为不超过int范围的整数,每个元素之间有个空格隔开。
输出描述：
针对每组数据输出一行数据，表示合并后的集合，要求从小到大输出，每个元素之间有一个空格隔开,行末无空格。
例如：
3 3 1 3 5 2 4 6
输出：1 2 3 4 5 6
var arr = readline().split(' ');
var strA = readline();
var strB = readline();
var res = (strA + ' ' + strB).split(' ');
res.sort((a, b) => (a - b));
// 集合中无重复元素(去重)
var obj = {};
var r = [];
for(var i=0;i<res.length;i++) {
if(!obj[res[i]]) {
r.push(res[i]);
obj[res[i]] = 1;
}
}
print(r.join(' '));3.
尽管是一个CS专业的学生，小B的数学基础很好并对数值计算有着特别的兴趣，喜欢用计算机程序来解决数学问题，现在，她正在玩一个数值变换的游戏。她发现计算机中经常用不同的进制表示一个数，如十进制数123表达为16进制时只包含两位数7、11（B），用八进制表示为三位数1、7、3，按不同进制表达时，各个位数的和也不同，如上述例子中十六进制和八进制中各位数的和分别是18和11,。 小B感兴趣的是，一个数A如果按2到A-1进制表达时，各个位数之和的均值是多少？她希望你能帮她解决这个问题？ 所有的计算均基于十进制进行，结果也用十进制表示为不可约简的分数形式。
输入描述：输入中有多组测试数据，每组测试数据为一个整数A(1 ≤ A ≤ 5000)
输出描述：对每组测试数据，在单独的行中以X/Y的形式输出结果。
输入：5 输出:7/3
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
int fun(int x, int y){
int sum = 0;
while(x){
sum += (x % y);
x /= y;
}
return sum;
}
int main(){
int n, ans;
while(scanf("%d", &n) == 1){
ans = 0;
for(int i = 2; i < n; i++) ans += fun(n, i);
int fenmu = n - 2, fenzi = ans;
for(int i = 2; i <= min(n-2, ans);i++)
while((fenmu % i == 0) &&(fenzi % i == 0)) {fenmu /= i; fenzi /= i;}
cout<<fenzi<<"/"<<fenmu<<endl;
}
return 0;
}4.
小明同学学习了不同的进制之后，拿起了一些数字做起了游戏。小明同学知道，在日常生活中我们最常用的是十进制数，而在计算机中，二进制数也很常用。现在对于一个数字x，小明同学定义出了两个函数f(x)和g(x)。 f(x)表示把x这个数用十进制写出后各个数位上的数字之和。如f(123)=1+2+3=6。 g(x)表示把x这个数用二进制写出后各个数位上的数字之和。如123的二进制表示为1111011，那么，g(123)=1+1+1+1+0+1+1=6。 小明同学发现对于一些正整数x满足f(x)=g(x)，他把这种数称为幸运数，现在他想知道，大于0且小于等于n的幸运数有多少个？
输入描述：每组数据输入一个数n(n<=100000)
输出描述：每组数据输出一行，小于等于n的幸运数个数。
输入：21 输出：3
var n = 21;
var count = 0;
for (var i = 1; i <= n; i++) {
var res_f = f(i);
// console.log(res_f);
var res_g = g2(i);
if (res_f == res_g) count++;
}
function f(num) {
var sum = 0;
while (num) {
sum += Math.floor(num % 10);
num = Math.floor(num/10);
}
return sum;
}
function g2(num) {
var sum = 0;
var str = num.toString(2);
for (var i = 0; i < str.length; i++) {
sum += parseInt(str[i]);
}
return sum;
}
console.log(count);5.
已知一个奇怪的队列，这个队列中有n个数，初始状态时，顺序是1,2,3,4,…n，是1-n按顺序排列。这个队列只支持一种操作，就是把队列中的第i号元素提前到队首(1<i<=n)，如有4个元素，初始为1，2，3，4,可以将3提前到队首，得到3，1，2，4 。 现在给出一个经过若干次操作之后的序列，请你找出这个序列至少是由原序列操作了多少次得到的。
输入描述：第一行是一个整数n(1<=n<=10^5)，表示序列中数字的数量。 接下来一行有n个数，是1-n的一个全排列。数字之间用空格隔开。
输出描述：输出仅包含一个数字，表示至少操作了几次
输入： 5 5 2 1 3 4
输出：2
var n = Number(readline());
var arr = readline().split(' ');
var num = n-1;
if(n==1){
print('0');
}else{
for(var i=arr.length-1;i>0;i--){
if(Number(arr[i])>Number(arr[i-1])){
num--;
}else{
break;
}
}
print(num);
}6.
拉齐有一个01序列，他可以对这个序列进行任意多次变换，每次变换都是把序列的最后若干个元素放到最前面，例如：010011，将最后3个元素011放到最前面，序列变为011010。所有变换结束后，拉齐需要挑出一个全为1的连续区间，要求最大化区间长度。
输入描述：共一行，一个01串，仅包含0或1。序列长度不超过50000。
输出描述：一个整数，表示最长区间的长度。
输入：11011 输出：4
var str = readline()
if(str.indexOf('0')===-1){
print(str.length)
}else{
var newstr = str+str
var list = newstr.match(/1+/g)
if(list === null){
print(0)
}else{
list = list.map(x=>x.length)
print(Math.max(...list))
}
}