Masalah:

Saya adalah pengembang utama untuk perusahaan besar, kami membuat Skynet. Saya telah ditugaskan

Tulis fungsi yang menginput dan mengembalikan jumlahnya

ATURAN: Tidak ada jawaban seperti

function sum(a,b){
    return "their sum";
}

EDIT: Jawaban yang diterima akan menjadi yang paling banyak mendapat dukungan pada 1 Januari 2014

^{Catatan: Ini adalah pertanyaan troll kode . Tolong jangan menganggap pertanyaan dan / atau jawaban dengan serius. Informasi lebih lanjut di sini .}

Itu masalah yang sangat kompleks! Inilah cara Anda mengatasinya dalam 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);
}

Cara kode ini bekerja (saya tidak akan menambahkan penjelasan ini dalam jawaban saya ke OP malas yang harus dikendalikan, jangan khawatir): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | amengembalikan adil adan ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bmengembalikan adil b.

6755 & 1436kembali 0, jadi dalam loop, isebenarnya dimulai dengan nilai 0, dan di dalam loop, Anda menambahkan nilai 1ke daftar. Jadi, jika aini 5dan badalah 3, nilai 1ditambahkan 8 kali ke dalam daftar.

The importantCalculationfungsi fungsi yang sangat panjang yang tidak apa-apa lain daripada menambahkan dua nomor. Anda menggunakan Aggregatefungsi LINQ untuk menambahkan semua angka. Ini juga tidak perlu untuk melemparkan hasil Convert.ToInt32ke int, karena sudah menjadi int.

Kode ini adalah sesuatu yang tidak dimengerti OP yang malas, yang persis seperti kehebatan :-)

Bash - 72 byte

Kadang-kadang teknik penambahan deterministik tradisional terlalu tepat, dan tidak perlu cepat - ada kalanya Anda ingin memberikan CPU sedikit istirahat.

Memperkenalkan algoritma SleepAdd lossy .

#!/bin/bash
(time (sleep $1;sleep $2)) 2>&1|grep re|cut -dm -f2|tr -d s

Contoh dijalankan:

> ./sleepadd.sh 0.5 1.5
2.001

Fungsi ini dimaksudkan sebagai pendamping SleepSort yang dihormati . Ini dibiarkan sebagai latihan bagi pembaca untuk mengadaptasi algoritma ini untuk membuat SleepMax yang lossy untuk mendapatkan yang lebih besar dari dua angka.

Pro Tip: Algoritma ini dapat lebih dioptimalkan - peningkatan kecepatan 2x dimungkinkan, jika angka yang diberikan dibagi 2 lebih dulu.

Jawa

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!
    }
}

Ini pada dasarnya menulis file dengan jumlah byte yang harus sama dengan jumlah aktual. Ketika file ditulis, ia meminta tabel file disk untuk ukuran file itu.

C

Di dunia kuantum Anda tidak dapat bergantung pada operator atom seperti +, inilah penerapan tambahan saya dalam hal komputasi kuantum:

#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

Haskell

Menghitung solusi yang benar dalam waktu O (n ^ 2) . Berdasarkan fungsi aplikatif yang juga menerapkan 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

Contoh: daSum [1,2,3,4,5]hasil 15.

Pembaruan: Cara kerjanya: Angka a direpresentasikan sebagai xin polinomial . Daftar angka a1, ..., aN kemudian direpresentasikan sebagai perluasan dari (x-a1) (x-a2) ... (x-aN) . Jumlah dari angka-angka tersebut kemudian koefisien dari tingkat tertinggi kedua. Untuk lebih jauh mengaburkan ide, polinomial direpresentasikan sebagai fungsi alternatif aplikatif + yang tidak benar-benar memiliki nilai, hanya mengkodekan polinomial sebagai daftar angka (isomorfik ke Constant [n]). The aplikatif operasi kemudian sesuai dengan perkalian polinomial dan alternatif operasi penambahan (dan mereka mematuhi untuk aplikatif / alternatif hukum juga).

Jumlah angka kemudian dihitung sebagai pemetaan setiap angka ke dalam polinomial yang sesuai dan kemudian melintasi daftar menggunakan Polyfrunctor aplikatif, yang menghitung produk dari polinomial, dan akhirnya mengekstraksi koefisien yang tepat pada akhirnya.

Anda ingin menambahkan angka ?!? Anda sadar bahwa ini adalah tindakan yang sangat rumit? OK, di sisi lain, Anda adalah pengembang utama, Anda harus menghadapi masalah seperti ini.

Ini adalah solusi paling sederhana yang bisa saya temukan:

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;
}

Jangan menjadi mangsa operator "+", ini sama sekali tidak efisien. Jangan ragu untuk memutar operator "menuju" atau menggunakannya untuk jumlah yang lebih kecil semakin besar.

NODE.JS - EDM SUMMMMYYMYYMY / IBM® Javascript Enterprise SUM Solution ™

Wow, ini pertanyaan yang sangat sulit, tetapi saya akan mencoba yang terbaik untuk menjawab ini.

LANGKAH SATU - Server TELNET

Pertama-tama kita harus menerima input, sekarang setiap programmer pro dan perusahaan (seperti saya) harus tahu cara terbaik untuk menerima input adalah dengan mengatur server telnet !!!

Mari kita mulai dengan server telnet dasar:

// 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,"");
}

Sebenarnya tidak ada sesuatu yang istimewa untuk itu, ini adalah Anda server telnet yang khas. Kami telah membuat beberapa fungsi pembersihan dasar UNICODE untuk memberikan kami string mentah yang bagus dan kami juga menambahkanSUM fungsi .

Sekarang pengguna harus memasukkan 'SUM'. Ini kemudian akan meminta mereka untuk masuk teh numberz, setelah memasukkan fungsi summm () dijalankan dan akan menghitung jumlah semua angka yang dimasukkan.

LANGKAH DUA - summm

Sekarang saatnya untuk membuat summmfungsi kita yang akan mendapatkan jumlah semua angka yang dimasukkan.
Ini kodenya:

//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;
}

Dan begitulah. Ini adalah Solusi IBM harian Anda. TELNET POWER ALL THE WAY!
Pertama Anda masuk SUM.
Server kemudian akan meminta nomor yang ingin Anda tambahkan, dan Anda dapat memasukkannya:a, b, c, etc..

Percayalah pada yang ini, semua botnet menggunakan IBM® Javascript Enterprise SUM Solution ™ hari ini;).

Dan ini adalah bukti bahwa semuanya berfungsi:
(DEKAT)

Inilah solusi di Jawa untuk Anda. Itu bergantung pada "teorema monyet tak terhingga" yang telah teruji waktu: jika Anda berada di sebuah ruangan dengan monyet tak terbatas, Anda akan berakhir dalam kotoran terlempar. Atau semacam itu.

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);
   }
}

C - pembunuhan berlebihan adalah yang terbaik

Komputer hanya memiliki 0s dan 1s, jadi sebenarnya sangat sulit untuk menerapkan solusi yang tepat, cepat, dan dapat diskalakan untuk cara menambahkan. Beruntung bagi Anda, saya mengembangkan skynet 0.1284a, jadi saya tahu bagaimana menyelesaikan masalah berbahaya ini.
Biasanya, Anda harus membeli DLC library standar C, karena intinya tidak berisi itu, tapi saya berhasil "menipu" jalan keluar saya. Singkatnya, ini adalah metode termurah dan paling efektif.

#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
}

Lihat saja itu. Jelas itu jahat.

Python

Menggunakan identitas matematika log(ab) = log(a) + log(b)untuk solusi yang berfungsi untuk jumlah kecil, tetapi meluap untuk aplikasi praktis apa pun.

Dengan demikian memastikan bahwa pemrogram malas kami akan berpikir itu berfungsi pada data uji, hanya untuk membuatnya crash di dunia nyata.

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

C #

Anda harus menggunakan rekursi untuk menyelesaikan masalah Anda

    public int Add(int a, int b)
    {
    if (b == 1)
    {
    //base case
    return ++a;
    }
    else 
    {
    return Add(Add(a, b-1),1);
    }

}

Jika itu cukup baik untuk Peano, itu cukup baik untuk semua orang.

C ++

Kami berharap operasi seperti penambahan menjadi sangat cepat. Banyak jawaban lain tidak cukup berkonsentrasi pada kecepatan. Inilah solusi yang hanya menggunakan operasi bitwise , untuk kinerja maksimum.

#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;
}

Solusi terbaik saya sejauh ini, memberikan jawaban yang cukup sulit dipahami sampai Anda menjalankan 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;

}

C ++ - Angka Peano dengan metaprogramming template (dengan doge opsional)

C, seperti banyak bahasa pemrograman lain menyulitkan hal-hal dengan mutlak tanpa alasan. Salah satu sistem yang paling kompleks dalam bahasa-bahasa ini adalah bilangan asli. C terobsesi dengan representasi biner dan semua detail yang sama sekali tidak berguna.

Pada akhirnya, bilangan alami hanya nol, atau bilangan alami lainnya bertambah satu. Ini disebut nomor Peano adalah cara yang bagus untuk mewakili angka dan melakukan perhitungan.

Jika Anda suka Doge saya telah menulis ekstensi C ++ untuk memungkinkan penggunaan bahasa alami untuk pemrograman. Ekstensi dan kode berikut ini menggunakan ekstensi saya dapat ditemukan di: 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 );
}

Untuk lebih lanjut menambahkan keunggulan metode ini: Matematika dilakukan pada waktu kompilasi! Tidak ada lagi program yang lambat, pengguna Anda tidak ingin menunggu Anda untuk menjumlahkan angka-angka itu.

Dan untuk bagian yang serius:

• Saya tidak berpikir saya harus mengatakan ini, tetapi ini benar-benar konyol.
• Hanya berfungsi untuk mengkompilasi konstanta waktu.
• Tidak bekerja dengan angka negatif.
• Jawabannya diberikan oleh seseorang yang sebenarnya tidak dapat membuat template metaprogram sendiri, jadi saya bahkan tidak akan tahu apakah ia memiliki kekurangan lain.

Teman-teman saya menyuruh saya untuk membuat kode, jadi saya melakukannya. Ini menyenangkan, tetapi saya pikir ini terlalu jauh dari kenyataan bahwa ini benar-benar bodoh, jadi saya hanya memasukkannya sebagai tautan.

Saya berhenti mempercayai komputer ketika saya belajar tentang kesalahan floating point.

JavaScript ini bergantung pada pemeriksaan kesalahan manusia yang tepat:

while(prompt("Is this the answer: " + Math.round(Math.random()* 1000000)) !== "yes") {}

"Tulis fungsi yang menginput dan mengembalikan jumlah mereka."

Baik:

public input String statisAndReturnTheirSum () {
    System.out.print ("Masukkan jumlah mereka:");
    mengembalikan Scanner baru (System.in) .nextLine ();
}

Java atau C-style. Ini adalah O (log n). Catatan: Ini tidak berfungsi untuk a atau b negatif.

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);
}

Demo Ideone di sini.

Bash dengan Hadoop Streaming

Jelas, adan bbisa menjadi sangat besar. Karena itu, kita harus menggunakan 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;}'

Sebagai bonus tambahan, pendekatan ini melibatkan a catdan awc . Ini seharusnya menyenangkan untuk ditonton! Tapi saya berencana menggunakan Mahout untuk ini di masa depan (walaupun saya suka kucing).

Ini harus menjadi solusi terukur yang Anda dapatkan untuk pertanyaan ini. Namun, saya dapat membayangkan bahwa solusi Hadoop rekursif jauh lebih elegan.

Abaikan semua orang bodoh itu dengan perilaku non-generik dan tidak bisa ditebak. Kami membutuhkan perpustakaan yang berkinerja tinggi, dapat diperluas, dan sederhana untuk proyek dengan skala seperti itu. Itu harus mendukung ekstensi dan substitusi di setiap titik kode. Untuk itu, kita memerlukan bahasa yang sama-sama dapat diperluas dan sederhana, itu sebabnya kandidat terbaik adalah C # .

Inilah sebabnya saya menyajikan versi beta dari Operable Commons Library Enterprise Edition saya, versi 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , yang pada versi ini memperlihatkanIOperable antarmuka, IAddableantarmuka sehingga Anda dapat menggunakan metode penambahan efisien Anda sendiri, dan implementasi standar IAddable:Addablekelas, yang menggunakan penambahan bitwise yang sangat efisien, tanpa curang dan menggunakan pengurangan asli yang lambat untuk carry shifting. Tentu saja, seperti perpustakaan yang baik, ia dilengkapi dengan pabrik untuk setiap jenis yang didukungnya. Perpustakaan juga mengikuti prinsip-prinsip "tangani sendiri", jadi Anda harus menjamin bahwa input tersebut valid dan bahwa output yang diinginkan layak, karena tidak akan memeriksa data yang tidak valid. Ini dia (Kode ini dilisensikan di bawah Microsoft Corporation Read-Only Proprietary Dont-Touch-Lisensi Obstruktif Ini, Revisi 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);
    }
}

JavaScript

Pemrograman adalah semua tentang algoritma. Mari kita kembali ke algoritma dasar apa yang kita pelajari pada usia 3 - menghitung jari.

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));

• Pertama, sebagai pengembang utama, mari kita memiliki pilihan bahasa yang bijak - lintas platform, ringan dan portabel.

• Kedua, memiliki visi global. Gunakan Global var.

• Ketiga, ++ s dan --s

• Sama seperti YFS (You-Finger-System), ini tidak mendukung angka negatif

• Akhirnya, Anda dapat mengubah FINGER_NUMBERsesuai dengan jumlah jari yang Anda miliki.

JSFiddle: http://jsfiddle.net/e3nc5/

TI-Basic 83/84

: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

Nah, yang ini agak sulit. Untungnya, Python membuatnya cukup mudah. Anda perlu PIL untuk melakukan ini dengan benar.

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

Komentar diadaptasi dari Watterson .

Sengaja menggunakan lambat Image.getpixel(). Saya tidak yakin itu sebenarnya cukup lambat , meskipun, sangat. RGBA hanya untuk mengambil memori ekstra.

JAWA

Dalam kode di bawah ini, ... berarti kode yang saya terlalu malas untuk menulis tetapi Anda harus bisa mengetahuinya. Untuk benar-benar melakukan ini dengan gaya, akan memerlukan program pembuatan kode. Batas 0 dan 10 dapat diubah menjadi apa pun. Semakin besar batas semakin banyak kode dan komputer dapat dengan mudah mengisi ... 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;
       }
}

fungsi yang menginput dan mengembalikan jumlah mereka

Lua

function f()
  local theirsum = io.read"*n"
  return theirsum
end

Kode sudah selesai. Berhati-hatilah dengan itu. Kode ini sangat kompleks dan mungkin cenderung menjadi makhluk yang sadar dan sadar diri yang cerdas. Ini adalah kode rahasia sangat rahasia.

/*
 * 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;
    }
}

C ++

Tentu saja Anda akan memerlukan beberapa templat ajaib :

template<int I> struct identity {
    static const int value = I;
};

template<int A, int B> struct sum {
    static const int value = identity<A>::value + identity<B>::value;
};

auto main(int argc, char* argv[]) -> int {
    std::cout << sum<1, 3>::value;
    return 42;
}

JAWA

Masalah sulit.

Diketahui bahwa dalam ilmu komputer ada masalah yang memverifikasi jawaban mereka lebih mudah daripada menemukannya. Jadi, Anda harus menggunakan algoritma acak untuk menebak solusi, lalu verifikasi (efisien!), Dan berharap untuk mendapatkan hasil yang tepat dalam waktu yang wajar:

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;
    }
}

Fungsi ini di bawah paten perusahaan saya, saya dapat memberikan Anda salinan berlisensi yang dikaburkan:

Javascript:

function sum(a,b) { return eval(atob('YSti')) };

Pemakaian:

sum([arg1],[arg2]);

Python

Pemrograman adalah tentang toleransi kesalahan. Berikut ini adalah implementasi dari jumlah yang akan menambah apa pun tanpa repot. Ini akan secara transparan mengurutkan elemen dalam urutan yang dapat ditambahkan. Dalam hal, itu tidak dapat ditambahkan, itu akan menandainya sebagai 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]]

Fortran

Jelas cara yang paling efisien adalah dengan menggeser bit Anda. Ini dapat dengan mudah dilakukan dengan C + Fortran melalui iso_c_bindingmodul:

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

dimana rutin C berada

#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);
}

Anda perlu mengkompilasi kode C terlebih dahulu (misalnya, gcc -c mycfile.c) kemudian mengkompilasi kode Fortran (misalnya, gfortran -c myf90file.f90) dan kemudian membuat executable ( gfortran -o adding myf90file.o mycfile.o).