精华内容
下载资源
问答
  • C51智能编译器 将HEX 文件 编译成 C 语言 有时候用得到哦 ,备份吧! C51智能编译器 将HEX 文件 编译成 C 语言 有时候用得到哦 ,备份吧!
  • #include <stdio.h> void daoshu(int n) ... char c; if(n==1) { c=getchar(); putchar(c); } else { c=getchar(); daoshu(n-1); putchar(c); } } int main() { daoshu(5); }
    #include <stdio.h>
    void daoshu(int n)
    {
    	char c;
    	if(n==1)
    	{
    		c=getchar();
    		putchar(c);
    	}
    	else
    	{
    		c=getchar();
    		daoshu(n-1);
    		putchar(c);
    	}
    }
    int main()
    {
    	daoshu(5);
    }
    
    
    展开全文
  • <div><p>api.huaban.com 只是没有文档说明而已 估计是他们自用c;没有开放</p><p>该提问来源于开源项目:LiCola1213/huabanDemo</p></div>
  • codevs5339(反着dp)

    2019-02-24 11:12:51
    小奇要开采一些矿物,它驾驶一台带有钻头(初始能力值w)飞船,按既定路线依次飞过喵星系n个星球。 【问题描述】 星球分为2类:资源型和维修型。  1.资源型:含矿物质量a[i],若选择开采,则得到a[i]p...

    【题目背景】

    小奇要开采一些矿物,它驾驶着一台带有钻头(初始能力值w)的飞船,按既定路线依次飞过喵星系的n个星球。

    【问题描述】

    星球分为2类:资源型和维修型。 
    1.资源型:含矿物质量a[i],若选择开采,则得到a[i]p的金钱,之后钻头损耗k%,即p=p(1-0.01k) 
    2.维修型:维护费用b[i],若选择维修,则支付b[i]p的金钱,之后钻头修复c%,即p=p(1+0.01c) 
    (p为钻头当前能力值) 
    注:维修后钻头的能力值可以超过初始值 
    请你帮它决策最大化这个收入

    【输入格式】

    第一行4个整数n,k,c,w。 
    以下n行,每行2个整数type,x。 
    type为1则代表其为资源型星球,x为其矿物质含量a[i]; 
    type为2则代表其为维修型星球,x为其维护费用b[i];

    【输出格式】

    输出一行一个实数(保留两位小数),表示要求的结果。

    【样例输入】

    5 50 50 10 
    1 10 
    1 20 
    2 10 
    2 20 
    1 30

    【样例输出】

    375.00

    【数据范围】

    对于30%的数据 n<=100 
    对于50%的数据 n<=1000,k=100 
    对于100%的数据 n<=100000,0<=k,c,w,a[i],b[i]<=100 
    保证答案不超过10^9

     

    思路:正着dp会有后效性,因为当前的p改变会影响后面的收益。所以反着想,假设当前p为1,f[i]表示i到n获得的最大收益。那么

    double p1=(1-0.01*k);
    double p2=(1+0.01*c);  
    if(type[i]==1) f[i]=max(f[i+1],f[i+1]*p1+a[i]);
    else f[i]=max(f[i+1],f[i+1]*p2-a[i]);

    最后答案就是f[1]*w.

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    double f[100500];
    int a[100500];int type[100500];
    int main()
    {
    	double w,k,c;int n;
    	cin>>n>>k>>c>>w;
    	double p1=(1-0.01*k);
    	double p2=(1+0.01*c);
    	for(int i=1;i<=n;i++) cin>>type[i]>>a[i];
    	for(int i=n;i>=1;i--)
    	{
    		if(type[i]==1) f[i]=max(f[i+1],f[i+1]*p1+a[i]);
    		else f[i]=max(f[i+1],f[i+1]*p2-a[i]);
    	}
    	printf("%.2lf\n",w*f[1]);
    	return 0;
    }
    

     

    展开全文
  • 幻方 我国古籍很早就记载 2 9 4 7 5 3 6 1 8 这是一个三阶幻方。每行每列以及对角线上数字相加都相等。...你任务是搜索所有三阶幻方。并统计出一共有多少种。 旋转或镜像算同一种。 比如: 9 1 2 8...

    反幻方

    我国古籍很早就记载着

    2 9 4
    7 5 3
    6 1 8

    这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。

    下面考虑一个相反的问题。
    可不可以用 1~9 的数字填入九宫格。
    使得:每行每列每个对角线上的数字和都互不相等呢?

    这应该能做到。
    比如:
    9 1 2
    8 4 3
    7 5 6

    你的任务是搜索所有的三阶反幻方。并统计出一共有多少种。
    旋转或镜像算同一种。

    比如:
    9 1 2
    8 4 3
    7 5 6

    7 8 9
    5 4 1
    6 3 2

    2 1 9
    3 4 8
    6 5 7

    等都算作同一种情况。

    请提交三阶反幻方一共多少种。这是一个整数,不要填写任何多余内容。

    Code

    /*
                                    ^....0
                                   ^ .1 ^1^
                                   ..     01
                                  1.^     1.0
                                 ^ 1  ^    ^0.1
                                 1 ^        ^..^
                                 0.           ^ 0^
                                 .0            1 .^
                                 .1             ^0 .........001^
                                 .1               1. .111100....01^
                                 00                 11^        ^1. .1^
                                 1.^                              ^0  0^
                                   .^                                 ^0..1
                                   .1                                   1..^
                                 1 .0                                     ^  ^
                                  00.                                     ^^0.^
                                  ^ 0                                     ^^110.^
                              0   0 ^                                     ^^^10.01
                       ^^     10  1 1                                      ^^^1110.1
                       01     10  1.1                                      ^^^1111110
                       010    01  ^^                                        ^^^1111^1.^           ^^^
                       10  10^ 0^ 1                                            ^^111^^^0.1^       1....^
                        11     0                                               ^^11^^^ 0..  ....1^   ^ ^
                        1.     0^                                               ^11^^^ ^ 1 111^     ^ 0.
                       10   00 11                                               ^^^^^   1 0           1.
                       0^  ^0  ^0                                                ^^^^    0            0.
                       0^  1.0  .^                                               ^^^^    1 1          .0
                       ^.^  ^^  0^                             ^1                ^^^^     0.         ^.1
                       1 ^      11                             1.                ^^^     ^ ^        ..^
                      ^..^      ^1                             ^.^               ^^^       .0       ^.0
                      0..^      ^0                              01               ^^^       ..      0..^
                     1 ..        .1                             ^.^              ^^^       1 ^  ^0001
                    ^  1.        00                              0.             ^^^        ^.0 ^.1
                    . 0^.        ^.^                             ^.^            ^^^         ..0.0
                   1 .^^.         .^                  1001        ^^            ^^^         . 1^
                   . ^ ^.         11                0.    1         ^           ^^          0.
                    0  ^.          0              ^0       1                   ^^^          0.
                  0.^  1.          0^             0       .1                   ^^^          ..
                  .1   1.          00            .        .1                  ^^^           ..
                 1      1.         ^.           0         .^                  ^^            ..
                 0.     1.          .^          .         0                                  .
                 .1     1.          01          .        .                                 ^ 0
                ^.^     00          ^0          1.       ^                                 1 1
                .0      00           .            ^^^^^^                                   .
                .^      00           01                                                    ..
               1.       00           10                                                   1 ^
              ^.1       00           ^.                                            ^^^    .1
              ..        00            .1                                        1..01    ..
             1.1         00           1.                                       ..^      10
            ^ 1^         00           ^.1                                      0 1      1
            .1           00            00                                       ^  1   ^
             .           00            ^.^                                        10^  ^^
           1.1           00             00                                              10^
           ..^           1.             ^.                                               1.
          0 1            ^.              00                 00                            .^
            ^            ^.              ^ 1                00   ^0000^     ^               01
         1 0             ^.               00.0^              ^00000   1.00.1              11
         . 1              0               1^^0.01                      ^^^                01
          .^              ^                1   1^^                                       ^.^
        1 1                                                                              0.
        ..                                                                              1 ^
         1                                                                               1
       ^ ^                                                                             .0
       1                                                                             ^ 1
       ..                                                          1.1            ^0.0
      ^ 0                                                           1..01^^100000..0^
      1 1                                                            ^ 1 ^^1111^ ^^
      0 ^                                                             ^ 1      1000^
      .1                                                               ^.^     .   00
      ..                                                                1.1    0.   0
      1.                                                                  .    1.   .^
      1.                                                                 1    1.   ^0
     ^ .                                                                 ^.1 00    01
     ^.0                                                                  001.     .^
     */
    // VB_king —— 2016_Finals_C_C++_2.cpp created by VB_KoKing on 2019-05-13:08.
    /* Procedural objectives:
    
     Variables required by the program:
    
     Procedural thinking:
     一个反幻方的镜像加旋转总共8次。
     Functions required by the program:
     
     Determination algorithm:
     
     Determining data structure:
     
    
    */
    /* My dear Max said:
    "I like you,
    So the first bunch of sunshine I saw in the morning is you,
    The first gentle breeze that passed through my ear is you,
    The first star I see is also you.
    The world I see is all your shadow."
    
    FIGHTING FOR OUR FUTURE!!!
    */
    #include <algorithm>
    #include <iostream>
    #include <cstring>
    #include <set>
    
    using namespace std;
    
    int num[9],sum[8];
    
    void print(){
        for (int i = 0; i < 9; i++) {
            if (i%3==0) cout<<endl;
            cout<<num[i]<<' ';
        }
    }
    
    bool check(){
        memset(sum,0, sizeof(sum));
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++)
                sum[j]+=num[i+j*3];
            for (int j = 0; j < 3; j++)
                sum[j+3]+=num[3*i+j];
            sum[6]+=num[4*i];
            sum[7]+=num[2*(i+1)];
        }
        set <int> s;
        for (int i = 0; i < 8; i++)
            s.insert(sum[i]);
        if (s.size()==8) return true;
        return false;
    }
    
    int main(){
        int ans=0;
        for (int i = 1; i < 10; i++)
            num[i-1]=i;
        do {
            if (check()){
    //            print();
                ans++;
    //            cout<<endl;
            }
        }while (next_permutation(num,num+9));
        cout<<endl<<ans/8<<endl;
        return 0;
    }
    
    展开全文
  • * Copyright (c) 2013, 烟台大学计算机学院 * All rights reserved. * 作 者: 马广明 * 完成日期:2013 年 12 月 1 日 * 版 本 号:v1.0 * * 输入描述: 无 * 问题描述:输出数组变化后数。 * 程序输出...
    /*
     * Copyright (c) 2013, 烟台大学计算机学院
    * All rights reserved.
    * 作    者: 马广明
    * 完成日期:2013 年 12 月 1 日
    * 版 本 号:v1.0
    *
    * 输入描述: 无
    * 问题描述:输出数组变化后的数。
    * 程序输出:输出数组变化后的数。
    * 问题分析:调用函数,数组。
    * 算法设计:略
    */
    #include <iostream>
    using namespace std;
    int main()
    {
        int a[10];
        for(int i=0;i<10;i++)
        {
            a[i]=i;
        }
        for(int i=9;i>=0;i--)
        cout<<a[i]*10<<'\t';
        return 0;
    }
    

    展开全文
  • 加载到内存中运行文件被称之为可执行文件,可执行文件中二进制对应着C源代码标识符和数据。由一个C源文件到可执行文件可分为两个阶段:编译和链接。对可执行文件进行汇编可以看到C代码中每个语句所对应....
  • 那些直觉数学

    2020-06-02 22:34:26
    半个小时后,三人都回来了,A一共拾了3斤柴火,B一共拾了4斤柴火,C这个家伙不知道是懒还是怎么,一点柴火都没拾到。于是为了弥补自己没拾到柴火,C拿出了7元钱作为补偿给A和B,问,A和B应该怎么分这7元钱? 首先...
  • 作为对比,C语言,截止到C11,关键字是44个显然,C++比C复杂,其关键字比C多一倍有余。但也有观点认为,C++只有在被孤立看待时候,才会觉得复杂性。设计任何一门语言都是有背景。C++面向...
  • c语言编程-小明加减法 主要思想:整数逆向输出 #include<stdio.h> int main() {int a,b,x,y,s,t,c=0,d=0; scanf("%d %d",&x,&... c=c*10+a%10; a=a/10; } while(b!=0) {...
  • 进入到Windows 2000中,在运行中分别输入 attrib c:/ntldr –s –r –h attrib c:/...现在从Windows XP安装光盘I386文件夹中复制这两个同名文件出来到C盘根目录,并覆盖原文件。这时你双启动菜单就已经恢复了
  • 来源 :老九学堂衡量一种语言(广义,不仅限...作为对比,C语言,截止到C11,关键字是44个显然,C++比C复杂,其关键字比C多一倍有余。但也有观点认为,C++只有在被孤立看待时候,才会觉得复杂性。设计任何一门语言...
  • Referer反反盗链

    2016-01-28 19:18:00
    但同时我并没有相见恨晚感觉,相反我很庆幸自己没有太早接触到Python,而是基本按着C→C++→Java→Python这条路学习下来,因为过早使用太便利方法有可能使你对底层细节一无所知。 现在我对HTTP协议了解完全...
  • IDisposable接口是一个常见而又重要接口。作为没有实战经历“理论学者”,自从第一眼看到它,三年来一直没...不像C、C++,一不留神就爆内存(其实我自学过C++,可惜技术菜到没引发过这种问题)。因为在后台有一...
  • 文本中不仅存在不同文体之间数次互涉与交流,无形中消解了西方传统文学中宏大叙事模式,与此同时也建构起一种积极的反话语姿态,其中还大量充斥作为公共知识分子库切和"他人"——C先生对于社会不公现象...
  • android安卓编译

    2016-11-05 18:49:25
    dist(里面存放打包出来APK文件) 二、Apk编译得到Java源代码 下载上述工具中dex2jar和jd-gui ,解压 将要编译APK后缀名改为.rar或则 .zip,并解压,得到其中额classes.dex文件(它就是java文件编译再...
  • java 接口回调实例详解首先官方对接口回调定义是这样,所谓回调:就是A类中调用B类中某个方法C,然后B类中过来调用A类中方法D,D这个方法就叫回调方法。这样听起来有点绕,我们可以这么理解接口回调:比如...
  • 最近由于要写一些界面东西,写了几个月c#(之前一直做c/c++项目),发现c#写界面很方便,效果也不错,在这个过程中也听说c#程序可以很容易被编译到,但一直也没时间去自己编译去试看看,心想就算能编译...
  • 所以我们今天用IDA pro 进行汇编(术语不太准确,应该是把汇编代码,变成我们能看的C代码) 引入IDA pro 开发ARM要用到,附带ARM汇编的IDA 版本不能出错 IDA下载 下载下面的版本 破解教程吾爱大神写的很好了,照安装...
  • 这里就是刚才你编译时输入(如C:\MusicPlayer),输入这行命令后,如果一切正常,你会发现C:\MusicPlayer内多了2个文件夹build和dist,其中分别存储编译过程中逐个编译文件以及最终打包apk文件。...
  • 安卓-APK编译

    2015-09-07 11:29:37
    通过编译,你得到了这个项目源代码,当然,如果这个apk经过了加密混淆处理,一些代码会用a,b,c命名,有关键东西会隐藏起来,你会很难看懂它代码,不过也能从中获取一些蛛丝马迹,当然,一个安卓程序是...
  • SX4U或Script eXtract for Unity会编译Unity 3D游戏引擎制作游戏,并为您提供制作游戏所用源代码。 Unity支持 C# UnityScript(Javascript) o 编译游戏时,Unity将所有脚本转换为C#代码。 这意味...
  • 平时上班很忙,回到家里,就想躺在沙发上不干活了,所以入手了一些懒人清洁神器,比如近期入米家扫拖机器人1C,大大解放双手,我终于不用拖地了,还能每天拥干净到反光地板!颜值高白色外观简洁大气,界面只有两...
  • 之后持续3731以来的c浪寻底之路。支撑位不变3356-3334-3300,估量明日会显缩量,因而抽高度不会很高,压力位3389邻近,强的话会去摸一下3400整数关口。 券商板块拉升了三天,今天放量冲高回落打开调整,现在先...
  • http紧跟着的斜杠,离手输入最近的斜杠,shift中间斜杠。45度角斜杠。正斜杠不需要转义 斜杠:回车与空格之间。程序表示时需要转义成\\。 str.replace(/\\/,/); 1》要想定义字符串a\b\c需要这样写var str = ...
  • 学破解,肯定要会逆向,要不然,堆一大堆的反汇编代码,你只能摇头长叹。明知道里面有你需要东西,却是不知该如何去挖掘,是一件很令人郁闷事。好了,废话不多说了,下面我们开始学习逆向。   不知道有多少...
  • 平时上班很忙,回到家里,就想躺在沙发上不干活了,所以入手了一些懒人清洁神器,比如近期入米家扫拖机器人1C,大大解放双手,我终于不用拖地了,还能每天拥干净到反光地板!颜值高白色外观简洁大气,界面只有两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 738
精华内容 295
关键字:

反着的c