互动媒体技术——编程习题集

最新推荐文章于 2024-08-24 09:47:11 发布
最新推荐文章于 2024-08-24 09:47:11 发布
阅读量205 收藏 2
点赞数
分类专栏： processing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43416024/article/details/103660182
版权

第0章 引言

参考 0.6.2 二维噪声
迷雾森林：


loat increment = 0.01;
float zoff = 0.0;  
float zincrement = 0.02; 

void setup() {
  size(200,200);
}

void draw() {
  background(0);
  loadPixels();

  float xoff = 0.0; 

  for (int x = 0; x < width; x++) {
    xoff += increment;   
    float yoff = 0.0;  
    for (int y = 0; y < height; y++) {
      yoff += increment;
      float bright = noise(xoff,yoff,zoff)*255;
      pixels[x+y*width] = color(bright*0.5,bright,bright*0.1);
    }
  }
  updatePixels();
  zoff += zincrement; 
}

在这里插入图片描述

第一章 向量

一个简化的"飞碟"，让它渐渐地驶向鼠标。（距离越近，渐进越慢）具有影子拖移效果

float x,
      x0=0.0,
      x1=0.0,
      x2=0.0,
      x3=0.0,
      x4=0.0,
      x5=0.0,
      x6=0.0,
      y,
      y0=0.0,
      y1=0.0,
      y2=0.0,
      y3=0.0,
      y4=0.0,
      y5=0.0,
      y6=0.0;
 
void positonsSet()
{
    y6=y5;
    y5=y4;
    y4=y3;
    y3=y2;
    y2=y1;
    y1=y;    
    x6=x5;
    x5=x4;
    x4=x3;
    x3=x2;
    x2=x1;
    x1=x;
}
 

float easing;
 
float diameterWidth = 32.0,
    diameterHeight = 4.0;
 
void draw_a_UFO(float x, float y, int c)
{
   fill(c);
   ellipse(x,y,diameterWidth / 2,diameterHeight * 2.5);
   ellipse(x,y,diameterWidth,diameterHeight); 
} 
 
int colorSet = 250;
int myColor;   
void colorChange()
{
    myColor -= 33;
    fill(myColor);
}
 
void setup()
{
    frameRate(10);
    size(720,404);
    smooth();
    x = 0.5 * width;
    y = 0.5 * height;
    easing = 0.2;
}
 
void draw()
{
    background(20);
    float targetX = mouseX,
          targetY = mouseY;
    x += (targetX - x) * easing;
    y += (targetY - y) * easing;
    noStroke();
    positonsSet();
    myColor = colorSet;
    draw_a_UFO(x0,y0,myColor);
    colorChange();
    draw_a_UFO(x1,y1,myColor);
    colorChange();
    draw_a_UFO(x2,y2,myColor);
    colorChange();
    draw_a_UFO(x3,y3,myColor);
    colorChange();
    draw_a_UFO(x4,y4,myColor);
    colorChange();
    draw_a_UFO(x5,y5,myColor);
    colorChange();
    draw_a_UFO(x6,y6,myColor);
    colorChange();
    println(frameCount);
}

在这里插入图片描述

第二章 力

2.7 摩檫力

摩檫力是一种耗散力.耗散力的定义是:在运动中使系统总能量减少的力.比如说,开车时,脚踩刹车板会让车通过摩檫力使轮胎减速,在这个过程中,动能被转化为热能.只要两个物体的表面相互接触,它们之间就有摩檫力.摩檫力可分为静摩檫力(物体相对表面静止不动)和动摩檫力(物体在表面上运动)


Mover[] movers = new Mover[20];

void setup() {
  size(1000,500);
  randomSeed(1);
  for(int i = 0; i < movers.length;i++) {
    movers[i] = new Mover(random(1,4),0,0); 
  }
}

void draw() {
  background(255);
  for(int i = 0; i < movers.length;i++) {
    PVector wind = new PVector(0.01,0);
    PVector gravity = new PVector(0,0.1 * movers[i].mass);
    float c = 0.05;
    float normal = 1;
    PVector friction = movers[i].velocity.get();
    friction.mult(-1);  
    friction.normalize();    
    friction.mult(c);  
    friction.mult(normal);  
    if(movers[i].location.x > width / 2) {
      movers[i].applyForce(friction);  
    }
    
    movers[i].applyForce(wind);
    movers[i].applyForce(gravity);
    movers[i].update();
    movers[i].display();
    movers[i].checkEdges();
  }
}

class PVector {
  float x;
  float y;
  PVector(float x_,float y_) {
    x = x_;
    y = y_;
  }
  
  PVector get() {
    PVector newVector = new PVector(x,y);
    return newVector;
  }
  
  void add(PVector v) {
    x = x + v.x; 
    y = y + v.y;
  }
  
  void sub(PVector v) {
    x = x - v.x;
    y = y - v.y;
  }
  
  void mult(float n) {
    x = x * n;
    y = y * n;
  }
  
  void div(float n) {
    x = x / n;
    y = y / n;
  }
  
  float mag() {
     return sqrt(x * x + y * y); 
  }
  
  void normalize() {
    float m = mag();
    if(m != 0) {
      div(m);  
    }
  }
  
  void limit(float max) {
    if(mag() > max) {
      normalize();
      mult(max);
      
      println(mag());
    }
  }
}

class Mover {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float mass;
  color c;
  
  Mover(float m,float x,float y) {
    location = new PVector(x,y);
    velocity = new PVector(0,0);
    acceleration = new PVector(0,0);
    mass = m;
    c = color(random(255),random(255),random(25));
  }
  
  void applyForce(PVector force) {
    PVector newVector = force.get();
    newVector.div(mass);
    acceleration.add(newVector);
  }
  
  void update() {
    velocity.add(acceleration);
    location.add(velocity);
    acceleration.mult(0);
  }
  
  void display() {
    stroke(0);
    strokeWeight(2);
    fill(c);
    fill(random(255),random(255),random(255));
    ellipse(location.x,location.y,mass * 16,mass * 16);
  }
  
  void checkEdges() {
    if(location.x > width) {
      location.x = width;
      velocity.x *= -1;
    } else if(location.x < 0) {
      velocity.x *= -1;
      location.x = 0;
    }
    
    if(location.y > height) {
      velocity.y *= -1;
      location.y = height;
    }
  }
}

在这里插入图片描述
液滴的大小会影响其所受阻力的大小，而在不同的介质中，液滴所受到的阻力也不同，所以他的下降速度也就不同。轻的液滴重量轻，碰到液面后会反弹，重点的液滴直接落入液体中，但受到阻力大本身重力也大，故向下的力大，液体中下降快。这里设置一条空气与蜂蜜的分界线，越过分界线后，下降所受的阻力加大，速度变慢。运用到物理上浮力的公式：F浮=ρ液gV排以及阻力公式f=k*v²

Mover[] movers = new Mover[10];
 
Liquid liquid;
 
void setup() {
  size(800, 500);
  reset();
  liquid = new Liquid(0, height/2, width, height/2, 0.3);
}
 
void draw() {
  background(255);
  liquid.display();
 
  for (int i = 0; i < movers.length; i++) {

    if (liquid.contains(movers[i])) {
      PVector drag = liquid.drag(movers[i]);
      movers[i].applyForce(drag);
    }
 
    PVector gravity = new PVector(0, 0.1*movers[i].mass);
    movers[i].applyForce(gravity);
    movers[i].update();
    movers[i].display();
    movers[i].checkEdges();
  }
   
  fill(0, 120);
 
}
 
void mousePressed() {
  reset();
}
 
void reset() {
  for (int i = 0; i < movers.length; i++) {
    movers[i] = new Mover(random(0.05, 3), 30+i*60, 0);
  }
}
  
 // Liquid class
 class Liquid {
   
  // Liquid is a rectangle
  float x,y,w,h;
  // Coefficient of drag
  float c;
 
  Liquid(float x_, float y_, float w_, float h_, float c_) {
    x = x_;
    y = y_;
    w = w_;
    h = h_;
    c = c_;
  }
   
  // Is the Mover in the Liquid?
  boolean contains(Mover m) {
    PVector l = m.location;
    if (l.x > x && l.x < x + w && l.y > y && l.y < y + h) {
      return true;
    } else {
      return false;
    }
  }
   
  // Calculate drag force
  PVector drag(Mover m) {
    // Magnitude is coefficient * speed squared
    float speed = m.velocity.mag();
    float dragMagnitude = c * speed * speed;
 
    PVector drag = m.velocity.get();
    drag.mult(-1);
     
    drag.setMag(dragMagnitude);
    return drag;
  }
   
  void display() {
    noStroke();
    fill(255,185,15);
    rect(x,y,w,h);
  }
 
}
 
class Mover {
 
  // location, velocity, and acceleration
  PVector location;
  PVector velocity;
  PVector acceleration;
   
  // Mass is tied to size
  float mass;
 
  Mover(float m, float x, float y) {
    mass = m;
    location = new PVector(x, y);
    velocity = new PVector(0, 0);
    acceleration = new PVector(0, 0);
  }
 
  // Newton's 2nd law: F = M * A
  // or A = F / M
  void applyForce(PVector force) {
    // Divide by mass
    PVector f = PVector.div(force, mass);
    // Accumulate all forces in acceleration
    acceleration.add(f);
  }
 
  void update() {
     
    // Velocity changes according to acceleration
    velocity.add(acceleration);
    // Location changes by velocity
    location.add(velocity);
    // We must clear acceleration each frame
    acceleration.mult(0);
  }
   
  // Draw Mover
  void display() {
    noStroke();
    fill(0,1, 255, 30);
    ellipse(location.x, location.y, mass*16, mass*16);
  }

  void checkEdges() {
    if (location.y > height) {
      velocity.y *= -1;  // A little dampening when hitting the bottom
      location.y = height;
    }
  }
}

在这里插入图片描述
当 mouseX > pmouseX 时，即向右运动时，设定腿部相对于身体的旋转角度为PI/4
当mouseX < pmouseX 时，即向左运动时，设定腿部相对于身体的旋转角度为-PI/4
当mouseX = pmouseX 时，即不动时，设定腿部相对于身体的旋转角度为0为避免太灵敏，可以设定一个范围（如-5～5）：
当mouseX - pmouseX > 5时，设定角度为PI/4
当mouseX - pmouseX < -5时，设定角度为-PI/4
当-5 <= mouseX - pmouseX <= 5时，设定角度为0
大白会随着鼠标的移动而移动，腿会随着身体而摆动。


void setup(){
  size(600,400);
}
void draw(){
  colorMode(HSB,360,100,100);
  background(0,40,100);
  float w = 120;
  float l = w/3*5;
  DaBai db = new DaBai(w,l);
  db.leftArm.a=atan2(mouseY,mouseX);
  db.rightArm.a=PI-atan2(mouseY,width-mouseX);
  if((mouseX-pmouseX)>5){
    db.leftLeg.a=PI/4;db.rightLeg.a=PI/4;
  }else if((mouseX-pmouseX)<-5){
    db.leftLeg.a=-PI/4;db.rightLeg.a=-PI/4;
  }else{
    db.leftLeg.a=0;db.rightLeg.a=0;
  }

  stroke(30,75,75);strokeWeight(2);
  line(0,0,mouseX-db.body.w-db.leftArm.l*cos(db.leftArm.a),mouseY-db.body.l/2-db.leftArm.l*sin(db.leftArm.a));
  line(width,0,mouseX+db.body.w-db.rightArm.l*cos(db.rightArm.a),mouseY-db.body.l/2-db.rightArm.l*sin(db.rightArm.a));
  
  pushMatrix();
  translate(mouseX,mouseY);
  db.display();
  popMatrix();
}

class DaBai{
  float w,l;
  Head head;
  Body body;
  Arm leftArm;
  Arm rightArm;
  Leg leftLeg;
  Leg rightLeg;
  DaBai(float w,float l){
    this.w=w;this.l=l;
    head = new Head(w/3.5);
    body = new Body(l/3);
    leftArm = new Arm(l/5,0);
    rightArm = new Arm(l/5,0);
    leftLeg = new Leg(l/6,0);
    rightLeg = new Leg(l/6,0);
  }
  void display(){
    ellipseMode(RADIUS);
    // left arm
    pushMatrix();
    translate(-body.w,-body.l/2);
    rotate(leftArm.a);
    leftArm.display();
    popMatrix();
    // right arm
    pushMatrix();
    translate(body.w,-body.l/2);
    rotate(rightArm.a);
    rightArm.display();
    popMatrix();
    // left leg
    pushMatrix();
    translate(-body.w/3,body.l/1.25);
    rotate(leftLeg.a);
    leftLeg.display();
    popMatrix();
    // right leg
    pushMatrix();
    translate(body.w/3,body.l/1.25);
    rotate(rightLeg.a);
    rightLeg.display();
    popMatrix();
    // body
    body.display();
    // head
    pushMatrix();
    translate(0,-body.l);
    head.display();
    popMatrix();
  } 
}
class Head{
  float w,l;
  Head(float w){
    this.w=w;l=w*2/3;
  }
  void display(){
    ellipseMode(RADIUS);
    fill(0,0,100);stroke(0,0,0);strokeWeight(2);
    ellipse(0,0,w,l);
    fill(0,0,0);stroke(0,0,0);
    ellipse(-w/5*2,-l/10,l/10,l/10);
    ellipse(w/5*2,-l/10,l/10,l/10);
    noFill();stroke(0,0,0);strokeWeight(2);
    bezier(-w/5*2,-l/10,0,l/20,0,l/20,w/5*2,-l/10);
    fill(20,80,80);stroke(20,80,80);strokeWeight(2);
    ellipse(-w/5*3,l/5,l/10,l/15);
    ellipse(w/5*3,l/5,l/10,l/15);
  } 
}
class Body{
  float w,l;
  Body(float l){
    this.l=l;w=l*1/1.2;
  }
  void display(){
    ellipseMode(RADIUS);
    fill(0,0,100);stroke(0,0,0);strokeWeight(2);
    ellipse(0,0,w,l);
    fill(30,10,100);stroke(0,10,60);strokeWeight(1);

    ellipse(w/5*2,-l/5*2,w/8,w/8);
    beginShape();
    vertex(w/5*2-w/8,-l/5*2);
    vertex(w/5*2-w/16,-l/5*2);
    vertex(w/5*2-w/16,-l/5*2-w/16);
    vertex(w/5*2+w/16,-l/5*2-w/16);
    vertex(w/5*2+w/16,-l/5*2);
    vertex(w/5*2+w/8,-l/5*2);
    endShape();
  }
}
class Arm{
  float w,l;
  float a;
  Arm(float w,float a){
    this.w=w;l=w*1/3;this.a=a;
  }
  void display(){
    ellipseMode(RADIUS);
    fill(0,0,100);stroke(0,0,0);strokeWeight(2);
    ellipse(0,0,w,l);
  } 
}
class Leg{
  float w,l;
  float a;
  Leg(float l,float a){
    this.l=l;w=l*1/2;this.a=a;
  }
  void display(){
    ellipseMode(RADIUS);
    fill(0,0,100);stroke(0,0,0);strokeWeight(2);
    ellipse(0,0,w,l);
  } 
}

在这里插入图片描述

第三章 震荡

带有角速度的振荡

一个以弧度为单位的圆(一个圆周为2π,即:360度=2π),在单位时间内所走的弧度即为角速度.公式为:ω=Ч/t(Ч为所走过弧度,t为时间)ω的单位为:弧度每秒

Oscillator[] oscillators = new Oscillator[200];

void setup() {
  size(800,500);
  background(255);
  for(int i = 0; i < oscillators.length; i++) {
    oscillators[i] = new Oscillator(); 
  }  
}

void draw() {
  background(255);
  for(int i = 0; i < oscillators.length; i++) {
    oscillators[i].oscillate();
    oscillators[i].display();
  }
}

class Oscillator {
  PVector angle;
  PVector velocity;
  PVector amplitude;
  color c;
  Oscillator() {
    angle = new PVector();
    velocity = new PVector(random(-0.05,0.05),random(-0.05,0.05));
    amplitude = new PVector(random(width / 2),random(height / 2));
    
    c = color(random(55),random(255),random(255));
  }
  
  void oscillate() {
    angle.add(velocity); 
  }
  
  void display() {
    float x = sin(angle.x) * amplitude.x;
    float y = sin(angle.y) * amplitude.y;
    
    pushMatrix();
    translate(width / 2,height / 2);
    stroke(0);
    fill(c);
    line(0,0,x,y);
    ellipse(x,y,16,16);
    popMatrix();
  }
}

class PVector {
  float x;
  float y;
  
  PVector() {
    x = 0;
    y = 0;
  }
  
  PVector(float x_,float y_) {
    x = x_;
    y = y_;
  }
  
  PVector get() {
    PVector newVector = new PVector(x,y);
    return newVector;
  }
  
  void add(PVector v) {
    x = x + v.x; 
    y = y + v.y;
  }
  
  void sub(PVector v) {
    x = x - v.x;
    y = y - v.y;
  }
  
  void mult(float n) {
    x = x * n;
    y = y * n;
  }
  
  void div(float n) {
    x = x / n;
    y = y / n;
  }
  
  float mag() {
     return sqrt(x * x + y * y); 
  }
  
  void normalize() {
    float m = mag();
    if(m != 0) {
      div(m);  
    }
  }
  
  void limit(float max) {
    if(mag() > max) {
      normalize();
      mult(max);
    }
  }
  
  float heading2D() {
    return atan2(y,x); 
  }
}

在这里插入图片描述

第四章 粒子系统

ParticleSystem ps;
PShape s;
float angle=0;
float aVelocity=0;
float aAcceleration=0.001;

void setup() {
  size(300, 800);
  ps = new ParticleSystem(new PVector(width/2, height-50));
}

void draw() {
  background(255);
  ps.addParticle();
  ps.run();
}

void mousePressed(){
  ps=(new ParticleSystem(new PVector(mouseX,mouseY)));
}

class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float lifespan;
  Particle(PVector l) {
    acceleration = new PVector(0, 0.05);
    velocity = new PVector(random(-1, 1), random(-14, -1));
    location = l.copy();
    lifespan = 255.0;
  }

  void run() {
    update();
    display();
  }

  void update() {
    velocity.add(acceleration);
    location.add(velocity);
  }

  boolean isDead() {

    if (lifespan <= 0) {
      return true;
    } else {
      return false;
    }
  }

  void display() {

    stroke(0, lifespan);
    strokeWeight(1);
    float r = random(0,255);
    float g = random(0,255);
    float b = random(0,255);
    fill(r,g,b, lifespan);
    rectMode(CENTER);
    pushMatrix();
    rotate(angle);
    float k=random(1,10);
    
    line(location.x-k,location.y,location.x+k,location.y);
    ellipse(location.x+k,location.y,8,8);
    ellipse(location.x-k,location.y,8,8);   
    line(location.x,location.y-k,location.x,location.y+k);
    ellipse(location.x,location.y+k,8,8);
    ellipse(location.x,location.y-k,8,8);
    s=createShape();
  s.beginShape();
  s.vertex(location.x+50/2,location.y+18/2);
  s.vertex(location.x+61/2,location.y+37/2);
  s.vertex(location.x+83/2,location.y+43/2);
  s.vertex(location.x+69/2,location.y+60/2);
  s.vertex(location.x+71/2,location.y+82/2);
  s.vertex(location.x+50/2,location.y+73/2);
  s.vertex(location.x+29/2,location.y+82/2);
  s.vertex(location.x+31/2,location.y+60/2);
  s.vertex(location.x+17/2,location.y+43/2);
  s.vertex(location.x+39/2,location.y+37/2);
  s.endShape();
    shape(s);
    popMatrix();

  }
}
class ParticleSystem {

  ArrayList<Particle> particles;
  PVector origin;

  ParticleSystem(PVector position) {
    origin = position.copy();
    particles = new ArrayList<Particle>();
  }

  void addParticle() {
    particles.add(new Particle(origin));
  }

  void run() {
    for (int i = particles.size()-1; i >= 0; i--) {
      Particle p = particles.get(i);
      p.run();
      if (p.isDead()) {
        particles.remove(i);
      }
    }
  }
}

在这里插入图片描述
参考到一个知乎博主的代码
利用公式：
x = r * sin(a) * cos(b)
y = r * cos(a) * cos(b)
z = r * sin(b)
设置粒子数：100
设置粒子的大小：8
背景使用P3D，使得可以旋转

int num = 100; 
ArrayList<Particle> particles;
PVector Rotate;
Particle tempP;
void setup(){
  size(1080,680,P3D); 
  colorMode(HSB);
  Rotate = new PVector();
  particles = new ArrayList<Particle>();
  for(int i = 0; i < num; i++){
    particles.add( new Particle() );
  }
  background(255);
}

void draw(){

  noStroke();
  fill(255, 18);
  rect(0,0,width,height);  
  

  Rotate = new PVector(frameCount*0.003, frameCount*0.04, frameCount*0.03);
  pushMatrix();
  translate(width/2, height/2);
  rotateX(Rotate.x);
  rotateY(Rotate.y);
  rotateZ(Rotate.z);

  for(int i = particles.size()-1; i >= 0; i--){
    tempP = particles.get(i);
    tempP.move();
  }
  popMatrix();
}




class Particle{
  PVector pos,radian;
  float dis,h,s,b;
  float _weight = 8;
  Particle(){
    radian = new PVector(random(TWO_PI), random(TWO_PI));  
    pos = new PVector();
    dis = 160;
  }
  
  void move(){
    update();
    display();
  }
  
  void update(){
    pos.x = dis*sin(radian.x)*cos(radian.y);
    pos.y = dis*cos(radian.x)*cos(radian.y);
    pos.z = dis*sin(radian.y);
  }
  
  void display(){
    h = noise(radian.x*0.3, frameCount*0.012)*95 + 130 + map(mouseX, 0 ,width, -20, 20);
    noStroke();
    fill(h,85,55);
    translate(pos.x,pos.y,pos.z);
    sphere(_weight);
    translate(-pos.x,-pos.y,-pos.z);
  }
}

在这里插入图片描述

Rwby一个小饼干杀手而已
关注
专栏目录
《AI聊天类工具之四——ChatGPT》
再见孙悟空的专栏
04-19 71
ChatGPTChatGPT是由OpenAI开发的一款先进的自然语言处理（NLP）模型。这款基于生成预训练Transformer的聊天机器人程序于2022年11月30日发布，并迅速成为人工智能领域的热门话题。ChatGPT不仅具备强大的对话功能，能够与用户进行自然、流畅的交流，还具备语言生成、文本分类、文本摘要、机器翻译和语音合成等多种功能。ChatGPT的核心优势在于其深度学习和自然语言处理的能力。它通过在大量文本数据上进行预训练，获得了对语言结构、语法和语义的深入理解。
java 习题1 ~~~~~~~~~
11-04
本次分享的是《Java习题集》，这份资料由知名Java认证专家Marcus Green编写，旨在帮助学习者深入理解和掌握Java语言的关键概念和技术要点。此套习题集是根据Sun Java Programmer Exam（现已被Oracle接管）的标准而...
推荐项目：Exercism Java Track —— 踏上编程旅程的卓越伴侣
gitblog_00751的博客
08-24 505
推荐项目：Exercism Java Track —— 踏上编程旅程的卓越伴侣 javaExercism exercises in Java.项目地址:https://gitcode.com/gh_mirrors/java30/java 在技术日新月异的今天，持续学习与实践是每位程序员的成长必经之路。为此，我们特别推荐一个专为Java学习者量身打造的开源项目——Exercism Java Tra...
**Python入门课程——你的编程旅程的完美起点**
gitblog_00074的博客
06-14 402
Python入门课程——你的编程旅程的完美起点 项目地址:https://gitcode.com/AFIF-UG/Introduccion_a_Python-Curso_Online 在当今的技术领域，Python无疑占据了主导地位，无论是在职业市场还是科研界都备受青睐。这门语言以其多范式、跨平台以及动态类型的特性而闻名，吸引了无数渴望学习者的目光。然而，很多对Python感兴趣的朋友可能尚未踏出...
探索统计的思维革命：Statistical Rethinking学习笔记与习题集
gitblog_00063的博客
06-14 315
探索统计的思维革命：Statistical Rethinking学习笔记与习题集 项目地址:https://gitcode.com/cavaunpeu/statistical-rethinking 项目介绍 在数据科学和机器学习蓬勃发展的今天，深入理解统计学已成为每位研究者和实践者的必修课。而Richard McElreath的《Statistical Rethinking》以其独特的视角和生动的...
推荐文章：探索ICS2015编程实践——深度揭秘NJU的模拟器之旅
gitblog_00050的博客
06-18 388
推荐文章：探索ICS2015编程实践——深度揭秘NJU的模拟器之旅 项目地址:https://gitcode.com/KiraMelody/nemu 在计算机科学的探索之路上，有一个项目如璀璨明星，照亮了学生们对底层系统理解的道路——那就是南京大学计算机科学与技术系的ICS2015编程作业。该项目不仅是学习的载体，更是一个充满挑战与乐趣的全系统x86模拟器——NEMU的实验场。 项目介绍 ICS2...
开启编程之旅——《Epic Notes》引领您的代码新篇章！
gitblog_00038的博客
06-12 404
???? 开启编程之旅——《Epic Notes》引领您的代码新篇章！ 项目地址:https://gitcode.com/BCAPATHSHALA/DSA-SUPREME-2-0-NOTES ✨ 项目简介 欢迎来到《Epic Notes》，一份由**The code help精心打造的全方位学习资料库，这里集结了知名导师Love Babbar与Lakshay Kumar**的心血之作，旨在为初学者和进阶...
编程书籍大全
06-02 3780
MFC程序开发参考大全USB应用开发技术大全HTML参考大全Java范例开发大全Java开发技术大全Java 2参考大全Java Web开发典型模块大全Java Web开发技术大全精通Java Web整合开发Java 2游戏设计Java游戏编程Java Web开发实战1200例Java Web 2.0架构开发与项目实战开发者突击Java Web 开发详解 XML+XSLT+Servlet+JS...
学习游戏编程小知识
冷崖的博客
05-02 651
所文地址 一、书籍： 算法与数据结构： 《数据结构（C语言版）》——严蔚敏、吴伟民 清华出版社 我觉得其配套习题集甚至比原书更有价值，每个较难的题都值得做一下。 《Introduction to Algorithms》第二版 中文名《算法导论》 关 于算法的标准学习教材与工程参考手册，在去年CSDN网站上其翻译版竟然评为年度二十大技术畅销书，同时《程序员》杂志上开设了“算法擂台”栏目，...
计算机网络——应用层
商务合作|种草文章|产品测评
07-22 3918
本文提供了关于计算机网络中多个重要主题和应用的概述和解释，帮助读者了解了这些关键概念和技术在网络通信中的作用和应用。
高职教育背景下在线开放课程的建设研究——以《Python 程序设计基础》 课程为例.zip
10-16
这包括视频教程、图文教材、编程实例、习题集和参考文献等，应覆盖Python的基础知识、编程实践和进阶主题。同时，课程应设置合理的章节结构，由浅入深，引导学生逐步掌握编程思维和技能。 此外，教师的角色在在线...
高职教育背景下在线开放课程的建设研究——以《Python程序设计基础》课程为例.zip
10-16
此外，配套的课件、习题集、编程实战项目和学习论坛也至关重要。这些资源能帮助学生自主学习，促进师生间、学生间的交流与合作。 再者，课程评估体系需适应在线学习的特点。除了传统的期末考试外，可以引入过程性...
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
多媒体计算机技术：习题与解答解析
"多媒体技术基础及应用（钟玉琢）习题解答" 这篇摘要涉及的是多媒体技术的基础知识和应用，特别是针对多媒体计算机的概念和相关技术。习题涵盖了多媒体的定义、核心软件、关键技术以及发展趋势。 1. 多媒体的范畴...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值