เป็นไปได้ไหมที่จะเขียนโปรแกรม C ที่คูณสองตัวเลขโดยไม่ต้องใช้ตัวคูณและตัวดำเนินการเพิ่มเติม?

ฉันพบนี้ในกองมากเกิน โปรดช่วยโปรแกรมเมอร์ผู้น่าสงสารคนนี้ด้วยปัญหาของเขา และโปรดอย่าให้คำตอบเหมือนซึ่งเป็นเหมือนกับc = a/(1/((float)b)) c = a*b(และได้รับคำตอบแล้ว)

คำตอบที่มีผู้โหวตสูงสุดในวันที่ 19 มกราคม 2014 เป็นผู้ชนะ

^{หมายเหตุ: นี่เป็นคำถามการหมุนรหัส กรุณาอย่าใช้คำถามและ / หรือคำตอบอย่างจริงจัง ข้อมูลเพิ่มเติมในรหัสหลอก}

ใช้การสอบถามซ้ำทุกครั้ง

Recusion เป็นวิธีที่ถูกต้อง!

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

คุณจะต้องรวบรวมโปรแกรมในแต่ละครั้ง แต่มันจะทำการคูณจำนวนเต็มบวกใด ๆ ใน C หรือ C ++ ทุกรุ่น

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

 typedef char buffer[A][B];

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

หากคุณไม่เป็นที่พอใจเล็กน้อยคุณสามารถใช้วิธี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));
}

ตัวอย่าง:

$ ./mul 300 250
300 * 250 = 74954

ฉันเดาว่านี่อาจจะดีพอ)

เนื่องจากคุณไม่ได้ระบุขนาดของตัวเลขฉันจึงคิดว่าคุณหมายถึงตัวเลขหนึ่งบิตสองตัว

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

หากคุณต้องการการใช้งานที่มีประสิทธิภาพสูงสุดให้ใช้การดำเนินการเล็ก ๆ ต่อไปนี้:

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

โปรดทราบว่ามันยังคงยอมรับบิตเพียงอย่างเดียวแม้ว่าชนิดนั้นจะเป็น ints โดยนัย - ใช้รหัสน้อยลงและดังนั้นจึงมีประสิทธิภาพมากขึ้น (และใช่มันรวบรวม)

นี่คือเชลล์สคริปต์แบบง่ายๆที่จะทำ:

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 ]*$"

UPDATE: แน่นอนที่จะทำมันใน C exec("bash", "-c", ...)เพียงห่อไว้ใน (ขอบคุณ AmeliaBR)

ทำไมเราลองทำการค้นหาแบบแบ่งครึ่งระหว่าง INT64_MIN และ 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));
}

ป.ล. มันจะมีความสุขกับ sigsegv ด้วยค่าบางอย่าง ;)

น่าเสียดายนี่ใช้ได้กับเลขจำนวนเต็มเท่านั้น

เนื่องจากไม่ได้รับอนุญาตนอกจากนี้ให้สร้างโอเปอเรเตอร์ที่เพิ่มขึ้นก่อน:

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

ต่อไปเราต้องจัดการกับสัญญาณ ก่อนอื่นให้หาเครื่องหมายบิต:

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

จากนั้นนำสัญลักษณ์และขนาดของแต่ละข้อโต้แย้ง ในการลบล้างจำนวนในส่วนเติมเต็มของสองให้กลับด้านบิตทั้งหมดและเพิ่ม

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

ในการคูณจำนวนเต็มบวกสองตัวเราสามารถใช้ความหมายทางเรขาคณิตของการคูณ:

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

โทรลล์:

• ไม่ได้รับอนุญาตนอกจากนี้ แต่a++จริงๆแล้วนับรวมเป็นอะไรเพิ่มเติม ฉันพนันว่าครูตั้งใจจะอนุญาต
• พึ่งพาส่วนประกอบสองอย่าง แต่นั่นเป็นพฤติกรรมที่กำหนดโดยการนำไปปฏิบัติและแพลตฟอร์มเป้าหมายไม่ได้ระบุไว้
• ในทำนองเดียวกันสมมติว่าการลบและการหารจะไม่ได้รับอนุญาตเช่นกัน
• << เป็นการคูณด้วยกำลังสองดังนั้นในทางเทคนิคควรไม่อนุญาต
• แผนภาพที่ไม่จำเป็นเป็นสิ่งที่ไม่จำเป็น นอกจากนี้มันอาจถูกย้ายเพื่อบันทึกหนึ่งบรรทัด
• การขยับซ้ำของ-1ไม่ใช่วิธีที่ดีที่สุดในการค้นหาบิต แม้ว่าจะไม่มีค่าคงที่ในตัวคุณก็สามารถทำการเลื่อนตรรกะทางขวาของ -1 จากนั้นสลับบิตทั้งหมด
• XOR -1 ไม่ใช่วิธีที่ดีที่สุดในการสลับบิตทั้งหมด
• ปริศนาทั้งหมดที่มีการแสดงสัญลักษณ์ขนาดไม่จำเป็น เพียงส่งไปยังเลขคณิตที่ไม่ได้ลงชื่อและโมดูลาร์แบบแยกส่วนจะทำส่วนที่เหลือ
• เนื่องจากค่าสัมบูรณ์ของMIN_INT(AKA signBit) เป็นลบการแบ่งนี้สำหรับค่านั้น โชคดีที่มันยังใช้งานได้ในครึ่งกรณีเพราะMIN_INT * [even number] ควรเป็นศูนย์นอกจากนี้ยังplusOneแบ่งสำหรับ-1ทำให้ลูปไม่มีที่สิ้นสุดทุกเวลาล้นผล plusOneทำงานได้ดีสำหรับค่าใด ๆ ขอโทษสำหรับความสับสน.

ใช้งานได้กับตัวเลขทศนิยมเช่นกัน:

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

ทุกคนรู้ว่า Python ใช้งานง่ายกว่า C และ Python มีฟังก์ชั่นที่สอดคล้องกับตัวดำเนินการทุกตัวในกรณีที่คุณไม่สามารถใช้ตัวดำเนินการได้ คำจำกัดความปัญหาของเราตรงไหน ดังนั้น:

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

ไม่มีคำตอบอื่นใดที่เป็นไปได้ในทางทฤษฎี ในฐานะที่เป็นความคิดเห็นแรกในคำถามพูดว่า:

โปรดเจาะจงมากขึ้นเกี่ยวกับ "หมายเลข"

เราจำเป็นต้องนิยามการคูณและตัวเลขก่อนที่จะตอบได้ เมื่อเราทำแล้วปัญหาจะกลายเป็นเรื่องเล็กน้อย

วิธีที่นิยมมากที่สุดในการทำเช่นนี้ในการเริ่มต้นตรรกะทางคณิตศาสตร์คือการสร้างเลข von Neumann ด้านบนของทฤษฎีเซต ZFและจากนั้นใช้หลักการอาโน่

สิ่งนี้แปลโดยธรรมชาติเป็น C โดยสมมติว่าคุณมีประเภทชุดที่สามารถมีชุดอื่นได้ มันไม่จำเป็นต้องมีอะไรเลยนอกจากเซตซึ่งทำให้มันไม่สำคัญ (ไม่มีvoid*เรื่องไร้สาระในการตั้งค่าไลบรารี่ส่วนใหญ่) ดังนั้นฉันจะปล่อยให้การนำไปใช้เป็นแบบฝึกหัดสำหรับผู้อ่าน

ดังนั้นก่อนอื่น:

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

หากคุณต้องการขยายจำนวนเต็ม rationals reals surreals และอื่น ๆ คุณสามารถ - ด้วยความแม่นยำที่ไม่มีที่สิ้นสุด (สมมติว่าคุณมีหน่วยความจำและ CPU ที่ไม่มีที่สิ้นสุด) แต่ดังที่ Kroenecker พูดอย่างมีชื่อเสียงพระเจ้าทรงสร้างตัวเลขตามธรรมชาติ ทั้งหมดเป็นงานของมนุษย์จริง ๆ แล้วทำไมต้องรำคาญ?

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

หากคุณคิดว่าการแฮ็ค [b] นั้นเป็นการโกง (เนื่องจากเป็นการเพิ่ม) การทำงานนี้แทน แต่การค้นหาตารางเกี่ยวข้องกับตัวชี้เพิ่มเช่นกัน

ดูhttp://en.wikipedia.org/wiki/IBM_1620 - conputer ที่เพิ่มตารางการค้นหาได้จริง ...

มีบางอย่างที่น่าพอใจเกี่ยวกับการใช้กลไกตารางเพื่อ 'เร่งความเร็ว' การดำเนินการที่สามารถทำได้จริงในคำสั่งเดียว

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

ฉันไม่แน่ใจว่าสิ่งใดที่ถือเป็นการ "โกง" ในโพสต์ "code troll" เหล่านี้ แต่นี่จะคูณจำนวนเต็ม 2 จำนวน ณ เวลารันไทม์โดยที่ไม่มี*หรือ+ตัวดำเนินการที่ใช้ไลบรารีมาตรฐาน (C99)

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

โซลูชันโทรลล์ของฉันสำหรับ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;
}

มีคำตอบที่ดีมากมายที่นี่ แต่ดูเหมือนว่าพวกเขาส่วนใหญ่จะใช้ประโยชน์จากความจริงที่ว่าคอมพิวเตอร์สมัยใหม่นั้นทรงพลังจริงๆ ซีพียูส่วนใหญ่มีหน่วยประมวลผลหลายหน่วยดังนั้นทำไมต้องใช้หน่วยประมวลผลเดียว? เราสามารถใช้ประโยชน์จากสิ่งนี้เพื่อให้ได้ผลลัพธ์ที่ยอดเยี่ยม

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

นี่คือตัวอย่างของการใช้งาน:

$ ./multiply
5 6
5 x 6 = 30

#pragma omp parallelสั่งทำให้ OpenMP แบ่งส่วนหนึ่งของแต่ละวงไปยังหน่วยการดำเนินการที่แตกต่างกันดังนั้นเราคูณในแบบคู่ขนาน!

โปรดทราบว่าคุณต้องใช้การ-fopenmpตั้งค่าสถานะเพื่อบอกให้คอมไพเลอร์ใช้ OpenMP

ชิ้นส่วนหมุนรอบ:

1. ทำให้เข้าใจผิดเกี่ยวกับการใช้การเขียนโปรแกรมแบบขนาน
2. ไม่ทำงานกับจำนวนลบ (หรือใหญ่)
3. ไม่ได้แบ่งส่วนของforลูปจริง ๆ- แต่ละเธรดจะรันลูป
4. ชื่อตัวแปรที่น่ารำคาญและการใช้ซ้ำตัวแปร
5. มีสภาพการแข่งขันที่บอบบางในanswer--; ส่วนใหญ่แล้วจะไม่ปรากฏ แต่บางครั้งอาจทำให้เกิดผลลัพธ์ที่ไม่ถูกต้อง

น่าเสียดายที่การคูณเป็นปัญหาที่ยากมากในวิทยาการคอมพิวเตอร์ ทางออกที่ดีที่สุดคือใช้การหารแทน:

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

ในชีวิตจริงฉันมักจะตอบโต้การหมุนรอบด้วยความรู้ดังนั้นนี่คือคำตอบที่ไม่หมุนรอบเลย มันใช้ได้กับทุกintค่าเท่าที่ฉันเห็น

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

นี่คือความเข้าใจที่ดีที่สุดของฉันเหมือนกับว่า CPU อาจทำการคูณจำนวนเต็มจริง ๆ อันดับแรกเราตรวจสอบให้แน่ใจว่าอย่างน้อยหนึ่งข้อโต้แย้ง ( a) เป็นค่าบวกโดยการพลิกเครื่องหมายทั้งคู่ถ้าaเป็นลบ (และไม่ฉันปฏิเสธที่จะนับการปฏิเสธว่าเป็นการบวกหรือการคูณ) จากนั้นwhile (a)วงเพิ่มสำเนาขยับตัวของผลการสำหรับทุกบิตตั้งอยู่ในb aการdoวนซ้ำนั้นr += xใช้และ, xor, และขยับในสิ่งที่เห็นได้ชัดว่าเป็นชุดของโปรแกรมเสริมครึ่งหนึ่งโดยมีบิตพกพาที่ป้อนกลับเข้าไปxจนกระทั่งไม่มีอีกต่อไป (CPU จริงจะใช้โปรแกรมเสริมเต็มซึ่งมีประสิทธิภาพมากขึ้น ไม่มีโอเปอเรเตอร์ที่เราต้องการสำหรับสิ่งนี้เว้นแต่คุณจะนับ+โอเปอเรเตอร์)

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

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

    }
    return C;
}

โยนสิ่งนี้ลงในส่วนผสม:

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

จากหน้าข้อมูล

- แนะนำสิ่งที่ไม่สามารถยอมรับได้หรือไม่มีเหตุผลอย่างมากในรหัสที่ไม่สามารถลบออกได้โดยไม่ทิ้งทุกอย่างออกไป

- […] ความตั้งใจคือทำการบ้านในภาษาที่ OP ขี้เกียจอาจคิดว่ายอมรับได้ แต่ก็ยังทำให้เขาหงุดหงิด

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

เป็นไปได้ไหมที่จะเขียนโปรแกรม C ที่คูณสองตัวเลขโดยไม่ต้องใช้ตัวคูณและตัวดำเนินการเพิ่มเติม?

แน่นอนว่า:

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

แต่แน่นอนว่าเป็นการโกง เห็นได้ชัดว่าเขาต้องการที่จะสามารถ _supply) ตัวเลขสองตัวใช่มั้ย

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

ไม่มีเลขคณิตเหมือนตัวชี้เลขคณิต:

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

ฟังก์ชันfใช้การคูณ mainเพียงแค่เรียกมันว่ามีสองข้อโต้แย้ง
ทำงานสำหรับตัวเลขลบเช่นกัน

C #

ฉันคิดว่าไม่อนุญาตให้ใช้การลบและการปฏิเสธ ... อย่างไรก็ตาม:

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

C พร้อม SSE อินทรินซิลส์ (เพราะทุกอย่างดีขึ้นด้วย 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;
}

ข้อได้เปรียบที่ยิ่งใหญ่ของการใช้งานนี้คือมันสามารถปรับได้อย่างง่ายดายเพื่อดำเนินการคูณ 4 ขนานโดยไม่ต้อง*หรือ+ถ้าจำเป็น

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

• ทำงานเพื่อผลคูณเท่านั้น <1 000 000
• จนถึงตอนนี้ไม่สามารถกำจัดตัวดำเนินการ - อาจปรับปรุงที่นี่
• ใช้ตัวระบุรูปแบบ% n ใน printf เพื่อนับจำนวนตัวอักษรที่พิมพ์ (ฉันโพสต์สิ่งนี้เพื่อเตือนว่ามีอยู่% n ใน C แทนที่จะเป็น% n อาจเป็น strlen เป็นต้น)
• พิมพ์อักขระ * b ของ '*'

อาจเร็วเกินไป :-(

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

รุ่น Haskell นี้ใช้งานได้เฉพาะกับจำนวนเต็มไม่ใช่ค่าลบ แต่มันจะทำการคูณวิธีที่เด็กเรียนรู้ครั้งแรก คือ 3x4 คือ 3 กลุ่มจาก 4 สิ่ง ในกรณีนี้ "สิ่ง" ที่ถูกนับนั้นมีรอยหยัก ('|') ติดอยู่

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

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

สิ่งนี้อาจใช้งานได้ใน C99 หากสภาพอากาศถูกต้องและคอมไพเลอร์ของคุณรองรับข้อมูลไร้สาระที่ไม่ได้กำหนด

เนื่องจากOP ไม่ได้ถาม Cนี่คือหนึ่งใน (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;
}

อาจมีร่องรอยของ 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;
}

ทดสอบการทำงาน:

$ ./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