Apakah mungkin untuk menulis program C yang mengalikan dua angka tanpa menggunakan operator perkalian dan penambahan?

Saya menemukan ini di Stack Overflow . Tolong bantu programmer miskin ini dengan masalahnya. Dan tolong jangan memberikan jawaban seperti c = a/(1/((float)b)), yang persis sama dengan c = a*b. (Dan sudah diberikan sebagai jawaban.)

Jawaban dengan suara terbanyak pada 19 Januari 2014 menang.

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

Selalu gunakan rekursi

Ilusi adalah cara yang benar!

int inc(int x) {
    return x&1?inc(x>>1)<<1:x|1;
}

int dec(int x) {
    return x&1?x^1:dec(x>>1)<<1|1;
}

int add(int x, int y) {
    return x?add(dec(x),inc(y)):y;
}

int mul(int x, int y) {
    return x?x^1?add(y,mul(dec(x),y)):y:0;
}

int main() {
    int a, b;
    scanf("%i\n%i", &a, &b);
    printf("%i", mul(a,b));
}

Anda harus mengkompilasi program setiap kali, tetapi ia melakukan multiplikasi bilangan bulat positif apa pun di versi C atau C ++.

 #define A 45  // first number
 #define B 315 // second number

 typedef char buffer[A][B];

 main() {
    printf("%d\n",sizeof(buffer));
 }

Jika Anda baik-baik saja dengan sedikit ketidaktepatan, Anda dapat menggunakan metode Monte Carlo :

#include <stdlib.h>
#include <stdio.h>

unsigned int mul(unsigned short a, unsigned short b) {
  const int totalBits = 24;
  const int total = (1 << totalBits);
  const int maxNumBits = 10;
  const int mask = (1 << maxNumBits) - 1;
  int count = 0, i;
  unsigned short x, y;
  for(i = 0; i < total; i++) {
    x = random() & mask;
    y = random() & mask;
    if ((x < a) && (y < b))
      count++;
  }
  return ((long)count) >> (totalBits - (maxNumBits << 1));
}

void main(int argc, char *argv[]) {
  unsigned short a = atoi(argv[1]);
  unsigned short b = atoi(argv[2]);
  printf("%hd * %hd = %d\n", a, b, mul(a, b));
}

Contoh:

$ ./mul 300 250
300 * 250 = 74954

Saya kira ini cukup bagus;)

Karena Anda tidak menentukan ukuran angka apa, saya berasumsi bahwa yang Anda maksud adalah dua angka satu bit.

#include <stdbool.h>
bool mul(bool a, bool b) {
    if (a && b) {
        return true;
    } else {
        return false;
    }
}

Jika Anda ingin implementasi yang efisien secara maksimal, gunakan implementasi kecil berikut:

m(a,b){return a&b;}

Perhatikan bahwa masih hanya menerima bit meskipun jenisnya ints implisit - ini membutuhkan lebih sedikit kode, dan karenanya lebih efisien. (Dan ya, itu mengkompilasi.)

Berikut ini skrip shell sederhana untuk melakukannya:

curl "http://www.bing.com/search?q=$1%2A$2&go=&qs=n&form=QBLH&pq=$1%2A$2" -s \
| sed -e "s/[<>]/\n/g" \
| grep "^[0-9 *]*=[0-9 ]*$"

PEMBARUAN: Tentu saja, untuk melakukannya dalam C, cukup bungkus exec("bash", "-c", ...). (Terima kasih, AmeliaBR)

Mengapa, mari kita lakukan pencarian separuh rekursif antara INT64_MIN dan INT64_MAX!

#include <stdio.h>
#include <stdint.h>

int64_t mul_finder(int32_t a, int32_t b, int64_t low, int64_t high)
{
    int64_t result = (low - (0 - high)) / 2;
    if (result / a == b && result % a == 0)
        return result;
    else
        return result / a < b ?
            mul_finder(a, b, result, high) :
            mul_finder(a, b, low, result);
}

int64_t mul(int32_t a, int32_t b)
{
    return a == 0 ? 0 : mul_finder(a, b, INT64_MIN, INT64_MAX);
}

void main(int argc, char* argv[])
{
    int32_t a, b;
    sscanf(argv[1], "%d", &a);
    sscanf(argv[2], "%d", &b);
    printf("%d * %d = %ld\n", a, b, mul(a, b));
}

PS Itu dengan senang hati akan sigsegv dengan beberapa nilai. ;)

Sayangnya, ini hanya berfungsi untuk bilangan bulat.

Karena penambahan tidak diizinkan, mari buat operator kenaikan terlebih dahulu:

int plusOne(int arg){
  int onMask = 1;
  int offMask = -1;
  while (arg & onMask){
    onMask <<= 1;
    offMask <<= 1;
  }
  return(arg & offMask | onMask);
}

Selanjutnya, kita harus menangani tandanya. Pertama, temukan bit tanda:

int signBit = -1;
while(signBit << 1) signBit <<=1;

Kemudian ambil tanda dan besarnya setiap argumen. Untuk meniadakan angka dalam komplemen dua, membalikkan semua bit, dan menambahkan satu.

int signA = a & signBit;
if(signA) a = plusOne(-1 ^ a);
int signB = b & signBit;
if(signB) b = plusOne(-1 ^ b);
int signRes = signA ^ signB;

Untuk melipatgandakan dua bilangan bulat positif, kita dapat menggunakan makna geometris perkalian:

// 3x4
//
// ooo
// ooo
// ooo
// ooo

int res = 0;
for(int i = 0; i < a; i = plusOne(i))
  for(int j = 1; j < b; j = plusOne(j))
    res = plusOne(res);

if(signRes) res = plusOne(-1 ^ res);

troll:

• Penambahan tidak diizinkan, tetapi apakah a++benar - benar dianggap sebagai tambahan? Saya yakin guru itu bermaksud untuk mengizinkannya.
• Bergantung pada komplemen dua, tetapi itu adalah perilaku yang ditentukan implementasi dan platform target tidak ditentukan.
• Demikian pula, mengasumsikan pengurangan dan pembagian juga dilarang.
• << sebenarnya perkalian dengan kekuatan dua, sehingga secara teknis harus dianulir.
• diagram uneccesary adalah uneccesary. Juga, itu bisa ditransposisikan untuk menyimpan satu baris.
• pengulangan pengulangan -1bukan cara terbaik untuk menemukan bit tanda. Bahkan jika tidak ada built-in konstan, Anda bisa melakukan pergantian logis kanan -1, lalu membalikkan semua bit.
• XOR -1 bukan cara terbaik untuk membalikkan semua bit.
• Seluruh sandiwara dengan representasi tanda-besarnya tidak perlu. Hanya melemparkan ke unsigned dan aritmatika modular akan melakukan sisanya.
• karena nilai absolut MIN_INT(AKA signBit) negatif, ini rusak untuk nilai itu. Untungnya, ia masih berfungsi dalam setengah kasus, karena MIN_INT * [even number] harus nol.Juga, plusOnebreak for -1, menyebabkan loop tak terbatas kapan saja hasilnya meluap. plusOneberfungsi dengan baik untuk nilai apa pun. Maaf bila membingungkan.

Berfungsi untuk nomor floating point:

float mul(float a, float b){
  return std::exp(std::log(a) - std::log(1.0 / b));
}

Semua orang tahu bahwa Python lebih mudah digunakan daripada C. Dan Python memiliki fungsi yang sesuai dengan setiap operator, untuk kasus di mana Anda tidak dapat menggunakan operator. Yang merupakan definisi masalah kita, bukan? Begitu:

#include <Python.h>

void multiply(int a, int b) {
    PyObject *operator_name, *operator, *mul, *pa, *pb, *args, *result;
    int result;

    operator_name = PyString_FromString("operator");
    operator = PyImport_Import(operator_name);
    Py_DECREF(operator_name);
    mul = PyObject_GetAttrString(operator, "__mul__");
    pa = PyLong_FromLong((long)a);
    pb = PyLong_FromLong((long)b);
    args = PyTuple_New(2);
    PyTuple_SetItem(args, 0, pa);
    PyTuple_SetItem(args, 1, pb);
    presult = PyObject_CallObject(mul, args);
    Py_DECREF(args);
    Py_DECREF(mul);
    Py_DECREF(operator);
    result = (int)PyLong_AsLong(presult);
    Py_DECREF(presult);
    return result;
}

int main(int argc, char *argv[]) {
    int c;
    Py_Initialize();
    c = multiply(2, 3);
    printf("2 * 3 = %d\n", c);
    Py_Finalize();
}

Tidak satu pun dari jawaban lain yang secara teoritis masuk akal. Seperti komentar pertama pada pertanyaan mengatakan:

Harap lebih spesifik tentang "angka"

Kita perlu mendefinisikan penggandaan, dan angka, sebelum jawaban dimungkinkan. Begitu kita lakukan, masalahnya menjadi sepele.

Cara yang paling populer untuk melakukan ini dalam memulai logika matematika adalah dengan membangun ordinal von Neumann di atas teori himpunan ZF , dan kemudian menggunakan aksioma Peano .

Ini diterjemahkan secara alami ke C, dengan asumsi Anda memiliki tipe set yang dapat berisi set lain. Itu tidak harus mengandung apa pun kecuali set, yang membuatnya sepele (tidak ada yang membuat void*omong kosong di sebagian besar set perpustakaan), jadi saya akan meninggalkan implementasi sebagai latihan untuk pembaca.

Jadi, pertama:

/* The empty set is 0. */
set_t zero() {
    return set_new();
}

/* The successor of n is n U {n}. */
set_t successor(set_t n) {
    set_t result = set_copy(n);
    set_t set_of_n = set_new();
    set_add(set_of_n, n);
    set_union(result, set_of_n);
    set_free(set_of_n);
    return result;
}

/* It is an error to call this on 0, which will be reported by
   running out of memory. */
set_t predecessor(set_t n) {
    set_t pred = zero();
    while (1) {
        set_t next = successor(pred);
        if (set_equal(next, n)) {
            set_free(next);
            return pred;
        }
        set_free(pred);
    }
}        

set_t add(set_t a, set_t b) {
    if (set_empty(b)) {
        /* a + 0 = a */
        return a;
    } else {
        /* a + successor(b) = successor(a+b) */
        set_t pred_b = predecessor(b)
        set_t pred_ab = add(a, pred_b);
        set_t result = successor(pred_ab);
        set_free(pred_b);
        set_free(pred_ab);
        return result;
    }
}

set_t multiply(set_t a, set_t b) {
    if (set_empty(b)) {
        /* a * 0 = 0 */
        return b;
    } else {
        /* a * successor(b) = a + (a * b) */
        set_t pred_b = predecessor(b)
        set_t pred_ab = mul(a, pred_b);
        set_t result = successor(pred_ab);
        set_free(pred_b);
        set_free(pred_ab);
        return result;
    }
}

Jika Anda ingin memperluas ini ke integer, rasional, real, surreals, dll., Anda bisa — dengan ketepatan tak terbatas (dengan asumsi Anda memiliki memori dan CPU tak terbatas), untuk melakukan booting. Tetapi seperti yang dikatakan Kroenecker, Tuhan membuat angka-angka alami; semua yang lain adalah pekerjaan manusia, jadi sungguh, mengapa repot-repot?

unsigned add( unsigned a, unsigned b )
{
    return (unsigned)&((char*)a)[b];  // ignore compiler warnings
       // (if pointers are bigger than unsigned). it still works.
}
unsigned umul( unsigned a, unsigned b )
{
    unsigned res = 0;
    while( a != 0 ){
        if( a & 1) res = add( res, b );
        b <<= 1;
        a >>= 1;
    }
    return res;
}

int mul( int a, int b ){
    return (int)umul( (unsigned)a, (unsigned)b );
}

Jika Anda menganggap hack a [b] sebagai curang (karena ini benar-benar add), maka ini berfungsi sebagai gantinya. Tapi pencarian tabel juga melibatkan pointer.

Lihat http://en.wikipedia.org/wiki/IBM_1620 - komputer yang benar-benar melakukan penambahan menggunakan tabel pencarian ...

Sesuatu yang memuaskan tentang menggunakan mekanisme tabel untuk 'mempercepat' operasi yang sebenarnya bisa dilakukan dalam satu instruksi.

static unsigned sumtab[17][16]= {
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15},
{ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16},
{ 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17},
{ 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18},
{ 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19},
{ 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20},
{ 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21},
{ 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22},
{ 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23},
{ 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24},
{10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25},
{11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26},
{12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27},
{13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28},
{14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29},
{15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30},
{16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31}
};

unsigned add( unsigned a, unsigned b )
{
   static const int add4hack[8] =  {4,8,12,16,20,24,28,32};
   unsigned carry = 0;
   unsigned (*sumtab0)[16] = &sumtab[0];
   unsigned (*sumtab1)[16] = &sumtab[1];
   unsigned result = 0;
   int nshift = 0;
   while( (a|b) != 0 ){
      unsigned psum = (carry?sumtab1:sumtab0)[ a & 0xF ][ b & 0xF ];
      result = result | ((psum & 0xF)<<nshift);
      carry = psum >> 4;
      a = a >> 4
      b = b >> 4;
      nshift= add4hack[nshift>>2];  // add 4 to nshift.
   }
   return result;
}

Saya tidak yakin apa yang merupakan "kecurangan" dalam posting "code troll" ini, tetapi ini mengalikan 2 bilangan bulat sewenang-wenang, pada saat run time, tanpa operator *atau +menggunakan perpustakaan standar (C99).

#include <math.h>
main()
{
  int a = 6;
  int b = 7;
  return fma(a,b,0);
}

Solusi troll saya untuk unsigned int:

#include<stdio.h>

unsigned int add(unsigned int x, unsigned int y)
{
  /* An addition of one bit corresponds to the both following logical operations
     for bit result and carry:
        r     = x xor y xor c_in
        c_out = (x and y) or (x and c_in) or (y and c_in)
     However, since we dealing not with bits but words, we have to loop till
     the carry word is stable
  */
  unsigned int t,c=0;
  do {
    t = c;
    c = (x & y) | (x & c) | (y & c);
    c <<= 1;
  } while (c!=t);
  return x^y^c;
}

unsigned int mult(unsigned int x,unsigned int y)
{
  /* Paper and pencil method for binary positional notation:
     multiply a factor by one (=copy) or zero
     depending on others factor actual digit at position, and  shift 
     through each position; adding up */
  unsigned int r=0;
  while (y != 0) {
    if (y & 1) r = add(r,x);
    y>>=1;
    x<<=1;
  }
  return r;
}

int main(int c, char** param)
{
  unsigned int x,y;
  if (c!=3) {
     printf("Fuck!\n");
     return 1;
  }
  sscanf(param[1],"%ud",&x);
  sscanf(param[2],"%ud",&y);
  printf("%d\n", mult(x,y));
  return 0;
}

Ada banyak jawaban bagus di sini, tetapi sepertinya tidak banyak yang memanfaatkan fakta bahwa komputer modern benar-benar kuat. Ada banyak unit pemrosesan di sebagian besar CPU, jadi mengapa menggunakan hanya satu? Kami dapat memanfaatkan ini untuk mendapatkan hasil kinerja yang hebat.

#include <stdio.h>
#include <limits.h>
#include "omp.h"

int mult(int a, int b);

void main(){
        int first;
        int second;
        scanf("%i %i", &first, &second);
        printf("%i x %i = %i\n", first, second, mult(first,second));
}

int mult(int second, int first){
        int answer = INT_MAX;
        omp_set_num_threads(second);
        #pragma omp parallel
        for(second = first; second > 0; second--) answer--;
        return INT_MAX - answer;
}

Berikut ini contoh penggunaannya:

$ ./multiply
5 6
5 x 6 = 30

The #pragma omp paralleldirektif membuat OpenMP membagi setiap bagian dari untuk loop ke unit eksekusi yang berbeda, jadi kita mengalikan secara paralel!

Perhatikan bahwa Anda harus menggunakan -fopenmpflag untuk memberi tahu kompiler untuk menggunakan OpenMP.

Troll bagian:

1. Menyesatkan tentang penggunaan pemrograman paralel.
2. Tidak berfungsi pada angka negatif (atau besar).
3. Tidak benar-benar membagi bagian-bagian dari forloop - setiap thread menjalankan loop.
4. Nama variabel yang mengganggu dan penggunaan kembali variabel.
5. Ada kondisi balapan yang halus pada answer--; sebagian besar waktu, itu tidak akan muncul, tetapi kadang-kadang itu akan menyebabkan hasil yang tidak akurat.

Sayangnya, perkalian adalah masalah yang sangat sulit dalam ilmu komputer. Solusi terbaik adalah dengan menggunakan pembagian sebagai gantinya:

#include <stdio.h>
#include <limits.h>
int multiply(int x, int y) {
    int a;
    for (a=INT_MAX; a>1; a--) {
        if (a/x == y) {
            return a;
        }
    }
    for (a=-1; a>INT_MIN; a--) {
        if (a/x == y) {
            return a;
        }
    }
    return 0;
}
main (int argc, char **argv) {
    int a, b;
    if (argc > 1) a = atoi(argv[1]);
    else a = 42;
    if (argc > 2) b = atoi(argv[2]);
    else b = 13;
    printf("%d * %d is %d\n", a, b, multiply(a,b));
}

Dalam kehidupan nyata saya biasanya merespons trolling dengan pengetahuan, jadi inilah jawaban yang tidak troll sama sekali. Ini berfungsi untuk semua intnilai sejauh yang saya bisa lihat.

int multiply (int a, int b) {
  int r = 0;
  if (a < 0) { a = -a; b = -b }

  while (a) {
    if (a&1) {
      int x = b;
      do { int y = x&r; r ^= x; x = y<<1 } while (x);
    }
    a>>=1; b<<=1;
  }
  return r;
}

Ini, sejauh yang saya pahami, sangat mirip dengan bagaimana CPU sebenarnya dapat melakukan penggandaan bilangan bulat. Pertama, kami memastikan bahwa setidaknya salah satu argumen ( a) positif dengan membalik tanda pada keduanya jika anegatif (dan tidak, saya menolak untuk menghitung negasi sebagai semacam penambahan atau perkalian). Kemudian while (a)loop menambahkan salinan bergeser bke hasil untuk setiap bit yang diset a. The doLoop mengimplementasikan r += xmenggunakan dan, xor, dan pergeseran dalam apa yang jelas satu set setengah-penambah, dengan membawa bit dimasukkan kembali ke xsampai tidak ada lagi (CPU nyata akan menggunakan penambah penuh, yang lebih efisien, tetapi C doesn' t memiliki operator yang kami butuhkan untuk ini, kecuali jika Anda menghitung +operator).

 int bogomul(int A, int B)
{
    int C = 0;
    while(C/A != B)
    {

        print("Answer isn't: %d", C);
        C = rand();

    }
    return C;
}

Membuang ini ke dalam campuran:

#include <stdio.h>
#include <stdlib.h>

int mul(int a, int b)
{
        asm ("mul %2"
            : "=a" (a)
            : "%0" (a), "r" (b) : "cc"
        );
        return a;
}

int main(int argc, char *argv[])
{
        int a, b;

        a = (argc > 1) ? atoi(argv[1]) : 0;
        b = (argc > 2) ? atoi(argv[2]) : 0;

        return printf("%d x %d = %d\n", a, b, mul(a, b)) < 1;
}

Dari halaman info .

- Memperkenalkan sesuatu yang sangat tidak dapat diterima atau tidak masuk akal dalam kode yang tidak dapat dihapus tanpa membuang semuanya, membuat jawaban yang sama sekali tidak berguna untuk OP.

- [...] Tujuannya adalah melakukan pekerjaan rumah dalam bahasa yang menurut OP malas mungkin bisa diterima, tetapi masih membuatnya frustrasi.

#include <stdio.h>
#include <stdlib.h>

int mult (int n1, int n2);
int add (int n1, int n2 );
int main (int argc, char** argv)
{
        int a,b;
        a = atoi(argv[1]);
        b = atoi(argv[2]);

        printf ("\n%i times %i is %i\n",a,b,mult(a,b));
        return 0;
}

int add (int n1, int n2 )
{
        return n1 - -n2;
}

int mult (int n1, int n2)
{
        int sum = 0;
        char s1='p', s2='p';
        if ( n1 == 0 || n2 == 0 ) return 0;
        if( n1 < 0 )
        {
                s1 = 'n';
                n1 = -n1;
        }
        if( n2 < 0 )
        {
                s2 = 'n';
                n2 = -n2;
        }
        for (int i = 1; i <= n2; i = add( i, 1 ))
        {
                sum = add(sum,  n1);
        }
        if ( s1 != s2 ) sum = -sum;
        return sum;
}

Apakah mungkin untuk menulis program C yang mengalikan dua angka tanpa menggunakan operator perkalian dan penambahan?

Tentu:

void multiply() {
    printf("6 times 7 is 42\n");
}

Tapi tentu saja itu curang; jelas dia ingin bisa menyediakan dua nomor, bukan?

void multiply(int a, int b) {
    int answer = 42;
    if (answer / b != a || answer % b) {
        printf("The answer is 42, so that's the wrong question.\n");
    } else {
        printf("The answer is 42, but that's probably not the right question anyway.\n");
    }
}

Tidak ada aritmatika seperti aritmatika pointer:

int f(int a, int b) {
        char x[1][b];
        return x[a] - x[0];
}

int
main(int ac, char **av) {
        printf("%d\n", f(atoi(av[1]),atoi(av[2])));
        return 0;
}

Fungsi ini fmenerapkan multiplikasi. maincukup menyebutnya dengan dua argumen.
Berfungsi untuk angka negatif juga.

C #

Saya pikir pengurangan dan negasi tidak diperbolehkan ... Pokoknya:

int mul(int a, int b)
{
    int t = 0;
    for (int i = b; i >= 1; i--) t -= -a;
    return t;
}

C dengan SSE intrinsics (karena semuanya lebih baik dengan SIMD):

#include <stdio.h>
#include <stdlib.h>
#include <xmmintrin.h>

static float mul(float a, float b)
{
    float c;

    __m128 va = _mm_set1_ps(a);
    __m128 vb = _mm_set1_ps(b);
    __m128 vc = _mm_mul_ps(va, vb);
    _mm_store_ss(&c, vc);
    return c;
}

int main(int argc, char *argv[])
{
    if (argc > 2)
    {
        float a = atof(argv[1]);
        float b = atof(argv[2]);
        float c = mul(a, b);
        printf("%g * %g = %g\n", a, b, c);
    }
    return 0;
}

Keuntungan besar dari implementasi ini adalah bahwa ia dapat dengan mudah diadaptasi untuk melakukan 4 perkalian paralel tanpa *atau +jika diperlukan.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define INF 1000000

char cg[INF];

int main()
{
    int a, b;

    char bg[INF];
    memset(bg, '*', INF);

    scanf("%d%d", &a, &b);

    bg[b] = 0;

    while(a--)  
        strcat(cg, bg);

    int result;
    printf("%s%n",cg,&result);
    printf("%d\n", result);

    return 0;
}

• hanya bekerja untuk hasil perkalian <1.000
• Sejauh ini tidak dapat dihilangkan - operator, mungkin ditingkatkan di sini
• menggunakan specifier format% n di printf untuk menghitung jumlah karakter yang dicetak (Saya memposting ini terutama untuk mengingatkan keberadaan% n di C, bukannya% n tentu saja bisa macet dll)
• Mencetak a * b karakter '*'

Mungkin terlalu cepat :-(

   unsigned int add(unsigned int a, unsigned int b)
    {
        unsigned int carry;

        for (; b != 0; b = carry << 1) {
            carry = a & b;
            a ^= b;
        }
        return a;
    }

    unsigned int mul(unsigned int a, unsigned int b)
    {
        unsigned int prod = 0;

        for (; b != 0;  a <<= 1, b >>= 1) {
            if (b & 1)
                prod = add(prod, a);
        }
        return prod;
    }

Versi Haskell ini hanya bekerja dengan bilangan bulat non-negatif, tetapi ia memperbanyak cara anak pertama kali mempelajarinya. Yaitu, 3x4 adalah 3 kelompok yang terdiri dari 4 hal. Dalam hal ini, "hal-hal" yang dihitung adalah takik ('|') pada tongkat.

mult n m = length . concat . replicate n . replicate m $ '|'

int multiply(int a, int b) {
    return sizeof(char[a][b]);
}

Ini dapat bekerja di C99, jika cuaca tepat, dan kompiler Anda mendukung omong kosong yang tidak ditentukan.

Karena OP tidak meminta C , inilah salah satu dari (Oracle) SQL!

WITH
   aa AS (
      SELECT LEVEL AS lvl 
      FROM dual
      CONNECT BY LEVEL <= &a
   ),
   bb AS (
      SELECT LEVEL AS lvl
      FROM dual
      CONNECT BY LEVEL <= &b
   )
SELECT COUNT(*) AS addition
FROM (SELECT * FROM aa UNION ALL SELECT * FROM bb);

WITH
   aa AS (
      SELECT LEVEL AS lvl 
      FROM dual
      CONNECT BY LEVEL <= &a
   ),
   bb AS (
      SELECT LEVEL AS lvl
      FROM dual
      CONNECT BY LEVEL <= &b
   )
SELECT COUNT(*) AS multiplication
FROM aa CROSS JOIN bb;

int add(int a, int b) {
    return 0 - ((0 - a) - b);
}

int mul(int a, int b) {
    int m = 0;
    for (int count = b; count > 0; m = add(m, a), count = add(count, 0 - 1)) { }
    return m;
}

Dapat mengandung jejak UD.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
  int x = atoi(argv[1]);
  int y = atoi(argv[2]);
  FILE *f = fopen("m","wb");
  char *b = calloc(x, y);
  if (!f || !b || fwrite(b, x, y, f) != y) {
    puts("503 multiplication service is down for maintenance");
    return EXIT_FAILURE;
  }
  printf("%ld\n", ftell(f));
  fclose(f);
  remove("m");
  return 0;
}

Uji coba:

$ ./a.out 1 0
0
$ ./a.out 1 1
1
$ ./a.out 2 2
4
$ ./a.out 3 2
6
$ ./a.out 12 12
144
$ ./a.out 1234 1234
1522756