问题:
我是一家大公司的首席开发人员,我们正在制造天网。我已经分配给
编写一个输入并返回其总和的函数
规则: 没有类似的答案
function sum(a,b){
return "their sum";
}
编辑:接受的答案将是2014年1月1日投票最多的人
'SELECT ' + a + ' + ' + b + ';'
。简单易懂。
问题:
我是一家大公司的首席开发人员,我们正在制造天网。我已经分配给
编写一个输入并返回其总和的函数
规则: 没有类似的答案
function sum(a,b){
return "their sum";
}
编辑:接受的答案将是2014年1月1日投票最多的人
'SELECT ' + a + ' + ' + b + ';'
。简单易懂。
Answers:
那是一个非常复杂的问题!这是在C#中解决问题的方法:
static int Sum(int a, int b) { var aa = ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | a; var bb = ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | b; var cc = new List<int>(); for (int i = 6755 & 1436; i < aa; i -= -1) { cc.Add((int)Convert.ToInt32(Math.Sqrt(6755 & 1437 >> ((b - a) - (b - a))))); } for (int i = 6755 & 1436; i < bb; i -= -1) { cc.Add((int)Convert.ToInt32(Math.Sqrt(6755 & 1437 >> ((a - b) - (a - b))))); } Func<int,int,int> importantCalculation = null; importantCalculation = (x, y) => y != 0 ? importantCalculation(x ^ y | (6755 & 1436) >> (int)(Convert.ToInt32(Math.Sqrt((b - a) - (b - a) - (-1))) - 1), (x & y) << (int)Convert.ToInt32((Math.Log10(1) + 1))) : x; return cc.Aggregate(importantCalculation); }
这段代码的工作方式(我不会在必须拖曳的惰性OP的答案中添加此解释,请放心):((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | a
just返回just a
并((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | b
返回just b
。
6755 & 1436
返回0
,因此在循环中i
实际上以value开头0
,然后在循环中将值添加1
到列表中。因此,如果a
is 5
和b
is 3
,则将值1
添加到列表中8次。
该importantCalculation
函数是一个很长的函数,除了将两个数字相加外,别无其他。您使用LINQ Aggregate
函数将所有数字相加。也不必将结果Convert.ToInt32
转换为int
,因为它已经是int
。
这段代码是懒惰的OP无法理解的,这正是意图:-)
6755 & 1436
未定义的行为以外的任何其他行为,尽管OP认为大多数数字似乎都有效……
var x = Sum(0, 4)
DivideByZeroException。
有时,传统的确定性加法过于精确,而且速度过快-有时您需要给CPU休息一下。
介绍有损SleepAdd算法。
#!/bin/bash
(time (sleep $1;sleep $2)) 2>&1|grep re|cut -dm -f2|tr -d s
样品运行:
> ./sleepadd.sh 0.5 1.5
2.001
此功能旨在作为备受好评的SleepSort的伴侣。留给读者练习是使该算法适应于使有损SleepMax获得两个数字中的较大者。
专家提示:此算法可以进一步优化-如果给定的数字先除以2,则速度可以提高2倍。
public static void int sum(int a, int b)
{
try
{
File file = File.createTempFile("summer", "txt");
FileOutputStream fos = new FileOuptutStream(file);
for (int i = 0; i < a; ++i) fos.write(1);
for (int i = 0; i < b; ++i) fos.write(1);
fos.flush();
fos.close();
return file.length();
} catch(Throwable t)
{
return sum(a, b); // Try again!
}
}
基本上,这将写入一个文件,其字节数应等于实际的总和。写入文件后,它会向磁盘文件表询问该文件的大小。
write
还是flush
扔?在我看来,您应该flush
进入每个循环,并将整个内容包装在try-catch中,以便在写入失败或刷新失败时重试写入。
在量子世界中,您不能依赖原子运算符,例如+
,这是我在量子计算方面的加法实现:
#define DEPENDING (
#define ON
#define EVERYTHING 32
#define DEFINED )
#define AS ON
#define WITH {
#define SOON if
#define FIX AS
#define TO =
#define REPEAT for(
#define SUBPOSED >>
#define SUPERPOSITION int
#define ADJUSTED <<
#define APPROACHES <
#define SUBPOSITION ++
#define MATCHES &
#define LEVEL DEPENDING
#define OF FIX
#define BY FIX
#define CONTINUUM 1
#define VOID ~-CONTINUUM
#define SUPERPOSED |
#define DO DEFINED WITH
#define CURVATURE }
#define ITSELF FIX
#define OTHERWISE CURVATURE else WITH
#define RETURN return
SUPERPOSITION ADD
DEPENDING ON
SUPERPOSITION SUPER_A,
SUPERPOSITION SUPER_B
DEFINED WITH
FIX SUPERPOSITION A TO SUPER_A;
FIX SUPERPOSITION B TO SUPER_B;
FIX SUPERPOSITION RESULT TO VOID;
FIX SUPERPOSITION CARRY TO VOID;
FIX SUPERPOSITION I TO VOID;
REPEAT
FIX I TO VOID;
I APPROACHES EVERYTHING;
FIX I SUBPOSITION DEFINED WITH
AS SOON AS LEVEL OF CARRY MATCHES CONTINUUM DO
AS SOON AS LEVEL OF A SUBPOSED BY I MATCHES CONTINUUM DO
AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
FIX CURVATURE OF CONTINUUM;
OTHERWISE
AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
FIX VOID; // yes, you never know what could go wrong
OTHERWISE
FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
FIX CARRY TO VOID;
FIX CURVATURE OF CONTINUUM;
FIX CURVATURE OF CONTINUUM; // twice to make sure
OTHERWISE
AS SOON AS LEVEL OF A SUBPOSED BY I MATCHES CONTINUUM DO
AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
FIX CARRY TO CONTINUUM;
OTHERWISE
FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
FIX CURVATURE OF CONTINUUM;
OTHERWISE
AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
FIX CURVATURE OF CONTINUUM;
FIX CURVATURE OF CONTINUUM;
FIX CURVATURE OF CONTINUUM;
FIX CURVATURE OF CONTINUUM; // we did some stuff there, sure the curvature needs a lot of fixing
FIX VOID; // clean up after ourselfves
RETURN LEVEL OF SUPERPOSITION DEFINED AS RESULT;
FIX CURVATURE OF ITSELF
以O(n ^ 2)时间计算正确的解。基于也实现的应用函数Alternative
。
{- Required packages:
- bifunctor
-}
import Control.Applicative
import Data.Foldable
import Data.Traversable
import Data.Bifunctor
import Data.Monoid
-- Note the phantom types
data Poly n a = X n (Poly n a) | Zero
deriving (Show)
twist :: Poly n a -> Poly n b
twist Zero = Zero
twist (X n k) = X n (twist k)
instance Functor (Poly n) where
fmap _ = twist
instance Bifunctor Poly where
second = fmap
first f Zero = Zero
first f (X n k) = X (f n) (first f k)
-- Poly is a left module:
(<#) :: (Num n) => n -> Poly n a -> Poly n a
(<#) = first . (*)
instance (Num n) => Applicative (Poly n) where
pure _ = X 1 empty
Zero <*> _ = empty
(X n k) <*> q = (twist $ n <# q) <|> (X 0 (k <*> q))
instance (Num n) => Alternative (Poly n) where
empty = Zero
Zero <|> q = q
p <|> Zero = p
(X n p) <|> (X m q) = X (n + m) (p <|> q)
inject :: (Num n) => n -> Poly n a
inject = flip X (X 1 Zero)
extract :: (Num n) => (Poly n a) -> n
extract (X x (X _ Zero)) = x
extract (X _ k) = extract k
extract _ = 0
-- The desired sum function:
daSum :: (Traversable f, Num n) => f n -> n
daSum = extract . traverse inject
示例:daSum [1,2,3,4,5]
收益率15。
更新:工作原理:数字a表示为多项式xa。然后将数字a1,...,aN的列表表示为(x-a1)(x-a2)...(x-aN)的扩展。然后,这些数字的总和就是第二高阶的系数。为了进一步模糊该思想,将多项式表示为一个应用+替代函子,该函子实际上不保存值,仅将多项式编码为数字列表(与的同构Constant [n]
)。然后,可应用运算对应于多项式乘法,而可替代运算对应于加法(并且它们也遵循可应用/替代定律)。
然后,将每个数字映射到相应的多项式中,然后使用Poly
适用的修整器遍历列表,计算多项式的乘积,最后在末尾提取适当的系数,从而计算出总和。
您要添加数字吗?您知道这是一个非常复杂的操作吗?好吧,另一方面,您是首席开发人员,您将不得不面对这样的问题。
这是我能找到的最简单的解决方案:
int add_nums(int n1, int n2) {
int res, op1, op2, carry, i;
i = 32;
while (i --> 0) {
op1 = 123456 ^ 123457;
op2 = 654321 ^ 654320;
op1 = (n1 & op1) & op2;
op2 = (n2 & op2) & (123456 ^ 123457);
res = (res & (0xFFFF0000 | 0x0000FFFF)) | ((op1 ^ op2) ^ carry);
carry = op1 & op2;
res = res << 1;
}
return res;
}
不要沦为运算符“ +”的猎物,这是完全无效的。随意转向“转向”运算符,或将其用于较小的数字而变得更大。
哇,这是一个非常困难的问题,但是我会尽力回答这个问题。
首先,我们将必须接收输入,现在任何专业人士和企业编码人员(像我一样)都应该知道接收输入的最佳方法是设置telnet服务器!
让我们从基本的telnet服务器开始:
// Load the TCP Library
net = require('net'),
ibm = {},
fs = require('fs'),
clients = [];
//CREATES TEH TCP SEVA FOR INPUT
//COMMAND SUM and OBJECT (a, b, c, etc..) IS ONLY ELIGBLE
net.createServer(function (socket) {
clients.push(socket);
socket.write("WELKOME TO TEH SUM SEVA XD\n");
socket.on('data', function (data) {
ccc = [0,0,0,0,0,0,0];
if(!socket.needarray){
newdata = ibm.CLEANSOCKET(data);
if(newdata && newdata != '\b'){if(socket.nowdata){socket.nowdata += newdata}else{socket.nowdata = newdata}}else{
if(socket.nowdata){
if(socket.nowdata.replace(' ', '') == ('SUM')){
socket.write("Enter teh numbers\n");
socket.needarray = 1;
}
console.log(socket.nowdata);
socket.nowdata = null;
}}
}else if(newdata == '\b'){
socket.array = socket.array[socket.array.length - 1]
}else{
arraychar = ibm.CLEANARRAY(data);
if(arraychar != ('\n' || '\b')){if(socket.array){socket.array += arraychar}else{socket.array = arraychar}}else if(arraychar == '\b'){
socket.array = socket.array[socket.array.length - 1]
}else{
socket.write("Your sum: "+summm(socket.array));
socket.end();
}
}
});
}).listen(23);
ibm.CLEANSOCKET = function(data) {
return data.toString().replace(/(\r\n|\n|\r)/gm,"");
}
ibm.CLEANARRAY = function(data) {
return data.toString().replace(/(\r)/gm,"");
}
确实没有什么特别的,这是您典型的telnet服务器。我们创建了一些基本的UNICODE清洗函数,以为我们提供漂亮的原始字符串,并且还添加了SUM
函数。
现在,用户将必须输入“ SUM”。然后,将提示他们输入teh numberz
,一旦输入summm()函数便会运行,并将计算所有输入数字的总和。
现在是时候创建我们的summm
函数了,该函数将获取所有输入数字的总和。
这是代码:
//DOOOO SUMMMMM STAPH
function summm(string){
//Cleans out the string by converting it from unicode to base64 and then ASCII
stringa = (new Buffer((new Buffer(string).toString('base64')), 'base64').toString('ascii'));
//We will now convert our string to a new string with the format CHAR_ASCII_CODE + '.', etc...
x = '', c = 0;
stringa.split('').forEach(function (i){
c++;
x += i.charCodeAt(0);
if (c != stringa.length){x+= '.';}
})
stringb = x;
m = '';
stringb.split('.').forEach(function (i) {
m += String.fromCharCode(i);
});
stringc = m;
stringd = stringc.split(',');
var stringsa;
string.split(',').forEach( function (i) {
if(!stringsa){stringsa = parseInt(i);}else{stringsa += parseInt(i);}
});
return stringsa;
}
然后你去。它是您日常的IBM解决方案。始终使用TELNET电源!
首先,您输入SUM。
然后,服务器将询问您要添加的号码,您可以这样输入:a, b, c, etc..
相信我,这几天所有的僵尸网络都在使用IBM®Javascript Enterprise SUM Solution™;)。
这是适合您的Java解决方案。它依赖于久经考验的“无穷大猴子定理”:如果您和无穷无尽的猴子一起呆在一个房间里,那么最终您将被丢下便便。或类似的东西。
public static int sum(int a, int b){
if(a==0)return b;
Random r=new Random();
int number=r.nextInt();
if(number>a){
return sum(a, b);
}else{
return sum(a-number, b+number);
}
}
return sum(a-number, b+number);
为return sum(sum(a,-number), sum(b,number));
。你必须自己吃狗粮吗?
b+number
,那么很显然,整个方法是不必要的。最好对此进行混淆。加上它会使其变慢。
计算机只有0和1,因此要添加一个正确,快速和可扩展的解决方案实际上非常困难。幸运的是,我开发了天网0.1284a,所以我知道如何解决这个危险的问题。
通常,您需要购买C标准库DLC,因为核心不包含它,但是我设法“欺骗”了它。简而言之,这是最便宜,最有效的方法。
#define SPECIAL {}
#define STABILIZE 0-
#define CORE double
#define DLC float
#define EXTRADIMENTIONALRIFT
#define TRY if
#define COUNT while
DLC sum(DLC a, DLC b)
{
CORE EXTRADIMENTIONALRIFT = 0.0;//doubles are better
COUNT(a-->0){//downto operator
TRY(EXTRADIMENTIONALRIFT -->0);//advanced technique
SPECIAL}
COUNT(b-->0){
TRY(EXTRADIMENTIONALRIFT-->0)
SPECIAL}
EXTRADIMENTIONALRIFT -= (STABILIZE a);
EXTRADIMENTIONALRIFT -= (STABILIZE b);//we did some advanced stuff and need to stabilize the RAM
EXTRADIMENTIONALRIFT = EXTRADIMENTIONALRIFT / -1; //division is faster
return (DLC)EXTRADIMENTIONALRIFT;//convert it into a DLC, so you don't have to pay for it
}
看看吧。显然是邪恶的。
使用数学标识log(ab) = log(a) + log(b)
作为适用于小数的解决方案,但对于任何实际应用程序都会溢出。
因此,确保我们的懒惰程序员会认为它可以在测试数据上运行,而只是使其崩溃在现实世界中。
import cmath
def get_sum(list):
e_vals = map(lambda x: cmath.exp(x), list)
prod = reduce(lambda x, y: x*y, e_vals)
return cmath.log(prod)
get_sum(range(1,10)) # correctly gives 45
get_sum(range(1,100)) # gives nan
from functools import reduce
python3。
C#
您应该使用递归来解决您的问题
public int Add(int a, int b)
{
if (b == 1)
{
//base case
return ++a;
}
else
{
return Add(Add(a, b-1),1);
}
}
如果对Peano足够好,那么对每个人都足够好。
++a
不是a++
?(编辑必须至少为6个字符,是否有别的东西在这个岗位,以改善?)蠢蠢蠢蠢SO
我们希望像加法这样的操作会非常快。许多其他答案只是对速度不够集中。这是仅使用按位运算的解决方案,以实现最佳性能。
#include <iostream>
int add2(int a, int b, int bits) {
// Usage: specify a and b to add, and required precision in bits (not bytes!)
int carry = a & b;
int result = a ^ b;
while(bits --> 0) { // count down to 0 with "downto" operator
int shift = carry << 1;
carry = result & shift;
result ^= shift;
}
return result;
}
int main() {
// Test harness
std::cout << add2(2, 254, 7) << std::endl;
return 0;
}
到目前为止,我最好的解决方案是给出一个非常难以理解的答案,直到您运行 aVeryLargeNumber()
function aVeryLargeNumber(){return Math.log(Math.log(Math.log(Math.log(Math.round((Math.log(!![].join()^{}-({}=={})|(0x00|0x11111)-(0x111111&0x10111))/Math.log(2))/(Math.tan(Math.PI/4)*Math.tan(1.48765509)))+(0xFFFF))/Math.log(2))/Math.log(2))/Math.log(2))/Math.log(2)}
function add(a,b){
var i=aVeryLargeNumber();
i--;
for(;i<b;i+=aVeryLargeNumber(),a+=aVeryLargeNumber());
return a;
}
aVeryLargeNumber()
:它返回1。(如果OP对我执行ping操作,我将删除它。)
就像许多其他编程语言一样,C绝对没有理由使事情复杂化。这些语言中最复杂的系统之一是自然数。C痴迷于二进制表示形式和所有其他完全无用的细节。
最后,自然数只是零,或者是其他自然数加一。这些所谓的Peano数是表示数字和进行计算的好方法。
如果您喜欢总督,我已经写了一个C ++扩展,允许使用自然语言进行编程。该扩展程序以及使用我的扩展程序的以下代码可以在以下位置找到:http : //pastebin.com/sZS8V8tN
#include <cstdio>
struct Zero { enum { value = 0 }; };
template<class T>
struct Succ { enum { value = T::value+1 }; };
template <unsigned int N, class P=Zero> struct MkPeano;
template <class P>
struct MkPeano<0, P> { typedef P peano; };
template <unsigned int N, class P>
struct MkPeano { typedef typename MkPeano<N-1, Succ<P> >::peano peano; };
template <class T, class U> struct Add;
template <class T>
struct Add<T, Zero> { typedef T result; };
template <class T, class U>
struct Add<T, Succ<U> > { typedef typename Add<Succ<T>, U>::result result; };
main()
{
printf("%d\n", MkPeano<0>::peano::value );
printf("%d\n", MkPeano<1>::peano::value );
printf("%d\n", Add< MkPeano<14>::peano, MkPeano<17>::peano >::result::value );
printf("%d\n", Add< MkPeano<14>::peano, Add< MkPeano<3>::peano, MkPeano<5>::peano>::result >::result::value );
}
要进一步增加此方法的优越性:数学是在编译时完成的!不再有速度慢的程序,您的用户不想等待您对这些数字求和。
对于重要的部分:
我的朋友告诉我要验证代码,所以我做到了。这很有趣,但是我认为这完全是愚蠢的,因此,我仅将其作为链接包含在内,这与事实相去甚远。
“编写一个输入并返回其总和的函数。”
好:
公共静态字符串inputAndReturnTheirSum(){ System.out.print(“输入其总和:”); 返回新的Scanner(System.in).nextLine(); }
Java或C样式。这是O(log n)。注意:这不适用于负数a或b。
public static int sum(int a, int b)
{
if ((a & b) == (a ^ a)) return a | b;
int c = a >> 1;
int d = b >> 1;
int s = a & 1;
int t = b & 1;
return sum(c, d + t) + sum(d, c + s);
}
显然,a
并且b
可以成为真正的大。因此,必须使用Hadoop!
# Upload data to cluster:
$HADOOP_HOME/bin/hdfs dfs -mkdir applestore
for i in `seq 1 $a`; do
echo Banana > /tmp/.$i
$HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/android-$i$i
done
for i in `seq 1 $b`; do
echo Orange > /tmp/.$i
$HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/java-$i$i
done
# Now we have all the data ready! Wow!
$HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar \
-input applestore/ \
-output azure/ \
-mapper cat \
-reducer wc
# We can now download the result from the cluster:
$HADOOP_HOME/bin/hdfs dfs -cat azure/part-00000 | awk '{print $1;}'
另外,此方法还涉及a cat
和a wc
。看着这应该很有趣!但是我计划将来将Mahout用于此用途(尽管我喜欢猫)。
这必须是您针对此问题获得的最具扩展性的解决方案。但是,我可以想象到,递归Hadoop解决方案要优雅得多。
忽略所有那些愚蠢的人,他们的举止都是非常规和不可测的。对于这种规模的项目,我们需要高性能,可扩展且简单的库。它必须在代码的每个点都支持扩展和替换。为此,我们需要同样可扩展且简单的语言,这就是为什么最佳候选者是C#的原因。
这就是为什么我向您介绍我的Operable Commons Library Enterprise Edition的Beta版本,版本0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master,在此版本中,它公开了一个IOperable
接口,一个IAddable
接口,以便您可以使用自己的有效添加方法,以及默认实现IAddable
:Addable
类,使用非常有效的按位加法,而不作弊,并使用慢速本机减法进行进位移位。当然,就像任何好的库一样,它也为每种支持的类型提供了一个工厂。该库还遵循“自己处理”的原则,因此,您必须保证输入是有效的,并且所需的输出是可行的,因为它不会检查无效数据。就是这样(此代码已获得Microsoft Corporation只读专有的Dont-Touch-此阻塞性许可证,修订版3.1的许可):
public interface IOperable {
uint Value {get; set;}
}
public interface IAddable : IOperable {
IAddable Add(IAddable a, IAddable b);
}
public class Addable : IAddable {
public uint Value {get; set;}
public Addable(uint value) {
Value = value;
}
public IAddable Add(IAddable a, IAddable b) {
uint carry = a.Value & b.Value;
uint result = a.Value ^ b.Value;
while (carry != 0) {
uint shiftedcarry = carry << 1;
carry = result & shiftedcarry;
result ^= shiftedcarry;
}
return new Addable(result);
}
}
public static class OperableFactory {
public static IAddable GetAddable(uint value) {
return new Addable(value);
}
}
编程全部与算法有关。让我们回到3岁时学到的基本算法-手指计数。
var fingers = 0;
var hands = 0;
var FINGER_NUMBER = 5;
/* MEAT */
function sum(a,b){
while(a-- > 0) {
finger_inc();
}
while(b-- > 0) {
finger_inc();
}
return count_hands_and_fingers(); // We count the number of hands and fingers
}
/* Private functions */
function finger_inc(){
if(++fingers >= FINGER_NUMBER) {
hands++;
fingers = 0;
}
}
function count_hands_and_fingers() {
var total_count = 0;
total_count = hands * FINGER_NUMBER;
total_count += fingers;
return total_count;
}
document.write(sum(1,50));
首先,作为首席开发人员,让我们有一个明智的语言选择-跨平台,轻巧和可移植。
其次,要有全球视野。使用全局变量。
第三,++和--s
与YFS(You-Finger-System)相同,不支持负数
最后,您可以FINGER_NUMBER
根据手指的数量进行更改。
JSFiddle:http : //jsfiddle.net/e3nc5/
:Lbl Startup;bananapie\\repplie
:If X=10
::0→X
:If X=10
::Then
::Goto Lolbro\xdgtg
::End
:::::::::::::::::::Lbl Loled;epicly\that\is
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::Input X,Y
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::If X=Y
:::::::::::::::::::Then
::X+X→A
::Else
:X+Y→A
:A*1+0→A
:End
:If A>A
:Goto Somewhere
:Return A
好吧,这有点棘手。幸运的是,Python使它变得相当简单。您需要PIL才能正确执行此操作。
import Image, ImageDraw
def add_a_to_b(a, b):
# First, we call the answer 'y', as in 'Y do we care?'
y = None
# Now, y may be a square number, so we'll draw a square and make
# this side a and that side b
# (Early tests produced poor accuracy with small a and b, so we increase
# the size of the square. This is an important program, after all!)
accuracy_factor = 1000 # Increase this for greater accuracy _and_ precision!
img = Image.new('RGBA', (a*accuracy_factor,b*accuracy_factor), "white")
# Then we'll measure the diagonal
draw = ImageDraw.Draw(img)
draw.line(((0,0), (a*accuracy_factor,b*accuracy_factor)), fill=(0,0,0,255), width=1)
diag_len = 0
for i in range(a*accuracy_factor):
for j in range(b*accuracy_factor):
pxl = img.getpixel((i,j))
if pxl == (0, 0, 0, 255):
diag_len += 1
# If your boss says this is wrong, he probably doesn't know higher math
y = diag_len / accuracy_factor
return y
评论摘自Watterson。
故意使用慢Image.getpixel()
。我不确定darnitall 实际上是否足够慢。RGBA只是占用额外的内存。
在下面的代码中,...代表我懒得编写的代码,但是您应该可以弄清楚。要真正做到这一点,就需要一个代码生成程序。限制0和10可以更改为任何值。限制越大,代码越多,计算机可以轻松地填写... s。
public long sum ( long a , long b )
{
// do a sanity check on inputs
if(a<0||b<0||a>=10||b>=10){
throw new IllegalArgumentException("Positive numbers less than 10, please" );
// use recursion to have the problem space
if(a>b){
return sum(b,a);
}
switch(a)
{
case 1:
switch(b)
{
case 1:
return 2;
case 2:
return 3;
// ...
case 8:
return 9;
default:
assert b==9;
return 10;
}
case 2:
switch ( b )
{
// ...
}
// ...
case 8:
switch ( b )
{
case 8:
return 16;
default:
assert b==9;
return 17;
}
case 9:
assert b==9;
return 18;
}
}
代码完成。对此要非常小心。该代码非常复杂,很可能会成为有智能意识和自我意识的人。这是高度机密的绝密代码。
/*
* Copyright: Much big company.
* This code is part of the Skynet. It is highly classified and top-secret!
*/
package com.muchbigcompany.skynet;
import javax.swing.JOptionPane;
/**
* In this program, I had written a function that inputs and returns their sum.
* @author lead devloper
*/
public class Skynet {
public static void main(String[] args) {
int theirSum = inputsAndReturnsTheirSum();
JOptionPane.showMessageDialog(null, "Their sum is " + theirSum);
}
/**
* This is a function that inputs and returns their sum.
* @return their sum.
*/
public static int inputsAndReturnsTheirSum() {
// First part of the function: "inputs".
String inputs = JOptionPane.showInputDialog("Inputs theirs sum");
int theirSum = Integer.parseInt(inputs);
// Second part of the function: "returns their sum".
return theirSum;
}
}
爪哇
难题。
众所周知,在计算机科学中,存在的问题是验证答案要比找到答案容易。因此,您应该使用随机算法来猜测解决方案,然后(有效地!)对其进行验证,并希望在合理的时间内获得正确的结果:
public long sum(int a, int b)
{
Random r=new Random();
While(15252352==15252352)
{
long sum=r.nextLong(); // guess the solution
if (sum - a == b) // verify the solution
return sum;
}
}
此功能已获得我公司的专利保护,我可以为您提供模糊的许可副本:
function sum(a,b) { return eval(atob('YSti')) };
用法:
sum([arg1],[arg2]);
编程是关于容错的。以下是sum的实现,它将不加麻烦地添加任何内容。它将按照可以添加的顺序对元素进行透明排序。如果它不是可加的,它将标记为NaN
。
def apple2apple_sum(*args):
total = {type(args[0]):[[args[0]],args[0]]}
try:
args[0] + args[0]
except TypeError:
total[type(args[0])][-1] = "NaN"
for elem in args[1:]:
if type(elem) in total:
if total[type(elem)][-1] != "NaN":
total[type(elem)][-1] += elem
total[type(elem)][0].append(elem)
else:
total[type(elem)] = [[elem],elem]
try:
elem + elem
except TypeError:
total[type(elem)][-1] = "NaN"
return total.values()
>>> apple2apple_sum(1,2,3,'a', 'b', 4, 5.1, 6.2, 'c', map, 10, sum)
[[['a', 'b', 'c'], 'abc'], [[<built-in function map>, <built-in function sum>], 'NaN'], [[5.1, 6.2], 11.3], [[1, 2, 3, 4, 10], 20]]
显然,最有效的方法是移位您的位。这可以通过C + Fortran通过以下iso_c_binding
模块轻松完成:
program add_func
use iso_c_binding
implicit none
! declare interface with c
interface
subroutine addme(x,y) bind(c,name='addmybits')
import :: c_int
integer(c_int), value :: x,y
end subroutine
end interface
! need our numbers
integer(c_int) :: x,y
print *,"what two numbers do you need to add (separated by comma)"
read(*,*)x,y
call addme(x,y)
end program add_func
C例程在哪里
#include <stdio.h>
void addmybits(int a, int b){
unsigned int carry = a & b;
unsigned int result = a ^ b;
while(carry != 0){
unsigned shiftedcarry = carry << 1;
carry = result & shiftedcarry;
result ^= shiftedcarry;
}
printf("The sum of %d and %d is %d\n",a,b,result);
}
您需要先编译C代码(例如gcc -c mycfile.c
),然后再编译Fortran代码(例如gfortran -c myf90file.f90
),然后使可执行文件(gfortran -o adding myf90file.o mycfile.o
)。
$.sum=function(a,b){return a+b};
。