arduino复制代码constexpr inline lsn_t log_translate_sn_to_lsn(lsn_t sn) {
  return (sn / LOG_BLOCK_DATA_SIZE * OS_FILE_LOG_BLOCK_SIZE +
          sn % LOG_BLOCK_DATA_SIZE + LOG_BLOCK_HDR_SIZE);
}

c复制代码const auto real_offset =
      log.current_file_real_offset + (lsn - log.current_file_lsn);

c复制代码/* Reserve space in sequence of data bytes: */
const sn_t start_sn = log.sn.fetch_add(len);

c复制代码/* LWM lsn for unflushed dirty pages in Buffer Pool */
lsn_t lwm_lsn = buf_pool_get_oldest_modification_lwm();

/* Note lsn up to which all dirty pages have already been added into Buffer Pool */
const lsn_t dpa_lsn = log_buffer_dirty_pages_added_up_to_lsn(log);

lsn_t checkpoint_lsn = std::min(lwm_lsn, dpa_lsn);

c复制代码/* LWM lsn for unflushed dirty pages in Buffer Pool */
const lsn_t lsn = buf_pool_get_oldest_modification_approx();
const lsn_t lag = log.recent_closed.capacity();
lsn_t lwm_lsn = lsn - lag;

/* Note lsn up to which all dirty pages have already been added into Buffer Pool */
const lsn_t dpa_lsn = log_buffer_dirty_pages_added_up_to_lsn(log);

lsn_t checkpoint_lsn = std::min(lwm_lsn, dpa_lsn);

java复制代码public class Consumer1 {
    // 普通交换机
    public static final String NORML_EXCHANGE ="normal_exchange";
    // 死信交换机
    public static final String DEAD_EXCHANGE ="dead_exchange";
    // 普通队列的名称
    public static final String NORML_QUEUE ="normal_queue";
    // 死信队列的名称
    public static final String DEAD_QUEUE ="dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2、设置连接属性
        connectionFactory.setHost("192.168.81.102");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("test");
        connectionFactory.setVirtualHost("test");

        //3、从连接工厂中获取连接
        Connection connection = connectionFactory.newConnection("consumer2");
        //4、从连接中获取通道 channel
        Channel channel = connection.createChannel();

        DeliverCallback deliverCallback =(String a, Delivery b)->{
            String message = new String(b.getBody());
            System.out.println("work1:"+message);
            // false 表示只确认 b.DelivertTag 这条消息，true 表示确认 小于等于 b.DelivertTag 的所有消息
            channel.basicAck(b.getEnvelope().getDeliveryTag(),false);
        };
        CancelCallback cancelCallback =(String a)->{
            System.out.println("消息消费被中断");
        };
        // 5、声明死信和普通交换机,类型为  direct
        channel.exchangeDeclare(NORML_EXCHANGE,BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);
        // 队列声明:普通队列需要设置 arguments 参数
        HashMap<String, Object> arguments = new HashMap<>();
        // 过期时间，正常队列设置死信交换机,当消费失败就发送到死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        arguments.put("x-dead-letter-routing-key","dead");// 设置路由key
        // 6、队列声明:普通队列需要设置 arguments 参数，普通队列添加参数
        channel.queueDeclare(NORML_QUEUE,false,false,false,arguments);
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);
        // 7、绑定关系
        channel.queueBind(NORML_QUEUE,NORML_EXCHANGE,"normal");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"dead");

        // 8、消费消息
        /**
         * 消费者消费消息
         * @params1: 消费哪个队列
         * @params2：消费成功之后是否要自动应答 true代表自动应答 ，flase代表手动应答。
         * @params3： 消费者消费成功的回调
         * @params4： 消费者消费失败的回调
         */
        channel.basicConsume(NORML_QUEUE,false,deliverCallback,cancelCallback);
    }
}

java复制代码public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2、设置连接属性
        connectionFactory.setHost("192.168.81.102");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("test");
        connectionFactory.setUsername("test");
        connectionFactory.setPassword("test");

        //3、从连接工厂中获取连接
        Connection connection = connectionFactory.newConnection("producer");
        //4、从连接中获取通道 channel
        Channel channel = connection.createChannel();
        AMQP.BasicProperties properties =new AMQP.BasicProperties().builder().expiration("10000").build(); // 单位毫秒 ，这里是10s
        // 6、发送死信队列，设置 TTL 消息
        for (int i = 1; i <=20; i++) {
            // @params1: 交换机exchange
            // @params2: 队列名称/routing
            // @params3: 属性配置，这里添加 ttl 消息
            // @params4: 发送消息的内容
            channel.basicPublish("normal_exchange","normal",properties,("潇雷挺帅，说第"+i+"遍。").getBytes());
            System.out.println("发送第"+i);
            Thread.sleep(1000);
        }
    }
}

javascript复制代码 arguments.put("x-max-length",5);

vbnet复制代码   DeliverCallback deliverCallback =(String a, Delivery b)->{
            String message = new String(b.getBody());
            System.out.println("work1:"+message);
            if(message.equals("5")){
                System.out.println("该消息被拒绝");
                channel.basicReject(b.getEnvelope().getDeliveryTag(),false);//true 塞回原队列，false 代表不放回原队列。
            }else{
                channel.basicAck(b.getEnvelope().getDeliveryTag(),false);
            }
        };

typescript复制代码@Configuration
public class DeadConfig {
    // 交换机
    public static final String dead_exchange_name = "dead_exchange_springboot";
    // 普通交换机
    public static final String normal_exchange_name = "normal_exchange_springboot";
    // 普通队列
    public static final String normal_queue_name="normal_queue_springboot";
    // 死信队列
    public static final String dead_queue_name = "dead_queue_springboot";

    // 声明交换机
    @Bean("deadExchange")
    public DirectExchange deadExchange(){
        return new DirectExchange(dead_exchange_name);
    }
    // 声明交换机
    @Bean("normalExchange")
    public DirectExchange normalExchange(){
        return new DirectExchange(normal_exchange_name);
    }
    // 声明队列
    @Bean("deadQueue")
    public Queue deadQueue() {
        return QueueBuilder.durable(dead_queue_name).build();
    }
    // 声明队列
    @Bean("normal_queue_name")
    public Queue normalQueue() {
        return QueueBuilder.durable(normal_queue_name)
                .withArgument("x-dead-letter-exchange",dead_exchange_name)
                .withArgument("x-dead-letter-routing-key","dead")
                .build();
    }
    // 绑定队列到交换机
    @Bean
    public Binding queueBingExchange3(){
        return BindingBuilder.bind(normalQueue()).to(normalExchange()).with("normal");
    }
    // 绑定队列到交换机
    @Bean
    public Binding queueBingExchange4(){
        return BindingBuilder.bind(deadQueue()).to(deadExchange()).with("dead");
    }
}

yaml复制代码# 服务端口
server:
  port: 8300
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: test
    password: test
    virtual-host: test
    host: 192.168.81.102
    port: 5672
    template:
      # 消息路由失败通知监听者，而不是将消息丢弃
      mandatory: true
    publisher-confirm-type: correlated
    publisher-returns: true

less复制代码@Slf4j
@RestController
@RequestMapping("/msg")
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/dead/{message}")
    public void sendConfirmMsg(@PathVariable String message){
        rabbitTemplate.convertAndSend(DeadConfig.normal_exchange_name,"normal",message,new CorrelationData("1"));
    }
}

yaml复制代码# 服务端口
server:
  port: 8301
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: test
    password: test
    virtual-host: test
    host: 192.168.81.102
    port: 5672
    listener:
      direct:
        # 表示消费者消费成功消息以后需要手动的进行签收（ack）
        acknowledge-mode: manual
        # 每次处理一个消息
        prefetch: 1
        retry:
          # 开启重试消费
          enabled: true
          # 最大重试次数
          max-attempts: 5

java复制代码    @RabbitListener(queues = DeadConfig.normal_queue_name)
    public void consumerDead(Message message, Channel channel) throws IOException {
        String s = new String(message.getBody());
        System.out.println(s);
        if(s.equals("2")){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);  //basicAck：表示成功确认，使用此回执方法后，消息会被rabbitmq broker 删除。
            log.info("接收的消息为:{}",message);
        }else{
            channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
            log.info("未消费数据");
        }
    }

ini复制代码输入：n = 2
输出：[0,1,1]
解释：
0 --> 0
1 --> 1
2 --> 10

lua复制代码输入：n = 5
输出：[0,1,1,2,1,2]
解释：
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101

java复制代码class Solution {
    public int[] countBits(int n) {
        int[] bits = new int[n + 1];
        int highBit = 0;
        for (int i = 1; i <= n; i++) {
            if ((i & (i - 1)) == 0) {
                highBit = i;
            }
            bits[i] = bits[i - highBit] + 1;
        }
        return bits;
    }
}

cpp复制代码template <typename Tuple>
void Fun(Tuple &tp)
{
    std::tuple_element<0, Tuple>::type first = std::get<0>(mytuple);
    std::tuple_element<1, Tuple>::type second = std::get<1>(mytuple);
}

cpp复制代码tuple t;
int size = std::tuple_size<decltype(t))>::value;

cpp复制代码template <class Tuple, std::size_t N>
struct TuplePrinter
{
    static void print(const Tuple &t)
    {
        TuplePrinter<Tuple, N - 1>::print(t); ///< 递归
        std::cout << ", " << std::get<N - 1>(t); ///< 第 N-1 个元素
    }
};

template <class Tuple>
struct TuplePrinter<Tuple, 1> ///< 递归终止， N == 1
{
    static void print(const Tuple &t)
    {
        std::cout << std::get<0>(t); ///< 第 0 个元素
    }
};

/// @note 可变参模板函数
template <class... Args>
void PrintTuple(const std::tuple<Args...> &t)
{
    std::cout << "(";
    /// @note tuple 类型、参数个数
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}

cpp复制代码namespace detail ///< 命名空间
{
    template <int I, typename T, typename... Args>
    struct find_index ///< 泛化版本
    {
        static int call(std::tuple<Args...> const &t, T &&val)
        {
            /// @note 如果找到该值，则返回对应索引，否则继续递归查找
            return (std::get<I - 1>(t) == val) ? I - 1 : find_index<I - 1, T, Args...>::call(t, std::forward<T>(val));
        }
    };

    template <typename T, typename... Args>
    struct find_index<0, T, Args...> ///< 偏特化，递归终止
    {
        static int call(std::tuple<Args...> const &t, T &&val)
        {
            /// @note 如果找到该值，则返回第 0 个索引，否则返回 -1
            return (std::get<0>(t) == val) ? 0 : -1;
        }
    };
}

/// @note 可变参模板函数
template <typename T, typename... Args>
int find_index(std::tuple<Args...> const &t, T &&val)
{
    return detail::find_index<sizeof...(Args) - 1, T, Args...>::
        call(t, std::forward<T>(val));
}

int main()
{
    std::tuple<int, int, int, int> a(2, 3, 1, 4);
    std::cout << find_index(a, 1) << std::endl; // Prints 2
    std::cout << find_index(a, 2) << std::endl; // Prints 0
    std::cout << find_index(a, 5) << std::endl; // Prints -1 (not found)
}

cpp复制代码#include <tuple>
#include <type_traits>
#include <utility>

template <size_t N>
struct Apply ///< 泛化
{
    template <typename F, typename T, typename... A>
    static inline auto apply(F &&f, T &&t, A &&...a)
        -> decltype(Apply<N - 1>::apply( ///< 推断返回值类型
            std::forward<F>(f), 
            std::forward<T>(t),
            std::get<N - 1>(std::forward<T>(t)),
            std::forward<A>(a)...))
    {
        /// @note 递归
        return Apply<N - 1>::apply(std::forward<F>(f),
                                   std::forward<T>(t),
                                   std::get<N - 1>(std::forward<T>(t)), ///< 取出并传递相应索引的 tuple 元素
                                   std::forward<A>(a)...);
    }
};

template <>
struct Apply<0> ///< 特化，终止递归
{
    template <typename F, typename T, typename... A>
    static inline auto apply(F &&f, T &&, A &&...a)
        -> decltype(std::forward<F>(f)(std::forward<A>(a)...)) ///< 推断返回值类型
    {
        return std::forward<F>(f)(std::forward<A>(a)...);
    }
};

template <typename F, typename T>
inline auto apply(F &&f, T &&t)
    -> decltype(Apply<std::tuple_size< ///< 推断返回值类型
                    typename std::decay<T>::type>::value>::apply(std::forward<F>(f),
                                                                   std::forward<T>(t)))
{
    return Apply<std::tuple_size<
        typename std::decay<T>::type>::value>::apply(std::forward<F>(f),
                                                       std::forward<T>(t));
}

/// @note 测试函数
void one(int i, double d)
{
    std::cout << "function one(" << i << ", " << d << ");\n";
}
int two(int i)
{
    std::cout << "function two(" << i << ");\n";
    return i;
}

/// @note 测试代码
int main()
{
    std::tuple<int, double> tup(23, 4.5);
    apply(one, tup);

    int d = apply(two, std::make_tuple(2));

    return 0;
}

java复制代码public interface CommandExecutor {

	public void runCommand(String cmd) throws Exception;
}

java复制代码import java.io.IOException;

public class CommandExecutorImpl implements CommandExecutor {
	@Override
	public void runCommand(String cmd) throws IOException {
                //执行操作系统命令
		Runtime.getRuntime().exec(cmd);
		System.out.println("'" + cmd + "' command executed.");
	}
}

java复制代码public class CommandExecutorProxy implements CommandExecutor {

	private boolean isAdmin;
    
	private CommandExecutor executor;
	
	public CommandExecutorProxy(String user){
		if("admin".equals(user) || "root".equals(user)) isAdmin=true;
		executor = new CommandExecutorImpl();
	}
	
	@Override
	public void runCommand(String cmd) throws Exception {
		if(isAdmin){
			executor.runCommand(cmd);
		}else{
			if(cmd.trim().startsWith("rm")){
				throw new Exception("rm command is not allowed for non-admin users.");
			}else{
				executor.runCommand(cmd);
			}
		}
	}
}

java复制代码
public class ProxyPatternTest {

	public static void main(String[] args){
		CommandExecutor executor = new CommandExecutorProxy("xiaohei");
		try {
			executor.runCommand("ls -ltr");
			executor.runCommand(" rm -rf /*");
		} catch (Exception e) {
			System.out.println("Exception Message::"+e.getMessage());
		}
	}
}

shell复制代码'ls -ltr' command executed.
Exception Message::rm command is not allowed for non-admin users.

java复制代码private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量发现比需要的容量还小，则以需要的容量为准
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果新容量已经超过最大容量了，则使用最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 以新容量拷贝出来一个新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

java复制代码/**
 * 默认容量
 */
private static final int DEFAULT_CAPACITY = 10;

java复制代码private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，就初始化为默认大小10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    if (minCapacity - elementData.length > 0)
        // 扩容
        grow(minCapacity);
}

java复制代码<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.19</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.19</version>
</dependency>

java复制代码@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
public class CollectionsTest
{
    private static final int TEN_MILLION = 10000000;

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void arrayList()
    {
        List<String> array = new ArrayList<>();
        for (int i = 0; i < TEN_MILLION; i++)
        {
            array.add("123");
        }
    }


    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void arrayListSize()
    {
        List<String> array = new ArrayList<>(TEN_MILLION);
        for (int i = 0; i < TEN_MILLION; i++)
        {
            array.add("123");
        }
    }


    public static void main(String[] args) throws RunnerException
    {
        Options opt = new OptionsBuilder()
                .include(CollectionsTest.class.getSimpleName())
                .forks(1)
                .build();
        new Runner(opt).run();
    }
}

java复制代码# Run complete. Total time: 00:00:23

Benchmark                      Mode  Cnt      Score       Error  Units
CollectionsTest.arrayList      avgt    5  50264.850 ±  6723.299  us/op
CollectionsTest.arrayListSize  avgt    5  38389.625 ± 14797.446  us/op

java复制代码public void add(int index, E element) {
    // 检查是否越界
    rangeCheckForAdd(index);
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1);
    // 将inex及其之后的元素往后挪一位，则index位置处就空出来了
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将元素插入到index的位置
    elementData[index] = element;
    // 大小增1
    size++;
}

yml复制代码apiVersion: v1
kind: Namespace
metadata:
  name: test-resource

yml复制代码apiVersion: v1
kind: LimitRange
metadata:
  name: limit-range-example
spec:
  limits:
    - max:
        cpu: 2
        memory: 2Gi
      min:
        cpu: 200m
        memory: 6Mi
      maxLimitRequestRatio:
        cpu: 3
        memory: 2
      type: Pod
    - default:
        cpu: 300m
        memory: 200Mi
      defaultRequest:
        cpu: 200m
        memory: 100Mi
      max:
        cpu: 2
        memory: 1Gi
      min:
        cpu: 100m
        memory: 3Mi
      maxLimitRequestRatio:
        cpu: 5
        memory: 4
      type: Container

yml复制代码apiVersion: v1
kind: Pod
metadata:
  name: test-default
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80

yml复制代码apiVersion: v1
kind: Pod
metadata:
  name: test-max
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80
      resources:
        limits:
          cpu: 3
          memory: 500Mi

yml复制代码apiVersion: v1
kind: Pod
metadata:
  name: test-ratio
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80
      resources:
        limits:
          cpu: 2
          memory: 500Mi
        requests:
          cpu: 300m
          memory: 50Mi

yml复制代码apiVersion: v1
kind: Namespace
metadata:
  name: quota-ns

yml复制代码apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-quota
spec:
  hard:
    pods: "4"

yml复制代码apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx-rc
spec:
  replicas: 3
  selector:
    name: nginx
  template:
    metadata:
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80

xml复制代码<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.graphql-java-kickstart/graphql-spring-boot-starter -->
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
        <version>12.0.0</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

yaml复制代码spring:
  datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password: "****"
      url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL55Dialect
    properties:
      hibernate:
        format_sql: true
        use_sql_comments: true
server:
  port: 8080
graphql:
  tools:
    schema-location-pattern: graphql/*.graphqls
  graphiql:
    # 开启可交互页面，用于调试
    enabled: true

java复制代码package top.fjy8018.graphsqldemo.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.Objects;

/**
 * 演员表实体映射
 *
 * @author F嘉阳
 * @date 2021/11/5 10:34
 */
@Data
@Entity
@Table(name = "actor", schema = "sakila")
public class ActorEntity {
    @Id
    @Column(name = "actor_id", nullable = false)
    private Integer actorId;

    @Column(name = "first_name", nullable = false, length = 45)
    private String firstName;

    @Column(name = "last_name", nullable = false, length = 45)
    private String lastName;

    @Column(name = "last_update", nullable = false)
    private Timestamp lastUpdate;
}

java复制代码package top.fjy8018.graphsqldemo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.graphsqldemo.entity.ActorEntity;

/**
 * 演员表DAO
 *
 * @author F嘉阳
 * @date 2021/11/5 10:35
 */
public interface ActorEntityRepository extends JpaRepository<ActorEntity, Integer> {
}

typescript复制代码type Query {
    actorList: [ActorEntity]
    findOneActor(id : ID!): ActorEntity
}

type ActorEntity {
    actorId: ID!
    firstName: String!
    lastName: String!
    lastUpdate: String
}

java复制代码package top.fjy8018.graphsqldemo.resolver;

import graphql.kickstart.tools.GraphQLQueryResolver;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import top.fjy8018.graphsqldemo.entity.ActorEntity;
import top.fjy8018.graphsqldemo.repository.ActorEntityRepository;

import java.util.Collection;

/**
 * 演员表GraphQL查询解析器
 *
 * @author F嘉阳
 * @date 2021/11/5 16:27
 */
@Component
@AllArgsConstructor
public class ActorGraphQLQueryResolver implements GraphQLQueryResolver {

    private final ActorEntityRepository actorRepository;

    public Collection<ActorEntity> actorList() {
        return actorRepository.findAll();
    }

    public ActorEntity findOneActor(Integer id) {
        return actorRepository.findById(id).orElse(null);
    }
}

Python复制代码Elias Delta Encoding(X)= Elias Gamma encoding (1+floor(log2(X)) + Binary representation of X without MSB.

Python复制代码def EliasGammaEncode(k):
	if (k == 0):
		return '0'
	N = 1 + floor(log(k, 2))
	Unary = (N-1)*'0'+'1'
	return Unary + Binary_Representation_Without_MSB(k)

Python复制代码def Binary_Representation_Without_MSB(x):
	binary = "{0:b}".format(int(x))
	binary_without_MSB = binary[1:]
	return binary_without_MSB

Python复制代码def EliasDeltaEncode(x):
	Gamma = EliasGammaEncode(1 + floor(log(k, 2)))
	binary_without_MSB = Binary_Representation_Without_MSB(k)
	return Gamma+binary_without_MSB


k = int(input('Enter a number to encode in Elias Delta: '))
print(EliasDeltaEncode(k))

Python复制代码from math import log
from math import floor

def Binary_Representation_Without_MSB(x):
	binary = "{0:b}".format(int(x))
	binary_without_MSB = binary[1:]
	return binary_without_MSB

def EliasGammaEncode(k):
	if (k == 0):
		return '0'
	N = 1 + floor(log(k, 2))
	Unary = (N-1)*'0'+'1'
	return Unary + Binary_Representation_Without_MSB(k)

def EliasDeltaEncode(x):
	Gamma = EliasGammaEncode(1 + floor(log(k, 2)))
	binary_without_MSB = Binary_Representation_Without_MSB(k)
	return Gamma+binary_without_MSB

k = 14
print(EliasDeltaEncode(k))

Python复制代码00100110