Est-il possible d'écrire un programme en langage C qui multiplie deux nombres sans utiliser les opérateurs de multiplication et d'addition?

J'ai trouvé ceci sur Stack Overflow . S'il vous plaît aider ce pauvre programmeur avec son problème. Et s'il vous plaît ne donnez pas de réponses comme c = a/(1/((float)b)), ce qui est exactement la même chose que c = a*b. (Et est déjà donné comme réponse.)

La réponse avec le plus de votes positifs le 19 janvier 2014 est la victoire.

^{Remarque: il s'agit d'une question à la traîne de code . S'il vous plaît ne prenez pas la question et / ou les réponses au sérieux. Plus d'informations sont en code-trolling .}

Toujours utiliser la récursivité

La recusion est la bonne façon!

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

Vous devrez compiler le programme à chaque fois, mais il multiplie tous les entiers positifs exactement dans toutes les versions de C ou C ++.

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

 typedef char buffer[A][B];

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

Si vous êtes OK avec un peu d'imprécision, vous pouvez utiliser la méthode de 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));
}

Exemple:

$ ./mul 300 250
300 * 250 = 74954

Je suppose que cela pourrait suffire;)

Puisque vous n'avez pas précisé la taille du nombre, je suppose que vous voulez dire deux nombres d'un bit.

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

Si vous souhaitez une implémentation extrêmement efficace, utilisez la minuscule implémentation suivante:

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

Notez qu'il n'accepte toujours que les bits, même si les types sont des enttes implicites - il prend moins de code et est donc plus efficace. (Et oui, ça compile.)

Voici un script shell simple pour le faire:

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: Bien sûr, pour le faire en C, emballez-le simplement exec("bash", "-c", ...). (Merci, AmeliaBR)

Pourquoi, effectuons une recherche récursive en divisant par deux entre INT64_MIN et 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));
}

Post-scriptum Il va sigsegv heureusement avec certaines valeurs. ;)

Malheureusement, cela ne fonctionne que pour les entiers.

Puisque l'addition est interdite, construisons d'abord un opérateur d'incrémentation:

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

Ensuite, nous devons gérer le signe. D'abord, trouvez le bit de signe:

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

Ensuite, prenez le signe et la magnitude de chaque argument. Pour annuler un nombre dans un complément à deux, inversez tous les bits et ajoutez un.

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

Pour multiplier deux entiers positifs, nous pouvons utiliser la signification géométrique de multiplication:

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

trolls:

• L'addition est interdite, mais compte-t-elle a++vraiment comme une addition? Je parie que le professeur avait l'intention de le permettre.
• S'appuie sur le complément à deux, mais il s'agit d'un comportement défini par la mise en œuvre et la plate-forme cible n'a pas été spécifiée.
• De même, on suppose que la soustraction et la division ne sont pas autorisées non plus.
• << est en fait la multiplication par une puissance de deux, il devrait donc être techniquement interdit.
• diagramme non nécessaire est inutile. En outre, il aurait pu être transposé pour enregistrer une ligne.
• le décalage répété de -1n'est pas la meilleure façon de trouver le bit de signe. Même s'il n'y avait pas de constante intégrée, vous pourriez effectuer un décalage logique à droite de -1, puis inverser tous les bits.
• XOR -1 n'est pas le meilleur moyen d'inverser tous les bits.
• Toute la charade avec une représentation de la grandeur du signe est inutile. Il suffit de choisir un calcul arithmétique modulaire et non signé pour le reste.
• puisque la valeur absolue de MIN_INT(AKA signBit) est négative, cela se brise pour cette valeur. Heureusement, cela fonctionne toujours dans la moitié des cas, car MIN_INT * [even number] devrait être nul.En outre, plusOnerompt pour -1, provoquant des boucles infinies chaque fois que le résultat déborde. plusOnefonctionne très bien pour n'importe quelle valeur. Désolé pour la confusion.

Fonctionne également pour les nombres à virgule flottante:

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

Tout le monde sait que Python est plus facile à utiliser que C. Et Python a des fonctions correspondant à chaque opérateur, dans les cas où vous ne pouvez pas utiliser l'opérateur. Quelle est exactement notre définition du problème, non? Alors:

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

Aucune des autres réponses n'est théoriquement valable. Comme le dit le tout premier commentaire sur la question:

S'il vous plaît être plus précis sur les "numéros"

Nous devons définir la multiplication et les nombres avant même de pouvoir obtenir une réponse. Une fois que nous le faisons, le problème devient trivial.

Le moyen le plus populaire de faire cela en commençant la logique mathématique consiste à construire des ordinaux de von Neumann sur la théorie des ensembles ZF , puis à utiliser les axiomes de Peano .

Cela se traduit naturellement en C, en supposant que vous ayez un type de jeu pouvant contenir d'autres jeux. Il ne doit pas contenir quoi que ce soit , mais des ensembles, ce qui le rend trivial (aucun de cette coulée void*non - sens dans la plupart des bibliothèques set), donc je vais laisser la mise en œuvre comme un exercice pour le lecteur.

Alors, d'abord:

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

Si vous souhaitez étendre cela aux entiers, aux rationnels, aux réels, aux surréels, etc., vous pouvez — avec une précision infinie (en supposant que vous avez une mémoire infinie et un processeur), de démarrer. Mais comme Kroenecker l'a dit, Dieu a créé les nombres naturels; tout le reste est le travail de l'homme, alors vraiment, pourquoi s'embêter?

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

Si vous considérez que le hack a [b] est une triche (puisqu'il s'agit vraiment d'un ajout), cela fonctionne à la place. Mais les recherches dans les tables impliquent également un ajout de pointeur.

Voir http://en.wikipedia.org/wiki/IBM_1620 - un ordinateur qui a effectivement ajouté des données à l'aide de tables de recherche ...

Quelque chose de satisfaisant à propos de l'utilisation d'un mécanisme de table pour «accélérer» une opération qui pourrait réellement être effectuée en une seule instruction.

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

Je ne suis pas sûr de ce qui constitue une "triche" dans ces publications "code troll", mais cela multiplie 2 entiers arbitraires, au moment de l'exécution, sans opérateur *ou +utilisant des bibliothèques standard (C99).

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

Ma solution troll pour 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;
}

Il y a beaucoup de bonnes réponses ici, mais il ne semble pas que beaucoup d'entre elles tirent parti du fait que les ordinateurs modernes sont vraiment puissants. Il existe plusieurs unités de traitement dans la plupart des processeurs, alors pourquoi en utiliser une seule? Nous pouvons exploiter cela pour obtenir d'excellents résultats.

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

Voici un exemple de son utilisation:

$ ./multiply
5 6
5 x 6 = 30

La #pragma omp paralleldirective oblige OpenMP à diviser chaque partie de la boucle for en une unité d'exécution différente, nous nous multiplions donc en parallèle!

Notez que vous devez utiliser l' -fopenmpindicateur pour indiquer au compilateur d'utiliser OpenMP.

Troll parties:

1. Tromper sur l'utilisation de la programmation parallèle.
2. Ne fonctionne pas sur les nombres négatifs (ou grands).
3. Ne divise pas réellement les parties de la forboucle - chaque thread exécute la boucle.
4. Noms de variables ennuyeux et réutilisation de variables.
5. Il y a une condition de course subtile answer--; la plupart du temps, il n'apparaîtra pas, mais occasionnellement, il provoquera des résultats inexacts.

Malheureusement, la multiplication est un problème très difficile en informatique. La meilleure solution consiste à utiliser la division à la place:

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

Dans la vraie vie, je réponds habituellement à la traîne par la connaissance, alors voici une réponse qui ne traine pas du tout. Cela fonctionne pour toutes les intvaleurs dans la mesure où je peux voir.

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

À ma connaissance, cela ressemble beaucoup à la façon dont un processeur peut en fait multiplier des nombres entiers. Premièrement, nous nous assurons qu'au moins un des arguments ( a) soit positif en retournant le signe si aest négatif (et non, je refuse de compter la négation comme une sorte d'addition ou de multiplication). Ensuite, la while (a)boucle ajoute une copie décalée de bau résultat pour chaque bit défini dans a. La doboucle implémente l' r += xutilisation de et, xor et transforme ce qui est clairement un ensemble de demi-additionneurs, avec les bits de report renvoyés xjusqu'à ce qu'il n'y en ait plus (un processeur réel utiliserait des additionneurs complets, ce qui est plus efficace, mais C t ont les opérateurs dont nous avons besoin pour cela, à moins que vous ne les comptiez +).

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

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

    }
    return C;
}

Jeter ceci dans le mélange:

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

De la page d'information .

- Introduire dans le code quelque chose d'extrêmement inacceptable ou déraisonnable qui ne peut pas être supprimé sans tout jeter, ce qui rend la réponse totalement inutile pour le PO.

- […] L'intention est de faire les devoirs dans une langue que le PO paresseux pourrait juger acceptable, mais qui le frustre encore.

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

Est-il possible d'écrire un programme en langage C qui multiplie deux nombres sans utiliser les opérateurs de multiplication et d'addition?

Sûr:

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

Mais bien sûr, c'est de la triche. il veut évidemment pouvoir _soumettre) deux nombres, non?

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

Il n'y a pas d'arithmétique comme l'arithmétique de pointeur:

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

La fonction fimplémente la multiplication. mainl'appelle simplement avec deux arguments.
Fonctionne aussi pour les nombres négatifs.

C #

Je pense que la soustraction et la négation ne sont pas autorisées ... Quoi qu'il en soit:

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

C avec SSE intrinsics (car tout va mieux avec 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;
}

Le gros avantage de cette implémentation est qu’elle peut être facilement adaptée pour effectuer 4 multiplications parallèles sans *ou +si nécessaire.

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

• ne fonctionne que pour un résultat de multiplication <1 000 000
• Jusqu'à présent, ne peut pas se débarrasser de - opérateur, éventuellement améliorer ici
• utiliser le spécificateur de format% n dans printf pour compter le nombre de caractères imprimés (je le poste principalement pour rappeler l'existence de% n en C, au lieu de% n pourrait bien sûr être strlen, etc.)
• Imprime les caractères a * b de '*'

Probablement trop vite :-(

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

Cette version de Haskell ne fonctionne qu'avec des entiers non négatifs, mais elle multiplie de la manière dont les enfants l’apprennent pour la première fois. Par exemple, 3x4 est 3 groupes de 4 choses. Dans ce cas, les "choses" prises en compte sont des entailles ('|') sur un bâton.

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

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

Cela peut fonctionner en C99, si le temps le permet, et si votre compilateur prend en charge les absurdités non définies.

Puisque le PO n'a pas demandé le C , en voici un en SQL (Oracle)!

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

Peut contenir des traces d'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;
}

Essai:

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