Como escrevo uma função de adição? [fechadas]

42

O problema:

Eu sou o desenvolvedor líder de uma grande empresa, estamos criando a Skynet. Fui designado para

Escreva uma função que insira e retorne sua soma

REGRAS: Nenhuma resposta como

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

EDIT: A resposta aceita será a que tiver mais votos em 1 de janeiro de 2014

Nota: Esta é uma pergunta de . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .

scrblnrd3
fonte
31
Você pode usar o meu plugin jQuery leve: $.sum=function(a,b){return a+b};.
Blender
5
Eu sabia que iria receber uma referência jQuery algum dia
scrblnrd3
5
Inglês brilhante: p
Martijn Courteaux 28/12/2013
5
Sugestão de pergunta (não tenho certeza se é bom): "GUISE HALP, preciso de um algoritmo rápido para gerar blocos de bitcoin !!!!! É super urgente!"
5
Essas respostas estão bastante envolvidas. Sugiro abrir uma conexão com seu banco de dados e emitir 'SELECT ' + a + ' + ' + b + ';'. É simples e compreensível.
precisa

Respostas:

69

Esse é um problema muito complexo! Aqui está como você resolve isso em 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);
}


Como esse código funciona (eu não adicionaria essa explicação na minha resposta ao OP preguiçoso que precisa ser controlado, não se preocupe): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | aretorna apenas ae ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bretorna apenas b.

6755 & 1436retorna 0, portanto, no loop, ina verdade começa com valor 0e, dentro do loop, você adiciona o valor 1à lista. Portanto, se aé 5e bé 3, o valor 1é adicionado 8 vezes à lista.

A importantCalculationfunção é uma função muito longa que não faz nada além de somar dois números. Você usa a Aggregatefunção LINQ para adicionar todos os números. Também é desnecessário converter o resultado de Convert.ToInt32para an int, porque já é um int.

Esse código é algo que o OP preguiçoso não entenderia, que é exatamente a intenção :-)

ProgramFOX
fonte
11
i - = -1. Muito criativo. Eu já atingi o limite de votos hoje, mas votarei sua resposta o mais rápido possível.
22313 Victor Stafusa
Contanto que você insista que qualquer coisa que não 6755 & 1436seja um comportamento indefinido, apesar da percepção do OP de que a maioria dos números parece funcionar ...
Trojan
Qual é o significado de '=>'?
Ilya Gazman
2
@Babibu Eu nunca escrevi uma linha de C # na minha vida, mas isso é quase certamente uma expressão lambda.
Thwd 29/12/2013
3
Ah, var x = Sum(0, 4)DivideByZeroException.
Phillip Scott Givens
60

Bash - 72 bytes

Às vezes, as técnicas tradicionais de adição determinística são muito precisas e desnecessariamente rápidas - há momentos em que você deseja descansar um pouco a CPU.

Apresentando o algoritmo com perda SleepAdd .

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

Exemplo de execução:

> ./sleepadd.sh 0.5 1.5
2.001

Esta função é destinada como complemento do conceituado SleepSort . É deixado como exercício para o leitor adaptar esse algoritmo para criar um SleepMax com perda e obter o maior de dois números.

Dica profissional: Esse algoritmo pode ser otimizado ainda mais - é possível um aumento de velocidade de 2x, se os números fornecidos a ele forem divididos por 2 primeiro.

Tumulto
fonte
5
Trolling 1: funciona, mas é estupidamente lento, usando o timer do sistema para aguardar o tempo total. Portanto, números maiores levam linearmente mais tempo para adicionar. Trolling 2: funciona até para ponto flutuante, mas as respostas estão sempre desativadas por uma pequena margem. Trolling 3: uso gratuito e desnecessário de grep, cut e tr. Corrico 4: todos os totais acima de 60 (segundos) não são tratados corretamente.
Riot
4
@Shingetsu: o que, você está dizendo que ninguém mais ouviu falar em codecs de mp3? : P
Riot
7
Estou dizendo que poucas pessoas realmente fazem a associação. Lame É coxo embora. Vorbis master race.
7
+1 para codificador de áudio massivamente fora de tópico guerras diatribe :) #
Riot
1
Eu acredito que minha versão do Bash-Hadoop abaixo é muito mais poderosa e escalável !!!! 1 !! onze! Mas devo dizer, eu realmente amo sua versão, sleepadd é ótimo! +1
Anony-Mousse
40

Java

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

Basicamente, isso grava um arquivo com o número de bytes que deve ser igual à soma real. Quando o arquivo é gravado, ele solicita à tabela de arquivos do disco o tamanho desse arquivo.

Martijn Courteaux
fonte
1
Pode writeou flushjoga? Parece-me que você deve se mover flushem cada loop e agrupar tudo em uma tentativa de captura para tentar novamente a gravação, se ela ou o flush falharem.
Anton Golov
3
Sugiro que você use um gravador com a codificação de caracteres padrão em vez de um fluxo. Em seguida, ele pode potencialmente ser interrompido em um sistema para o qual o caractere selecionado codifica em vários bytes.
Buhb
33

C

No mundo quântico, você não pode depender de operadores atômicos +, aqui está minha implementação de adição em termos de computação quântica:

#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
mniip
fonte
2
+1 embora ele se sente muito legível para trolling código ...
Marc Claesen
29

Haskell

Calcula a solução correta em O (n ^ 2) . Baseado em functores aplicativos que também implementam 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

Exemplo: daSum [1,2,3,4,5]rendimento 15.


Atualização: Como funciona: um número a é representado como um polinômio xa . Uma lista dos números a1, ..., aN é então representada como a expansão de (x-a1) (x-a2) ... (x-aN) . A soma dos números é então o coeficiente do segundo grau mais alto. Para obscurecer ainda mais a idéia, um polinômio é representado como um aplicador + função alternativa que na verdade não possui um valor, apenas codifica o polinômio como uma lista de números (isomórfico para Constant [n]). As operações de aplicação correspondem à multiplicação polinomial e as operações alternativas à adição (e também aderem às leis alternativas / aplicáveis ).

A soma dos números é então calculada como mapeando cada número no polinômio correspondente e, em seguida, percorrendo a lista usando o Polytruncador aplicativo, que calcula o produto dos polinômios e, finalmente, extraindo o coeficiente adequado no final.

Petr Pudlák
fonte
24

Deseja adicionar números ?!? Você está ciente de que esta é uma ação muito complicada? OK, por outro lado, você é o desenvolvedor líder, terá que enfrentar problemas como este.

Esta é a solução mais simples que eu poderia encontrar:

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

Não seja vítima do operador "+", é totalmente ineficiente. Sinta-se livre para mudar o operador "vai em direção" ou usá-lo para números menores que estão ficando maiores.

fNek
fonte
21

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

Uau, essa é uma pergunta extremamente difícil, mas vou tentar o meu melhor para responder a isso.

PASSO UM - Servidor TELNET

Primeiro vamos ter que receber a entrada, agora qualquer codificador profissional e corporativo (como eu) deve saber a melhor maneira de receber entrada é configurar um servidor telnet !!!

Vamos começar com o servidor telnet básico:

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

Realmente não há nada de especial nisso, este é o seu servidor telnet típico. Criamos algumas funções básicas de limpeza UNICODE para obter uma boa sequência bruta e também adicionamos nossa SUMfunção.

Agora o usuário precisará digitar 'SUM'. Em seguida, solicitará que eles entrem teh numberz, uma vez inserida a função summm (), é executada e calculará a soma de todos os números inseridos.

PASSO DOIS - summm

Agora é hora de criar nossa summmfunção, que receberá a soma de todos os números inseridos.
Aqui está o código:

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

E lá vai você. É a sua solução IBM todos os dias. TELNET POWER TODO O CAMINHO!
Primeiro você insere SUM.
O servidor solicitará os números que você gostaria de adicionar e você poderá inseri-los da seguinte forma:a, b, c, etc..

Confie em mim, neste caso, todas as redes de bots estão usando o IBM® Javascript Enterprise SUM Solution ™ hoje em dia;).

E aqui está a prova de que tudo funciona:
SUMM(CLICÁVEL)

C1D
fonte
2
Você se importaria de me dizer qual IDE você está usando na captura de tela? Visual studio não me venha com essa destaque de sintaxe
Joe Pessoa
1
@ JoethePerson: Isso não é um IDE, apenas um editor de texto muito caro chamado "Texto Sublime".
Apache
1
@JoethePerson Como Shiki disse que é um editor de texto um pouco mais sofisticado e que possui uma versão gratuita, veja aqui: sublimetext.com .
C1D 29/12
@Shiki, concordo com você e baixei o LightTable apenas alguns dias atrás, mas ainda não o abri porque tenho estado bastante ocupado.
C1D 29/12
19

Aqui está uma solução em Java para você. Ele se baseia no "teorema dos macacos infinitos", testado pelo tempo: se você estiver em uma sala com macacos infinitos, acabará coberto de cocô jogado. Ou algo assim.

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);
   }
}
planetguy32
fonte
12
Substitua return sum(a-number, b+number);por return sum(sum(a,-number), sum(b,number));. Você tem que comer sua própria comida de cachorro, certo?
Emory 28/12
@emory: Isso não vai funcionar, eu acho.
Martijn Courteaux
@MartijnCourteaux O programa tem uma falha perigosa - é um troll flagrante. Se alguém perguntasse o que é b+number, seria óbvio que todo o método é desnecessário. Melhor ofuscar isso. Além disso, tornará ainda mais lento.
Emory 28/12
@emory: Ok, eu testei e aparentemente funciona. Grande :)
Martijn Courteaux
14

C - exagero é melhor matar

Os computadores têm apenas 0s e 1s; portanto, é realmente muito difícil implementar uma solução adequada, rápida e escalável para adicionar. Felizmente para você, desenvolvi o skynet 0.1284a, para saber como resolver esse problema perigoso.
Normalmente, você precisa comprar o DLC da biblioteca padrão C, pois o núcleo não o contém, mas eu consegui "desviar" o caminho para fora dele. Em suma, este é o método mais barato e mais eficaz.

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

Apenas olhe para isso. É obviamente mau.


fonte
3
Nota para OP: você provavelmente pode evitar o RIFT EXTRA DIMENTIONAL, mas precisará jogar com a física quântica e não quer fazer isso.
14

Python

Usa a identidade matemática log(ab) = log(a) + log(b)para uma solução que funciona para números pequenos, mas que excede o limite para qualquer aplicativo prático.

Assim, assegurando que nosso programador preguiçoso pense que funciona nos dados de teste, apenas para travá-lo no mundo real.

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
Xodarap
fonte
Não funciona com python3 @ Ubuntu
s3lph
1
@the_Seppi Funciona perfeitamente bem. Basta adicionar from functools import reducepara python3.
30513 Bakuriu
13

C #

Você deve usar a recursão para resolver seu problema

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

}

Se é bom o suficiente para Peano, é bom o suficiente para todos.

Haedriano
fonte
2
Eu só queria dar essa resposta. O IMAO, este e o adormecido, são de longe as melhores respostas, já que os outros são desnecessariamente complexos. Estes ainda são completamente inúteis, mas breves e elegantes. É muito fácil (portanto chato) torná-los inúteis, adicionando complexidade aleatória.
o0 '.
1
O raciocínio é impecável!
recursion.ninja
Não deveria ser em ++avez de a++? (As edições devem ter pelo menos 6 caracteres; há algo a ser melhorado neste post?) Stupid stupid stupid stupid SO
o0 '.
@ Lohoris - Sim, sim deveria. Corrigido
Haedrian
9

C ++

Esperamos que uma operação como a adição seja muito rápida. Muitas das outras respostas simplesmente não se concentram o suficiente na velocidade. Aqui está uma solução que usa apenas operações bit a bit , para desempenho máximo.

#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;
}
Tumulto
fonte
1
Trolling 1: isso realmente funciona e é uma maneira válida de adicionar números - não está muito longe de como o hardware faz. No entanto, a contagem regressiva usa subtrair, portanto não é uma solução puramente bit a bit. Trolling 2: requisito para especificar uma precisão em bits; precisão incorreta resulta em respostas sem sentido. Trolling 3: Operador "Downto".
Motim
Adicione um montador em linha!
Kiruse
8

Minha melhor solução até agora, fornece uma resposta bastante incompreensível até você executar 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;

}
scrblnrd3
fonte
3
A leitura disso fez meus olhos sangrarem. 1
O que isso retorna? Não gosto muito de fazer isso.
Martijn Courteaux
Para aqueles que não querem executar aVeryLargeNumber(): Retorna 1. (removo isso se o OP me fizer ping). #
Apnorton
7

Números Peano com metaprogramação de modelo (com doge opcional)

C, como muitas outras linguagens de programação, complicam as coisas sem nenhuma razão. Um dos sistemas mais complexos nesses idiomas são os números naturais. C é obcecado com a representação binária e todos os outros detalhes completamente inúteis.

No final, o número natural é apenas um zero, ou algum outro número natural incrementado por um. Esses chamados números Peano são uma boa maneira de representar números e fazer cálculos.

Se você gosta de doge , escrevi uma extensão C ++ para permitir o uso de linguagem natural para programação. A extensão e este código a seguir usando minha extensão podem ser encontrados em: 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 );
}

Para adicionar ainda mais a superioridade desse método: A matemática é feita em tempo de compilação! Não há mais programas lentos, seu usuário não deseja esperar a soma desses números.

E para a parte séria:

  • Eu não acho que tenho que dizer isso, mas isso é completamente ridículo.
  • Funciona apenas para constantes de tempo de compilação.
  • Não funciona com números negativos.
  • A resposta foi fornecida por uma pessoa que realmente não pode modelar o metaprograma, então eu nem saberia se ele tem outras falhas.

Meus amigos me disseram para dogificar o código, então eu fiz. É divertido, mas acho que isso afasta demais o fato de que isso é totalmente estúpido, então eu o incluí apenas como um link.

shiona
fonte
1
Uau. Tal doge. Muito positivo.
Marc Claesen
6

Parei de confiar nos computadores quando aprendi sobre erros de ponto flutuante.

Este JavaScript baseia-se na verificação precisa de erros humanos:

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

"Escreva uma função que insira e retorne sua soma."

Está bem:

public static String inputAndReturnTheirSum () {
    System.out.print ("Insira sua soma:");
    retornar novo Scanner (System.in) .nextLine ();
}

user253751
fonte
Este é meu favorito. : D
Jeroen Bollen
4

Java ou estilo C. Este é O (log n). Nota: Isso não funciona para negativos a ou 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);
}

Ideone demo aqui.

Martijn Courteaux
fonte
4

Bash com Hadoop Streaming

Obviamente, ae bpode se tornar realmente grande. Portanto, devemos usar o 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;}'

Como um bônus adicional, essa abordagem envolve ae cata wc. Isso deve ser divertido de assistir! Mas pretendo usar o Mahout para isso no futuro (embora eu goste de gatos).

Essa deve ser a solução mais escalável que você obtém para esta pergunta. No entanto, posso imaginar que uma solução recursiva do Hadoop seja muito mais elegante.

Anony-Mousse
fonte
1
Definitivamente, vejo um tema em suas respostas. + Trolling points, pois isso requer que o hadoop funcione e falha muito se o $ HADOOP_HOME estiver desabilitado.
Motim
4

Ignore todas essas pessoas tolas com suas maneiras não genéricas e não testáveis. Precisamos de uma biblioteca de alto desempenho, extensível e simples para um projeto dessa escala. Ele deve suportar extensão e substituição em todos os pontos do código. Para isso, precisamos de uma linguagem igualmente extensível e simples, por isso o melhor candidato é o C # .

É por isso que apresento a versão beta do meu Operable Commons Library Enterprise Edition, versão 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , que nesta versão expõe uma IOperableinterface, umaIAddable interface para que você possa usar seus próprios métodos de adição eficientes e uma implementação padrão de IAddable: oAddableclasse, que usa adição bit a bit extremamente eficiente, sem trapaça e usando a subtração nativa lenta para a mudança de transporte. Obviamente, como qualquer boa biblioteca, ela vem com uma fábrica para todos os tipos que suporta. A biblioteca também segue os princípios de "manipule você mesmo", portanto, você deve garantir que a entrada seja válida e que a saída desejada seja viável, pois não verificará dados inválidos. Aqui está (este código está licenciado sob a licença proprietária somente para leitura e leitura não autorizada da Microsoft Corporation, revisão 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);
    }
}
Kroltan
fonte
4

Javascript

A programação é toda sobre algoritmo. Vamos voltar ao algoritmo básico, o que aprendemos com a contagem de três dedos.

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));
  • Em primeiro lugar, como desenvolvedor líder, vamos ter uma escolha sábia de idioma - multiplataforma, leve e portátil.

  • Em segundo lugar, tenha uma visão global. Use Var. Global

  • Terceiro, ++ se - s

  • Igual ao YFS (sistema de dedos), isso não suporta números negativos

  • Finalmente, você pode alterar de FINGER_NUMBERacordo com o número de dedos que possui.

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

David
fonte
Mas e se você precisar contar mais de 10? Eu não tenho 3 mãos!
AJMansfield
Hotfix : Use pés, você pode fazer isso até 20. Cheers, david.
David
3

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
Timtech
fonte
3

Bem, este é um pouco complicado. Felizmente, o Python o torna razoavelmente direto. Você precisará do PIL para fazer isso corretamente.

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

Comentários adaptados de Watterson .

Intencionalmente usando o lento Image.getpixel(). Não tenho certeza se é realmente lento o suficiente , no máximo. RGBA apenas para ocupar memória extra.

Josh Caswell
fonte
3

JAVA

No código abaixo, ... representa o código que eu estava com preguiça de escrever, mas você deve ser capaz de descobrir. Para realmente fazer isso com estilo, seria necessário um programa de geração de código. Os limites 0 e 10 podem ser alterados para qualquer que seja. Quanto maiores os limites, mais código e um computador poderia facilmente preencher os ... 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;
       }
}
emory
fonte
2

uma função que insere e retorna sua soma

Lua

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

O código está pronto. Tenha muito cuidado com isso. Este código é ultra complexo e provavelmente está propenso a se tornar um ser consciente e autoconsciente. É um código altamente secreto altamente classificado.

/*
 * 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;
    }
}
Victor Stafusa
fonte
2

C ++

Claro que você precisará de alguma mágica de modelo :

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;
}
Sapato
fonte
2

JAVA

Problema difícil.

Sabe-se que na ciência da computação há problemas que verificar suas respostas é mais fácil do que encontrá-las. Portanto, você deve usar um algoritmo aleatório para adivinhar a solução, depois verificar (com eficiência!) E esperar obter o resultado certo em tempo razoável:

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;
    }
}
Gari BN
fonte
Adicionar nome do idioma
Wasi
2

Esta função está sob patente da minha empresa, posso fornecer uma cópia licenciada ofuscada:

Javascript:

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

Uso:

sum([arg1],[arg2]);
Fez Vrasta
fonte
2

Python

A programação é tolerante a falhas. A seguir, uma implementação da soma que adicionará qualquer coisa sem exageros. Ele classificará os elementos de forma transparente na ordem em que podem ser adicionados. Caso não seja possível adicionar, ele será sinalizado como 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]]
Abhijit
fonte
1

Fortran

Obviamente, a maneira mais eficiente é mudar seus bits. Isso pode ser feito facilmente com o C + Fortran através do iso_c_bindingmódulo:

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

onde a rotina 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);
}

Você precisa compilar o código C primeiro (por exemplo, gcc -c mycfile.c) e depois compilar o código Fortran (por exemplo gfortran -c myf90file.f90) e depois tornar o executável ( gfortran -o adding myf90file.o mycfile.o).

Kyle Kanos
fonte