第一章、逻辑代数基础,那么在子类中是足以访问父类的类变量的

传送门

在Ruby中类实例变量、类实例方法和类变量、类措施的分别相比较神秘,而且用法也有一定的界别。本文研究一下他们的定义和主导的运用情况,以一得之见…
 
一.类实例变量和类变量
 
类变量我们都很熟谙了,正是在类定义中用@@开首的变量。类变量是用于存储类的全局音信,它只属于类,分裂与类实例变量(即用@开首定义的变量)每1个类的对象都有一份数据。
类变量是足以被三番四回的,也正是说假诺大家派生八个子类,那么在子类中是可以访问父类的类变量的。子类和父类共享一份数据,对一个类的修改会反映到另2个类中。如上边包车型大巴代码运维结果彰显:

首先章、数制与编码

  • ### 进制转换

    • 平尾部分:除r倒取余
    • 小数部分:乘r顺取整
    • 2ⁿ进制转换
  • ### 带符号数的代码表示

    • ##### 原码

      • 纯整数纯小数
      • 8位二进制表示
      • + ⇒ 0
      • – ⇒ 1
      • 原码加法:同号相加,异号相减
      • 0

        00000000 10000000
        0.0000000 1.0000000

    • ##### 反码

      • + ⇒ 0 数值位不变

      • – ⇒ 1 数值位按位变反

      • 加减法:全部做加法

        • [ x + y ]反 = [ x ]反 + [ y ]反
        • [ x – y]反 = [ x ]反 + [ -y ]反
        • 标志位进位加到最终一人
      • 0

        00000000 11111111
        0.0000000 1.1111111

    • ##### 补码

      • + ⇒ 0 数值位不变

      • – ⇒ 1 数值位按位变反,末尾加一

      • 加减法:全部做加法

        • [ x + y ]反 = [ x ]反 + [ y ]反
        • [ x – y]反 = [ x ]反 + [ -y ]反
        • 标记位进位丢掉
      • 0

        00000000 0.0000000

  • ### 小数的意味

    • ##### 定点表示

      小数点地点一定

    • ##### 浮点表示

      • 组成
        指数部分 + 尾数部分

  • ### 十进制数的二进制编码

    • 8421码
      +0
      +011
      +011
    • 2421码
    • 余三码
      -011
      +011
  • ### 可信赖性编码

    • 格雷码
      隔壁编码只有一位不同
    • 步进码
    • 奇偶校验码
      校验位 信息位

      • 奇校验 使校验码中1的个数是奇数
      • 偶校验 使校验码中1的个数是偶数
  • ### 字符编码

    • ASCII码

生成树计数裸题,因为模数不是质数所以要用辗转相除的高斯消元。

复制代码 代码如下:

第一章、逻辑代数基础

  • ### 基本概念

    • 概念

      • 某一时时必出现仅出现一种的状态
      • 一种情景是另一种情景的反状态
    • 逻辑值,用0,1表示

    • 逻辑变量,逻辑常量

    • 逻辑运算

      • ,逻辑加
        ” + ” 或 ” V “
      • ,逻辑乘
        ” · ” 或 ” Λ “
      • ,逻辑否定
        ” – ” 或 ” ¬ “
    • 逻辑函数

      F = f(A1,A2,A3,…,An)

      • 特点:
        • 0,1
        • 或、与、非
      • 逻辑函数的对等
      • 逻辑函数的表示法
        • 表达式
        • 真值表
        • 卡诺图
  • ### 基本定理和规则

    • 公理

      • 交换律
      • 结合律
      • 分配律

        • A + B·C = (A + B) · (A + C)
      • 0-1律

        • A + 0 = A
        • A + 1 = 1
        • A · 1 = A
        • A · 0 = 0
      • 互补律

        • A + ¬A = 1
        • A · ¬A = 0
    • 定理

      • ① 、基本逻辑运算

      • 贰 、重叠定理:贰个变量本人多次自加或频仍自乘的结果为自家

        • A+A=A
        • A·A=A
      • 三、吸收定理:假如逻辑表明式中某一项包蕴式内别的一项,则该项是剩下的

        • A+A·B=A
        • A·(A+B)=A
      • 四 、若是逻辑表明式中某项的“非”被另一项所涵盖,则可从另一项中去掉该项的“非”

        • A+¬A·B=A+B
        • A·(¬A+B)=A·B
      • ⑤ 、如若逻辑表明式中的某两项除去相同的片段剩余部分互为相“反”,则可合并为一项,合并时保存相同部分,去掉相反部分

        • A·B+A·¬B=A
        • (A+B)·(A+¬B)=A
      • 六、Morgan定理

        • ¬(A+B)=¬A·¬B
        • ¬(A·B)=¬A+¬B
        • N变量的摩尔根定理
      • 七 、对合定理

        • ¬¬A=A
      • 八、结余项定理

        • A·B+¬A·C+B·C=A·B+A·C
        • (A+B)·(¬A+C)·(B+C)=(A+B)·(A+C)
    • 最首要规则

      • 带入规则

        其它3个分包变量A的逻辑等式,假诺将全数出现A的地方代之同3个逻辑函数F,则等式仍旧创建

      • 反演规则

        假使将逻辑函数表达式F中

        • 所有的“·”变成“+”“+”变成“·”
        • 所有的“0”变成“1”“1”变成“0”
        • 所有的原变量变成反变量反变量变成原变量
        • 并保持原函数中的运算顺序不变

        则所得到的新的函数为原函数F的反函数¬F

      • 对偶规则

        只要将逻辑函数表明式F中

        • 所有的“·”变成“+”“+”变成“·”
        • 所有的“0”变成“1”“1”变成“0”
        • 并维持原函数中的运算顺序不变

        则所收获的新的逻辑表明式称为函数F的对偶式,并记作F’

    • 复合逻辑

      • 与非逻辑
      • 或非逻辑
      • 与或非逻辑
      • 异或逻辑及同或逻辑
  • ### 逻辑函数表达式的款式与转换

    • 骨干格局

      • 与-或表达式
      • 或-与表达式
    • 行业内部格局

      • 最小项和最大项

        • 最小项

          假诺三个全体n个变量的函数的“与项”包括全体n个变量,各类变量都以原变量或反变量格局出现二回,且仅现身3遍,则该“与项”被称为最小项。有时又将最小项称为标准“与项”

          • 最小项的多少:n个变量能够整合2n个最小项
          • 简写:mi
        • 最大项

          假诺三个颇具n个变量的函数的“或项”蕴含全部n个变量,各样变量都以原变量或反变量情势现身贰次,且仅出现一回,则该“或项”被称呼最大项。有时又将最大项称为标准“或项”

          • 最大项的数码:n个变量能够构成2n个最大项
          • 简写:Mi
      • 规范情势

    • 表明式的更换

      • 代数转换法
      • 真值表转换法
  • ### 逻辑函数化简

    • 代数化简

      • 与-或表达式化简
      • 或-与表明式化简
    • 卡诺图化简

de了很久的bug然后发现3个变量A赋值后下一行又发明了多个新的近年来变量A(:

class A 
   #类变量在做客前必须赋值,不然会有”uninitialized class variable“
错误 
  @@alpha=123                # Initialize @@alpha 
  @@beta=456                 #Initialize @@beta 
  @@gamma=789              #Initialize @@gamma 
  
  def A.alpha 
    @@alpha 
  end  
  
  def A.alpha=(x) 
    @@alpha=x 
  end 
  
  def A.beta 
    @@beta 
  end 
  
  def A.beta=(x) 
     @@beta=x 
  end  
   
  def A.gamma 
   @@gamma 
  end 
  
  def A.gamma=(x) 
    @@gamma=x 
  end  
  def A.look 
    puts “#@@alpha, #@@beta, #@@gamma” 
  end 
  end 
 
 
class B<A   
end 
 
#初阶的数据 
A.look 
B.look 
 
#修改父类中的类变量 
A.alpha=111 
A.look 
B.look 

图片 1图片 2

 
 
运作结果: 

//Achen
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
#include<ctime>
const int mod=2007; 
const int N=507;
typedef long long LL;
using namespace std;
int T,n,g[N][N],ans;

template<typename T> void read(T &x) {
    T f=1; x=0; char ch=getchar();
    while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
    if(ch=='-') f=-1,ch=getchar();
    for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; x*=f;
}

int guess(int n) {
    int res=1,f=1; 
    for(int i=1;i<=n;i++) {
        for(int j=i+1;j<=n;j++) {
            int A=g[i][i],B=g[j][i];
            while(B) {
                int t=A/B; A=A%B; swap(A,B); 
                for(int k=i;k<=n;k++) 
                    g[i][k]=(g[i][k]-t*g[j][k]%mod+mod)%mod;
                for(int k=i;k<=n;k++) 
                    swap(g[i][k],g[j][k]);
                f=-f;
            }
        }
        if(!g[i][i]) return 0;
        res=(res*g[i][i])%mod;
    }
    if(f==-1) res=(mod-res)%mod;
    return res; 
}

int main() {
    read(T);
    while(T--) {
        read(n);
        if(n==1) printf("4\n");
        else if(n==2) printf("40\n");
        else {
            int tot=n;
            memset(g,0,sizeof(g));
            for(int i=1;i<=n;i++) {
                if(i==1) g[i][n]--,g[i][2]--;
                else if(i==n) g[i][1]--,g[i][i-1]--;
                else g[i][i-1]--,g[i][i+1]--;
                g[i][i]+=4;
            }
            for(int i=1;i<=tot;i++) {
                int x=n+1,y=n+2,z=n+3,w=(i==n)?1:i+1;
                g[x][i]--; g[i][x]--;
                g[x][y]--; g[y][x]--;
                g[y][z]--; g[z][y]--;
                g[z][w]--; g[w][z]--;
                g[x][x]+=2; g[y][y]+=2; g[z][z]+=2;
                n+=3;
            } 
            for(int i=1;i<=n;i++) 
            for(int j=1;j<=n;j++) 
                (g[i][j]+=mod)%=mod;
        }
        ans=guess(n-1);
        printf("%d\n",ans);
        }
    }
    return 0;
}

复制代码 代码如下:

View Code

123, 456, 789 
123, 456, 789 
111, 456, 789 
111, 456, 789 

 

那就是说怎么着是类的类实例变量呢?类的类实例变量是在类的类方法中或形式外边(无法在实例方法中,那是类的实例变量)以@初阶定义的变量,那样定义的变量值属于类对象自笔者,不能被子类继承。类对象那些说法只怕有些令人思疑,其实Ruby中的一起都是指标,我们定义的类和Ruby的内置类本人正是元类的靶子。因而只要要定义须求和子类共享的类全局数据,使用类变量;不过只要要定义仅供类本人使用的类全局数据能够使用类实例变量。还有某个急需留意的是,和类变量不一样的是类实例变量不要求访问前必须赋值,不赋值它的值正是nil
。我们依旧看四个例证,能够更通晓一点…
 

复制代码 代码如下:

class A 
   #类的类实例变量在拜访前能够赋值也得以不赋值,不赋值正是nil 
  @alpha=123              # Initialize @alpha 
  @beta=456                #Initialize @beta 
  @gamma=789             #Initialize @gamma 
  
  def A.alpha 
    @alpha 
  end  
  
  def A.alpha=(x) 
    @alpha=x 
  end 
  
  def A.beta 
    @beta 
  end 
  
  def A.beta=(x) 
     @beta=x 
  end  
   
  def A.gamma 
   @gamma 
  end 
  
  def A.gamma=(x) 
    @gamma=x 
  end  
  def A.look 
    puts “#@alpha, #@beta, #@gamma” 
  end 
  end 
 
 
class B<A   
end 
 
A.look 
B.look 

代码的运营结果如下:

复制代码 代码如下:

123, 456, 789
, ,
nil

您或者感兴趣的稿子:

相关文章