草庐IT

【牛客】8 企业真题

magnolia666 2023-03-28 原文

VL59 根据RTL图编写Verilog程序

这题比较简单，照着写就好了。

`timescale 1ns/1ns

module RTL(
    input clk,
    input rst_n,
    input data_in,
    output reg data_out
    );
    reg data_in_reg;
    always@(posedge clk)
    begin
        if(~rst_n)
        begin
            data_in_reg <= 1'b0;
            data_out <= 1'b0;
        end
        else begin
            data_in_reg <= data_in;
            data_out <= data_in&~data_in_reg;
        end
    end

endmodule

VL60 使用握手信号实现跨时钟域数据传输

题目只给了一个模块的接口，实际看testbench要写两个模块。

一开始用状态机写的，实在和答案对不上，还是照着题解写了。单bit数据跨时钟域常用方法：打两拍。

`timescale 1ns/1ns
module data_driver(
    input clk_a,
    input rst_n,
    input data_ack,
    output reg [3:0]data,
    output reg data_req
    );
reg data_ack_reg_1;
reg data_ack_reg_2;
always @ (posedge clk_a or negedge rst_n)
begin
    if (!rst_n) begin
        data_ack_reg_1 <= 1'b0;
        data_ack_reg_2 <= 1'b0;
    end else begin
        data_ack_reg_1 <= data_ack;
        data_ack_reg_2 <= data_ack_reg_1;
    end
end
always@(posedge clk_a or negedge rst_n)
begin
    if(~rst_n)
        data <= 'd0;
    else if(~data_ack_reg_2&data_ack_reg_1)//每次传输结束数据+1
        data <= data + 1'b1;
end
reg [3:0]count;
always@(posedge clk_a or negedge rst_n)
begin
    if(~rst_n)
        count <= 'd0;
    else if(~data_req)
        count <= count + 1;
    else
        count <= 0;
end

always@(posedge clk_a or negedge rst_n)
begin
    if(~rst_n)
        data_req <= 'd0;
    else if(count == 4)
        data_req <= 1'b1;
    else if(~data_ack_reg_2&data_ack_reg_1)//传输结束，data_req清零
        data_req <= 1'b0;
end

endmodule

module data_receiver(
    input clk_b,
    input rst_n,
    input [3:0]data,
    input data_req,
    output reg data_ack
    );
reg data_req_reg_1;
reg data_req_reg_2;
always @ (posedge clk_b or negedge rst_n)
begin
    if (!rst_n) begin
        data_req_reg_1 <= 0;
        data_req_reg_2 <= 0;
    end else begin
        data_req_reg_1 <= data_req;
        data_req_reg_2 <= data_req_reg_1;
    end
end
always@(posedge clk_b or negedge rst_n)
begin
    if(~rst_n)
        data_ack <= 1'b0;
    else if(data_req_reg_2 == 1'b1)
        data_ack <= 1'b1;
    else
        data_ack <= 1'b0;
end
    
endmodule

VL61 自动售卖机

感觉用计数器会很简单，状态机复杂一点，不过题目要求用状态机那就用吧。

 看了一下，感觉两个状态应该就够了，一个状态代表售卖机内没钱，一个状态代表售卖机内有5元钱。

`timescale 1ns/1ns

module sale(
   input                clk   ,
   input                rst_n ,
   input                sel   ,//sel=0,5$dranks,sel=1,10&=$drinks
   input          [1:0] din   ,//din=1,input 5$,din=2,input 10$
 
   output   reg  [1:0] drinks_out,//drinks_out=1,output 5$ drinks,drinks_out=2,output 10$ drinks
   output    reg        change_out   
);

reg state,next_state;
localparam S0=0,S1=1;
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)
        state <= S0;
    else
        state <= next_state;
end    
always@(*)
begin
    case(state)
    S0:begin//0
        if(sel==0&&din==1||sel==1&&din==2)
            next_state = S0;
        else if(sel==1&&din==1)
            next_state = S1;
        else
            next_state = S0;
    end
    S1:begin//5
        next_state = din?S0:S1; 
    end
    endcase
end

always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)begin
        drinks_out <= 0;
        change_out <= 0;
    end else begin
        case(state)
        S0:begin
            if(sel==0&&din==1)begin
                drinks_out <= 1;
                change_out <= 0;
            end else if(sel==1&&din==2)begin
                drinks_out <= 2;
                change_out <= 0;
            end else if(sel==0&&din==2)begin
                drinks_out <= 1;
                change_out <= 1;
            end else begin
                drinks_out <= 0;
                change_out <= 0;
            end                
        end
        S1:begin
            if(sel==0&&din==1)begin
                drinks_out <= 1;
                change_out <= 1;
            end else if(sel==1&&din==2)begin
                drinks_out <= 2;
                change_out <= 1;
            end else if(sel==1&&din==1)begin
                drinks_out <= 2;
                change_out <= 0;
            end else begin
                drinks_out <= 0;
                change_out <= 0; 
            end             
        end
        endcase
    end
end
endmodule

 VL62 序列发生器

直接移位寄存器秒了，不过用状态机的话所用寄存器会少一点。

`timescale 1ns/1ns

module sequence_generator(
    input clk,
    input rst_n,
    output reg data
    );
reg [5:0]data_reg;
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)begin
        data_reg <= 6'b001011;
        data <= 1'b0;
    end else begin
        data_reg <= {data_reg[4:0],data_reg[5]};
        data <= data_reg[5];
    end
end
endmodule

 VL63 并串转换

说是华为暑期实习的题，感觉题目出的一般，不懂是要考啥。

`timescale 1ns/1ns
module huawei5(
    input wire clk  ,
    input wire rst  ,
    input wire [3:0]d ,
    output wire valid_in ,
    output wire dout
    );

//*************code***********//
reg [3:0]data;
reg valid;
reg [1:0]count;
always@(posedge clk or negedge rst)
begin
    if(!rst)begin
        data <= 'd0;
        valid <= 1'b0;
        count <= 'd0;
    end else begin
        if(count == 'd3)begin
            valid <= 1'b1;
            count <= 0;
            data <= d;
        end else begin
            valid <= 1'b0;
            count <= count + 1;
            data <= data << 1;
        end
    end
end
assign dout = data[3];
assign valid_in = valid;
//*************code***********//

endmodule

VL64 时钟切换

核心是没有毛刺，我以为把sel打两拍用来控制就行了，结果发现想简单了。参考（数字 IC 设计）5.4 时钟切换 - 知乎 (zhihu.com)

为了防止两个输出产生毛刺，两个时钟不能进行相反的极性转换，由图中clk0和clk1可以看出clk0的上升沿和clk1的下降沿是重合的。为避免毛刺的产生，需要在两个时钟都为低电平的时候进行时钟切换。

反馈信号q1

`timescale 1ns/1ns

module huawei6(
    input wire clk0  ,
    input wire clk1  ,
    input wire rst  ,
    input wire sel ,
    output wire clk_out
);
//*************code***********//
reg q0, q1;
    
always@(negedge clk0 or negedge rst)
    if(!rst)
        q0 <= 0;
    else
        q0 <= ~sel & ~q1;
    
always@(negedge clk1 or negedge rst)
    if(!rst)
        q1 <= 0;
    else
        q1 <= sel & ~q0;

assign clk_out = (q0 & clk0) | (q1 & clk1);
//*************code***********//
endmodule

 VL65 状态机与时钟分频

也可以用四个状态，更简单一点。

`timescale 1ns/1ns

module huawei7(
    input wire clk  ,
    input wire rst  ,
    output reg clk_out
);

//*************code***********//
reg[1:0]count;
reg state,next_state;
localparam S0=0,S1=1;
always@(posedge clk or negedge rst)
begin
    if(!rst)
        state <= S0;
    else
        state <= next_state;
end
always@(*)
begin
    case(state)
    S0:next_state=S1;
    S1:next_state=(count==2)?S0:S1;
    endcase
end
always@(posedge clk or negedge rst)
begin
    if(!rst)
        clk_out <= 1'b0;
    else begin
        if(state==S0)
            clk_out <= 1'b1;
        else
            clk_out <= 1'b0;
    end
end
always@(posedge clk or negedge rst)
begin
    if(!rst)
        clk_out <= 1'b0;
    else begin
        if(state==S1)
            count <= count + 1;
        else
            count <= 0;
    end
end
//*************code***********//
endmodule

VL66 超前进位加法器

 超前进位加法器原理：

 

 

 注意！进位C必须要拆开划成最后那个表达式，不然Cn+1需要Cn的值的话，仍然会导致组合逻辑越来越长。划成最后的表达式，Ci始终是三级组合逻辑：1、P、G的运算　　2、多输入与门　　3、或门。

`timescale 1ns/1ns

module huawei8//四位超前进位加法器
(
    input wire [3:0]A,
    input wire [3:0]B,
    output wire [4:0]OUT
);

//*************code***********//
wire [3:0] G;
wire [3:0] P;
wire [3:0] F;
wire [4:1] C;
 Add1 u0
 (    .a(A[0]),
    .b(B[0]),
    .C_in(1'b0),
    .f(F[0]),
    .g(G[0]),
    .p(P[0])
 );
  Add1 u1
 (    .a(A[1]),
    .b(B[1]),
    .C_in(C[1]),
    .f(F[1]),
    .g(G[1]),
    .p(P[1])
 );
   Add1 u2
 (    .a(A[2]),
    .b(B[2]),
    .C_in(C[2]),
    .f(F[2]),
    .g(G[2]),
    .p(P[2])
 );
   Add1 u3
 (    .a(A[3]),
    .b(B[3]),
    .C_in(C[3]),
    .f(F[3]),
    .g(G[3]),
    .p(P[3])
 );
 CLA_4 u4
 (
    .P(P),
    .G(G),
    .C_in(C_in),
    .Ci(C),
    .Gm(),
    .Pm()
 );
  assign OUT={C[4],F};

//*************code***********//
endmodule



//////////////下面是两个子模块////////

module Add1
(
        input a,
        input b,
        input C_in,
        output f,
        output g,
        output p
        );
assign f = a^b^C_in;//每一位的输出
assign g = a&b;//生成信号
assign p = a|b;//传播信号
endmodule


//CLA Carry Look Ahead
module CLA_4(
        input [3:0]P,
        input [3:0]G,
        input C_in,
        output [4:1]Ci,
        output Gm,
        output Pm
    );
assign Ci[1]=G[0]|P[0]&C_in;
assign Ci[2]=G[1]|P[1]&G[0]|P[1]&P[0]&C_in;
assign Ci[3]=G[2]|P[2]&G[1]|P[2]&P[1]&G[0]|P[2]&P[1]&P[0]&C_in;
assign Ci[4]=G[3]|P[3]&G[2]|P[3]&P[2]&G[1]|P[3]&P[2]&P[1]&G[0]|P[3]&P[2]&P[1]&P[0]&C_in;    //注意这里一定要拆开写，不然就和行波进位加法器差不多了。
//Gm和Pm是用来拓展更高位加法器的。
assign Gm=G[3]|P[3]&G[2]|P[3]&P[2]&G[1]|P[3]&P[2]&P[1]&G[0];
assign Pm=P[3]&P[2]&P[1]&P[0];
endmodule

VL67 十六进制计数器

这题放这里多少有点离谱。。

`timescale 1ns/1ns

module counter_16(
   input                clk   ,
   input                rst_n ,
 
   output   reg  [3:0]  Q      
);
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        Q <= 4'b0;
    end else begin
        Q <= Q +1'b1;
    end
end
endmodule

VL68 同步FIFO

之前写过，注意按题目给的接口，reg输出wfull和rempty会晚一个周期。实际要么在下一个读/写要空/满的时候通过reg输出，或者组合逻辑输出。

`timescale 1ns/1ns

/**********************************RAM************************************/
module dual_port_RAM #(parameter DEPTH = 16,
                       parameter WIDTH = 8)(
     input wclk
    ,input wenc
    ,input [$clog2(DEPTH)-1:0] waddr  
    ,input [WIDTH-1:0] wdata          
    ,input rclk
    ,input renc
    ,input [$clog2(DEPTH)-1:0] raddr  
    ,output reg [WIDTH-1:0] rdata         
);

reg [WIDTH-1:0] RAM_MEM [0:DEPTH-1];

always @(posedge wclk) begin
    if(wenc)
        RAM_MEM[waddr] <= wdata;
end 

always @(posedge rclk) begin
    if(renc)
        rdata <= RAM_MEM[raddr];
end 

endmodule  

/**********************************SFIFO************************************/
module sfifo#(
    parameter    WIDTH = 8,
    parameter     DEPTH = 16
)(
    input                     clk        , 
    input                     rst_n    ,
    input                     winc    ,
    input                      rinc    ,
    input         [WIDTH-1:0]    wdata    ,

    output reg                wfull    ,
    output reg                rempty    ,
    output wire [WIDTH-1:0]    rdata
);
parameter ADDR_WIDTH = $clog2(DEPTH);
reg [ADDR_WIDTH:0]waddr,raddr;//多一位用于比较空满
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)
        waddr <= 'd0;
    else if(winc&&~wfull)
        waddr <= waddr + 1;
end
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)
        raddr <= 'd0;
    else if(rinc&&~rempty)
        raddr <= raddr + 1;
end
/*空满判断*/
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)begin
        wfull <= 'd0;
        rempty <= 'd0;
    end else begin
        wfull <= (waddr[ADDR_WIDTH]==~raddr[ADDR_WIDTH])&&(waddr[ADDR_WIDTH-1:0]==raddr[ADDR_WIDTH-1:0]);
        rempty <= (raddr==waddr);
    end
end

dual_port_RAM #(.WIDTH(WIDTH),.DEPTH(DEPTH))
U0(
    .wclk(clk),
    .wenc(winc&&~wfull),
    .waddr(waddr[ADDR_WIDTH-1:0]),
    .wdata(wdata),
    .rclk(clk),
    .renc(rinc&&~rempty),
    .raddr(raddr[ADDR_WIDTH-1:0]),
    .rdata(rdata) );     
endmodule

 VL69 脉冲同步器（快到慢）

又是在前面做过的题。【牛客】6 跨时钟域传输 - Magnolia666 - 博客园 (cnblogs.com)

sig_a在时钟域a持续一个周期，在这个周期翻转toggle电平，下一个脉冲再恢复toggle低电平，把toggle信号在时钟域b打两拍，再恢复成单周期脉冲。

 

`timescale 100ps/100ps

module pulse_detect(
    input                 clka    , 
    input                 clkb    ,   
    input                 rst_n        ,
    input                sig_a        ,

    output               sig_b
);
reg toggle;
always@(posedge clka or negedge rst_n)
begin
    if(!rst_n)
        toggle <= 1'b0;
    else
        toggle <= sig_a?~toggle:toggle;
end  
reg [2:0]sig_syn; 
always@(posedge clkb or negedge rst_n)
begin
    if(!rst_n)
        sig_syn <= 'd0;
    else begin
        sig_syn <= {sig_syn[1:0],toggle};
    end
end
assign sig_b = sig_syn[2]^sig_syn[1];
endmodule

VL70 序列检测器（Moore型）

要求使用Moore状态机，也就是输出只和状态有关，注意是不重叠检测。

`timescale 1ns/1ns

module det_moore(
   input                clk   ,
   input                rst_n ,
   input                din   ,
 
   output    reg         Y   
);
reg[2:0]state,next_state;
localparam S0=0,S1=1,S2=2,S3=3,S4=4;
always@(posedge clk or negedge rst_n)
begin
    if(!rst_n)
        state <= S0;
    else 
        state <= next_state;
end
always@(*)
begin
    case(state)
    S0:next_state = din?S1:S0;
    S1:next_state = din?S2:S0;
    S2:next_state = din?S2:S3;
    S3:next_state = din?S4:S0;
    S4:next_state = din?S1:S0;
    endcase
end
always@(posedge clk or negedge rst_n)
begin
    if(!rst_n)
        Y <= 1'b0;
    else begin
        if(state == S4)
            Y <= 1'b1;
        else
            Y <= 1'b0;
    end
end

endmodule

 

 

 VL71 乘法与位运算

要求资源最少，那肯定是移位资源少了。

`timescale 1ns/1ns

module dajiang13(
    input  [7:0]    A,
    output [15:0]   B
    );

//*************code***********//

assign B = (A<<8)-(A<<2)-A;
//*************code***********//

endmodule

VL72 全加器

要求使用半加器实现全加器。半加器没有低位的进位，全加器有。

我写的：

`timescale 1ns/1ns

module add_half(
   input                A   ,
   input                B   ,
 
   output    wire        S   ,
   output   wire        C   
);

assign S = A ^ B;
assign C = A & B;
endmodule

/***************************************************************/
module add_full(
   input                A   ,
   input                B   ,
   input                Ci  , 

   output    wire        S   ,
   output   wire        Co   
);
wire S_half,C_half;
assign S = S_half^Ci;
assign Co = C_half | (A&Ci) |(B&Ci);
add_half u0(
    .A(A),
    .B(B),
    .S(S_half),
    .C(C_half)
);
endmodule

看了一下答案，其实可以用两个半加器实现全加器:

`timescale 1ns/1ns

module add_half(
   input                A   ,
   input                B   ,
 
   output    wire        S   ,
   output   wire        C   
);

assign S = A ^ B;
assign C = A & B;
endmodule

/***************************************************************/
module add_full(
   input                A   ,
   input                B   ,
   input                Ci  , 

   output    wire        S   ,
   output   wire        Co   
);
wire S1,Co1,Co2;
add_half u0(
    .A(A),
    .B(B),
    .S(S1),
    .C(Co1)
);
add_half u1(
    .A(Ci),
    .B(S1),
    .S(S),
    .C(Co2)
);
assign Co = Co1|Co2; 
endmodule

确实这样写才更合理些。

VL73 串行进位加法器

或者叫行波进位加法器，加法器级联即可。

`timescale 1ns/1ns

module add_4(
   input         [3:0]  A   ,
   input         [3:0]  B   ,
   input                Ci  , 

   output    wire [3:0]  S   ,
   output   wire        Co   
);
wire [3:1]C;
add_full u0(
    .A(A[0]),
    .B(B[0]),
    .Ci(Ci),
    .S(S[0]),
    .Co(C[1])
);
add_full u1(
    .A(A[1]),
    .B(B[1]),
    .Ci(C[1]),
    .S(S[1]),
    .Co(C[2])
);
add_full u2(
    .A(A[2]),
    .B(B[2]),
    .Ci(C[2]),
    .S(S[2]),
    .Co(C[3])
);
add_full u3(
    .A(A[3]),
    .B(B[3]),
    .Ci(C[3]),
    .S(S[3]),
    .Co(Co)
);
endmodule

 VL74 异步复位同步释放

对复位信号做两级同步，消除亚稳态，具体可以参考【《硬件架构的艺术》读书笔记】02 时钟和复位（3） - Magnolia666 - 博客园 (cnblogs.com)

`timescale 1ns/1ns

module ali16(
input clk,
input rst_n,
input d,
output reg dout
 );

//*************code***********//
reg [1:0]rst_n_syn;
always@(posedge clk or negedge rst_n)
begin
    if(~rst_n)
        rst_n_syn <= 2'b0;
    else 
        rst_n_syn <= {rst_n_syn[0],1'b1};
end
always@(posedge clk or negedge rst_n_syn[1])
begin
    if(~rst_n_syn[1])
        dout <= 1'b0;
    else
        dout <= d;
end
//*************code***********//
endmodule

VL75 求最小公倍数

查了一下，求最大公约数用的辗转相除法，又想起了高中被数论支配的恐惧。

原理：两个数的最大公约数等于它们中较小的数和两数之差的最大公约数。

求最小公倍数则根据最小公倍数等于两数之积除以他们的最大公约数，可以直接用一个'/'表示。

不过这里标答写的两段式代码感觉有点奇怪，每次状态跳变都会多延一个周期。下面我修改之后的代码。

`timescale 1ns/1ns

module lcm#(
parameter DATA_W = 8)
(
input [DATA_W-1:0] A,
input [DATA_W-1:0] B,
input             vld_in,
input            rst_n,
input             clk,
output    wire    [DATA_W*2-1:0]     lcm_out,
output    wire     [DATA_W-1:0]    mcd_out,
output    reg                    vld_out
);
reg [DATA_W*2-1:0]  mcd,a_buf,b_buf;
reg [DATA_W*2-1:0] mul_buf;
reg [1:0]           cur_st,nxt_st;
parameter IDLE= 2'b00,S0 = 2'b01, S1 = 2'b10;

always @(posedge clk or negedge rst_n)
    if (!rst_n)
        cur_st <= IDLE;
    else
        cur_st <= nxt_st;
always@(*)
begin
    case(cur_st)
    IDLE:nxt_st = vld_in?S0:IDLE;
    S0:nxt_st = (a_buf==b_buf)?S1:S0;
    S1:nxt_st = IDLE;
    default:nxt_st = IDLE;
    endcase
end
always @(posedge clk or negedge rst_n)
begin
    if (!rst_n) begin
        mcd   <= 0;
        a_buf <= 0;
        b_buf <= 0;
        mul_buf <= 0;
        vld_out <= 1'b0;
    end
    else begin
        case (cur_st)
        IDLE:if(vld_in) begin 
                a_buf <= A;
                b_buf <= B;
                mul_buf <= A*B;
                vld_out <= 1'b0;
            end
            else
                vld_out <= 1'b0;
        S0:if(a_buf!=b_buf)begin
                if(a_buf>b_buf)
                    a_buf <= a_buf - b_buf;
                else
                    b_buf <= b_buf - a_buf;
            end
        S1:begin   
            mcd <= b_buf;
            vld_out <= 1'b1;
        end
        endcase
    end
end   
assign mcd_out = mcd;
assign lcm_out = mul_buf/mcd;
endmodule

VL76 任意奇数倍时钟分频

也是之前写过的，用一个上升沿计数器和一个下降沿计数器即可。

为了满足题目波形，强行把下降沿时钟提前一个周期翻转了。

`timescale 1ns/1ns

module clk_divider
    #(parameter dividor = 5)
(     input clk_in,
    input rst_n,
    output clk_out
);
reg clk_pos,clk_neg;
reg [3:0]cnt0,cnt1;
always@(posedge clk_in or negedge rst_n)
begin
    if(~rst_n)begin
        clk_pos <= 1'b0;
        cnt0 <= 'd0;
    end else begin
        cnt0 <= (cnt0 <dividor-1)?cnt0+1:0;
        if(cnt0==dividor-1||cnt0==(dividor-1)/2)
            clk_pos <= ~clk_pos;
    end
end
always@(negedge clk_in or negedge rst_n)
begin
    if(~rst_n)begin
        clk_neg <= 1'b0;
        cnt1 <= 'd0;
    end else begin
        cnt1 <= (cnt1 <dividor-1)?cnt1+1:0;
        if(cnt1==dividor-2||cnt1==(dividor-1)/2-1)
            clk_neg <= ~clk_neg;
    end
end
assign clk_out = clk_pos|clk_neg;
    
endmodule

VL77 编写乘法器求解算法表达式

主要就是要写一个4bit乘法器，用移位实现即可；

感觉自己代码没错，不知道为啥牛客一直出错

 

 

`timescale 1ns/1ns

module calculation(
    input clk,
    input rst_n,
    input [3:0] a,
    input [3:0] b,
    output [8:0] c
    );
wire [8:0]c1,c2;
mult4 u0(
    .clk(clk),
    .rst_n(rst_n),
    .a(12),
    .b(a),
    .c(c1)
);
mult4 u1(
    .clk(clk),
    .rst_n(rst_n),
    .a(5),
    .b(b),
    .c(c2)
);
assign c = c1+c2;
endmodule

module mult4(
    input clk,
    input rst_n,
    input [3:0] a,
    input [3:0] b,
    output reg[8:0] c
);
wire [8:0]c_temp[3:0];
genvar i;
generate
    for(i=0;i<4;i=i+1)
        assign c_temp[i] = a[i]?b<<i:0;
endgenerate

always@(posedge clk or negedge rst_n)
begin
    if(!rst_n)
        c <= 'd0;
    else begin
        c <= c_temp[0] + c_temp[1] + c_temp[2] + c_temp[3];
    end
end
endmodule

总算是刷完了，刷这个还是浪费了很多时间的，题目质量一般，而且还经常出错。接下来要好好准备实习了。

真题牛客spancolorstyleVerilog

有关【牛客】8 企业真题的更多相关文章

  1. 牛客网专项练习30天Pytnon篇第02天 - 2

    1.在Python3中，下列关于数学运算结果正确的是:（B）a=10b=3print(a//b)print(a%b)print(a/b)A.3，3，3.3333...B.3，1，3.3333...C.3.3333...，3.3333...，3D.3.3333...，1，3.3333...解析：    在Python中，//表示地板除（向下取整），%表示取余，/表示除（Python2向下取整返回3）2.如下程序Python2会打印多少个数:（D）k=1000whilek>1:    print(k)k=k/2A.1000 B.10C.11D.9解析：    按照题意每次循环K/2，直到K值小于等

  2. 华为OD机试真题 C++ 实现【带传送阵的矩阵游离】【2023 Q2 | 200分】 - 2

            所有题目均有五种语言实现。C实现目录、C++实现目录、Python实现目录、Java实现目录、JavaScript实现目录题目n行m列的矩阵，每个位置上有一个元素你可以上下左右行走，代价是前后两个位置元素值差的绝对值.另外，你最多可以使用一次传送阵(只能从一个数跳到另外一个相同的数)求从走上角走到右下角最少需要多少时间。输入描述：第一行两个整数n,m，分别代表矩阵的行和列。后面n行，每行m个整数，分别代表矩阵中的元素。输出描述：一个整数，表示最少需要多少时间。

  3. 网页设计期末作业，基于HTML+CSS+JavaScript超酷超炫的汽车类企业网站(6页) - 2

    🎉精彩专栏推荐💭文末获取联系✍️作者简介:一个热爱把逻辑思维转变为代码的技术博主💂作者主页:【主页——🚀获取更多优质源码】🎓web前端期末大作业：【📚毕设项目精品实战案例(1000套)】🧡程序员有趣的告白方式：【💌HTML七夕情人节表白网页制作(110套)】🌎超炫酷的Echarts大屏可视化源码：【🔰Echarts大屏展示大数据平台可视化(150套)】🔖HTML+CSS+JS实例代码：【🗂️5000套HTML+CSS+JS实例代码(炫酷代码)继续更新中…】🎁免费且实用的WEB前端学习指南：【📂web前端零基础到高级学习视频教程120G干货分享】🥇关于作者:💬历任研发工程师，技术组长，教学总监；

  4. 企业大数据发展面临问题之存算分离技术思考 - 2

    文章目录概述背景为何要存算分离优势**应用场景**存算分离产品技术流派华为JuiceFSHashDataXSKY概述背景Hadoop一出生就是奔存算一体设计，当时设计思想就是存储不动而计算(code也即是代码程序)动，负责调度Yarn会把计算任务尽量发到要处理数据所在的实例上，这也是与传统集中式存储最大的不同。为何当时Hadoop设计存算一体的耦合？要知道2006年服务器带宽只有100Mb/s~1Gb/s,但是HDD也即是磁盘吞吐量有50MB/s，这样带宽远远不够传输数据，网络瓶颈尤为明显，无奈之举只好把计算任务发到数据所在的位置。众观历史常言道天下分久必合合久必分，随着云计算技术的发展，数据

  5. ruby - 从企业防火墙后面安装 gem - 2

    我怀疑公司防火墙阻止安装gem。我定义了HTTP_PROXY，我可以通过以下命令查看远程gem:jruby-Sgemlist-r但是当我去安装gem时，我得到一个404:jruby-Sgeminstallrails除了维护内部gem存储库之外，是否有解决此问题的良好解决方法？ 最佳答案 对于ruby​​gems，将它放在我的gem.bat中这对我有用@"%~dp0ruby.exe""%~dpn0"%*--http-proxyhttp://domainname.ccc.com:8080对于jrubygems这有效@"%~dp0jrub

  6. 【华为OD机试真题 java、python、c++】荒地电站建设【2022 Q4 100分】（100%通过+复盘思路） - 2

    代码请进行一定修改后使用，本代码保证100%通过率，本题目提供了java、python、c++三种代码。复盘思路在文章的最后题目描述祖国西北部有一片大片荒地，其中零星的分布着一些湖泊，保护区，矿区;整体上常年光照良好，但是也有一些地区光照不太好。某电力公司希望在这里建设多个光伏电站，生产清洁能源对每平方公里的土地进行了发电评估，其中不能建设的区域发电量为0kw，可以发电的区域根据光照，地形等给出了每平方公里年发电量x千瓦。我们希望能够找到其中集中的矩形区域建设电站，能够获得良好的收益。输入描述第一行输入为调研的地区长，宽，以及准备建设的电站【长宽相等，为正方形】的边长最低要求的发电量之后每行为

  7. Microsoft Bitlocker企业级管理部署方案 - 2

    目录一、前言二、BitLocker部署前的准备工作三、BitLocker的部署方式3.1通过群组策略部署BitLocker

  8. java 版本企业电子招投标采购系统源码之登录页面 - 2

    ​ 信息数智化招采系统服务框架：SpringCloud、SpringBoot2、Mybatis、OAuth2、Security前端架构：VUE、Uniapp、Layui、Bootstrap、H5、CSS3涉及技术：Eureka、Config、Zuul、OAuth2、Security、OSS、Turbine、Zipkin、Feign、Monitor、Stream、ElasticSearch等企业电子化采购系统企业电子化采购系统是明理公司在多家大、中、小型企业采购需求的分析与实际应用的基础上，结合企业采购流程优化再造理念开发的一体化电子招标采购平台，对于招标项目提供交易过程的全流程电子化、规范化管

  9. ruby-on-rails - Ruby 企业版与 Ruby 1.9 - 2

    我打算建立一个简单的CMS网站，用户可以在其中提交和查看包含视频、照片和文本的帖子。我想做的一个决定是在Ruby企业版和Ruby1.9之间做出选择。我关心的事情按顺序排列:性能和可扩展性。与现有gems/插件/开源项目的兼容性。开发和部署速度(我将在VPS上部署)。你有什么建议？ 最佳答案 根据我的经验，REE倾向于在奇怪的地方抛出malloc(2009年1月脚本/控制台中的选项卡完成-https://webrat.lighthouseapp.com/projects/10503/tickets/89-excessive-outpu

  10. ＜Java＞逻辑控制，方法详解，重载，牛客习题，IDEA调试方法... - 2

    目录一.逻辑控制+方法1.java输入2.循环输入3.switch4.循环结构 5.三种输出6.java生成随机数7.java方法二.习题+方法21.返回二进制中1的个数2.获取一个二进制序列中的偶数位和奇数位，分别输出二进制序列3.JAVA比较字符串是否相同4.牛客网ACM书写格式5.方法的重载一.逻辑控制+方法1.java输入注意大小写！下面代码会出现什么问题？？2.循环输入Ctrl+D结束循环输入3.switch面试问题：不能做switch()参数的类型有哪些？longfloatdoubleboolean(其他的都可以)4.循环结构 continue该程序运行的结果是什么？？5.三种输出

随机推荐