js 3-50 题

ㅤ穆如春风

于 2023-03-02 17:48:29 发布

阅读量1.6k

点赞数 8

分类专栏： js 文章标签： javascript 前端开发语言

本文链接：https://blog.youkuaiyun.com/qq_52425315/article/details/129305800

版权

js 专栏收录该内容

1 篇文章

订阅专栏

//3.已知立方体的边长为123456，编写程序，计算立方体的体积，在控制台输出。注意不要输出多余的字符。
 var num = 123456*123456*123456
console.log(num);

//4.已知长方体的边长分为123456、234567、345678，编写程序，计算长方体的体积，在控制台输出。注意不要输出多余的字符。
var num = 123456*234567*345678
console.log(num);

//5.编写程序，在控制台输出19!。注意不要输出多余的字符。
var n = 1
var num = 1
while (n<=19){
	num = num*n;
	n++;
}
console.log(num);

//6.编写程序，在控制台输出10000!末尾的0的个数。注意不要输出多余的字符。
var num = 0;
    for (var i = 5;i <= 10000;){
		var j = i;
	    while (j % 5 == 0){
		   num++;
		   j = j/5;
	}
	i += 5;
}
console.log(num);

//7.编写程序，在控制台输出1000000以内最大的素数。注意不要输出多余的字符。

var i,n;
for(n = 1000000;n >= 2;n--){
	for(i = 2;i <= n-1;i++)
		if(n%i == 0) break;
	    if(i >= n) break;
}
console.log(n);

//8.编写程序，在控制台输出10000以内第二大的素数。注意不要输出多余的字符。

var n,i,a = 0;
for(n = 100000;n >= 2;n--){
	for(i = 2;i <= n-1;i++)
		if(n%i ==0) break;
	        if(i >= n) {
			    a++;
			    if(a == 2) {break;}
			}
}
console.log(n);

//9. 星际战舰载满燃料航行距离为1星际单位。现计划探索未知星域，目标距离为8星际距离，需要自建补给站。编写程序，在控制台输出最少需准备多少单位舰载燃料（取整）。注意不要输出多余的字符。


var count = 0;
var sum = 0;
 
for(var i = 1;sum <= 8;i = i+2){
	sum = sum+1/i;
	count++;
}
console.log(count);


//下面是数值为7的答案
var count = 0;
var sum = 0;
 
for(var i = 1;sum <= 7;i = i+2){
	sum = sum+1/i;
	count++;
}
console.log(count-1);

//10.一对小兔子从第2个月开始每月产3对小兔子，编程在控制台输出一年后最多可以有多少对兔子。注意不要输出多余的字符。
var small = 1;
var big = 0;
for(var i=2;i <= 12;i++){
	big = small + big;
	small = big * 3;
}
console.log(big+small);

//11. 声明函数factorial(n)，参数n为自然数，函数返回n的阶乘。注意0!=1。注意不要在控制台输出任何内容。
function factorial(n)
{
	if(n==0)
	{return 1}
    else
		return n*factorial(n-1)
}

//12.
function prime(n){
	if(n == 0 || n ==1)
		return false;
	else{
		for(let i = 2;i <= Math.sqrt(n);i++){
			if(n % i == 0){
				return false;
			}
		}
	    return true;
	}
}

//13.声明函数f(n)，参数n为自然数，函数返回n以内的素数个数。注意不要在控制台输出任何内容。

function f(n){
	var a=0;
for(var n;n >= 2;n--)
{
	for(i = 2;i <= n-1;i++)
		if(n%i == 0)break;
	       if(i >= n){
			   a++;
		   }
    }return a;
}

//14如果n和n+2都是素数，则称n和n+2是一对姐妹素数。声明函数f(n)，参数n为自然数，函数返回n以内的姐妹素数的对数。注意不要在控制台输出任何内容。
function f(n){
	var i,j,k,sum=0,num1,num2;
	for(i = 3;i <= n;i++)
	{
		num1=1,num2=1;
		for(j = 2;j < i;j++){
			if(i%j == 0){
			  num1=0;
			  break;
			}
			for(k = 2;k < i + 2;k++){
				if((i + 2) % k == 0){
				  num2 = 0;
				  break;
				}
			}
		}
		if(num1 == 1 && num2 == 1){
			sum++;
		}
	}
	return sum;
}

//15一个m(m>1)位素数，依次去掉最低一位数字，得到的都是素数，则该数称为超级素数。声明函数f(n)，参数n为自然数，如果n是超级素数，则函数返回true，否则返回false。例如：23、239都是超级素数，7、137、307都不是是超级素数注意不要在控制台输出任何内容。
function f(n){
	if(n == 0 || n == 1||n<10) return 0;
	else{
		var array = [];
		var count = 0;
		for(let j = n; j >= 2; j--){
			let flag = 0;
			for(let i = 2; i <= Math.sqrt(j); i++){
				if(j % i == 0){
					flag = 1;
					break;
				}	
			}
			if(flag == 0){
				array.push(j);
			}
		}
		if(array[0] != n) return false;
		var len = n.toString().length;
		for(let k = 0 ;n >= 10; k++){
			n = n / 10;
			n  = Math.floor(n);
			for(let m = 0; m < array.length; m++){
				if(n == array[m]){
					count++;
				}
			}
		}
		if(count == len -1){
			return true;
		} else{
			return false;
		}
	}
}

//16如果一个素数依次去掉其最低位数字后，所得均为素数，则该数是超级素数。注意超级素数不能是个位数。声明函数f(n)，参数n为自然数，函数返回n以内的超级素数的个数。例如：20以内的超级素数的个数为0，100以内的超级素数的个数为9。注意不要在控制台输出任何内容。

function f(n){
	if(n<=20) return 0;
	else{
		var array = [];
		var count = 0;
		var count1 = 0;
		for(let j = n; j >= 2; j--){
			let flag = 0;
			for(let i = 2; i <= Math.sqrt(j); i++){
				if(j % i == 0){
					flag = 1;
					break;
				}	
			}
			if(flag == 0){
				array.push(j);
			}
		}
		for(var q = 0; q < array.length; q++){
			var len = array[q].toString().length;
			let number = array[q];
			for(let k = 0 ;number >= 10; k++){
					number = number / 10;
					number  = Math.floor(number);
					for(let m = 0; m < array.length; m++){
						if(number == array[m]){
							count++;
						}
					}
			}
			if(count == len -1){
				count1++;
			}
			count = 0;
		}
		return count1-4;
	}
}

//17.超级素数的另一种概念：如果2位数素数去掉高位数字后是1位数素数，则该数是超级素数；m(m>2)位超级素数去掉最高位后是m-1位超级素数。声明函数f(n)，参数n为自然数，如果n是超级素数，则函数返回true，否则返回false。例如：233是超级素数，3、103都不是超级素数。注意不要在控制台输出任何内容。

function f(n){
	if(n<=100) return false;   
	else{
		var array = [];
		var count = 0;
		for(let j = n; j >= 2; j--){   
			let flag = 0;
			for(let i = 2; i <= Math.sqrt(j); i++){
				if(j % i == 0){
					flag = 1;
					break;
				}	
			}
			if(flag == 0){
				array.push(j);  
			}
		}
		if(n != array[0]) return false;  
		var len = n.toString().length; 
		let number = n;  
		let count11 = len - 1; 
		let flag1 = 0; 
		for(let k = 0 ; number >= 10; k++){
				flag1  = Math.floor(number/Math.pow(10,count11)); 
				number = number - (flag1 * Math.pow(10,count11)); 
				for(let m = 0; m < array.length; m++){
					if(number == array[m]){   
						count++;
					}
				}
				count11 = count11 - 1;
		}
	    if(count == len - 1){  
			return true;
		}else{
			return false;
		}
	}
}

//18 超级素数的另一种概念：如果2位数素数去掉高位数字后是1位数素数，则该数是超级素数；m(m>2)位超级素数去掉最高位后是 m-1 位超级素数。声明函数f(n)，参数n为自然数，函数返回n以内的超级素数的个数。例如：100以内的超级素数的个数是11。注意不要在控制台输出任何内容。

function f(n){
	if(n < 10) return 0;
	else{
		var array = [];
		var count = 0;
		var count1 = 0;
		var count111 = 0;
		for(let j = n; j >= 2; j--){
			let flag = 0;
			for(let i = 2; i <= Math.sqrt(j); i++){
				if(j % i == 0){
					flag = 1;
					break;
				}	
			}
			if(flag == 0){
				array.push(j);
			}
		}
		for(var q = 0; q < array.length; q++){
			var len = array[q].toString().length;
			let number = array[q];
			let count11 = len - 1;
			let flag1 = 0;
			for(let k = 0 ;number >= 10; k++){
				    flag1  = Math.floor(number/Math.pow(10,count11));
					number = number-flag1*Math.pow(10,count11);
					for(let m = 0; m < array.length; m++){
						if(number == array[m]){
							count++;
						}
					}
				    count11 = count11 - 1;
			}
			if(count == len - 1){
				count111++;
			}
			count = 0;
		}
		return count111-4;
	}
}

//19..汉诺塔问题：n个金盘按由大到小的顺序叠放在1号塔台上，现要将其移动到3号塔台上，每次只能移动一个金盘，可以借助2号塔台，每个塔台都必须保持由大到小的叠放次序。声明函数f(n,m)，n为金盘数，m为最少移动步数方案中的第m步，返回第m步从哪个塔台取金盘。例如：3个金盘，第6步从2号塔台取金盘。注意不要在控制台输出任何内容。
var num=0,sum,result=1;
function move(n,from,buffer,to)
{
    if (n == 1)
	{
		num++;
		if(sum==num)
		{
			result=from;
			return result;
		}
    }
    else {
        move (n-1, from, to, buffer);
        num++;
		if(sum==num)
		{
			result=from;
			return result;
		}
        move (n-1, buffer, from, to);
    }
}
 
function f(n,m)
{	
	sum=m;
	move(n,1,2,3);
	return result;
}

//20声明函数f(a,b)，如果b是数组a的元素，则返回第一个b的下标，否则返回-1。注意不要在控制台输出任何内容。
function f(a,b)
{
	var num=0,flag=0,i=0;
	for(var i=0;i<a.length;i++)
	{
		if(a[i]==b)
		{
			flag=1;
			num=i;
			break;
		}
	}
	if(flag==1)
		return num;
	else 
		return -1;
}

//21.声明函数f(a)，将数组a元素逆转，返回数组a。注意不要在控制台输出任何内容。
function f(a)
{
	var num=0,flag=0,i=0;
	a.reverse();
	return a;
}

//22 声明函数f(a,b)，返回新的数组，包含数组a和数组b的元素，a在前，b在后，元素顺序不变。注意不要在控制台输出任何内容。
function f(a,b)
{
	var num=0,flag=0,i=0;
	var c = a.concat(b); 
	return c;
}

//23声明函数f(a,b)，删除数组a的下标为b的元素，返回数组a。注意不要在控制台输出任何内容。
function f(a,b)
{
	var num=0,flag=0,i=0;
	a.splice(b, 1); 
	return a;
}

//24声明函数f(a,b)，将b插入已按升序排序的数组a，保持a的排序状态，并返回数组a。注意不要在控制台输出任何内容。
function f(a,b)
{
	var num=0,flag=0,i=0;
	a.sort(function(a, b){return a - b})
	for(i=0;i<a.length;i++)
	{
		if(b>a[i])
		num=i;
		break;
	}
	a.splice(num+1, 0,b); 
	return a;
}

//25.声明函数f(a)，对数组a按升序排序，并返回数组a。注意不要在控制台输出任何内容。


function f(a)
{
	var num=0,flag=0,i=0;
	a.sort(function(a, b){return a - b}) 
	return a;
}

//26..声明一个函数f(x)，，当x取值为0~100以外的值时触发异常。例如：try{f(0);f(-1);}catch(e){console.log(e);}输出:“错误值：-1”。注意不要在控制台输出任何内容。
const f = x => {
   if (x < 0 || x > 100) {
      throw '错误值：-1';
   }
}

//27.声明一个函数f(x)，返回访问累加器的唯一函数，x为累加器的基数。返回的函数的参数y，用于累加到累加器中，返回累加器的当前值。例如：let a=f(3);console.log(a(4),a(5));输出:“7 12”。注意不要在控制台输出任何内容。
const f = x => {
   let arr = [];
   arr.push(x);
   return function (y) {
      arr.push(y);
      return arr.reduce((prev, cur) => {
         return prev + cur;
      });
   }
}

//28.声明生成器函数g(x)，创建的生成器第一次生成x+3，第二次生成x+5，第三次返回x+7并结束。例如：let a=g(3);a.next();console.log(a.next().value);输出:“8”。注意不要在控制台输出任何内容。

let g = function* (x) {
   yield x + 2;
   yield x + 5;
   return x + 7;
}

//29.声明生成器函数g(x)，创建的生成器第一次生成x+3，第二次生成next方法的参数+5，第三次返回next方法的参数+7。例如：let a=g(3);a.next();console.log(a.next(4).value);输出:“9”。注意不要在控制台输出任何内容。
let g = function* (x) {
   let y = yield x + 2;
   let z = yield (y + 5);
   let u = yield (z + 7)
}

//30.声明一个构造函数A，创建的对象包含属性a，其初始值等于构造函数的第一个参数。例如：console.log(new A(3).a==3?1:0);输出:“3”。注意不要在控制台输出任何内容。
function A(a) {
   this.a = a;
}

//31.声明一个构造函数A，创建的对象包含方法a，其返回值等于构造函数的第一个参数。例如：console.log(new A(3).a==3?1:0);输出:“3”。注意不要在控制台输出任何内容。
function A(a) {
   this.a = a;
}

//32.声明一个构造函数A，继承构造函数B，覆盖基类的方法a，返回值为基类方法a的返回值的2倍。例如：function B(){this.a=()=>3;}let a=new A;console.log(a.a());输出:“6”。注意不要在控制台输出任何内容。
function B() {
   this.a = () => 3;
}
 
function A() {
 
}
let b = new B();
A.prototype = new B();
A.prototype.a = function () {
   return b.a() * 2;
}

//33.声明一个构造函数A，继承构造函数B，改写基类的属性a，返回值为基类属性值的2倍。例如：function B(){this.a=3;}let a=new A;console.log(a.a);输出:“6”。注意不要在控制台输出任何内容
function B() {
   this.a = 3;
}
 
function A() {
 
}
 
let b = new B();
A.prototype.a = b.a * 2;

//34.声明一个类A，创建的对象包含属性a，其初始值等于构造方法的第一个参数。例如：let a=new A(3);console.log(a.a);输出:“3”。注意不要在控制台输出任何内容。

class A {
   constructor(x) {
      this.a = x;
   }
}

//35.声明一个类A，创建的对象包含方法a，其返回值为参数的累加值，累加器的初始值等于构造方法的第一个参数。例如：;let a=new A(3);console.log(a.a(4),a.a(5));输出:“7 12”。注意不要在控制台输出任何内容。

class A {
   constructor(x) {
      this.sum = x;
   }
   a(x) {
      this.sum += x;
      return this.sum;
   }
}

//36.声明一个类A，创建的对象包含只写属性a，当其赋值为0~100以外的值时触发异常。例如：let a=new A;try{a.a=0;a.a=-1;}catch(e){console.log(e);}输出:“错误值：-1”。注意不要在控制台输出任何内容。
class A {
   #a
   set a(x) {
      if (x < 0 || x > 100) {
         throw '错误值：' + x
      } else {
         this.#a = x;
      }
   }
}

//37.声明一个函数f，在函数体中声明一个类，该类继承类A。函数f返回该派生类。例如：class A{a=1;}console.log((new (f())).a);输出:“1”。注意不要在控制台输出任何内容。

function f() {
   class Partical extends A {
 
   }
   return Partical;
}

//38.声明一个函数f，在函数体中声明一个类，该类继承类A。派生类添加构造方法，将构造方法的第一个参数累加到基类的属性a中。函数f返回该派生类。例如：class A{a=2;}console.log((new (f())(3)).a);输出:“5”。注意不要在控制台输出任何内容。
function f() {
   class Partical extends A {
      constructor(x) {
         super();
         this.a += x;
      }
   }
   return Partical;
}

//39.声明一个函数f，在函数体中声明一个类，该类继承类A。派生类覆盖基类的方法a，返回值为基类方法a的返回值的2倍。函数f返回该派生类。例如：class A{a(){return 3;}}console.log((new (f())).a());输出:“6”。注意不要在控制台输出任何内容。

function f() {
   class Partical extends A {
      a() {
         let var1 = new A();
         return var1.a() * 2;
      }
   }
   return Partical;
}

//40.声明一个类A，包含类方法a，返回值为A的实例。例如：let a=A.a();console.log(a instanceof A);输出:“true”。注意不要在控制台输出任何内容。
class A {
   static a() {
      return new A();
   }
}

//41.声明一个类A，包含类属性a，返回值为A的实例。例如：console.log(A.a instanceof A);输出:“true”。注意不要在控制台输出任何内容。
class A {
   static a = new A();
}

//42.函数a(cb)是一个异步回调函数，参数cb(x)是回调函数。声明一个函数f，在函数体中调用三次函数a，要保证三次调用按序执行完成。将其传回的回调函数参数x按序拼接成字符串，然后在控制台输出。注意不要在控制台输出多余的内容。
function a(cb) {
   if (typeof cb === "function") {
      cb(1);
      //console.log('true');
   } else {
      return "返回值无法获取"
   }
}
function f() {
   let str = '';
   a(function cb(x) {
      str += x;
      a(function cb(x) {
         str += x;
         a(function cb(x) {
            str += x;
            console.log(str);
         })
      })
   })
 
}

//43.函数a是一个Promise构造函数的参数函数，其中调用了某个异步回调函数。声明一个函数f,在函数体中利用a作为参数创建3个Promise实例，调用三次异步回调函数。要保证三次调用按序执行完成。将传回的值按序拼接成字符串，然后在控制台输出。注意不要在控制台输出多余的内容。

const f = () => {
   let str = '';
   new Promise(a).then(v => {
      str += v;
      new Promise(a).then(v => {
         str += v;
         new Promise(a).then(v => {
            str += v;
            console.log(str);
         })
      })
   })
}

//44.函数a(cb)是一个异步回调函数，参数cb(x)是回调函数。声明一个Promise构造函数的参数函数p，在函数体中调用函数a，传回回调函数cb的参数x。注意不要在控制台输出任何内容。
let p = (resolve) => {
   a(function cb(x) {
      resolve(x)
   });
}

//45.函数a是一个Promise构造函数的参数函数。声明一个async函数f，执行以p为构造函数参数的Promise，执行成功后传回数据。注意不要在控制台输出任何内容。

const f = async function () {
   return await new Promise(a)
}

//46.函数p是一个async函数。声明一个async函数f，在函数体中三次调用p，保证按调用顺序执行完成，将返回的数据拼接成字符串，在控制台输出。注意不要在控制台输出多余的内容

const f = async function () {
   let str = '';
   let data1 = await p();
   let data2 = await p();
   let data3 = await p();
   console.log('' + data1 + data2 + data3);
}

//47.声明一个堆栈类Stack，包含入栈方法push(x)和出栈方法pop()。通过构造方法的参数指定栈容量。当栈空时出栈报错“空栈！”，当栈满时入栈报错“满栈！”。例如：let a=new Stack(3);let b="";for(let i=1;i<5;i++)   try{a.push(i);}catch(e){b+=e;continue;}for(let i=1;i<5;i++)try{b+=a.pop();}catch(e){b+=e;continue;}console.log(b);输出：“满栈！321空栈！”注意不要在控制台输出多余的内容。

class Stack {
   #maxlength;
   arr = [];
   constructor(maxlength) {
      this.#maxlength = maxlength;
   }
   push(x) {
      if (this.#maxlength == this.arr.length) {
         throw '满栈！'
         return;
      }
      this.arr.push(x);
   }
   pop() {
      if (this.arr.length == 0) {
         throw '空栈！'
         return;
      }
      return this.arr.pop();
   }
}

//48.声明一个队列类Queue，包含入列方法push(x)和出列方法shift()。通过构造方法的参数指定队列容量。当队列空时出列报错“空列！”，当队列满时入列报错“满列！”。例如：let a=new Queue(3);let b="";for(let i=1;i<5;i++)    try{a.push(i);}catch(e){b+=e;continue;}for(let i=1;i<5;i++)   try{b+=a.shift();}catch(e){b+=e;continue;}console.log(b);输出：“满列！123空列！”注意不要在控制台输出多余的内容。
class Queue {
   #maxlength;
   arr = [];
   constructor(maxlength) {
      this.#maxlength = maxlength;
   }
   push(x) {
      if (this.#maxlength == this.arr.length) {
         throw '满列！'
         return;
      }
      this.arr.push(x);
   }
   shift() {
      if (this.arr.length == 0) {
         throw '空列！'
         return;
      }
      return this.arr.shift();
   }
}

49.声明一个双向队列类Deque ，包含头端入列方法unshift(x)和出列方法shift()、尾端入列方法push(x)和出列方法pop()、获取队列长度的属性length。
// 通过构造方法的参数指定队列容量。
// 队列空时出列，或队列满时入列，均返回undefined，队列不变。
// 例如：
// let a=new Queue(3);
// let b="";
// a.push(1);
// a.unshift(2);
// a.push(3);
// a.unshift(4);
// b+=a.length;
// b+=a.shift();
// b+=a.pop();
// b+=a.shift();
// b+=a.pop();
// console.log(b);
// 输出：“3231undefined”
// 注意不要在控制台输出多余的内容。
class Queue {
   #maxlength;
   length;
   arr = [];
   constructor(maxlength) {
      this.#maxlength = maxlength;
   }
   push(x) {
      if (this.#maxlength == this.arr.length) {
         return undefined;
      }
      this.arr.push(x);
      this.length = this.arr.length;
   }
   unshift(x) {
      if (x == undefined) {
         return;
      }
      if (this.#maxlength == this.arr.length) {
         return undefined;
      }
      this.arr.unshift(x);
      this.length = this.arr.length;
   }
   shift() {
      if (this.arr.length == 0) {
         return undefined;
      }
      let data = this.arr.shift();
      this.length = this.arr.length;
      return data;
   }
   pop() {
      if (this.arr.length == 0) {
         return undefined
      }
      let data = this.arr.pop();
      this.length = this.arr.length;
      return data;
   }
}

//50.声明一个函数f(a,b,c)。
// 参数a是数组，元素是块地址和块长，每块地址和块长连续存储，数组已按块地址升序排序。
// 参数b和c是要插入到数组中的块地址和块长，插入后保持按块地址升序排序。如果块与块之间已连接在一起，则需要合并。
// 例如：
// let a=[2,2,6,3];
// f(a,4,2);
// console.log(a.toString());
// 输出:“2,7”。
// 注意不要在控制台输出任何内容。
const clear = (arr) => {
   while (arr.length > 0) {
      arr.pop();
   }
}
 
const cutArea = (arr) => {
   let cpArr = [].concat(arr);
   clear(arr);
   while (cpArr.length > 0) {
      arr.push(cpArr.splice(0, 2));
   }
}
 
 
const isLinked = (arr, b, c) => {
   for (let i = 0; i < arr.length; i++) {
      if (arr[i][0] + arr[i][1] == b && arr[i + 1][0] - c == b) {
         return true;
      }
   }
   return false;
}
 
const doLink = (arr, b, c) => {
   let sumLength = 0;
   let initial = arr[0][0];
   for (let i = 0; i < arr.length; i++) {
      sumLength += arr[i][1];
   }
   sumLength += c;
   clear(arr);
   arr.push([initial, sumLength]);
}
 
let f = (a, b, c) => {
   cutArea(a);
 
   if (isLinked(a, b, c)) {
      doLink(a, b, c)
   } else {
      let temp = [b, c];
      a.push(temp)
      a.sort(function (arr1, arr2) {
         if (arr1[0] < arr2[0]) {
            return -1;
         } else if (arr1[0] == arr2[0]) {
            return 0;
         } else {
            return 1;
         }
      });
   }
}