* এবং + অপারেটর ব্যবহার না করে গুণনের জন্য সি প্রোগ্রাম কীভাবে লিখবেন?

68

গুণগতকরণ এবং সংযোজন অপারেটরগুলি ব্যবহার না করেই কোনও সি প্রোগ্রাম লিখতে সম্ভব যা দুটি সংখ্যাকে গুণ করে?

আমি এটি স্ট্যাক ওভারফ্লোতে পেয়েছি । দয়া করে এই দরিদ্র প্রোগ্রামারকে তার সমস্যাটিতে সহায়তা করুন। এবং দয়া করে উত্তরগুলি দেবেন না c = a/(1/((float)b)), যা ঠিক একই রকম c = a*b। (এবং ইতিমধ্যে একটি উত্তর হিসাবে দেওয়া হয়েছে।)

19 শে জানুয়ারী 2014-এ সর্বাধিক প্রচারিত উত্তর জিতেছে।

দ্রষ্টব্য: এটি একটি কোড-ট্রোলিং প্রশ্ন। দয়া করে প্রশ্ন এবং / অথবা উত্তরগুলি গুরুত্ব সহকারে নেবেন না। আরও তথ্য কোড ট্রোলিং হয় ।

popularity-contest  code-trolling 
— s3lph
সূত্র
2
@ পলআর আপনার ফ্যান্টাসি ব্যবহার করুন
— জন ডিভোরাক
26
কোড-গল্ফ.এসই আপনার স্ট্যাক ওভারফ্লোতে যে প্রশ্নগুলি দেখেছেন তা ঠকানোর জন্য জায়গা হওয়া উচিত নয়।
— গ্যারেথ
17
@ গ্যারেথ, আপনি কি নিশ্চিত? এর প্রথম লাইনটি এটি বেশ উপযুক্ত হতে পারে।
— ড্যারেন স্টোন
5
আমি অপেক্ষা করছি কেউ ঘুমের উপর ভিত্তি করে একটি অ্যালগরিদম লেখার জন্য অপেক্ষা করছে
— কেবি_সু
21
এই প্রশ্নটি যেমন শোনাচ্ছে তত হাস্যকর নয়। প্রকৃত কম্পিউটার হার্ডওয়্যার (ট্রানজিস্টর) এর গুণক এবং সংযোজন অপারেশন নেই - তাদের মধ্যে নন, এবং, বা, এক্সওর এর মতো প্রাথমিক লজিক অপারেশন রয়েছে। এই প্রশ্নের উত্তর কীভাবে দেবেন তা নির্ধারণ করা আপনাকে কম্পিউটার কীভাবে যুক্তি গেটগুলির স্তরে কাজ করে তা সম্পর্কে দুর্দান্ত অন্তর্দৃষ্টি দিতে পারে।
— গাবে

উত্তর:

147

সর্বদা পুনরাবৃত্তি ব্যবহার করুন

রিক্রুশন সঠিক উপায়!

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));
}
— Oberon
সূত্র
8
আমি পারলে +3 দিতাম: চূড়ান্ত পুনরাবৃত্তির জন্য একটি, প্রথম ??::বন্ধনী ছাড়া একটি, নিয়মগুলিকে টুইঙ্ক করার চেষ্টা না করেই সমস্যা সমাধানের জন্য;)
— yo '
10
পিকাসো যদি প্রোগ্রামার
— আর হিউজেস
4
@SargeBorsch কিন্তু মজা কোথায় পেলেন হতে যে ?
— ওবেরন
3
@ এইচসি_এর incফাংশনটি সর্বনিম্ন বিটটি রয়েছে কিনা তা দেখার জন্য তার যুক্তিটি পরীক্ষা করে 1; যদি তাই হয়, এটি নিজে যুক্তির অবশিষ্ট উপরের বিট আহ্বান এবং একই কম বিট যে সেট হওয়া চেক করা ছিল ফলাফলের ফেরৎ 0, যখন যদি না (অর্থাত সর্বনিম্ন বিট 0), এটা যে প্রতিস্থাপন 0একটি সঙ্গে 1এবং ফলাফল ফেরৎ । প্রক্রিয়াটি আপনি যা করতে চান তার সাথে খুব মিল যদি আপনি হাত দিয়ে মানগুলি বাইনারি অঙ্কের সাথে বাইনারি অঙ্ক যুক্ত করে থাকেন were
— জ্যাব
2
ইনক্রিমেন্ট ফাংশন -1 এর জন্য কি অসীম লুপে যায় না? (0xFFFF) আইডিয়োন শো (-1 >> 1) == -1।
— ডেস্ট্রাক্টর
87

আপনাকে প্রতিটি সময় প্রোগ্রামটি সংকলন করতে হবে, তবে এটি সি বা সি ++ এর যে কোনও সংস্করণে ঠিক কোনও ধনাত্মক পূর্ণসংখ্যার গুণকে করতে পারে।

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

 typedef char buffer[A][B];

 main() {
    printf("%d\n",sizeof(buffer));
 }
— লাকাটা চিহ্নিত করুন
সূত্র
4
এটিকে কোনও কাঠামোর ভিতরে রাখুন এবং আপনার স্মৃতির প্রয়োজন নেই।
— বেন জ্যাকসন
4
হাহাহাহাহা দুর্দান্ত !!
— অলমো
1
"%zu"বিন্যাস স্ট্রিং ব্যবহার করুন ।
— গ্রিজেশ চৌহান
5
কেবলমাত্র sizeof(char[A][B])কাজ করবে (A <= 0 বা B <= 0 বা A * B ওভারফ্লো না হওয়া
— সেক্ষেত্রে আপনার
3
@ ডেভিডরিচার্বি - আমি কোডটি সহজ করে তুলতে main(){return sizeof(char[A][B]);}এবং আপনি ব্যবহার করে সংকলন করতে পারেনcc -DA=6 -DB=7 a.c; ./a.out; echo $?
— মার্ক Lakata
47

আপনি যদি কিছুটা অসম্পূর্ণতার সাথে ঠিক থাকেন তবে আপনি মন্টি কার্লো পদ্ধতিটি ব্যবহার করতে পারেন :

#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

আমার ধারণা এটি যথেষ্ট ভাল হতে পারে;)

— পেটর পুডলক
সূত্র
3
আপনার আমার ভোট আছে। শুনেছি মন্টে কার্লো হ'ল নাসা তার পাটিগণিতের জন্য যা ব্যবহার করে। তবে আমি ++অপারেটরের দুটি উদাহরণ ছাড়াই এটি দেখতে চাই ।
— ড্যারেন স্টোন
1
@ ড্যারেনস্টোন-= -1
— টিমটেক
20
@ টিমটেক |= 1(50% সংখ্যার উপর কাজ করবে, সময়ের 100%)
— ড্যারেন স্টোন
2
+1, তবে লক্ষ্য করা যায় যে এটি খুব ধীর হতে পারে, এবং আপনি মাল্টি-থ্রেড সমর্থন যুক্ত করতে পারেন, সাবধানতার সাথে 'গণনা ++' :
— লক করা
1
সবসময় এর printf: বাড়ায় printf("%*cc%n\n", count, &count, 'c');(ছাপে 'গ' গণনা বার, তারপর অন্য 'গ', এবং সঞ্চয় করে ফিরে লিখিত অক্ষরের সংখ্যা count।
— MSalters
45

যেহেতু আপনি কোন সংখ্যার আকার নির্দিষ্ট করেন নি, আমি ধরে নিলাম যে আপনি দুটি এক-বিট সংখ্যা বোঝাচ্ছেন।

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

আপনি যদি সর্বাধিক দক্ষ দক্ষতা প্রয়োগ করতে চান তবে নীচের ছোট বাস্তবায়নটি ব্যবহার করুন:

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

নোট করুন যে এটি এখনও বিটগুলি গ্রহণ করে যদিও প্রকারগুলি অন্তর্নিহিত ইনটগুলি হয় - এটি কম কোড নেয় এবং তাই আরও কার্যকর। (এবং হ্যাঁ, এটি সংকলন করে))

— সেল স্কেগস
সূত্র
8
খুশী হলাম। প্রশ্নের ইচ্ছাকৃত ভুল ব্যাখ্যা :-)
— জন ডভোরাক
6
আপনি এটি অনুকূলিত করতে পারেন return a && b;। এটি খাটো, তাই এটি দ্রুত।
— রাই-
1
@ এমনিটেক: কোডটি কিছুটা খারাপ করার জন্য আমি এর বিরুদ্ধে সিদ্ধান্ত নিয়েছি। আমি যদি এটির সাথে আরও যেতে চাই, আমি এটি তৈরি করব return a&b;।
— সেল স্কেজেস
1
সি #include<stdbool.h>সংজ্ঞায়িত করতে হয় trueএবং false।
— লিউজ
1
হ্যাঁ, #include<stdbool.h>মাত্র তিন মনে করা হয় #define(গুলি যে আপনি নিজেকে কি করতে পারেন true, false, bool, এবং একটি পতাকা চিহ্নিত করতে এটি সক্রিয় করা হয়েছে সেগুলিও)। আপনি অন্য উত্তরগুলির মধ্যে একটি থেকে একটি কৌশলও নিতে পারেন এবং int"সংক্ষিপ্ত" সংস্করণের জন্য অন্তর্নিহিত ব্যবহার করতে পারেন ।
— লিউজ
31

এটি করার জন্য এখানে একটি সাধারণ শেল স্ক্রিপ্ট রয়েছে:

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

আপডেট: অবশ্যই এটি সিতে করার জন্য, কেবল এটি মুড়ে দিন exec("bash", "-c", ...)। (ধন্যবাদ, আমেলিয়াবিআর)

— Vroo
সূত্র
41
কোনটি ভয়াবহ তা আমি সিদ্ধান্ত নিতে পারি না। আপনি নিজের গণনাটিকে অনুসন্ধান ইঞ্জিনে আউটসোর্সিং করছেন বা আপনার নির্বাচিত অনুসন্ধান ইঞ্জিনটি বিং। দুর্ভাগ্যক্রমে, আমি মনে করি না যে এটি আমাদের সুখী ওপি'র পক্ষে কাজ করবে, যার সিতে কিছু দরকার ছিল
— এমেলিয়াবিআর
5
এই নজরদারি ধরার জন্য ধন্যবাদ। এফওয়াইআই, আমি বিং ব্যবহার করছি কারণ গুগল এই জাতীয় অনুরোধগুলি ইস্যু করা আরও জটিল করে তোলে - গুগলকে বোঝাতে আপনাকে শিরোনাম যুক্ত করতে হবে আপনার অনুরোধটি সত্যিই ব্রাউজার থেকে আসছে।
— ভ্রুও
2
@ বার্নার্ট হুম ... বিং কি "সময়" বোঝে? ওল্ফ্রাম আলফা, যদিও।
— জন ডিভোরাক
2
@JanDvorak: হ্যাঁ, উল্ফর্যাম কাজ করে। ( %20কোনও +চিহ্ন ব্যবহার না করার জন্য দ্রষ্টব্য ।) তবে এর মানটি বের করার জন্য আপনাকে এখনও আউটপুট (সিতে) পার্স করতে হবে। যা বিশেষত জটিল হবে, যেহেতু আউটপুটটি কোনও চিত্র নয়, টেক্সট হিসাবে প্রদর্শিত হবে। এইচটিএমএল পার্সিং প্লাস ওসিআর এই সমস্যার সেরা উত্তর হতে পারে।
— 13:48 এ 12 এয়ার্নার্ট
3
@ জনডভোরাক: এটি মজাদার নয়। আমি এমন কোনও ব্যক্তির অপেক্ষায় ছিলাম যে কোনও যোগ বা গুণ ছাড়াই একটি সাধারণ ওসিআর লাইব্রেরি লিখছি ...
— 1314
27

কেন, আসুন 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));
}

পিএস এটি আনন্দের সাথে কিছু মান সহ সিগসেগভ করবে। ;)

— treamur
সূত্র
18

দুর্ভাগ্যক্রমে, এটি কেবল পূর্ণসংখ্যার জন্য কাজ করে।

যেহেতু সংযোজন অনুমোদিত নয়, আসুন প্রথমে একটি ইনক্রিমেন্ট অপারেটর তৈরি করুন:

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++সত্যিই সংযোজন হিসাবে গণনা করা হয়? আমি শিক্ষককে এটির অনুমতি দেওয়ার জন্য বাজি ধরলাম।
  • দু'জনের পরিপূরক উপর নির্ভর করে, তবে এটি একটি বাস্তবায়ন-সংজ্ঞায়িত আচরণ এবং লক্ষ্য প্ল্যাটফর্ম নির্দিষ্ট করা হয়নি।
  • একইভাবে, ধরে নেওয়া হয় বিয়োগ এবং বিভাগকে ঠিক ততই অনুমোদিত নয়।
  • << আসলে দু'জনের পাওয়ার দ্বারা গুণ করা হয়, সুতরাং এটি প্রযুক্তিগতভাবে বর্জন করা উচিত।
  • অযৌক্তিক ডায়াগ্রাম unneccesary হয়। এছাড়াও, এটি একটি লাইন সংরক্ষণের জন্য স্থানান্তরিত করা যেতে পারে।
  • বারবার স্থানান্তরিত করা -1সাইন বিটটি খুঁজে পাওয়ার সর্বোত্তম উপায় নয়। এমনকি যদি কোনও অন্তর্নির্মিত ধ্রুবক নাও থাকে তবে আপনি ডানদিকে -1 এর লজিকাল শিফট করতে পারেন, তারপরে সমস্ত বিট উল্টে দিন।
  • এক্সওর -1 হ'ল সমস্ত বিট উল্টানোর সেরা উপায় নয়।
  • সাইন-প্রস্থের উপস্থাপনা সহ পুরো চারাডা অদম্য। কেবল স্বাক্ষরবিহীন কাস্ট করা এবং মডিউলার গাণিতিক বাকীগুলি করবে।
  • যেহেতু MIN_INT( একে signBit) এর পরম মানটি নেতিবাচক, এটি এই মানটির জন্য বিরতি দেয়। ভাগ্যক্রমে, এটি এখনও অর্ধেক ক্ষেত্রে কাজ করে, কারণ শূন্য MIN_INT * [even number] হওয়া উচিত ।এছাড়াও, plusOneবিরতি -1, ফলস্বরূপ যে কোনও সময় অসীম লুপগুলি সৃষ্টি করে। plusOneযে কোনও মানের জন্য ঠিক কাজ করে। বিভ্রান্তির জন্য দুঃখিত.
— জন ডিভোরাক
সূত্র
প্রকৃত কোড ট্রোলের জন্য +1: দেখে মনে হচ্ছে এটির কাজ করা উচিত তবে এটি সম্ভবত ওপি এবং গুলি বয়ে যাবে / কেন তার কোনও ধারণা নেই।
— কেভিন
1
কেবলমাত্র শিফট, এক্সওআর এবং এ্যান্ড ব্যবহার করে কোনও সংযোজন অপারেটর ছাড়া এটি করা সম্ভব। এই সমস্ত ++ এর ফলে আমার মাথায় আঘাত লাগছে - ক্যারি সহ সিঙ্গল বিট এডিড (x ^ y) | ((এক্স ও ওয়াই) << 1) (এই ক্রেডিট ছোট্ট টেক্সট বাক্সে টাইপ করার ফলে যে কোনও ত্রুটি হয়েছে তা মডুলো করুন))
— অস্টিনের জুলি
@ জুলিয়িন অস্টিন হ্যাঁ অ্যালগরিদম এটির প্রয়োজনের চেয়ে আরও বেশি অদক্ষ। আমি ট্রল তালিকা সংশোধন করা উচিত? :-)
— জন ডিভোরাক
1
@ জুলিয়িন অস্টিন (x ^ y) | ((x & y) << 1)বেশ কার্যকরভাবে কাজ করে না, এক্স বা ওয়াই এবং ক্যারি উভয় একই পদে সত্য হলে এটি বহন করবে না :)
— হবিস
@ হাবস সমাধান: ওরিংয়ের পরিবর্তে, ক্যারি শূন্য না হলে এগুলি পুনরাবৃত্তভাবে যুক্ত করুন।
— জন ডিভোরাক
14

ভাসমান পয়েন্ট সংখ্যাগুলির জন্যও কাজ করে:

float mul(float a, float b){
  return std::exp(std::log(a) - std::log(1.0 / b));
}
— nbubis
সূত্র
11

প্রত্যেকেই জানেন যে সি এর চেয়ে পাইথন ব্যবহার করা আরও সহজ এবং পাইথনের প্রতিটি অপারেটরের সাথে সম্পর্কিত ফাংশন রয়েছে, আপনি অপারেটরটি ব্যবহার করতে পারবেন না এমন ক্ষেত্রে। আমাদের সমস্যা সংজ্ঞাটি ঠিক কোনটি, তাই না? তাই:

#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();
}
— abarnert
সূত্র
10

অন্যান্য উত্তরগুলির কোনওটিই তাত্ত্বিকভাবে সাবলীল নয়। যেমন প্রশ্নের প্রথম মন্তব্যটি বলেছেন:

"সংখ্যা" সম্পর্কে আরও সুনির্দিষ্ট হন

উত্তরটি এমনকি সম্ভব হওয়ার আগে আমাদের সংখ্যা এবং সংখ্যার সংজ্ঞা দেওয়া দরকার। আমরা একবার করলে সমস্যাটি তুচ্ছ হয়ে যায়।

গাণিতিক যুক্তির শুরুতে এটি করার সর্বাধিক জনপ্রিয় উপায় হ'ল জেডএফ সেট তত্ত্বের শীর্ষে ভন নিউম্যান অর্ডিনালগুলি তৈরি করা এবং তারপরে পিয়ানো অ্যাক্সিমিয়ামগুলি ব্যবহার করা ।

এটি সিতে প্রাকৃতিকভাবে অনুবাদ করে, ধরে নিই যে আপনার কাছে এমন একটি সেট ধরণের রয়েছে যাতে অন্যান্য সেট থাকতে পারে। এটা তোলে কিছু ধারণ করার নেই কিন্তু সেট, যা (যে ঢালাই কেউ এটা তুচ্ছ তোলে 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;
    }
}

আপনি যদি এটি পূর্ণসংখ্যা, যুক্তি, বাস্তবসত্তা, পরাবাস্তব ইত্যাদিতে প্রসারিত করতে চান তবে আপনি inf অসীম নির্ভুলতার সাথে (ধরে নিতে পারেন যে আপনার অসীম স্মৃতি এবং সিপিইউ রয়েছে) বুট করতে পারেন। তবে ক্রোনেক্কার যেমনটি বিখ্যাত বলেছেন, Godশ্বর প্রাকৃতিক সংখ্যা করেছেন; অন্য সব মানুষের কাজ তাই সত্যিই কেন বিরক্ত করবেন?

— abarnert
সূত্র
1
কি দারুন. তুমি আমার চেয়ে ধীর।
— জন ডিভোরাক
10 
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 );
}

আপনি যদি [খ] হ্যাকটিকে প্রতারণা বলে মনে করেন (যেহেতু এটি সত্যই একটি অ্যাড) তবে এটি পরিবর্তে এটি কার্যকর হয় works তবে টেবিল দেখার মধ্যে পয়েন্টার যুক্ত হয়।

দেখুন http://en.wikedia.org/wiki/IBM_1620 - এমন এক বিষয় যিনি প্রকৃতপক্ষে অনুসন্ধান সারণী ব্যবহার করে আরও কিছু করেছেন ...

কোনও ক্রিয়াকলাপকে গতি বাড়ানোর জন্য কোনও টেবিল প্রক্রিয়াটি ব্যবহার করার বিষয়ে সন্তুষ্টিজনক কিছু যা আসলে একটি নির্দেশে করা যেতে পারে।

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;
}
— greggo
সূত্র
ওহো, এখানে *চর আছে (যদিও এটি গুণ নয়)
— সার্জে বোর্স
উহ, টেবিল সন্ধানটিতে সংযোজন ব্যবহার করা হয় - (এ [i]) (* (a + i)) এর সমান।
— জুলি অস্টিনে
@ জুলিয়িন অস্টিন আমি এটি উল্লেখ করেছি। ক্ষেত্রগুলিকে মার্জ করে (সংযুক্তি আইবিএম ১ 16২০-তে চিত্রিত হিসাবে লিঙ্কটি দেখুন) যোগ করা ছাড়াই সারণী সন্ধান করা যেতে পারে তবে এটি সি-তে সেট আপ করা অগোছালো - একটি জিনিসের জন্য আপনাকে টেবিলটিকে একটি সঠিক ঠিকানায় প্রান্তিককরণ করতে হবে যাতে সূচকগুলি হতে পারে শুধু or'd in।
— গ্রেগো
8

আমি নিশ্চিত নই যে এই "কোড ট্রল" পোস্টগুলিতে "প্রতারণামূলক" কে কী গঠন করা হয়, তবে এটি স্ট্যান্ডার্ড লাইব্রেরি (সি 99) ব্যবহার করে *বা +অপারেটরের সাথে চালানোর সময়ে 2 টি স্বেচ্ছাচারিত পূর্ণসংখ্যাকে গুণ করে।

#include <math.h>
main()
{
  int a = 6;
  int b = 7;
  return fma(a,b,0);
}
— লাকাটা চিহ্নিত করুন
সূত্র
8

আমার ট্রোল সমাধান এর জন্য 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;
}
— ম্যাথিয়াস
সূত্র
1
+1 বহন মূল্যায়নের সুন্দর বাস্তবায়ন। আমি আপনার কোডটি পছন্দ করি :)
— yo
@ বিউ: আমার দোষ, আমি ভেবেছিলাম ট্রোলিং বোধগম্য নয়। নাম পরিবর্তন এবং মন্তব্য যুক্ত করা হয়েছে।
— ম্যাথিয়াস
দুঃখিত। আমি সেই ট্যাগটি কী, এবং প্রশ্নটি আসলে কী তা ভুল বুঝেছি। আপনি এটা প্রত্যাবর্তন করা উচিত
— BЈовић
@ মাথিয়াস এক্ষেত্রে এটি কীভাবে কাজ করে তা বোঝার জন্য এটি দরকারী যে এটি রূপান্তর-বহন অপারেশনটি কতটা বাঁকানো হয়েছে তা আমরা উপলব্ধি করতে পারি। একটি আসল কোড-
— ট্রোল
আমি উল্লেখ করতে চাই যে আপনি যদি বিট-বিপরীত সংখ্যাগুলি যুক্ত করতে চান (উচ্চ থেকে লো-ক্যারি প্রপ সঙ্গে) এবং আপনার কাছে 'বিট্রেভ' নির্দেশনা নেই, সম্ভবত এটি একটি সম্পূর্ণ যুক্তিসঙ্গত পন্থা (সি> এ পরিবর্তনের পরে) > = অবশ্যই 1)
— গ্রেগো
7

এখানে প্রচুর ভাল উত্তর রয়েছে, তবে আধুনিক কম্পিউটারগুলি সত্যই শক্তিশালী এই সত্যটির সদ্ব্যবহার করে এমনটি মনে হয় না। বেশিরভাগ সিপিইউতে একাধিক প্রসেসিং ইউনিট রয়েছে, তবে কেন কেবল একটি ব্যবহার করবেন? দুর্দান্ত পারফরম্যান্স ফলাফল পেতে আমরা এটি কাজে লাগাতে পারি।

#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ওপেনএমপি ব্যবহার করতে সংকলকটি বলতে আপনাকে পতাকা ব্যবহার করতে হবে।

ট্রোল অংশ:

  1. সমান্তরাল প্রোগ্রামিংয়ের ব্যবহার সম্পর্কে বিভ্রান্তিকর।
  2. নেতিবাচক (বা বড়) সংখ্যায় কাজ করে না।
  3. forলুপের অংশগুলি আসলে ভাগ করে না - প্রতিটি থ্রেড লুপটি চালায়।
  4. বিরক্তিকর পরিবর্তনশীল নাম এবং পরিবর্তনশীল পুনরায় ব্যবহার।
  5. একটি সূক্ষ্ম রেসের শর্ত রয়েছে answer--; বেশিরভাগ সময়, এটি প্রদর্শিত হবে না, তবে মাঝেমধ্যে এটি ভুল ফলাফল হতে পারে।
— millinon
সূত্র
2
কেন এটি পল আর-এর সিমডি উত্তরের সাথে সংযুক্ত করবেন না, সুতরাং আপনি 8x এর পরিবর্তে 32x হিসাবে দ্রুত চালাতে পারেন? যদিও সত্যই, আপনি জিপিইউ পাশাপাশি কোরগুলিও যুক্ত করতে চান; তাহলে এটি সত্যিই জ্বলবে। :)
— abarnert
2
সমান্তরালে কয়েকটি মেশিনে এটি চালনার জন্য ওপেনএমপিআই ব্যবহার করতে পারে।
— মিলিএনন
6

দুর্ভাগ্যক্রমে, কম্পিউটার বিজ্ঞানে একটি গুণ খুব জটিল সমস্যা। পরিবর্তে বিভাগ ব্যবহার করা ভাল সমাধান:

#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));
}
— user3175123
সূত্র
6

বাস্তব জীবনে আমি সাধারণত জ্ঞানের সাথে ট্রলিংয়ের প্রতিক্রিয়া জানায়, তাই এখানে এমন একটি উত্তর দেওয়া হবে যা মোটেও ট্রল হয় না। 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;
}

এটি আমার বোধগম্যতার পক্ষে, অনেকটা এরকম একটি সিপিইউ আসলে কীভাবে পূর্ণসংখ্যা গুণ করে। প্রথমত, আমরা নিশ্চিত করে নিই যে কমপক্ষে একটি যুক্তি ( a) aনেতিবাচক হলে উভয়কেই সাইনটি উল্টিয়ে ইতিবাচক হয় (এবং না, আমি প্রত্যাখ্যানকে একরকম যোগ বা গুণকে এক হিসাবে গণ্য করতে অস্বীকার করি)। তারপরে while (a)লুপটি bপ্রতিটি সেট বিটের জন্য ফলাফলের একটি স্থানান্তরিত অনুলিপি যুক্ত করে a। doলুপ প্রয়োগ r += xব্যবহার করে এবং, XOR, এবং কি পরিষ্কারভাবে অর্ধ adders একটি সেট এর নাড়াচাড়া, বিট বহন ফিরে খাওয়ানো সঙ্গে xযতদিন না (একটি বাস্তব CPU- র, যা অধিক দক্ষ হয় পূর্ণ adders ব্যবহার করেন, কিন্তু সি doesn ' আমাদের কাছে অপারেটরগুলির দরকার নেই, যদি না আপনি +অপারেটরটি গণনা করেন )।

— হবস
সূত্র
4
প্রশ্নকারী ট্রল করেনি। আপনারা ট্রল করার কথা।
— জন ডিভোরাক
2
এটি স্টিলথ ট্রল! গোপন ব্যর্থতা একটি == INT_MIN এ রয়েছে।
— জান্ডার
1
@ জেন্ডার হুঁ হ্যাঁ, এটি একটি ভাল। আমি অনুমান করছি (সাধারণ দু'জনের পরিপূরক সিস্টেমগুলিতে) এটিকে অগ্রাহ্য করার ফলাফলটি এখনও negativeণাত্মক, এবং while(a)লুপটি কখনই শেষ হয় না।
— hobbs
@ হোবস হ্যাঁ, এটি আমার কাছে ঠিক শোনাচ্ছে। অন্যথায় খুব সুন্দর উত্তর।
— Jander
6 
 int bogomul(int A, int B)
{
    int C = 0;
    while(C/A != B)
    {

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

    }
    return C;
}
— Chengarda
সূত্র
1
ফলাফল ভেসে উঠলে এটি মারাত্মকভাবে ব্যর্থ হবে। নিস! আমার ধারণা আপনার প্রিন্ট করা উচিত হবে না।
— জন ডিভোরাক
2
a = 2, b = 2, c = 5
— ব্যর্থ
@ BЈовић: while(C/A != B || C%A)?
— ই
2
মনে রাখবেন যে এটি ডিপ থটসের উত্তরসূরির মতো একই কাজ করার একটি প্রচেষ্টা, তবে উত্তর সম্ভবত 42 টির পরিবর্তে সমস্ত সম্ভাব্য মহাবিশ্বের জন্য। যা বাগের জন্য না থাকলে এটি খুব চিত্তাকর্ষক হবে। এবং ভোগনসের ক্ষেত্রে ত্রুটিটি পরিচালনা করার অভাব।
— ই
1
একাধিক থ্রেড প্রয়োজন। আপনি জানেন, এটি দক্ষ করতে।
— গ্রেগো 15
6

এটি মিশ্রণে নিক্ষেপ করা হচ্ছে:

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

তথ্য পৃষ্ঠা থেকে ।

- কোডটিতে অত্যন্ত অগ্রহণযোগ্য বা অযৌক্তিক কিছু উপস্থাপন করা যা এটিকে সবকিছু ফেলে দেওয়া ছাড়াই মুছে ফেলা যায় না, উত্তরটি ওপির পক্ষে একেবারে অকেজো করে দেওয়া।

- […] অভিব্যক্তিটি এমন একটি ভাষায় হোমওয়ার্ক করা যা অলস ওপি গ্রহণযোগ্য মনে করতে পারে, তবে তারপরেও তাকে হতাশ করে।

— Runium
সূত্র
2
"গুণ এবং সংযোজন অপারেটরগুলি ব্যবহার না করে"। নিয়মগুলি ভালভাবে বাঁকানো - এটি প্রশ্নকারীর পক্ষে একেবারেই অকেজো হবে :-)
— জন ডিভোরাক
2
এটি আসলে কোনও সি সমাধান নয়। এছাড়াও, এটি আমার এআরএম 9 সংকলন করতে ব্যর্থ।
— 13:51
1
@ বার্নার্ট: আপনার বক্তব্যটিকে প্রাসঙ্গিক যুক্তি হিসাবে স্বীকৃতি দিতে ব্যর্থ।
— রুনিয়াম
@ সুকিমিন্ডার: প্রশ্নটি হচ্ছে "একটি সি প্রোগ্রাম লেখা কি সম্ভব…?" ইনলাইন অ্যাসেম্বলি সি নয়। কিছু সি সংকলক ইনলাইন অ্যাসেমব্লিও করতে পারে এমনটি পরিবর্তিত হয় না, কিছু সি সংকলক সি ++ও করতে পারে বা ওবিজসি সি কোড হিসাবে সি ++ বা ওবিজেসি গণনা করে।
— ই
2
@ বার্নার্ট: এটি সি প্রোগ্রামগুলিতে বহুল ব্যবহৃত এম্বেড কোড। যদিও এটি ক্রস-ব্রিডের একটি তর্ক করতে পারে এটি একটি সি প্রোগ্রাম । এটি এমনকি প্রশংসনীয় ওপি সি কোড হিসাবে স্বীকৃতি জানাতে পারে। এটি স্পষ্টভাবে অজগর নয়, নাকি?
— রুনিয়াম
5 
#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;
}
— jaybers
সূত্র
5

গুণগতকরণ এবং সংযোজন অপারেটরগুলি ব্যবহার না করেই কোনও সি প্রোগ্রাম লিখতে সম্ভব যা দুটি সংখ্যাকে গুণ করে?

নিশ্চিত:

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

তবে অবশ্যই তা প্রতারণা করছে; স্পষ্টতই তিনি দুটি সংখ্যা _ই সাপ্লাই করতে সক্ষম হতে চান, তাই না?

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");
    }
}
— abarnert
সূত্র
কেন, এটা আমার কাছে মোটেই সুস্পষ্ট ছিল না!
— লিউজ
4

পয়েন্টার গাণিতিকের মতো কোনও পাটিগণিত নেই:

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কেবল দুটি যুক্তি দিয়ে এটিকে কল করে।
Negativeণাত্মক সংখ্যার জন্যও কাজ করে।

— ugoren
সূত্র
নেতিবাচক a, হ্যাঁ, নেতিবাচক bআমি এটি মনে করি না। তবে এটি অনেক সৃজনশীল উপায়ে স্থিরযোগ্য। সহজ হবে sign_a ^ = sign_b, sign_b = 0.
— MSalters
@ এসএমএল্টাররা পরীক্ষিত এবং সমস্ত সাইন সংমিশ্রণের জন্য (লিনাক্স / জিসিসি সহ) কাজ করে।
— ugoren
3

সি শার্প

আমি মনে করি বিয়োগ এবং অবহেলা অনুমোদিত নয় ... যাইহোক:

int mul(int a, int b)
{
    int t = 0;
    for (int i = b; i >= 1; i--) t -= -a;
    return t;
}
— thepirat000
সূত্র
1
এটি হ'ল ঠিক সেই সমাধানটি যা আমি ভেবেছিলাম ... তবে দেরিতে পার্টিতে এসে আমি জানতাম যে এটি ইতিমধ্যে কেউ লিখে ফেলেছে আমি অবধি স্ক্রোল করার বিষয়। তবুও, আপনি আমার কাছ থেকে একটি (- - 1) পান।
— ফ্লোরিস 15'14
3

সি এস এস ই আন্তঃব্যবস্থা সহ (কারণ সিমডের সাথে সবকিছুই ভাল):

#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 টি সমান্তরাল গুণগুলি সম্পাদনের জন্য সহজেই রূপান্তর করা যায় ।

— পল আর
সূত্র
আমি মনে করি না এটি ট্রল করছে ...
— জন ডিভোরাক
সত্যি? আমি ভেবেছিলাম সিমডির অর্থহীন, কৃত্রিম এবং আর্কিটেকচার-নির্দিষ্ট ব্যবহার কোড-ট্রোলিংয়ের জন্য এটি যোগ্যতা অর্জন করবে?
— পল আর
হুম ... সত্য। বুঝতে পারেনি এটি আর্কিটেকচার-নির্দিষ্ট।
— জন ডিভোরাক
3 
#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 ফর্ম্যাট স্পেসিফায়ার ব্যবহার করে (আমি মূলত এটি সি এর মধ্যে% n অস্তিত্বের কথা মনে করিয়ে দেওয়ার জন্য পোস্ট করছি,% n এর পরিবর্তে অবশ্যই স্ট্রেন ইত্যাদি হতে পারে)
  • '*' এর একটি * বি অক্ষর মুদ্রণ করে
— marol
সূত্র
এখন 'টিউরিং মেশিন এমুলেশন' সমাধানের জন্য অপেক্ষা করছি।
— গ্রেগো 15
1
যদিও strlen(cg) != aএটি --(ওকে (এন * এন)) নির্মূল করার জন্য খুব ট্রোলিং পদ্ধতি ।
— এমসাল্টাররা 15:54
3

সম্ভবত খুব দ্রুত :-(

   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;
    }
— ডেভিড লাইট
সূত্র
1
Ungh। এটি ট্রলিং হয় না। এটি এটি করার সম্পূর্ণ যুক্তিসঙ্গত উপায়।
— জন ডিভোরাক
1
এটি
— ট্রলি
3

এই হ্যাস্কেল সংস্করণটি কেবল ননজেগটিভ পূর্ণসংখ্যার সাথেই কাজ করে, তবে শিশুরা যেভাবে প্রথমে এটি শিখবে সেভাবে এটি গুণটি করে। অর্থাত, 3x4 4 টি জিনিসের 3 টি গ্রুপ। এই ক্ষেত্রে, "জিনিসগুলি" গণনা করা হচ্ছে এটি একটি লাঠির উপর খড়ি ('|')।

mult n m = length . concat . replicate n . replicate m $ '|'
— mhwombat
সূত্র
3 
int multiply(int a, int b) {
    return sizeof(char[a][b]);
}

এটি আবহাওয়া ঠিক থাকলে C99 এ কাজ করতে পারে এবং আপনার সংকলক অপরিজ্ঞাত বাজে কথা সমর্থন করে।

— কনরাড বোরোস্কি
সূত্র
3

যেহেতু ওপি সি এর জন্য জিজ্ঞাসা করেনি , তাই এখানে (ওরাকল) এসকিউএল-তে একটি রয়েছে! 

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;
— SQB
সূত্র
1
আমার Godশ্বর, এটি *s এর পূর্ণ !
— পল আর
1
@ পলআর :) তবে তারা অপারেটর নয় ।
— এসকিউবি
2 
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;
}

ইউডির ট্রেস থাকতে পারে।

— Joker_vD
সূত্র
2 
#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
— Kaz
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.