代码造山

n为迭代精度,128比较合适,越高山越精细,但是程序会卡顿。

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.util.StringTokenizer;
public class moutain extends Applet
    implements MouseListener, MouseMotionListener {
	/**
	 * n:迭代次数
	 * n1:
	 * h:绘画区域高度
	 * w:绘画区域宽度
	 * h2:焦点坐标
	 * w2:焦点坐标
	 * mx0:
	 * my0: 
	 * xpol:
	 * ypol:
	 * icol:
	 * */
  int n =128, n1,  h,w,h2,w2, mx0,my0,  xPol[],yPol[], iCol[][][];
  double rnd,  fiX = .2, fiY = .3, dfi = .01, scale = .8, m20,m21,m22;
  double vert[][][], vert1[][][], Norm[][][][], Norm1z[][][], M[];
  Image buffImage;     Graphics buffGraphics;
  Color col[][];
  boolean painted;

public void init(){
//  w = getSize().width;  h = getSize().height;   
  //设置绘画的区域高度和宽度
  w=1024;h=768;
  
  w2 = w/2;  h2 = h/2;//视角聚焦点
  String s=getParameter("N");  if (s != null) n = Integer.parseInt(s);
  xPol = new int[3];  yPol = new int[3];
  buffImage = createImage(w, h);   buffGraphics = buffImage.getGraphics();
  col = new Color[4][256];
  for (int i = 0; i < 256; i++){
    col[0][i] = new Color(0, 0, i);
    col[1][i] = new Color(0, (i*220)/256, 0);
    col[2][i] = new Color((i*150)/256, (i*150)/256, (i*50)/256);
    col[3][i] = new Color(i, i, i);}
  s = getParameter("bgColor"); if (s != null){
  StringTokenizer st = new StringTokenizer(s);
   int red = Integer.parseInt(st.nextToken());
   int green = Integer.parseInt(st.nextToken());
   int blue = Integer.parseInt(st.nextToken());
   setBackground( new Color(red, green, blue));}
  else setBackground(new Color(255,255,255));
  addMouseListener(this);
  addMouseMotionListener(this);
  setup();
}

public double R(){ return rnd*(Math.random()-.5);}

public void setup(){
  rnd = 1;
  n1 = n+1;
  iterate();
  vert = new double[n1][n1][3];  vert1 = new double[n1][n1][2];
  double dx = w/(double)n;
  int t = 0;
  for (int i = 0; i < n1; i++) 
   for (int j = 0; j < n1; j++){
    vert[i][j][0] = dx*i - w2;  vert[i][j][2] = dx*j - w2;
    double mi = M[t++];
    if (mi < 0) mi = .01*Math.random();
    vert[i][j][1] = w*mi - w2/2;}
  Norm = new double[n1][n1][2][3];  Norm1z = new double[n1][n1][2];
  iCol = new int[n][n][2];
  for (int i = 0; i < n; i++)
   for (int j = 0; j < n; j++){
     double s =
      ((vert[i][j][1] + vert[i+1][j][1] + vert[i+1][j+1][1])/3 + w2/2)/w;
     if (s < .01) iCol[i][j][0] = 0;
     else if (s+.1*Math.random() > .35) iCol[i][j][0] = 3;
      else if (s+.1*Math.random() > .15)  iCol[i][j][0] = 2;
       else  iCol[i][j][0] = 1;
     s = ((vert[i][j][1] + vert[i][j+1][1] + vert[i+1][j+1][1])/3 + w2/2)/w;
     if (s < .01) iCol[i][j][1] = 0;
     else if (s+.1*Math.random() > .35) iCol[i][j][1] = 3;
      else if (s+.1*Math.random() > .15)  iCol[i][j][1] = 2;
       else  iCol[i][j][1] = 1;
    Norm[i][j][0][0] = vert[i][j][1] - vert[i+1][j][1];
    Norm[i][j][0][1] = dx;
    Norm[i][j][0][2] = vert[i+1][j][1] - vert[i+1][j+1][1];
    double mod = Math.sqrt(Norm[i][j][0][0]*Norm[i][j][0][0] + Norm[i][j][0][1]*
     Norm[i][j][0][1] + Norm[i][j][0][2]*Norm[i][j][0][2]) / 255.5;
    Norm[i][j][0][0] /= mod; Norm[i][j][0][1] /= mod; Norm[i][j][0][2] /= mod;
    Norm[i][j][1][0] = vert[i][j+1][1] - vert[i+1][j+1][1];
    Norm[i][j][1][1] = dx;
    Norm[i][j][1][2] = vert[i][j][1] - vert[i][j+1][1];
    mod = Math.sqrt(Norm[i][j][1][0]*Norm[i][j][1][0] + Norm[i][j][1][1]*
     Norm[i][j][1][1] + Norm[i][j][1][2]*Norm[i][j][1][2]) / 255.5;
    Norm[i][j][1][0] /= mod; Norm[i][j][1][1] /= mod; Norm[i][j][1][2] /= mod;}
  rotate();
}

public void iterate(){
  int nc=n, Max=n1*n1, ncn1;
  double Min=-1;
  M = new double[Max];
  for (int i=n+2; i < n*n1-1; i++) M[i] = Min;
  for (int i=2*n1; i < n*n1; i += n1) M[i] = M[i-1] = 0;
  while ( (nc /= 2) >= 1){
    ncn1 = nc*n1;
    for (int j=ncn1; j < Max; j += ncn1+ncn1){
      for (int i= nc; i < n; i += nc+nc){
        if (M[i+j]==Min)
           M[i+j] = (M[i+j+nc-ncn1] + M[i+j-nc+ncn1])/2.+R();
        if (M[i+j+nc]==Min)
           M[i+j+nc] = (M[i+j+nc+ncn1] + M[i+j+nc-ncn1])/2.+R();
        if (M[i+j+ncn1]==Min)
           M[i+j+ncn1] = (M[i+j-nc+ncn1] + M[i+j+nc+ncn1])/2.+R(); }}
    rnd /= 2.;}
}

public void destroy() {
  removeMouseListener(this);
  removeMouseMotionListener(this);
}
public void mouseClicked(MouseEvent e){}       // event handling
public void mousePressed(MouseEvent e) {
  mx0 = e.getX();  my0 = e.getY();
  if ( e.isControlDown() ){
    setup();
    repaint();}
  if ( e.isAltDown() ){
    if ( e.isShiftDown() ){ n /= 2;  if (n < 1) n = 1;}
    else n *= 2;
    setup();
    repaint();}
  e.consume();
}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e)  {}
public void mouseDragged(MouseEvent e) {
  int x1 = e.getX();  int y1 = e.getY();
  if ( e.isShiftDown() )  scale *= Math.exp(-(y1 - my0)/(double)w);
  else   fiX += dfi*(y1 - my0);
  fiY += dfi*(x1 - mx0);   mx0 = x1;  my0 = y1;
  rotate();
  repaint();
  e.consume();
}

public void rotate(){
  double ct = Math.cos(fiX), cf = Math.cos(fiY),
         st = Math.sin(fiX), sf = Math.sin(fiY),
         m00 =  scale*cf,    m02 =  scale*sf,
         m10 = scale*st*sf, m11 =  scale*ct, m12 = -scale*st*cf;
         m20 = -ct*sf; m21 = st; m22 = ct*cf;
  for (int i = 0; i < n1; i++)
   for (int j = 0; j < n1; j++){
    vert1[i][j][0] = m00*vert[i][j][0] + m02*vert[i][j][2];
    vert1[i][j][1] = m10*vert[i][j][0] + m11*vert[i][j][1] + m12*vert[i][j][2];}
  for (int i = 0; i < n; i++)
   for (int j = 0; j < n; j++)
    for (int k = 0; k < 2; k++)
     Norm1z[i][j][k] = m20*Norm[i][j][k][0] + m21*Norm[i][j][k][1] +
      m22*Norm[i][j][k][2];
  painted = false;
}

public void mouseMoved(MouseEvent e) {}

public void paint(Graphics g) {
 if ( !painted ){
  buffGraphics.clearRect(0, 0, w, h);
  int ib=0, ie=n, sti=1,  jb=0, je=n, stj=1;
  if (m20 < 0){ ib = n; ie = -1; sti = -1;}
  if (m22 < 0){ jb = n; je = -1; stj = -1;}
  for (int i = ib; i != ie; i += sti)
   for (int j = jb; j != je; j += stj){
    if (Norm1z[i][j][0] > 0){
     xPol[0] = w2 + (int)vert1[i][j][0];
     xPol[1] = w2 + (int)vert1[i+1][j][0];
     xPol[2] = w2 + (int)vert1[i+1][j+1][0];
     yPol[0] = h2 - (int)vert1[i][j][1];
     yPol[1] = h2 - (int)vert1[i+1][j][1];
     yPol[2] = h2 - (int)vert1[i+1][j+1][1];
     buffGraphics.setColor(col[iCol[i][j][0]][(int)(Norm1z[i][j][0])]);
     buffGraphics.fillPolygon(xPol,yPol, 3);}
    if (Norm1z[i][j][1] > 0){
     xPol[0] = w2 + (int)vert1[i][j][0];
     xPol[1] = w2 + (int)vert1[i][j+1][0];
     xPol[2] = w2 + (int)vert1[i+1][j+1][0];
     yPol[0] = h2 - (int)vert1[i][j][1];
     yPol[1] = h2 - (int)vert1[i][j+1][1];
     yPol[2] = h2 - (int)vert1[i+1][j+1][1];
     buffGraphics.setColor(col[iCol[i][j][1]][(int)(Norm1z[i][j][1])]);
     buffGraphics.fillPolygon(xPol,yPol, 3);} }
  painted = true;}
 g.drawImage(buffImage, 0, 0, this);
 showStatus( "n=" + n);
}
public void update(Graphics g){ paint(g); }

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言是一种广泛使用的编程语言,它具有高效、灵活、可移植性强等特点,被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构(如if语句、循环语句等)、函数、指针等。下面详细介绍C语言的基本概念和语法。 1. 变量和数据类型 在C语言中,变量用于存储数据,数据类型用于定义变量的类型和范围。C语言支持多种数据类型,包括基本数据类型(如int、float、char等)和复合数据类型(如结构体、联合等)。 2. 运算符 C语言中常用的运算符包括算术运算符(如+、、、/等)、关系运算符(如==、!=、、=、<、<=等)、逻辑运算符(如&&、||、!等)。此外,还有位运算符(如&、|、^等)和指针运算符(如、等)。 3. 控制结构 C语言中常用的控制结构包括if语句、循环语句(如for、while等)和switch语句。通过这些控制结构,可以实现程序的分支、循环和多路选择等功能。 4. 函数 函数是C语言中用于封装代码的单元,可以实现代码的复用和模块化。C语言中定义函数使用关键字“void”或返回值类型(如int、float等),并通过“{”和“}”括起来的代码块来实现函数的功能。 5. 指针 指针是C语言中用于存储变量地址的变量。通过指针,可以实现对内存的间接访问和修改。C语言中定义指针使用星号()符号,指向数组、字符串和结构体等数据结构时,还需要注意数组名和字符串常量的特殊性质。 6. 数组和字符串 数组是C语言中用于存储同类型数据的结构,可以通过索引访问和修改数组中的元素。字符串是C语言中用于存储文本数据的特殊类型,通常以字符串常量的形式出现,用双引号("...")括起来,末尾自动添加'\0'字符。 7. 结构体和联合 结构体和联合是C语言中用于存储不同类型数据的复合数据类型。结构体由多个成员组成,每个成员可以是不同的数据类型;联合由多个变量组成,它们共用同一块内存空间。通过结构体和联合,可以实现数据的封装和抽象。 8. 文件操作 C语言中通过文件操作函数(如fopen、fclose、fread、fwrite等)实现对文件的读写操作。文件操作函数通常返回文件指针,用于表示打开的文件。通过文件指针,可以进行文件的定位、读写等操作。 总之,C语言是一种功能强大、灵活高效的编程语言,广泛应用于各种领域。掌握C语言的基本语法和数据结构,可以为编程学习和实践打下坚实的基础。
该资源内项目源码是个人的课程设计、毕业设计,代码都测试ok,都是运行成功后才上传资源,答辩评审平均分达到96分,放心下载使用! ## 项目备注 1、该资源内项目代码都经过测试运行成功,功能ok的情况下才上传的,请放心下载使用! 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习,也适合小白学习进阶,当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行,也可在此代码基础上进行修改,以实现其他功能,也可用于毕设、课设、作业等。 下载后请首先打开README.md文件(如有),仅供学习参考, 切勿用于商业用途。 该资源内项目源码是个人的课程设计,代码都测试ok,都是运行成功后才上传资源,答辩评审平均分达到96分,放心下载使用! ## 项目备注 1、该资源内项目代码都经过测试运行成功,功能ok的情况下才上传的,请放心下载使用! 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习,也适合小白学习进阶,当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行,也可在此代码基础上进行修改,以实现其他功能,也可用于毕设、课设、作业等。 下载后请首先打开README.md文件(如有),仅供学习参考, 切勿用于商业用途。
自动机是一种计算模型,可以用于解决字符串匹配、词法分析、语法分析等问题。下面是一个简单的自动机构造代码示例,用于匹配字符串 "hello"。 ```python def construct_automaton(): automaton = {} state = 0 for c in "hello": if c not in automaton: automaton[c] = {} automaton[c][state] = state + 1 state += 1 return automaton ``` 在这个例子中,我们首先创建了一个空的自动机 `automaton`,然后从字符串 "hello" 中逐个读取字符。对于每个字符,我们检查它是否已经在自动机中出现过,如果没有,我们就添加一个新的状态。然后将当前状态和下一个状态添加到自动机中,其中下一个状态是当前状态加 1。最后返回构造好的自动机。 这个自动机可以用于检查一个字符串是否包含子串 "hello"。我们可以按照以下方式使用它: ```python def match_string(s): automaton = construct_automaton() state = 0 for c in s: if c not in automaton: return False if state not in automaton[c]: return False state = automaton[c][state] return state == 5 ``` 在这个例子中,我们首先构造自动机 `automaton`,然后从字符串 `s` 中逐个读取字符。对于每个字符,我们检查它是否已经在自动机中出现过,如果没有,说明该字符串不包含子串 "hello",返回 `False`。然后检查当前状态和下一个状态是否在自动机中定义,如果不是,说明该字符串不包含子串 "hello",返回 `False`。最后检查最终状态是否为 5,如果是,说明该字符串包含子串 "hello",返回 `True`。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值