Hunterlan38

1. Calasheons
2. Colhash
3. Calashes
4. Calihash

• This multifunctional tool lets you control basic Unix programs built-into macOS. Moreover, using it, you can delete files associated with uninstalled apps, rebuild the. This website provides operating system utilities for macOS. OnyX- Maintenance- Deeper- CalHash- Access Menu- They are free, fully usable, and no registration is necessary.
• CalHash is a utility for macOS that you can use to calculate and compare the checksum for a file.

One of the attributes of a killer application is that it does something cool: it allows you to view or organize information in new and interesting ways, saves you time, or helps you win that auction bid. Yet one of the fundamental aggravations of applications in general is that they don’t always work well together; typically, you cannot send your data to mixed-and-matched applications unless they were explicitly designed to allow this. One of the great strengths of a language such as Perl is its ability to overcome these differences and act as “glue.” As long as you can figure out what the incoming data looks like, and how the outgoing data should look, it is very simple to share data between previously incompatible applications. By simply building a parser between the applications and creating input files for the target application from the former’s data, you extend the usefulness of your tools. In a sense, you can create killer applications out of various mundane tools on your system.

Start date:: Start time: 19:38:51: Joe Sandbox Product: CloudBasic: Overall analysis duration: 0h 5m 31s: Hypervisor based Inspection enabled: false. 本文通过编程的方式浅析基于rsa算法的数字签名技术的内部实现原理。 一、数字签名的原理 发送报文时，发送方由报文文本计算生成报文摘要，然后用自己的私钥对这个摘要进行加密，这个加密后的摘要将作为报文的数字签名和报文一起发送给接收方。接收到报文之后，接收方使用发送方的公钥对.

A somewhat trivial example of this sort of creation is an application that converts iCalendar data into a directed graph, readable by an application such as GraphViz. This example seems so trivial that you might ask yourself why you would wish to do such a thing. The answer is perhaps equally trivial: aside from the challenge factor, the ability to convert data could provide an alternative (or complement) to Gantt charts in project documentation, map relationships between events, etc. Moreover, by providing a simple way to allow disparate applications to interoperate, you can cumulatively build suites of applications, hopefully allowing for unforeseen advantages in the future.

Returning to the example, say you would like to take an iCal calendar (Figure 1) and turn it into an interesting visualization (Figure 2). How would you do this? Such an ability to convert formats is one step in constructing that killer application.

Figure 1. An iCal calendar

Figure 2. An alternate visualization of the calendar data

Reading the iCalendar Format

RFC 2446 defines the iCalendar format, which Apple’s iCal application uses. Each iCalendar file represents an individual calendar and contains at least one block of event data in key:value tuples, starting with a BEGIN:VEVENT tuple and ending with END:VEVENT. Here is an example (with indentation added for readability) of a small iCalendar file containing two events:

There are several possible approaches to parsing the above data in Perl, but perhaps the easiest one is to create a hash of events, modeled after the iCalendar structure. With this approach, a single calendar becomes a hash of hashes with a key:value pair for each event, where the key is the event ID and the value is a hash containing the event data. While it would be just as easy to store the data as an array of hashes, the ability to pull an event by its ID allows greater flexibility and power to manipulate the data. The data for a single event might look like this:

Note that these keys represent only a subset of all possibilities as defined in RFC 2246. Each event may not contain all of the above keys. For example, the first event in my example does not contain DURATION. Further, certain keys (such as SEQUENCE) may be irrelevant for your purposes.

With the data structure designed, what’s the right way to convert iCalendar data into such a structure? Realizing the mantra of Perl, that there is more than one way to do things, perhaps the easiest approach is to match key names, starting a new event block when the parser sees BEGIN:VEVENT and ending it when END:VEVENT appears. Given the large number of possible keys, it may be easiest to use switch-like behavior. Here is an example of how to do this, splitting a key:value on the colon character (as the semicolon precedes any modifiers to the data):

While this example does a good job of showing how to fill the data structure, it does a poor job of leveraging the power of Perl. More extensive use of regular expressions, the use of one of the Parse modules in CPAN, or even a bit of recursive programming could make this code more elegant and perhaps even a bit faster. However, these tactics may also make the code a bit harder to read–which is not always bad, unless you are attempting to explain concepts in an article. For further ideas, Toedor Zlatanov has written an article on using Perl parsing modules as well as a real mind-bender on using a functional programming approach in Perl.

The Dot Specification

Dot (PDF) is a diagramming, or directed, graph language created by Emden Gansner, Eleftherios Koutsofios, and Stephen North at Bell Labs. There are several implementations of Dot, including GraphViz, WebDot, and Grappa. Interestingly, OmniGraffle, a powerful diagramming tool for Macintosh computers, can read simple Dot files.

Creating Dot Files

The basic syntax of Dot is that there are objects or things that you describe by adding data within digraph {} braces. You denote relationships between objects with the -> combination of characters. With this code:

your Dot-driven application (such as GraphViz) will display an image something like Figure 3.

Figure 3. A simple graph

The specification describes additional complexity in terms of sub-objects/structures, alternate shapes (the default is an oval), ranking, and more. One additional item worth noting is that Dot recognizes comments in C- and Java-style formats (// and /*). To help troubleshoot problems (and for good coding practice), I suggest that your parser insert comments into the Dot input file.

Consider how you might create a Dot file from the data parsed earlier. If you pass to the function that handles the writing of the Dot file the reference to the filehandle of your Dot input file (the output of your conversion) along with the reference to your parsed data structure, then you might generate your Dot file along these lines:

This code will produce the following Dot file:

Note that this code uses the record shape, holding individual segments within the larger object. This is slightly more complicated than the default oval that Dot uses.

Where to Go from Here

If you are using Apple’s iCal application, note that the location and naming scheme of iCalendar files changed between the 1.x and 2.x releases. Previously, iCalendar files went in the ~/Library/Calendars/ directory and had names of the form <calendar name>.ics. Thus, a calendar named Work would have a file Work.ics. However, the 2.x release keeps iCalendar information in the ~/Library/Application Support/iCal/Sources/<calendar name>/ directory as sources.ics.

Other applications that implement the iCalendar specification, such as Mozilla’s Calendar extension for Mozilla/Firefox/Thunderbird, may follow a different convention. On a Mac, Firefox stores .ics files in the ~/Library/Application Support/FireFox/Profiles/<profile>/Calendar/ directory, where <profile> is the profile specified in the Firefox profile.ini file. Again, other systems will likely store this information in different locations.

Calasheons

While on the topic of different implementations, bear in mind that, while the key:value specifications are consistent (as long as the application conforms to RFC 2246), the actual .ics file may look slightly different. For example, Firefox lays out that first event from the previous example as:

Here, the key:value tuples (plus any data modifiers such as VALUE=DATE) almost always split up across lines. In this case, it would be best to handle this difference when reading in the .ics file, so that the rest of the script can expect data in a generic format. One way to do this is to copy the array representing the .ics file using a finite-state machine. Another method would be to walk the array and join array elements under certain conditions, such as if the first non-white-space character of the current element begins with a colon or semicolon character, or is simply non-alphabetic.

Hopefully, this article will spur you to create a bridge between two of your favorite applications. Good luck, and please remember to share your contributions with the community.

经典好题。

题意是要我们找出所有的正方形。1000点，只有枚举咯。

如图，如果我们知道了正方形A，B的坐标，便可以推测出C，D两点的坐标。反之，遍历所有点作为A，B点，看C，D点是否存在。存在的话正方形数+1。

假设A点坐标为(x1,y1)，B点坐标为(x2，y2)，则根据三角形全等，易知

C点坐标：( x1+(y2-y1),y1-(x2-x1) )

D点坐标：( x2+(y2-y1),y2-(x2-x1) )

当然，如果我们遍历任意两个点，一个正方形将会被计数四次（四条边）。我们可以只判断斜率>=0的边，这条边在正方形的上方（如图AB边），这样不用重复验证四次了。

过程搞清楚了，下面要解决的就是如何判断C，D点是否存在了。

最简单的办法，直接使用set。我们把出现的点加到set里，判断时用find函数即可。当然，时效比较差。笔者测试是1000MS+。

而后，我们也可以使用二分查找。

当然，最快还是hash了。hash分为两种，开放寻址和链式，来解决冲突。在网上搜了很多解题报告，发现大家很多把链式叫做开放寻址……百度百科上有说明，大家可以看一下：http://baike.baidu.com/view/3140124.htm

Colhash

下面，贴代码：

开放寻址，POJ测试最快是219MS，125MS级别的代码不知是如何实现的

Calashes

链式，即发现冲突就在当前位置加一个槽。POJ上最快319MS。当然，每次新建的槽并没有delete，会造成内存泄露，现实中还是别这么干，或者及时delete吧。

最简单的办法，set……1360MS

三个版本是慢慢优化出来的，哈希函数也有区别。

Calihash