Menu
You asked for it. Python:
# Copyright (c) 1999 - 2010
# Large Company, Inc. ("THE COMPANY")
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COMPANY AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COMPANY OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.
"""This program outputs an enthusiastic "Hello World" in english.
"""
# FIXME: Where are the unit tests for this? QA called and says we
# can't ship this without tests. Also, while writing documentation
# may be boring, you can't expect everyone to understand all this!
# Go ahead and write some docstrings! -- O.D. 2004/7/22
class Expression(object):
def get_value(self, **kwargs):
"""get_value returns the value of this Expression.
Any keyword arguments that the method receives should
be passed on to the get_value methods of possibly called
subexpressions, even if this method does not handle
them.
This method must be reimplemented by the subclass."""
raise NotImplementedError
class Word(Expression):
def __init__(self, value):
self.value = value
def get_value(self, **kwargs):
return self.value
class Sentence(Expression):
def __init__(self, expressions, punctuation = "."):
self.expressions = list(expressions)
self.punctuation = punctuation
def get_value(self, separator = " ", **kwargs):
mainpart = separator.join(
subexpression.get_value(separator = separator, **kwargs)
for subexpression in self.expressions
)
if len(mainpart) > 0:
capitalized = mainpart[0].upper() + mainpart[1:]
else:
capitalized = ""
# FIXME: We're hardcoding "" here. Should we be prepared for
# languages that require a separator before the punctuation mark?
# NB: A workaround for now would be adding an empty word
return "".join((capitalized, self.punctuation))
class Hello(Word):
# FIXME: We should be prepared for languages where "hello" is
# represented by more than one word.
hello_by_language = {"en": "hello", "de": "hallo"}
def __init__(self, language = "en"):
super(Hello, self).__init__(self.hello_by_language[language])
class World(Word):
# FIXME: We should be prepared for languages where "world" is
# represented by more than one word.
world_by_language = {"en": "world", "de": "Welt"}
def __init__(self, language = "en"):
super(World, self).__init__(self.world_by_language[language])
class HelloWorld(Sentence):
def __init__(self, punctuation, language):
hello = Hello(language)
world = World(language)
super(HelloWorld, self).__init__([hello, world], punctuation)
class EnthusiasticHelloWorld(HelloWorld):
def __init__(self, language):
# FIXME: We should be prepared for languages where enthusiasm
# is not expressed with an exclamation mark.
super(EnthusiasticHelloWorld, self).__init__("!", language)
def main():
english_enthusiastic_hello_world = EnthusiasticHelloWorld("en")
print english_enthusiastic_hello_world.get_value()
if __name__ == "__main__":
main()
Can someone help me speed up my program. Python is so slow even to run just one line!
python -c '[__import__("os").write(1,__import__("urllib2").urlopen("http://stackoverflow.com/questions/2052137").read()[x+__import__("urllib2").urlopen("http://stackoverflow.com/questions/2052137").read().find("Hello World")]) for x,_ in enumerate("Hello World")]'
I think it's pretty hard to beat the GNU "Hello World" (view the tar to enjoy it in its full glory, including tests, makefile(s!), man, etc.):
/* hello.c -- print a greeting message and exit.
Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2005,
2006, 2007, 2008 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include "system.h"
/* String containing name the program is called with. */
const char *program_name;
static const struct option longopts[] =
{
{ "greeting", required_argument, NULL, 'g' },
{ "help", no_argument, NULL, 'h' },
{ "next-generation", no_argument, NULL, 'n' },
{ "traditional", no_argument, NULL, 't' },
{ "version", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 }
};
/* Different types of greetings; only one per invocation. */
typedef enum {
greet_gnu, greet_new, greet_traditional, greet_user
} greeting_type;
/* Forward declarations. */
static void print_help (void);
static void print_version (void);
int
main (int argc, char *argv[])
{
int optc;
int lose = 0;
const char *greeting_msg = NULL;
greeting_type g = greet_gnu;
program_name = argv[0];
/* Set locale via LC_ALL. */
setlocale (LC_ALL, "");
#if ENABLE_NLS
/* Set the text message domain. */
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
#endif
/* Even exiting has subtleties. On exit, if any writes failed, change
the exit status. The /dev/full device on GNU/Linux can be used for
testing; for instance, hello >/dev/full should exit unsuccessfully.
This is implemented in the Gnulib module "closeout". */
atexit (close_stdout);
while ((optc = getopt_long (argc, argv, "g:hntv", longopts, NULL)) != -1)
switch (optc)
{
/* --help and --version exit immediately, per GNU coding standards. */
case 'v':
print_version ();
exit (EXIT_SUCCESS);
break;
case 'g':
greeting_msg = optarg;
g = greet_user;
break;
case 'h':
print_help ();
exit (EXIT_SUCCESS);
break;
case 'n':
g = greet_new;
break;
case 't':
g = greet_traditional;
break;
default:
lose = 1;
break;
}
if (lose || optind < argc)
{
/* Print error message and exit. */
if (optind < argc)
fprintf (stderr, _("%s: extra operand: %s\n"),
program_name, argv[optind]);
fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
exit (EXIT_FAILURE);
}
/* Print greeting message and exit. */
if (g == greet_traditional)
printf (_("hello, world\n"));
else if (g == greet_new)
/* TRANSLATORS: Use box drawing characters or other fancy stuff
if your encoding (e.g., UTF-8) allows it. If done so add the
following note, please:
[Note: For best viewing results use a UTF-8 locale, please.]
*/
printf (_("\
+---------------+\n\
| Hello, world! |\n\
+---------------+\n\
"));
else if (g == greet_user)
puts (greeting_msg);
else if (g == greet_gnu)
puts (_("Hello, world!"));
else {
/* No need for this impossible message to be translated. */
fprintf (stderr, "Impossible hello value %d\n", g);
exit (EXIT_FAILURE);
}
exit (EXIT_SUCCESS);
}
/* Print help info. This long message is split into
several pieces to help translators be able to align different
blocks and identify the various pieces. */
static void
print_help (void)
{
/* TRANSLATORS: --help output 1 (synopsis)
no-wrap */
printf (_("\
Usage: %s [OPTION]...\n"), program_name);
/* TRANSLATORS: --help output 2 (brief description)
no-wrap */
fputs (_("\
Print a friendly, customizable greeting.\n"), stdout);
puts ("");
/* TRANSLATORS: --help output 3: options 1/2
no-wrap */
fputs (_("\
-h, --help display this help and exit\n\
-v, --version display version information and exit\n"), stdout);
puts ("");
/* TRANSLATORS: --help output 4: options 2/2
no-wrap */
fputs (_("\
-t, --traditional use traditional greeting format\n\
-n, --next-generation use next-generation greeting format\n\
-g, --greeting=TEXT use TEXT as the greeting message\n"), stdout);
printf ("\n");
/* TRANSLATORS: --help output 5 (end)
TRANSLATORS: the placeholder indicates the bug-reporting address
for this application. Please add _another line_ with the
address for translation bugs.
no-wrap */
printf (_("\
Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
}
/* Print version and copyright information. */
static void
print_version (void)
{
printf ("hello (GNU %s) %s\n", PACKAGE, VERSION);
/* xgettext: no-wrap */
puts ("");
/* It is important to separate the year from the rest of the message,
as done here, to avoid having to retranslate the message when a new
year comes around. */
printf (_("\
Copyright (C) %s Free Software Foundation, Inc.\n\
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
This is free software: you are free to change and redistribute it.\n\
There is NO WARRANTY, to the extent permitted by law.\n"),
"2008");
}
I'm paranoid. I don't trust the compiler. I have to tell it how to do its job (C#):
using System;
using System.Reflection;
.
static void Main()
{
Type ConsoleType = Type.GetType("System.Console");
Type StringType = Type.GetType("System.String");
Type CharArrayType = Type.GetType("System.Char[]");
MethodInfo WriteLineMethod = ConsoleType.GetMethod("WriteLine", new Type[] { StringType });
MethodInfo ReadLineMethod = ConsoleType.GetMethod("ReadLine");
ConstructorInfo StringConstructorInfo = StringType.GetConstructor(new Type[] { CharArrayType });
object HelloWorldStringObject = StringConstructorInfo.Invoke(new object[] {
new char[] { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd' } });
WriteLineMethod.Invoke(null, new object[] { HelloWorldStringObject });
ReadLineMethod.Invoke(null, new object[] { });
}
It's always a matter of finding the good language for the job. How about brainfuck ?
+++++ +++++
[
> +++++ ++
> +++++ +++++
> +++
> +
<<<< -
]
> ++ .
> + .
+++++ ++ .
.
+++ .
>++ .
<< +++++ +++++ +++++ .
> .
+++ .
----- - .
----- --- .
> + .
> .
C++ template abuse.
#include <iostream>
#include <string>
#include <new>
namespace HelloLand
{
template<int Ordinal=1> class Hello
{
private:
Hello<Ordinal<<1> * next;
//We don't want no damned copies
Hello(const Hello<Ordinal> & Other) {}
Hello<Ordinal>& operator=(const Hello<Ordinal>& Other) {}
public:
Hello()
{
next=new Hello<Ordinal<<1>;
}
~Hello()
{
delete next;
}
std::string GetString()
{
return next->GetString() + GetChar();
}
char GetChar();
};
template <> char Hello<1<<0>::GetChar() { return '!'; }
template <> char Hello<1<<1>::GetChar() { return 'd'; }
template <> char Hello<1<<2>::GetChar() { return 'l'; }
template <> char Hello<1<<3>::GetChar() { return 'r'; }
template <> char Hello<1<<4>::GetChar() { return 'o'; }
template <> char Hello<1<<5>::GetChar() { return 'w'; }
template <> char Hello<1<<6>::GetChar() { return ' '; }
template <> char Hello<1<<7>::GetChar() { return 'o'; }
template <> char Hello<1<<8>::GetChar() { return 'l'; }
template <> char Hello<1<<9>::GetChar() { return 'l'; }
template <> char Hello<1<<10>::GetChar() { return 'e'; }
template <> char Hello<1<<11>::GetChar() { return 'H'; }
template<> class Hello<1<<12>
{
public:
std::string GetString()
{
return "";
}
};
}
int main()
{
HelloLand::Hello<> hello;
std::cout<<hello.GetString()<<std::endl;
return 0;
}
What I like most of this thing:
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With