কোড রোমানাইজেশন

33

চ্যালেঞ্জটি হ'ল আপনার নির্বাচিত ভাষায় যে কোনও রোমান সংখ্যা বৈধ কোড করা।

এগুলি স্ট্রিং বা অনুরূপ কোনও কিছুর অভ্যন্তরে উপস্থিত হওয়া উচিত নয় , তবে অন্য টোকেন, আক্ষরিক যেমন ( আরবি ) সংখ্যা, অক্ষর বা স্ট্রিংয়ের মতো কাজ করা উচিত; অথবা ভেরিয়েবল / পদ্ধতি / ফাংশন শনাক্তকারী ইত্যাদি

উদাহরণস্বরূপ, জাভাতে, নীচেরগুলিকে সংকলন করতে হবে এবং চালাতে হবে ঠিক iতেমনভাবে 42:

int i = XLII;

সংখ্যার আসল বিশ্লেষণ গৌণ, সুতরাং আপনি চাইলে আপনি একটি লাইব্রেরি ব্যবহার করতে পারেন তবে এটি একটি জনপ্রিয়তা প্রতিযোগিতা, তাই সৃজনশীলতাকে উত্সাহ দেওয়া হয়।

আপনি এমন কোনও ভাষা ব্যবহার করতে পারবেন না যা প্রকৃতপক্ষে রোমান অঙ্কগুলি ব্যবহার করে, যদি এমন কোনও জিনিস থাকে।

শুভকামনা।

popularity-contest  roman-numerals  parsing  syntax 
— daniero
সূত্র
1
সুতরাং, আমাদের কী ভাষাতে একটি এক্সটেনশন লিখতে হবে, এর ফলে একটি নতুন তৈরি করা উচিত?
— কেন্ডাল ফ্রে
4
আমি চাইলে অভিযোগ করব, কারণ আমি যে ভাষাগুলি ব্যবহার করি সেগুলি এর মতোই বর্ধনযোগ্য নয়, তাই আমি অংশ নিতেও পারি না।
— কেন্ডল ফ্রে
3
সূত্রটি সংকলন ও চালনা করতে হবে। জাভার জন্য, আপনি এমন একটি "সংকলক" লিখতে পারেন যা উত্সটি সম্পাদন করে, তারপরে প্রোগ্রামগতভাবে সংকলিত হয় । এ জাতীয় সংকলনের একটি উপায় হ'ল Process
— জাস্টিন
1
বেশিরভাগ ভাষায় বোরিং লাগে। উদাহরণস্বরূপ পাইথনে আমি কেবল একটি স্ক্রিপ্ট লিখব astযা উত্সকে বিশ্লেষণ করতে ব্যবহার করে। এএসটি শীর্ষে রোমান সংখ্যার সংজ্ঞা 1 থেকে 3999 পর্যন্ত সন্নিবেশ করান। পুরো জিনিসটি সঙ্কলন করুন এবং এটি চালান। প্রক্রিয়াটি পরিচালনা করার জন্য কোডটি লিখে দেওয়া কেবল বিরক্তিকর।
— বাকুরিউ
2
@ বাকুরিউ এবং আপনার মন্তব্যটিও বিরক্তিকর। এটি একটি জনপ্রিয়তা প্রতিযোগিতা, সুতরাং আপনার মজাদার কিছু নিয়ে আসার চেষ্টা করা উচিত। আমি মনে করি এখানে কিছু সুন্দর উত্তর রয়েছে যা আরও কল্পনাযোগ্য (কোনও স্ক্রিপ্টিং ভাষার সংকলনের চেয়ে)।
— দানিরো

উত্তর:

40

সি

কেবলমাত্র অনেকগুলি রোমান সংখ্যা রয়েছে, যেহেতু 4000 বা ততোধিক উচ্চমানের কোনও মানক স্বীকৃতি নেই, এবং প্রিপ্রসেসর একটি দুর্দান্ত ডিকম্প্রেশন সরঞ্জাম, বিশেষত যদি কোডটি অপরিবর্তিত আচরণের সাথে আপনার কোনও সমস্যা না থাকে।

enum{_
#define a_
#define d_
#define g_
#define j_
#define a(x)c(x)b
#define b(x)c(x)a
#define c(x)x,
#define d(x)f(x)e
#define e(x)f(x)d
#define f(x)m(a(x)(x##I)(x##II)(x##III)(x##IV)(x##V)(x##VI)(x##VII)(x##VIII)(x##IX))
#define g(x)i(x)h
#define h(x)i(x)g
#define i(x)m(d(x)(x##X)(x##XX)(x##XXX)(x##XL)(x##L)(x##LX)(x##LXX)(x##LXXX)(x##XC))
#define j(x)l(x)k
#define k(x)l(x)j
#define l(x)m(g(x)(x##C)(x##CC)(x##CCC)(x##CD)(x##D)(x##DC)(x##DCC)(x##DCCC)(x##CM))
#define m(x)n(x)
#define n(...)__VA_ARGS__##_
m(j()(M)(MM)(MMM))
};

এই থেকে সব রোমান সংখ্যাসমূহ সংজ্ঞায়িত Iকরতে MMMCMXCIXশুমার ধ্রুবক যেমন, প্লাস _শূন্য হিসাবে (আপনার পছন্দ মতন কিছু দ্বারা প্রতিস্থাপিত করা যেতে পারে)।

— hvd
সূত্র
12
একেবারে উজ্জ্বল, পরবর্তী সি রিলিজ (সি 2 এক্স?) ​​এ <রোমান।> হিসাবে যুক্ত করার প্রস্তাব দিন! % R এবং% আর প্রিন্টফ ফর্ম্যাট সহ!
3
আমি ভেবেছিলাম এখন পর্যন্ত কীভাবে প্রিপ্রোসেসর ব্যবহার করতে হয় তা আমি জানি: | আপনি কি এই উত্তরটির ন্যূনতম ব্যবহারের উদাহরণ দিয়ে আপনার উত্তর আপডেট করতে পারবেন?
— ক্লিংটনেট
scanf@ ইয়িমিনরং এবং খুব :) @ ক্লিংট নেট আপনি কী ধরণের উদাহরণ খুঁজছেন তা আমি নিশ্চিত নই। মোটামুটি সহজ একটি হতে হবেint main() { return MMMCMXCIX - M - M - M - CM - XC - IX; }
— এইচডিডি
আমি ধারণাটি পছন্দ করি, তবে সংজ্ঞায়িত আচরণটি যখন বেশ সরল ছিল তখন আপনি কেন অপরিজ্ঞাত আচরণের সাথে যেতে চান? বিচার করছেন না, শুধু কৌতূহলী?
— কাসাডিরোবিসন
1
মূলত মজাদার জন্য @ ক্যাসাডিরোবিসন আমি এটি পছন্দ করি কারণ এটি প্রিপ্রোসেসিংয়ের সময় অপরিজ্ঞাত আচরণের খুব কম কয়েকটি ক্ষেত্রে একটি, যা বর্তমান সংকলক দ্বারা ত্রুটি হিসাবে চিহ্নিত করা হয় নি এবং সম্ভবত ভবিষ্যতেও হবে না। আমি কোডটিতে এর মতো কিছু কখনই ব্যবহার করি না যা কার্যকর হতে বোঝায়, তবে এখানে পোস্ট করা কোডটি কার্যকর হতে বোঝা যাচ্ছে না, তাহলে এটির চেষ্টা করার জন্য এর চেয়ে ভাল আর কী হবে?
— এইচডিভি
15

চুনি

def Object.const_missing(const)
  i = const.to_s
  if i =~ /^[IVXLCDM]+$/
    #http://codegolf.stackexchange.com/questions/16254/convert-arbitrary-roman-numeral-input-to-integer-output
    %w[IV,4 IX,9 XL,40 XC,90 CD,400 CM,900 I,1 V,5 X,10 L,50 C,100 D,500 M,1000].map{|s|k,v=s.split ?,;i.gsub!(k,?++v)}
    eval(i)
  else
    super
  end
end

যে কোনও (বড় হাতের) রোমান সংখ্যাগুলি এখন তাদের দশমিক সমতুল্যের মতো পার্স করা হবে। একমাত্র সমস্যা হ'ল তারা এখনও নিযুক্তযোগ্য: আপনি করতে পারেন X = 9তবে তা করতে পারেন না 10 = 9। আমি মনে করি না এটি ঠিক করার কোনও উপায় আছে।

— histocrat
সূত্র
1
এটি নিখুঁত। অ্যাসাইনমেন্ট জিনিসটি কোনও সমস্যা নয়; আপনি সব ধরণের বোকা জিনিস করার জন্য অ্যাসাইনমেন্ট ব্যবহার করতে পারেন।
— দানিরো
12

জাভাস্ক্রিপ্ট (ES6)

Proxyরোমান অঙ্কগুলি ধরতে ব্যবহার করুন ।

ফায়ারফক্সে পরীক্ষামূলক (সর্বশেষ) জেএসফিডেলে ।
ক্রম (ট্রেসারের সাথে) পরীক্ষামূলক নয় যেহেতু Proxyবাস্তবায়নটি ভেঙে গেছে।

// Convert roman numeral to integer.
// Borrowed from http://codegolf.stackexchange.com/a/20702/10920
var toDecimal = (s) => {
  var n = 0;
  var X = {
    M: 1e3, CM: 900, D: 500, CD: 400, C: 100, XC: 90, 
    L: 50,  XL: 40,  X: 10,  IX: 9,   V: 5,   IV: 4,  I: 1
  };

  s.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g, (d) => n += X[d]);
  return n;
};

// Whether a string is a valid roman numeral.
var isRoman = (s) => s.match(/^[MDCLXVI]+$/);

// Profixy global environment to catch roman numerals.
// Since it uses `this`, global definitions are still accessible.
var romanEnv = new Proxy(this, {
  get: (target, name) => isRoman(name) ? toDecimal(name) : target[name],
  set: (target, name, value) => isRoman(name) ? undefined : (target[name] = value),
  has: (target, name) => isRoman(name) || name in target,
  hasOwn: (target, name) => name in target
});

ব্যবহার:

with (romanEnv) {
  var i = MIV + XLVIII;
  console.log(i); // 1052
}
— ফ্লোরেন্ট
সূত্র
10

সি ও সি ++ (আপডেট উত্তর)

একটি মন্তব্যে পর্যবেক্ষণ হিসাবে, আমার আসল সমাধানটিতে দুটি সমস্যা ছিল:

  1. Cচ্ছিক পরামিতিগুলি কেবলমাত্র ভাষা পরিবারের সি 99 এবং পরবর্তী মানকগুলিতে উপলভ্য।
  2. এনাম সংজ্ঞাতে ট্রেলিং কমাটি C99 এবং তার পরেও নির্দিষ্ট।

যেহেতু আমি চাইছিলাম যে আমার কোডটি পুরানো প্ল্যাটফর্মগুলিতে কাজ করার জন্য যথাসম্ভব জেনেরিক হোক, তাই আমি এটিতে আরও একটি ছুরিকাঘাত নেওয়ার সিদ্ধান্ত নিয়েছি। এটি আগের চেয়ে লম্বা, তবে এটি সি 98 / সি 90 সামঞ্জস্যতা মোডে সেট করা সংকলক এবং প্রিপ্রসেসারগুলিতে কাজ করে। সমস্ত ম্যাক্রোগুলি উত্স কোডে উপযুক্ত সংখ্যক আর্গুমেন্ট পাস হয়, যদিও কখনও কখনও those ম্যাক্রোগুলি কিছুইতে "প্রসারিত" হয় না।

ভিজ্যুয়াল সি ++ 2013 (অরফ সংস্করণ 12) অনুপস্থিত পরামিতি সম্পর্কে সতর্কতা প্রকাশ করে, তবে এমসিপিপি (কোনও ওপেন সোর্স প্রিপ্রোসেসর যা মানের সাথে উচ্চ সম্মতি দাবি করে) বা জিসিসি 4.8.1 (-std = iso9899: 1990 -ডেপ্যান্টিক-ত্রুটিগুলি স্যুইচ) নির্গত করে কার্যকরভাবে খালি যুক্তি তালিকা সহ সেই ম্যাক্রো অনুরোধগুলির জন্য সতর্কতা বা ত্রুটি।

প্রাসঙ্গিক মান (এএনএসআই / আইএসও 9899-1990, 6.8.3, ম্যাক্রো রিপ্লেসমেন্ট) পর্যালোচনা করার পরে, আমি মনে করি যে যথেষ্ট অস্পষ্টতা রয়েছে যে এটি মানহীন হিসাবে বিবেচিত হবে না। "ফাংশনের মতো ম্যাক্রোর অনুরোধে যুক্তিগুলির সংখ্যা ম্যাক্রো সংজ্ঞাতে পরামিতিগুলির সংখ্যার সাথে একমত হবে ..."। ম্যাক্রোকে ডাকার জন্য প্রয়োজনীয় প্যারেনেসিসগুলি (এবং একাধিক পরামিতিগুলির ক্ষেত্রে কমাগুলি) যতক্ষণ না খালি যুক্তি তালিকাটি আবদ্ধ করে বলে মনে হয় না

পেছনের কমা সমস্যা হিসাবে, এটি গণনাতে একটি অতিরিক্ত শনাক্তকারী যুক্ত করে সমাধান করা হয়েছে (আমার ক্ষেত্রে, এমএমএমএম যা সনাক্তকারীকে 3999 অনুসরণ করতে পারে তার পক্ষে যতটা যুক্তিসঙ্গত বলে মনে হয় এমনকি এটি রোমান সংখ্যার সিকোয়েন্সিংয়ের স্বীকৃত নিয়ম না মানলেও ঠিক)।

একটি সামান্য ক্লিনার সমাধান এনামগুলিকে সরানো এবং ম্যাক্রোগুলিকে একটি পৃথক শিরোনামের ফাইলটিতে সমর্থন করা যেমন অন্য কোথাও একটি মন্তব্যে উল্লিখিত ছিল এবং ম্যাক্রোর নামগুলি ব্যবহার করার পরপরই ব্যবহার করা জড়িত যাতে নাম স্থান দূষিত করতে না পারে। নিঃসন্দেহে ভাল ম্যাক্রোর নামগুলিও বেছে নেওয়া উচিত, তবে এটি হাতের কাজটির জন্য পর্যাপ্ত।

আমার আপডেট হওয়া সমাধান, তারপরে আমার আসল সমাধানটি:

#define _0(i,v,x)
#define _1(i,v,x) i
#define _2(i,v,x) i##i
#define _3(i,v,x) i##i##i
#define _4(i,v,x) i##v
#define _5(i,v,x) v
#define _6(i,v,x) v##i
#define _7(i,v,x) v##i##i
#define _8(i,v,x) v##i##i##i
#define _9(i,v,x) i##x

#define k(p,s) p##s,
#define j(p,s) k(p,s)
#define i(p) j(p,_0(I,V,X)) j(p,_1(I,V,X)) j(p,_2(I,V,X)) j(p,_3(I,V,X)) j(p,_4(I,V,X)) j(p,_5(I,V,X)) j(p,_6(I,V,X)) j(p,_7(I,V,X)) j(p,_8(I,V,X)) j(p,_9(I,V,X))
#define h(p,s) i(p##s)
#define g(p,s) h(p,s)
#define f(p) g(p,_0(X,L,C)) g(p,_1(X,L,C)) g(p,_2(X,L,C)) g(p,_3(X,L,C)) g(p,_4(X,L,C)) g(p,_5(X,L,C)) g(p,_6(X,L,C)) g(p,_7(X,L,C)) g(p,_8(X,L,C)) g(p,_9(X,L,C))
#define e(p,s) f(p##s)
#define d(p,s) e(p,s)
#define c(p) d(p,_0(C,D,M)) d(p,_1(C,D,M)) d(p,_2(C,D,M)) d(p,_3(C,D,M)) d(p,_4(C,D,M)) d(p,_5(C,D,M)) d(p,_6(C,D,M)) d(p,_7(C,D,M)) d(p,_8(C,D,M)) d(p,_9(C,D,M))
#define b(p) c(p)
#define a() b(_0(M,N,O)) b(_1(M,N,O)) b(_2(M,N,O)) b(_3(M,N,O))

enum { _ a() MMMM };

#include <stdio.h>

int main(int argc, char** argv)
{
    printf("%d", MMMCMXCIX * MMMCMXCIX);
    return 0;
}

আসল উত্তর (যা প্রথম ছয়টি উপগ্রহ পেয়েছে, সুতরাং কেউ যদি আর এটিকে পুনরুদ্ধার না করে, তবে আপনি ভাববেন না যে আমার হালনাগাদ সমাধানটি আপভোটগুলি পেয়েছে):

পূর্বের উত্তর হিসাবে একই আত্মায়, তবে এমনভাবে সম্পন্ন হয়েছে যা কেবলমাত্র সংজ্ঞায়িত আচরণ ব্যবহার করে পোর্টেবল হওয়া উচিত (যদিও বিভিন্ন পরিবেশ সর্বদা প্রিপ্রোসেসরের কিছু দিকগুলির সাথে একমত হয় না)। কিছু প্যারামিটারগুলি alচ্ছিক হিসাবে বিবেচনা করে, অন্যকে উপেক্ষা করে, এটি __VA_ARGS__সি ++ সহ ম্যাক্রো সমর্থন করে না এমন প্রিপ্রসেসরগুলিতে কাজ করা উচিত , টোকেন আটকানোর আগে প্যারামিটারগুলি প্রসারিত করা হয় তা নিশ্চিত করার জন্য এটি পরোক্ষ ম্যাক্রো ব্যবহার করে, এবং শেষ পর্যন্ত এটি ছোট হয় এবং আমি পড়তে সহজ মনে করি ( যদিও এটি এখনও জটিল এবং সম্ভবত পড়া সহজ নয় , কেবল সহজ):

#define g(_,__) _, _##I, _##II, _##III, _##IV, _##V, _##VI, _##VII, _##VIII, _##IX,
#define f(_,__) g(_,)
#define e(_,__) f(_,) f(_##X,) f(_##XX,) f(_##XXX,) f(_##XL,) f(_##L,) f(_##LX,) f(_##LXX,) f(_##LXXX,) f(_##XC,)
#define d(_,__) e(_,)
#define c(_,__) d(_,) d(_##C,) d(_##CC,) d(_##CCC,) d(_##CD,) d(_##D,) d(_##DC,) d(_##DCC,) d(_##DCCC,) d(_##CM,)
#define b(_,__) c(_,)
#define a       b(,) b(M,) b(MM,) b(MMM,)
enum { _ a };
— CasaDeRobison
সূত্র
1
+1, তবে মনে রাখবেন যে খালি ম্যাক্রো আর্গুমেন্টগুলির ব্যবহার এবং একটি তালিকা তালিকার শেষে কমা, C99 এবং C ++ 11 এর দুটি নতুন বৈশিষ্ট্য এবং C99 এবং C ++ 11 উভয়ই সমর্থন করে __VA_ARGS__।
— এইচডিভি
ডাঙ যদি ঠিক না হয়! আমার ধারণা আমি এই সমস্ত সময় এটি এক্সটেনশন হিসাবে দেখছি। আহ ভালো. :)
— কাসাডিরোবিসন
8

কমন লিস্প

নীচে একটি ম্যাক্রো তৈরি করেছি যা আপনি এটির মতো ব্যবহার করতে পারেন তার একটি দীর্ঘতর ব্যাখ্যা রয়েছে:

(roman-progn
  (+ XIV XXVIII))

কমন লিস্পে যখন কোনও ম্যাক্রো কল করা হয়, এটি মূলত একটি ফাংশনের মতো কাজ করে, কেবলমাত্র আর্গুমেন্টগুলি আগে পাওয়া যায় মূল্যায়নের । আসলে, যেহেতু প্রচলিত লিস্প কোডটি কেবলমাত্র ডেটা, তাই আমরা যা পাই তা হ'ল একটি (নেস্টেড) তালিকা যা একটি পার্সড সিনট্যাক্স ট্রিকে উপস্থাপন করে যা আমরা যা চাই তা করতে পারি এবং এটি সংকলন-সময়ে সম্পন্ন হয়।

সহায়ক কার্যাদি

পরিকল্পনার প্রথম পদক্ষেপ হ'ল এই গাছটি নেওয়া এবং রোমান সংখ্যার মতো দেখতে এমন কোনও কিছুর জন্য এটি স্ক্যান করা। এটি লিস্প এবং সমস্তই, আসুন এটি কিছুটা কার্যকরভাবে করার চেষ্টা করি: আমাদের এমন একটি ফাংশন প্রয়োজন যা একটি গাছের গভীর ট্র্যাভারসাল করবে এবং প্রদত্ত ফাংশনটি searchpসত্য হিসাবে প্রত্যাবর্তিত প্রতিটি বস্তুর ফিরিয়ে দেবে। এই এক সম (আধা) পুচ্ছ-পুনরাবৃত্তি।

(defun deep-find-all (searchp tree &optional found)
  (if (null tree)
    found
    (let* ((item (car tree))
           (new-found (if (consp item)
                        (deep-find-all searchp item found)
                        (if (funcall searchp item)
                          (cons item found)
                          found))))

      (deep-find-all searchp (cdr tree) new-found))))

তারপরে রোজটা কোডের সৌজন্যে রোমান অঙ্কগুলি পার্স করার জন্য কিছু কোড :

(defun mapcn (chars nums string)
  (loop as char across string as i = (position char chars) collect (and i (nth i nums))))

(defun parse-roman (R)
  (loop with nums = (mapcn "IVXLCDM" '(1 5 10 50 100 500 1000) R)
        as (A B) on nums if A sum (if (and B (< A B)) (- A) A)))

আসল ম্যাক্রো

আমরা সিনট্যাক্স ট্রি ( body) নিই, আমাদের গভীর-সন্ধানকারী সমস্ত পদ্ধতির সাহায্যে এটি অনুসন্ধান করি এবং কোনওভাবে রোমানকে আমরা যে সন্ধান পাই তা উপলভ্য করে।

(defmacro roman-progn (&body body)
  (let* ((symbols (deep-find-all (lambda (sym)
                                   (and
                                     (symbolp sym)
                                     (loop for c across (string sym)
                                           always (find c "IVXLCDM")))) body))
         (parsed-romans (mapcar (lambda (sym)
                                  (list sym (parse-roman (string sym)))) symbols)))

    (if parsed-romans
      `(let (,@parsed-romans)
         ,@body)  
      `(progn
         ,@body))))

তো, কী 1 + 2 + 3 + (4 * (5 + 6)) + 7?

(roman-progn
  (+ I II III (* IV (+ V VI)) VII))
=> 57

এবং ম্যাক্রোকে আহ্বান করার সময় আসলে কী ঘটেছিল তা দেখতে:

(macroexpand-1 +)
=> (LET ((VII 7) (VI 6) (V 5) (IV 4) (III 3) (II 2) (I 1))
   (+ I II III (* IV (+ V VI)) VII))
— daniero
সূত্র
7

অ্যাপ্লিকেশন Lua

setmetatable(_G, {
    __index = function(_, k)
        if k:match"^[IVXLCDM]*$" then
            local n = 0
            for _, v in ipairs{{IV = 4}, {IX = 9}, {I = 1}, {V = 5}, {XL = 40}, {X = 10}, {XC = 900}, {CD = 400}, {CM = 900}, {C = 100}, {D = 500}, {M = 1000}} do
                local p, q = next(v)
                local r
                k, r = k:gsub(p, "")
                n = n + r * q
            end
            return n
        end
    end
})

কেবলমাত্র বিশ্বব্যাপী সারণির জন্য একটি ফ্যালব্যাক __ সূচক। Gsub ব্যবহার করে আসল রূপান্তরটি আমি এটি কল্পনা করার চেয়ে অনেক সুন্দর করে পরিণত করেছি।

— mniip
সূত্র
5

পুনশ্চ

আমি সিটিকে অনুসরণ করার চেষ্টা করেছি কিন্তু আমি তা বুঝতে পারি নি। সুতরাং আমি এটি এইভাবে করেছি:

/strcat{
    2 copy length exch length add string % 1 2 3 
    3 2 roll % 2 3 1 
    2 copy 0 exch putinterval % 2 3 1 
    2 copy length % 2 3 1 3 n(1)
    5 4 roll putinterval % 3 1 
    pop 
}def
/S{
    dup length string cvs 
} def 
[
/u {/ /I /II /III /IV /V /VI /VII /VIII /IX}
/t {/ /X /XX /XXX /XL /L /LX /LXX /LXXX /XC}
/h {/ /C /CC /CCC /CD /D /DC /DCC /DCCC /CM}
/m {/ /M /MM /MMM /MMMM}
>>begin
[0
[
[m]{ % M*
    S   
    [h]{ % M* H*
        S
        [t]{ % M* H* T*
            S
            [u]{ % M* H* T* U*
                S
                4 copy
                strcat strcat strcat % M* H* T* U* M*H*T*U*
                5 1 roll % M*H*T*U* M* H* T* U*
                pop % (M*H*T*U*)* M* H* T*
            }forall
            pop % (M*H*T*U*)** M* H*
        }forall
        pop % (M*H*T*U*)*** M*
    }forall
    pop % (M*H*T*U*)****
}forall
]
{exch dup 1 add}forall pop>>end begin

পোস্টস্ক্রিপ্টের নেই enumতবে আমরা অনুক্রমিক পূর্ণসংখ্যার মানগুলির সাথে একটি অভিধান তৈরি করতে পারি এবং এগুলিকে একটি অ্যারেতে ভাঁজ করতে পারি। এটি ধারাবাহিকভাবে সমস্ত স্ট্রিং উত্পন্ন করতে সমস্যা হ্রাস করে, যা 4 নেস্টেড লুপগুলিতে কনটেনেট করে করা হয়। সুতরাং এটি সমস্ত স্ট্রিং উত্পন্ন করে, তারপরে প্রতিটি স্ট্রিংকে ক্রমবর্ধমান পাল্টা মান দিয়ে ইন্টারলিভ করে, ফলস্বরূপ স্ট্যাকের উপর <স্ট্রিং> <int> জোড়গুলির একটি দীর্ঘ সিরিজ তৈরি হয় <<...>> একটি অভিধান অবজেক্ট তৈরি করতে।

প্রোগ্রামটি রোমান সংখ্যার জন্য সংশ্লিষ্ট নামের সাথে সমস্ত নাম ম্যাপ করে একটি অভিধান তৈরি করে এবং ইনস্টল করে। সুতরাং উত্স পাঠ্যে নাম উল্লেখ করা স্বয়ংক্রিয় নাম-সন্ধানের অনুরোধ করে এবং স্ট্যাকের উপর পূর্ণসংখ্যার মান দেয়।

II IV MC pstack

কপি করে প্রিন্ট

2
4
600
— লুজার ড্রাগ
সূত্র
4

স্মলটালক (স্মার্টটাক / এক্স) (87-101 অক্ষর)

অবশ্যই আমরা সহজেই পার্সারের টোকেনাইজারটি সংশোধন করতে পারি (এটি ক্লাস লাইব্রেরির অংশ হিসাবে, এবং যেমন পরিবর্তনের জন্য উন্মুক্ত, এবং সর্বদা উপস্থিত থাকে), তবে একটি চ্যালেঞ্জ একটি নির্দিষ্ট প্রসঙ্গে কেবল মূল্যায়নকে প্রভাবিত করে, যাতে বাকি অংশগুলি সিস্টেম যথারীতি কাজ করে।

সংস্করণ 1:

মূল্যায়ন নেমস্পেসে বেশ কয়েকটি ভেরিয়েবল নির্ধারণ করুন। সুতরাং এটি ইন্টারেক্টিভ doIts (ওরফে evals) প্রভাবিত করবে:

(1 to:3999) do:[:n | 
    Workspace workspaceVariables at:(n romanPrintString asUppercase) put:n]

তাহলে আমি করতে পারি (একটি doIt এ, তবে সংকলিত কোডে নয়):

   |a b|
   a := MMXIV.
   b := V.
   a + b

-> 2019

দ্রষ্টব্য: 101 টি অক্ষরে সাদা স্থান অন্তর্ভুক্ত রয়েছে; আসলে এটি 87 টি চর দ্বারা করা যেতে পারে।
এছাড়াও লক্ষ্য করুন, যখন গ্লোবাল স্মলটালক নেমস্পেসে সংজ্ঞা দেওয়া হয়, তখন আমি সেই ধ্রুবকগুলি সংকলিত কোডেও দেখতে পাই।

সংস্করণ 2:

একটি মেথড্র্যাপার হুক ব্যবহার করুন, যা বিদ্যমান কোডটি পুনরায় সংশোধন না করে মোড়ানোর অনুমতি দেয়। নিম্নলিখিতটি পার্সারের টোকেনাইজারকে স্ক্যান করার জন্য কোনও রোমান শনাক্তকারীকে সন্ধান করতে মোড়ানো এবং এটি একটি পূর্ণসংখ্যা হিসাবে তৈরি করে। কলিং অংশটি গতিশীলরূপে সনাক্ত করতে হয় যে কলিং প্রসঙ্গটি রোমান সাম্রাজ্যের থেকে এসেছে কিনা। এটি একটি ক্যোয়ারী সিগন্যাল (যা প্রযুক্তিগতভাবে এগিয়ে যাওয়ার ব্যতিক্রম) ব্যবহার করে করা হয়েছে:

ক্যোরির সংজ্ঞা দিন:

InRomanScope := QuerySignal new defaultAnswer:false.

সুতরাং আমরা যে কোনও সময় ("InRomanScope কোয়েরি") ডিফল্টরূপে মিথ্যা পেতে বলতে পারি।

তারপরে স্ক্যানারের চেকআইডেন্টিফায়ার পদ্ধতিটি মোড়ুন:

MessageTracer 
    wrapMethod:(Scanner compiledMethodAt:#checkForKeyword:)
    onEntry:nil
    onExit:[:ctx :ret |
        InRomanScope query ifTrue:[
            |scanner string token n|

            scanner := ctx receiver.
            string := ctx argAt:1.
            (n := Integer readFromRomanString:string onError:nil) notNil
            ifTrue:[
                scanner "/ hack; there is no setter for those two
                    instVarNamed:'tokenType' put:#Integer;
                    instVarNamed:'tokenValue' put:n.
                true
            ] ifFalse:[
                ret
            ].
        ] ifFalse:[
            ret
        ]
    ].

এখন স্ক্যানার যথারীতি কাজ করে, যদি না আমরা রোমান সাম্রাজ্যে থাকি:

InRomanScope answer:true do:[
    (Parser evaluate:'MMDXXV') printCR.
].

-> 2525

আমরা কোডও সংকলন করতে পারি:

Compiler 
    compile:'
        inTheYear2525
            ^ MMDXXV
    '
    forClass:Integer.

ভাল চেষ্টা; তবে এটি একটি সিনট্যাক্স ত্রুটির সাথে ব্যর্থ হয় (যা আমরা যা চাই ঠিক তাই)। তবে রোমান সাম্রাজ্যে আমরা সংকলন করতে পারি:

InRomanScope answer:true do:[

    Compiler 
        compile:'
            inTheYear2525
                ^ MMDXXV
        '
        forClass:Integer.
]

এবং এখন, আমরা রোমের অভ্যন্তর এবং বাইরে থেকে যে কোনও পূর্ণসংখ্যার (বার্তাটি প্রেরণ করতে) জিজ্ঞাসা করতে পারি:

(1000 factorial) inTheYear2525

-> 2525

— blabla999
সূত্র
স্মার্টটাক দেখে ভালো লাগল!
4

হাস্কেল, টেমপ্লেট হাস্কেল এবং রোমান-অঙ্কগুলিতে মেটা-প্রোগ্রামিং ব্যবহার করে :

{-# LANGUAGE TemplateHaskell #-}
import Data.Char (toLower)
import Language.Haskell.TH
import Text.Numeral.Roman

$( mapM (\n -> funD (mkName . map toLower . toRoman $ n)
                    [ clause [] (normalB [| n |]) []]) $ [1..1000 :: Int] )

main = print xlii

হাস্কেল নির্মাতাদের পক্ষে আপার কেস চিঠি দিয়ে শুরু করে সনাক্তকারীদের সংরক্ষণ করে, তাই আমি লোয়ার-কেস ব্যবহার করি।

— পেটর পুডলক
সূত্র
4

জে - 78 চর

অন্যান্য সমাধানগুলির মতো এটি কেবল এমএমএমসিএমএক্সএক্সএক্স = 3999 পর্যন্ত যায়।

(}.,;L:1{M`CDM`XLC`IVX('';&;:(_1,~3#.inv]){' ',[)&.>841,3#79bc5yuukh)=:}.i.4e3

এটিকে ভেঙে দিন (স্মরণ করুন জে সাধারণত ডান থেকে বামে পড়া হয়, যদি না বন্ধনী দ্বারা চাপিত হয়):

  • M`CDM`XLC`IVX- চিঠি চার বক্স। আমরা এই বর্ণগুলিতে সূচকে সংখ্যাসূচক অ্যারে ব্যবহার করতে যাচ্ছি এবং রোমান সংখ্যার সাবওয়ার্ড তৈরি করব।
  • 841,3#79bc5yuukh - এটি এমন সাংখ্যিক ডেটা, শক্তভাবে এনকোড করা * *
  • (_1,~3#.inv]) - এটি টার্নারি এবং সংযোজন -1 এ বিস্তৃত করে উপরের ডেটাটি ডিকোড করবে।
  • ('';&;:(...){' ',[)&.>- ডানে ( &.>) বাক্সগুলির সাহায্যে বামে সংখ্যাগুলি সংযুক্ত করে , সংখ্যার অ্যারেগুলি ডিকোড করুন এবং অক্ষরগুলিতে সূচীতে এগুলি ব্যবহার করুন। আমরা 0 টি অক্ষরের তালিকাগুলিতে একটি স্পেস ক্যারেক্টার প্রিফেন্ড করে স্পেস হিসাবে বিবেচনা করি। এই পদ্ধতিটি শব্দের তালিকা তৈরি করে I II III IV V VI VII VIII IXএবং পছন্দ করে M MM MMM।
  • {- এই চারটি বাক্সের শব্দের কার্টেসিয়ান পণ্যটি নিন। এখন আমাদের কাছে সমস্ত রোমান সংখ্যার 4D অ্যারে রয়েছে।
  • }.,;L:1- রোমান সংখ্যার একক 1D তালিকায় এগুলি সমস্ত চালান, এবং সামনে খালি স্ট্রিংটি সরিয়ে ফেলুন কারণ এটি একটি ত্রুটি তৈরি করবে। ( L:জে গল্ফের একটি বিরল দর্শন! সাধারণত এই স্তরের বক্সিং জড়িত না))
  • }.i.4e3- 0 থেকে 4000 পূর্ণসংখ্যার, ব্যতীত দিয়ে ।
  • অবশেষে, আমরা একটি বিশ্বব্যাপী অ্যাসাইনমেন্টের সাথে সবকিছু একসাথে রেখেছি =:। জে আপনাকে এলএইচএসে নামগুলির একটি বাক্সিত তালিকা রাখতে অনুমতি দেয়, একাধিক অ্যাসাইনমেন্টের গুন হিসাবে, সুতরাং এটি কাজ করে।

এখন জে নেমস্পেসে রোমান সংখ্যার প্রতিনিধিত্বকারী ভেরিয়েবলগুলি পূর্ণ।

   XCIX
99
   MMCDLXXVIII
2478
   V * LXIII   NB. 5*63
315
   #4!:1]0     NB. How many variables are now defined in the J namespace?
3999

* পরে ২ য় বেসে পড়ার জন্য আমার ২৯৩৩9977 the০ need০৯৯৮৮ নম্বরটি দরকার AZ)। এটি দশমিকের চেয়ে তিনটি অক্ষর সাশ্রয় করে।

— algorithmshark
সূত্র
3

পাইথন

অন্যান্য উত্তর হিসাবে আইডিয়া সহজ simple তবে কেবল ঝরঝরে হতে এবং বিশ্বব্যাপী নেমস্পেসকে দূষিত না করার জন্য একটি প্রসঙ্গ পরিচালক ব্যবহার করা হয়। এটি আপনাকে এই নিষেধাজ্ঞার চাপ দেয় যে আপনাকে নিজের হাতের আগে যে পরিমাণ রোমান সংখ্যার ব্যবহার করার পরিকল্পনা করছেন তা ঘোষণা করতে হবে।

দ্রষ্টব্য কেবল এটি সহজ রাখার জন্য, এবং চক্রটি পুনরায় উদ্ভাবন না করার জন্য, আমি রোমান পাইথন প্যাকেজটি ব্যবহার করেছি

বাস্তবায়ন

class Roman(object):
    memo = [0]
    def __init__(self, hi):
        import rome
        if hi <= len(RomanNumericals.memo):
            self.romans = Roman.memo[0:hi]
        else:
            Roman.memo += [str(rome.Roman(i))
                    for i in range(len(Roman.memo),
                            hi+1)]
            self.romans = Roman.memo
    def __enter__(self):
        from copy import copy
        self.saved_globals = copy(globals())
        globals().update((v,k) for k,v in enumerate(self.romans[1:], 1))
    def __exit__(self,*args ):
        globals().clear()
        globals().update(self.saved_globals)

ডেমো

with Roman(5):
    with Roman(10):
        print X
    print V
    print X


10
5

Traceback (most recent call last):
  File "<pyshell#311>", line 5, in <module>
    print X
NameError: name 'X' is not defined
— অভিজিৎ
সূত্র
3

পাইথন

পাইথন ব্যবহার করে এটি সম্ভবত সবচেয়ে সহজ সমাধান:

ns = [1000,900,500,400,100,90,50,40,10,9,5,4,1]
ls = 'M CM D CD C XC L XL X IX V IV I'.split()
for N in range(1, 4000):
    r=''
    p=N
    for n,l in zip(ns,ls):
        while p>=n:
            r+=l
            p-=n
    exec('%s=%d'%(r,N))


i, j = XIX, MCXIV
print i, j
— ধারা
সূত্র
3
উন্নত ব্যবহার করতে globals()[var] = valueচেয়ে exec()।
— রামচন্দ্র আপ্তে
3

ডি

ডি সংকলন সময় ফাংশন মূল্যায়ন ব্যবহার করে

import std.algorithm;
string numerals(){
    auto s = cartesianProduct(["","I","II","III","IV","V","VI","VII","VIII","IX"], 
                              ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"],
                              ["","X","XX","XXX","XL","L","LX","LXX","LXXX","XC"],
                              ["","M","MM","MMM"]);
    s.popFront();//skip first
    char[] result="enum ";
    int i=1;
    foreach(p;s){
        result~=p[3]~p[2]~p[1]~p[0]~"="~i++~",";
    }
    result[$-1]=';';//replace last , with a ;
    return result.idup;
}
mixin(numerals());
— র‌্যাচেট ফ্রিক
সূত্র
3

এপিএল (ডায়ালগ এপিএল) , 77 বাইট

রোমান সংখ্যার সর্বোচ্চ দৈর্ঘ্যের জন্য অনুরোধ জানায় এবং সমস্ত ভেরিয়েবল সংজ্ঞায়িত করে।

t←'IVXLCDM',⊂⍬
{⍎⍕⍵'←',+/2(⊣ׯ1*<)/0,⍨(∊1 5∘ר10*⍳4)[t⍳⍵]}¨,/t[⍉8⊥⍣¯1⍳¯1+8*⎕]

t← টি পায়

'IVXLCDM', রোমান চরগুলি অনুসরণ করে

⊂ একটি বদ্ধ

⍬ খালি তালিকা

t[… এর সাথে ] সূচী টি …

 ⍉ স্থানান্তরিত (সঠিক ক্রম পেতে)

 8⊥⍣¯1 উপযুক্ত প্রস্থ বেস-আট উপস্থাপনা

 ⍳ প্রথম এন সূচক, যেখানে এন হল

 ¯1+ এর চেয়ে কম

 8*⎕ সংখ্যার ইনপুট শক্তি আট

,/ সমতল সারি (প্রতিটি উপস্থাপনা)

{...}¨  প্রতিটি উপস্থাপনের জন্য নিম্নলিখিত বেনাম ফাংশন প্রয়োগ করুন…

 (... )[t⍳⍵] মধ্যে যুক্তি এর আইটেম অবস্থানের সংশ্লিষ্ট টি , থেকে নির্বাচন করুন ...

  ∊ তালিকাভুক্ত

  1 5∘ר এক এবং পাঁচ বার প্রতিটি

  10* শক্তি দশ

  ⍳4 তিনটি মাধ্যমে শূন্য

 0,⍨ শূন্য যোগ করুন

 2(…)/ প্রতিটি দৈর্ঘ্য-দুটি স্লাইডিং উইন্ডোতে, নিম্নলিখিত বেনামে ফাংশন ট্রেন প্রয়োগ করুন…

  ⊣× বাম আর্গুমেন্ট বার

  ¯1* নেতিবাচক এক শক্তি

  < বাম আর্গুমেন্টটি সঠিক আর্গুমেন্টের চেয়ে কম কিনা

 +/ সমষ্টি

 ⍵'←', আর্গুমেন্ট (রোমান অঙ্ক) এবং একটি অ্যাসাইনমেন্ট তীরটি পূর্ববর্তী করুন

 ⍕ বিন্যাস (ফ্ল্যাট করতে এবং টেক্সটে নম্বর রূপান্তর করতে)

 ⍎ এটি কার্যকর করুন (বেনামে ফাংশনের বাইরে অ্যাসাইনমেন্ট তৈরি করে)

এটি অনলাইন চেষ্টা করুন! (সর্বোচ্চ দৈর্ঘ্য 5 ব্যবহার করে)

— আদম
সূত্র
2

পিএইচপি

বৈধ রোমান সংখ্যাগুলির জন্য কয়েকটি বিধি রয়েছে

  1. নিম্ন মানগুলির জন্য সর্বাধিক মানটি লিখুন

  2. [I,X,C]পরের 2 বৃহত্তর মানগুলির আগে কেবল বিয়োগ করুন

  3. [I,X,C]পরের 2 বৃহত্তর মানের আগে ডাবল বিয়োগ করুন

  4. [I,X,C]বৃহত্তর মানগুলির আগে ডাবল বিয়োগ করুন

  5. 4 + 5 একত্রিত করুন

অনলাইন সংস্করণ

পদক্ষেপ 1 নিয়ম তৈরি করুন

{"M":1000,"IM":999,"IIM":998,"XM":990,"XXM":980,"CM":900,"CCM":800,"D":500,"ID":499,"IID":498,"XD":490,"XXD":480,"CD":400,"C":100,"IC":99,"IIC":98,"XC":90,"XXC":80,"L":50,"IL":49,"IIL":48,"XL":40,"X":10,"IX":9,"IIX":8,"V":5,"IV":4,"I":1}

সমস্ত বৈধ রোমান সংখ্যার জন্য JSON আউটপুট

$rule_sub_all=$rule_add=$rule_sub_simple=["M"=>1000,"D"=>500,"C"=>100,"L"=>50,"X"=>10,"V"=>5,"I"=>1];
foreach(["I","X","C"]as$roman_letter){
    $rule_sub_simple[$roman_letter.array_search($value=$rule_add[$roman_letter]*5,$rule_add)]=$value-$rule_add[$roman_letter];
    $rule_sub_simple[$roman_letter.array_search($value=$rule_add[$roman_letter]*10,$rule_add)]=$value-$rule_add[$roman_letter];
}
$rule_sub_lower_one=$rule_sub_double=$rule_sub_simple;
foreach(["I","X","C"]as$roman_letter){
    $rule_sub_double[$roman_letter.$roman_letter.array_search($value=$rule_add[$roman_letter]*10,$rule_add)]=$value-2*$rule_add[$roman_letter];

foreach($rule_add as$key=>$value){
    if($value>$rule_add[$roman_letter])$rule_sub_all[$roman_letter.$key]=$value-$rule_add[$roman_letter];
    if($value>5*$rule_add[$roman_letter])$rule_sub_all[$roman_letter.$roman_letter.$key]=$value-2*$rule_add[$roman_letter];
    if($value>10*$rule_add[$roman_letter])$rule_sub_lower_one[$roman_letter.$key]=$value-$rule_add[$roman_letter];
    }
}
arsort($rule_sub_all);
arsort($rule_sub_lower_one);
arsort($rule_sub_double);
arsort($rule_sub_simple);

পদক্ষেপ 2 3999 পর্যন্ত সমস্ত নিয়মের তালিকা তৈরি করুন

$array_sub_lower_one=$array_sub_double=$array_sub_all=$array_add=$array_sub_simple=[];
for($i=1;$i<4000;$i++){
    $number_sub_all=$number_add=$number_sub_simple=$number_sub_double=$number_sub_lower_one=$i;
    $roman_letter_sub_all=$roman_letter_add=$roman_letter_sub_simple=$roman_letter_sub_double=$roman_letter_sub_lower_one="";
    foreach($rule_sub_all as$key=>$value){
        $roman_letter_sub_all.=str_repeat($key,$d=$number_sub_all/$value^0);$number_sub_all-=$value*$d;
        if(in_array($value,$rule_sub_lower_one)){
        $roman_letter_sub_lower_one.=str_repeat($key,$d=$number_sub_lower_one/$value^0);$number_sub_lower_one-=$value*$d;}    
        if(in_array($value,$rule_add)){
        $roman_letter_add.=str_repeat($key,$d=$number_add/$value^0);$number_add-=$value*$d;}
        if(in_array($value,$rule_sub_simple)){
        $roman_letter_sub_simple.=str_repeat($key,$d=$number_sub_simple/$value^0);$number_sub_simple-=$value*$d;}
        if(in_array($value,$rule_sub_double)){
        $roman_letter_sub_double.=str_repeat($key,$d=$number_sub_double/$value^0);$number_sub_double-=$value*$d;}
     }
    $array_sub_lower_one[$roman_letter_sub_lower_one]=$i;   
    $array_sub_all[$roman_letter_sub_all]=$i;
    $array_add[$roman_letter_add]=$i;
    $array_sub_simple[$roman_letter_sub_simple]=$i;
    $array_sub_double[$roman_letter_sub_double]=$i;
}

পদক্ষেপ 3 ধ্রুবক তৈরি করুন

সমস্ত তালিকা একত্রিত করুন এবং ধ্রুবকগুলি সংজ্ঞায়িত করুন

foreach(array_merge($array_add,$array_sub_simple,$array_sub_lower_one,$array_sub_double,$array_sub_all)as$key=>$value){ define($key,$value); }

আউটপুট

উদাহরণস্বরূপ, 8 টি সংখ্যাটির দু'টি বৈধ সংস্করণ মুটিপ্লাই করুন

echo IIX *  VIII;
— জার্গ হালসারম্যান
সূত্র
ভাল লাগছে, তবে আমি এটি কীভাবে ব্যবহার করব? আমি পিএইচপি তে সাবলীল নই; আপনি কি দয়া করে কোডটিতে রোমান সংখ্যা লিখতে সক্ষম হন তার একটি উদাহরণ দিতে পারেন?
— ডানিরো
@ ডানিরো এখন কোডটি কাজ করা উচিত
— জার্গ হালসারম্যান ২n:
আহ, আরও ভাল :)
— ডানিরো
1

Rebol

Rebol []

roman-dialect: func [
    {Dialect which allows Roman numerals as numbers (integer!)}
    block [block!]
    /local word w m1 m2 when-in-rome rule word-rule block-rule
  ][
    when-in-rome: does [
        if roman? w: to-string word [change/part m1 roman-to-integer w m2]
    ]

    word-rule:  [m1: copy word word! m2: (when-in-rome)]
    block-rule: [m1: any-block! (parse m1/1 rule)]
    rule:       [any [block-rule | word-rule | skip]]

    parse block rule
    do block
]

; couple of helper functions used in above parse rules

roman-to-integer: func [roman /local r eval] [
    r: [IV 4 IX 9 XL 40 XC 90 CD 400 CM 900 I 1 V 5 X 10 L 50 C 100 D 500 M 1000]
    eval: join "0" copy roman
    foreach [k v] r [replace/all eval k join " + " v]
    do replace/all to-block eval '+ '+
]

roman?: func [s /local roman-chars] [
    roman-char: charset "IVXLCDM"
    parse/case s [some roman-char]
]


উদাহরণ

roman-dialect [
    m: X + V
    print m
    print M + m  ; doesn't confuse the variable m with Roman Numeral M
    if now/year = MMXIV [print "Yes it is 2014"]
    for n I V I [
        print [rejoin [n "+" X "="] n + X]
    ]
]

আউটপুট:

15

1015

হ্যাঁ এটি 2014

1 + 10 = 11

2 + 10 = 12

3 + 10 = 13

4 + 10 = 14

5 + 10 = 15


দাবি অস্বীকার: আমি নিশ্চিত রেবলে আরও কিছু করার (এবং সম্ভবত আরও ভাল!) উপায় আছে।

গীত। আমার roman-to-integerফাংশন হিস্টোক্র্যাট এর দুর্দান্ত রুবি অ্যালগরিদমের একটি লিখিত লিপি রচনা যা রোমান সংখ্যার স্ট্রিংকে একটি সংখ্যায় রূপান্তরিত করার জন্য। ধন্যবাদ দিয়ে ফিরে! +1 টি

— draegtun
সূত্র
1

অ্যাপ্লিকেশন Lua

local g={}
setmetatable(_G,g)
local romans = {I = 1,
                V = 5,
                X = 10,
                L = 50,
                C = 100,
                D = 500,
                M = 1000}
local larger = {    -- Precalced, for faster computing.
                I = "VXLCDM",
                V = "XLCDM",
                X = "LCDM",
                L = "CDM",
                C = "DM",
                D = "M",
                M = " " -- A space will never be found, and it prevents the pattern matcher from erroring.
}
local storedRomans = {}
function g:__index(key)
    if storedRomans[key] then
        return storedRomans[key]
    end
    if key:match"^[IVXLCDM]+$" then
        local n = 0
        local i = 1
        for s in key:gmatch"." do
            local N = romans[s]
            if key:find('['..larger[s]..']',i) then
                n = n - N
            else
                n = n + N
            end
            i = i + 1
        end
        storedRomans[key] = n
        return n
    end
end

এটি বিশ্বব্যাপী সারণীর মেটাটেবলকে প্রভাবিত করে, এটি একটি নতুন সূচক ফাংশন দেয়। যখন কেবলমাত্র রোমান সংখ্যাসমৃদ্ধ একটি বৈশ্বিক চলক জিজ্ঞাসা করা হয়, উদাহরণস্বরূপ XVII, এটি এটি বিশ্লেষণ করে।

পরীক্ষা সহজ;

print(XVII) -- 42
print(VI)   -- 6
print(III)  -- 3
print(MMM)  -- 3000

এটি অনলাইন চেষ্টা করুন!

— ATaco
সূত্র
1

ভিবিএ, 204 বাইট

একটি ঘোষিত সাবরুটিন যা কোনও ইনপুট নেয় না এবং চালিত হলে publicলাইকে অ্যাক্সেসযোগ্য করে তোলে Enum,R যা রোমান সংখ্যা মূল্যবোধের সব ধারণ করে। এই মানগুলি এনামকে উল্লেখ না করে সরাসরি ব্যবহার করা যেতে পারে।

এনুমের মান 1 থেকে 3999 অবধি রয়েছে।

বিঃদ্রঃ:" 3 এবং 7 লাইনগুলিতে টার্মিনাল গুলি কেবল সিনট্যাক্স হাইলাইট করার জন্য অন্তর্ভুক্ত রয়েছে এবং বাইটকাউন্টে অবদান রাখবেন না

Public Sub i
Set c=ThisWorkbook.VBProject.VBComponents.Add(1).CodeModule
c.AddFromString"Public Enum R"
For n=1To 3999
c.AddFromString WorksheetFunction.Roman(n)&"="&n
Next
c.AddFromString"End Enum"
End Sub

অবহেলিত এবং ব্যাখ্যা

Public Sub InitializeRomanNumerals()
    Dim c As CodeModule                                            ''  Dim CodeModule
    Set c=ThisWorkbook.VBProject.VBComponents.Add(1).CodeModule    ''  Create Module
    Let c.Parent.Name = "RomanNumeral_Module"                      ''  Name the Module
    Call c.AddFromString("Public Enum RomanNumerals")              ''  Declare the Enum
        For n=1To 3999Step 1                                       ''  Iter from 1 to 3999
            Call c.AddFromString(WorksheetFunction.Roman(n)&"="&n) ''  Add the Roman
                                                                   ''  Numeral to Enum
        Next n                                                     ''  Loop
    Call c.AddFromString("End Enum")                               ''  End The Enum
End Sub
— টেলর স্কট
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.