সর্বাধিক জটিল "হ্যালো ওয়ার্ল্ড" প্রোগ্রাম আপনি ন্যায্য করতে পারেন [বন্ধ]

Question

আপনার বস আপনাকে "হ্যালো ওয়ার্ল্ড" প্রোগ্রাম লিখতে বলেছে। যেহেতু আপনি কোডের লাইনের জন্য অর্থপ্রদান পেয়েছেন তাই আপনি এটিকে যতটা সম্ভব জটিল করতে চান। তবে আপনি যদি কেবল অযৌক্তিক রেখাগুলি যুক্ত করেন বা স্পষ্টতই অকেজো বা অবর্ণনীয় স্টাফ যোগ করেন তবে কোড পর্যালোচনার মাধ্যমে আপনি এটি কখনই পাবেন না। সুতরাং চ্যালেঞ্জটি হ'ল:

একটি "হ্যালো ওয়ার্ল্ড" প্রোগ্রাম লিখুন যা কোডের প্রতিটি জটিলতার জন্য "ন্যায়সঙ্গততা" দিতে পারে সেই শর্তে যতটা সম্ভব জটিল।

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

"ন্যায্যতা" অন্তর্ভুক্ত:

• বুজওয়ার্ডের সামঞ্জস্যতা ("আধুনিক সফ্টওয়্যার অবজেক্ট অরিয়েন্টেড!")
• সাধারণত গৃহীত ভাল প্রোগ্রামিং অনুশীলনগুলি ("সকলেই জানেন যে আপনার আলাদা মডেল এবং দেখা উচিত")
• রক্ষণাবেক্ষণযোগ্যতা ("যদি আমরা এটি এভাবে করি তবে আমরা আরও বেশি পরে XXX করতে পারি")
• এবং অবশ্যই অন্য যে কোনও ন্যায্যতা আপনি রিয়েল কোডের জন্য (অন্যান্য পরিস্থিতিতে) ব্যবহার করে কল্পনা করতে পারেন।

অবশ্যই নিরীহ ন্যায়সঙ্গততা গ্রহণ করা হবে না।

এছাড়াও, আপনার নিজের ভাষার পছন্দকে "ন্যায্যতা" দিতে হবে (সুতরাং যদি আপনি অন্তর্নিহিত শব্দভাণ্ডার ভাষা চয়ন করেন তবে আপনাকে কেন এটি "সঠিক" পছন্দ তা ন্যায়সঙ্গত করতে হবে)। আনলম্বদা বা ইন্টারকালের মতো মজাদার ভাষা গ্রহণযোগ্য নয় (যদি না আপনি সেগুলি ব্যবহারের জন্য খুব ভাল যুক্তি দিতে পারেন )।

যোগ্যতা প্রবেশের স্কোর নিম্নলিখিত হিসাবে গণনা করা হয়:

• প্রতিটি বিবৃতি জন্য 1 পয়েন্ট (বা একটি বিবৃতি সমান যাই হোক না কেন আপনার পছন্দ ভাষা)।
• কোনও ক্রিয়াকলাপ, প্রকার, পরিবর্তনশীল ইত্যাদির প্রতিটি সংজ্ঞার জন্য 1 পয়েন্ট (মূল ফাংশন বাদে যেখানে প্রযোজ্য)।
• প্রতিটি মডিউল ব্যবহার বিবৃতি জন্য 1 পয়েন্ট, ফাইল নির্দেশাবলী অন্তর্ভুক্ত, বিবৃতি বা অনুরূপ ব্যবহার করে নেমস্পেস।
• প্রতিটি উত্স ফাইলের জন্য 1 পয়েন্ট।
• প্রতিটি প্রয়োজনীয় ফরোয়ার্ড ঘোষণার জন্য 1 পয়েন্ট (আপনি যদি কোডটি পুনরায় সাজানোর মাধ্যমে এ থেকে মুক্তি পেতে পারেন তবে আপনার যে ব্যবস্থাটি বেছে নেওয়া হয়েছে সেটিকে "সঠিক" হিসাবে কেন "ন্যায্যতা" দিতে হবে)।
• প্রতিটি নিয়ন্ত্রণ কাঠামোর জন্য 1 পয়েন্ট (যদি, যখন, এর জন্য, ইত্যাদি)

মনে রাখবেন যে আপনাকে প্রতিটি একক লাইন "ন্যায্যতা" দিতে হবে।

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

প্রতিযোগীদের তাদের প্রবেশের স্কোর গণনা করতে এবং উত্তরে এটি লিখতে বলা হয়।

Comments

আমি এটি আগে দেখেছি: স্ট্যাকওভারফ্লো

— ক্রিস্টোফিড

কোনওভাবে, এই 'আরও বেশি গিমমে আরও বেশি' - চ্যালেঞ্জগুলি কেবল 5 মিনিটের জন্য আকর্ষণীয় দেখায়। আসুন একটি প্রক্সিপুলফ্যাক্টরিপুলফ্যাক্যাডপুলপ্রক্সিফ্যাক্টরি (পুল) করি! আপনার যেমন বাধা দরকার: এখন থেকে 20 মিনিটের মধ্যে শেষ করুন! আর একটি সমস্যা হ'ল 'নির্বুদ্ধ সমর্থনযোগ্যতা গ্রহণ করা হবে না'। এটি কেবল ব্যক্তিগত নয়, এটি শুরু থেকেই অকার্যকর, যেহেতু আমরা জানি যে পুরো জিনিসটি নির্বোধ। ঠিক আছে - প্রক্সিপুলের পরিবর্তে, কিছু কম বোকামি ব্যবহার করুন, সম্ভবত একটি পুলপ্রক্সিপ্রক্সী?

— ব্যবহারকারী অজানা

@ ক্রিস্টোফিড: যদিও আমি জানি না যে এই প্রশ্নটি ছিল না, আমার মধ্যে একটি মোচড় রয়েছে যা সেইটির মধ্যে নেই: আপনাকে নিজের পছন্দগুলি "ন্যায্যতা" দিতে হবে (যেমন এটি আরও জটিল করে তোলা যথেষ্ট নয়, আপনাকে করতে হবে) জটিলতার জন্য একটি ভাল কারণ দিন)।

— celtschk

আমি নিশ্চিত নই যে ন্যায্যতার উপর "স্পষ্টতই নির্বোধ নয়" নিষেধাজ্ঞাগুলি এফএকিউর সাথে একমত হতে পারে যেখানে বলা হয়েছে "এই সাইটের সমস্ত প্রশ্ন [...] হওয়া উচিত [...] একটি উদ্দেশ্যমূলক প্রাথমিক বিজয়ী মানদণ্ড " ।

— dmckee

জিএনইউ হ্যালো ওয়ার্ল্ডকে ( gnu.org/software/hello ) পরাজিত করা শক্ত বলে মনে হচ্ছে - সংস্করণ ২.7 এর সোর্স কোডটি একটি সংক্ষেপিত সংরক্ষণাগার হিসাবে একটি 586 কেবি ডাউনলোড, স্বয়ংক্রিয় পরীক্ষা, আন্তর্জাতিককরণ, ডকুমেন্টেশন ইত্যাদি দিয়ে সম্পূর্ণ

— হ্যান

Answer 1

সি ++, ট্রলপোস্ট

সর্বাধিক জটিল "হ্যালো ওয়ার্ল্ড" প্রোগ্রামটি আপনি ন্যায়সঙ্গত করতে পারেন

#include <iostream>

using namespace std;

int main(int argc, char * argv[])
{
    cout << "Hello, world!" << endl;
    return 0;
}

আমার মস্তিষ্ক আর একটি লেখার পক্ষে ন্যায়সঙ্গত হতে পারে না :)

Comments

এখানে সেরা উত্তর।

— জো জে।

"নেমস্পেস স্ট্যান্ড ব্যবহার করে" ন্যায়সঙ্গত হতে পারে না! প্লাস আপনার প্রধান এটি ব্যবহার করে না যুক্তি লাগে। অযথা! ;)

— দাঙ্গা

আমার জন্য খুব জটিল। এর মানে কী? কিছু ইউনিট পরীক্ষা যুক্ত করার সম্ভাবনা আছে?

— নাথান কুপার

Answer 2

আমি এখানে ক্ষমতা ও বলা স্ক্রিপ্টিং ভাষা ব্যবহারযোগ্যতা প্রকট হবে পাইথন যেমন ডাটা স্ট্রাকচার - এর জেনারেটর এবং - উপর উপরোক্ত স্ক্রিপ্টিং ভাষা এর অপারেটার মাধ্যমে একটি সুতনু এবং দক্ষ পদ্ধতিতে একটি বরং জটিল টাস্ক সমাধান করে তালিকা এবং অভিধান ।

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

1. বর্ণমালা সংজ্ঞায়িত করুন - সুস্পষ্ট প্রথম পদক্ষেপ। প্রসারণযোগ্যতার জন্য, আমরা পুরো আসকি ব্যাপ্তিটি বেছে নিই। অন্তর্নির্মিত তালিকা-জেনারেটরের ব্যবহারটি নোট করুন যা আমাদের ক্লান্তিকর তালিকা সূচনার কয়েক ঘন্টা ধরে বাঁচাতে পারে।

2. বর্ণমালার প্রতিটি বর্ণের মধ্যে কতটি ব্যবহার করব তা বলুন। এটি কেবল অন্য তালিকা হিসাবে উপস্থাপন করা হয়!

3. এই দুটি তালিকাকে একটি সহজ অভিধানে মার্জ করুন, যেখানে কীগুলি আসকি পয়েন্ট এবং মানগুলি পছন্দসই পরিমাণ।

4. আমরা এখন অক্ষর তৈরি শুরু করতে প্রস্তুত! অভিধানের বাইরে অক্ষরের একটি স্ট্রিং তৈরি করে শুরু করুন। এটিতে আমাদের চূড়ান্ত আউটপুটে আমাদের সমস্ত অক্ষর এবং প্রত্যেকটির সঠিক পরিমাণ থাকবে!

5. অক্ষরগুলির কাঙ্ক্ষিত ক্রমটি ঘোষণা করুন এবং একটি নতুন তালিকা শুরু করুন যা আমাদের চূড়ান্ত আউটপুট ধারণ করবে। সাধারণ পুনরাবৃত্তির সাহায্যে আমরা উত্পন্ন অক্ষরগুলিকে তাদের চূড়ান্ত অবস্থানে রাখব এবং ফলাফলটি মুদ্রণ করব!

আসল বাস্তবায়ন এখানে

# 1: Define alphabet:
a = range(255)

# 2: Letter count:
n = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0)

# 3: Merge to dictionary:
d = { x: y for x, y in zip(a,n) }

# 4: 'Initialize' characters
l = ''.join([chr(c) *n for c,n in d.items()])

# 5: Define the order of the characters, initialize final string
#    and sort before outputting:
z = [6,5,0,7,11,1,2,3,4,8,9]
o = [0] * 13

for c in l:
    i = z.pop(0)
    o[i] = c

print ''.join(o)

---

_{ঠিক আছে, কেবল একটি সংক্ষিপ্ত কিন্তু বোকামির জন্য গিয়েছি এবং একটি টিএল; ডিআর কোড সমাধানের পরিবর্তে একগুচ্ছ পাঠ্য যুক্ত করেছি}

Comments

nএখানে সংজ্ঞাটি কি 1 লাইন বা 11 হিসাবে গণনা করা হয়?

— ড্রাকো 18

Answer 3

ডার্টের হ্যালো ওয়ার্ল্ড জেএস-এ সংকলিত হয়েছে (2 936 012)

http://code.google.com/p/dart/issues/detail?id=14686

(যদিও আমি গুগলকে এটি সমর্থন করতে দেব)

Answer 4

স্কেল, স্কোর: 62

ঠিক আছে, আমি আমার টুপিটি রিংয়ের মধ্যে ফেলে দিই।

ContentProvider.scala:

/*  
    As we all know, the future is functional programming. 

    And one of the mantras of pure functional programming is, to avoid mutable data 
    as hell. Using case classes and case objects allows us to create very small,
    immutable Flight-Weight-Pattern like objects (Singletons, if you like).

    I'm choosing scala, because its compiled to bytecode for the JVM and therefore very 
    portable. I could of course have implemented it in Java, but as we all know,
    Javacode is boilerplaty, while scala is a concise language.     

    S: for easy grepping of scoring hints. 
    Scoring summary: 

        1 import 
        3 control structures
        8 function calls
       22 function definitions
       14 type definitions
       14 files: Seperate files speed up the compilation process, 
          if you only happen to make a local change. 
*/

/**
   To change the content and replace it with something else later, we generate 
   a generic Content trait, which will be 'Char' in the beginning, but could be Int or
   something. 

S:   1 type definition. 
S:   1 function 
*/
trait ContentProvider [T] {
  // ce is the content-element, but we like to stay short and lean. 
  def ce () : T 
}

HWCChain.scala:

//S:  1 import, for the tailcall annotation later. 
import annotation._

/**
   HWCChain is a Chain of HelloWordCharacters, but as a lean, concise language, 
   we do some abbrev. here. 
   We need hasNext () and next (), which is the iterator Pattern.

S: 1 type 
S: 2 functions definitions 
S: 4 function calls
S: 1 if 
*/
trait HWCChain[T] extends Iterator [HWCChain[T]] with ContentProvider[T] {
  // tailrec is just an instruction for the compiler, to warn us, if this code 
  // can't be tail call optimized. 
  @tailrec 
  final def go () : Unit = {
    // ce is our ContentProvider.ce 
    System.out.print (ce);
    // and here is our iterator at work, hasNext and next:  
    if (hasNext ()) next ().go ()
  }
  // per default, we have a next element (except our TermHWWChain, see close to bottom) 
  // this follows the DRY-principle, and reduces the code drastically.
  override def hasNext (): Boolean = true 
}

HHWCChain.scala:

/**
  This is a 'H'-element, followed by the 'e'-Element. 
S: 1 type 
S: 2 functions
*/
case object HHWCChain extends HWCChain[Char] with ContentProvider[Char] {
  override def ce = 'H'
  override def next = eHWCChain
}

eHWCChain.scala:

/*
  and here is the 'e'-Element, followed by l-Element 1, which is a new Type

S: 1 type 
S: 2 functions
*/
case object eHWCChain extends HWCChain[Char] {
  override def ce = 'e'
  override def next = new indexedLHWCChain (1) 
}

theLThing.scala:

/**
  we have to distinguish the first, second and third 'l'-thing. 
  But of course, since all of them provide a l-character, 
    we extract the l for convenient reuse. That saves a lotta code, boy! 

S: 1 type
S: 1 function
*/
trait theLThing extends HWCChain[Char] {
  override def ce = 'l'
}

indexedLHWCChain.scala:

/**
  depending on the l-number, we either have another l as next, or an o, or the d. 
S: 1 type 
S: 1 function definition
S: 2 function calls
S: 1 control structure (match/case) 
*/
case class indexedLHWCChain (i: Int) extends theLThing {
  override def next = i match { 
    case 1 => new indexedLHWCChain (2) 
    case 2 => new indexedOHWCChain (1) 
    case _ => dHWCChain
  }
}

theOThing.scala:

// see theLTHing ...
//S: 1 type
//S: 1 function
trait theOThing extends HWCChain[Char] {
  override def ce = 'o'
}

indexedOHWCChain.scala:

// and indexedOHWCCHain ...
//S: 1 type 
//S: 1 function definition
//S: 1 function call 
//S: 1 control structure 
case class indexedOHWCChain (i: Int) extends theOThing {
  override def next = i match { 
    case 1 => BlankHWCChain
    case _ => rHWCChain
  }
}

BlankHWCChain.scala:

// and indexedOHWCCHain ...
//S: 1 type
//S: 2 function definitions
case object BlankHWCChain extends HWCChain[Char] {
  override def ce = ' '
  override def next = WHWCChain
}

WHWCChain.scala:

//S: 1 type
//S: 2 function definitions
case object WHWCChain extends HWCChain[Char] {
  override def ce = 'W'
  override def next = new indexedOHWCChain (2) 
}

rHWCChain.scala:

//S: 1 type 
//S: 2 function definitions
case object rHWCChain extends HWCChain[Char] {
  override def ce = 'r'
  override def next = new indexedLHWCChain (3) 
}

dHWCChain.scala:

//S: 1 type
//S: 2 function definitions
case object dHWCChain extends HWCChain[Char] {
  override def ce = 'd'
  override def next = TermHWCChain
}

TermHWCChain.scala:

/*
   Here is the only case, where hasNext returns false. 
   For scientists: If you're interested in terminating programs, this type is 
   for you!

S: 1 type 
S: 3 function definitions
*/ 
case object TermHWCChain extends HWCChain[Char] {
  override def ce = '\n'
  override def hasNext (): Boolean = false 
  override def next = TermHWCChain // dummy - has next is always false
}

HelloWorldCharChainChecker.scala:

/* 
S: 1 type
S: 1 function call
*/ 
object HelloWorldCharChainChecker extends App {
  HHWCChain.go ()
}

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

প্রোগ্রামটি পরিষ্কার, সহজ এবং সহজে বোঝা যায়। এটি সহজ পরীক্ষাযোগ্য এবং জেনেরিক এবং অত্যধিক রেকর্ডিংয়ের জাল এড়ানো যায় (আমার দলটি সূচকযুক্ত ওএইচডাব্লুডিসিইন এবং ইনডেক্সড এলএইচডব্লিউসিসেইনকে একটি সাধারণ গৌণ বৈশিষ্ট্যে পুনরুদ্ধার করতে চেয়েছিল, যার লক্ষ্য এবং একটি দৈর্ঘ্যের ক্ষেত্র রয়েছে, তবে এটি কেবল নির্বোধ!)!

Comments

14 টি ফাইল কোথায়?

— celtschk

0 কলামে প্রতিটি বন্ধনী বন্ধনী পরে, একটি নতুন ফাইল তৈরি করা হয়। বস্তু, শ্রেণি ও বৈশিষ্ট্য প্রতি এক ফাইল। এটি বিল্ড প্রক্রিয়াটিকে গতি দেয়, যদি আপনি কেবল একটি একক বস্তুটি পরিবর্তন করেন।

— ব্যবহারকারী অজানা

তাহলে দয়া করে উত্তরে এটি পরিষ্কার করুন।

— celtschk

এটি complexমূল প্রশ্নের অনুরোধ হিসাবে নয় । এটা ঠিক খুব verbose। পার্থক্য আছে.

— মনোক্রোম

"জাভাকোড বোয়্যারপ্লাইটি, যখন স্কেল একটি সংক্ষিপ্ত ভাষা for" এর জন্য +1। আমি দেখেছি সর্বাধিক বয়লারপ্লেটি কোড অনুসরণ করে।

— টিম এস

Answer 5

খাঁটি বাশের কোনও কাঁটাচামচ (কিছু গণনা, প্রায় 85 বলে মনে হচ্ছে ...)

• 6 ফাংশন initRotString 2 ভেরিয়েবল, 3 স্ট্যাটমেন্ট
• 14 ফাংশন বিনটোচার 2 ভেরিয়েবল, 7 স্টেটমেন্ট + সাব ডাইফাইন : 1 ফানক, 1 ভ্যার, 2 স্ট্যাটাস
• 34 ফাংশন রোটিও 9 ভেরিয়েবল, 25 স্ট্যাটামেন্ট
• 9 ফাংশন rle 4 ভেরিয়েবল, 5 স্ট্যাটমেন্ট
• 22 মেইন 13 ভেরিয়েবল, 9 টি স্ট্যাটামেন্ট

বৈশিষ্ট্য :

• দুটি স্তরের আরএলই : প্রথম বাইনারি প্রতিটি অক্ষর এনকোড এবং দ্বিতীয়টি পুনরাবৃত্ত অক্ষরের জন্য
• কী ভিত্তিক সংশোধিত রোট 13 : রোটআইও ফাংশনটি রোট 13 এর মতো ঘূর্ণন সম্পাদন করে তবে 26 (* রট 47) এর পরিবর্তে 96 টি মানগুলিতে, তবে জমা কী দ্বারা স্থানান্তরিত হয়।
• দ্বিতীয় সংস্করণ ব্যবহার gzipএবং এর uuencodeমাধ্যমে perl(এর চেয়ে আরও সাধারণভাবে ইনস্টল করা uudecode)

সম্পূর্ণ পুনর্লিখন (বাগ সংশোধন, ascii- আর্ট অঙ্কন এবং দুটি স্তরের rle):

#!/bin/bash

BUNCHS="114 11122 112111 11311 1213 15 21112 11311 1123 2121 12112 21211"
MKey="V922/G/,2:"

export RotString=""
function initRotString() {
    local _i _char
    RotString=""
    for _i in {1..94} ;do
        printf -v _char "\\%03o" $((_i+32))
        printf -v RotString "%s%b" "$RotString" $_char
    done
}

 

function rotIO() {
    local _line _i _idx _key _cidx _ckey _o _cchar _kcnt=0
    while read -r _line ;do
        _o=""
        for (( _i=0 ; _i < ${#_line} ; _i++)) ;do
            ((_kcnt++ ))
            _cchar="${_line:_i:1}"
            [ "${_cchar//\(}" ] || _cchar="\("
            [ "${_cchar//\*}" ] || _cchar="\*"
            [ "${_cchar//\?}" ] || _cchar="\?"
            [ "${_cchar//\[}" ] || _cchar="\["
            [ "${_cchar//\\}" ] || _cchar='\\'
            if [ "${RotString//${_cchar}*}" == "$RotString" ] ;then
                _o+="${_line:_i:1}"
            else
                _kchar="${1:_kcnt%${#1}:1}"
                [ "${_kchar//\(}" ] || _kchar="\("
                [ "${_kchar//\*}" ] || _kchar="\*"
                [ "${_kchar//\?}" ] || _kchar="\?"
                [ "${_kchar//\[}" ] || _kchar="\["
                [ "${_kchar//\\}" ] || _kchar='\\'
                _key="${RotString//${_kchar}*}"
                _ckey=${#_key}
                _idx="${RotString//${_cchar}*}"
                _cidx=$(((1+_ckey+${#_idx})%94))
                _o+=${RotString:_cidx:1}
            fi; done
        if [ "$_o" ] ; then
            echo "$_o"
    fi ; done ; }

 

function rle() {
    local _out="" _c=1 _l _a=$1
    while [ "${_a}" ] ; do
        printf -v _l "%${_a:0:1}s" ""
        _out+="${_l// /$_c}"
        _a=${_a:1} _c=$((1-_c))
        done
    printf ${2+-v} $2 "%s" $_out
}
function binToChar() {
    local _i _func="local _c;printf -v _c \"\\%o\" \$(("
    for _i in {0..7} ;do
        _func+="(\${1:$_i:1}<<$((7-_i)))+"
        done
    _func="${_func%+}));printf \${2+-v} \$2 \"%b\" \$_c;"

    eval "function ${FUNCNAME}() { $_func }"
    $FUNCNAME $@
}

initRotString

 

for bunch in "${BUNCHS[@]}" ; do
    out=""
    bunchArray=($bunch)
    for ((k=0;k<${#bunchArray[@]};k++)) ; do
        enum=1
        if [ "${bunchArray[$k]:0:1}" == "-" ];then
            enum=${bunchArray[$k]:1}
            ((k++))
        fi
        ltr=${bunchArray[$k]}
        rle $ltr binltr
        printf -v bin8ltr "%08d" $binltr
        binToChar $bin8ltr outltr
        printf -v mult "%${enum}s" ""
        out+="${mult// /$outltr}"
    done
    rotIO "$MKey" <<< "$out"
done

(ব্যবহৃত কীটি খুব বেশি V922/G/,2:ভিত্তিক HelloWorld, তবে এটি কোনও বিষয় নয়;)

ফলাফল (অনুরোধ হিসাবে):

Hello world!

আরও একটি সংস্করণ রয়েছে:

#!/bin/bash

eval "BUNCHS=(" $(perl <<EOF | gunzip
my\$u="";sub d{my\$l=pack("c",32+.75*length(\$_[0]));print unpack("u",\$l.\$
_[0]);"";}while(<DATA>){tr#A-Za-z0-9+/##cd;tr#A-Za-z0-9+/# -_#;\$u.=\$_;while
(\$u=~s/(.{80})/d(\$1)/egx){};};d(\$u);__DATA__
H4sIAETywVICA8VZyZLcMAi9z1e4+q6qAHIr+f8fi7UgyQYs3DOp5JBxywKxPDZr27bthRFgA4B9C0Db
8YdoC+UB6Fjewrs8A8TyFzGv4e+2iLh9HVy2sI+3lQdk4pk55hdIdQNS/Qll2/FUuAD035V3Y1gEAUI4
0yBg3xxnaZqURYvAXLoi2Hj1N4U84HQsy1MPLiRC4qpj3CgKxc6qVwMB8+/0sR0/k8a+LZ4M2o6tUu1V
/oMM5SZWBLslsdqtsMaTvbG9gqpbU/d4iDgrmtXXtD3+0bBVleJ4o+hpYAGH1dkBhRfN7mjeapbpPu8P
1QzsKRLmCsNvk2Hq6ntYJjOirGaks58ZK2x7nDHKj7H8Fe5sK21btwKDvZtCxcKZuPxgL0xY5/fEWmVx
OxEfHAdptnqcIVI4F15v2CYKRkXsMVBDsOzPNqsuOBjXh8mBjA+Om/mkwruFSTwZDlC30is/vYiaRkWG
otG0QDVsz2uHQwP+6usNpwYHDgbJgvPiWOfsQAbBW6wjFHSdzoPmwtNyckiF1980cwrYXyyFqCbS1dN3
L60+yE727rSTeFDgc+fWor5kltEnJLsKkqSRWICZ2WWTEAmve5JmK/yHnNxYj26oX+0nTyXViwaMlwh2
CJW1ugBEargbGtJFhigVFCs6Tn36GFjThTIUukPIQqSyMcgso6stk8xnxp8K9Cr2HDhhFR3glpa6ZiKO
HfIkFSt+PoO7wB7hjaEc7tJEk8w8CNcB5uB1ySaWJVsZRHzqLoPTMvaSp1wocFezmxI/M5SfptDkyO3f
gJNeUUNaNweooE6xkaNe3TUxAW+taR+jGoo0cCtHJC3e+xGXLKq1CKumAbW0kDxtldGLLfLLDeWicIkg
1jOEFtadl9D9scGSm9ESfTR/WngEIu3Eaqv0lEzbsm7aPfJVvTyBmBY/jZZIslEDaNnH+Ojs4KwTYZ/+
Lx8D1ulL7YmUOPkhNur0piXlMH2QkcWFvMs36crIqVrSv3p7TKjhzwMba3axh6WP2SwwQKvBc2ind7E/
wUhLlLujdK3KL67HVG2Wf8pj7T1zBjBOGT22VUPcY9NdNRXOWNUcw4dqSvJ3V8+lMptHtQ+696DdiPo9
z/ks2lI9C5aBkJ9gpNaG/fkk0UYmTyHViWWDYTShrq9OeoZJvi7zBm3rLhRpOR0BqpUmo2T/BKLTZ/HV
vLfsa40wdlDezKUBP5PNF8RP1nx2WuPkCGeV1YNQ0aDuJL5c5OBN72m1Oo7PVpWZ7+uIb6BMzwuWVnb0
2cYxyciKaRneNRi5eQWfwYKvCLr5uScSh67/k1HS0MrotsPwHCbl+up00Y712mtvd33j4g/4UnNvyahe
hLabuPm+71jmG+l6v5qv2na+OtwHL2jfROv/+daOYLr9LZdur6+/stxCnQsgAAA=
EOF
) ")"

MKey="V922/G/,2:"
export RotString=""

function initRotString() {
    local _i _char
    RotString=""
    for _i in {1..94} ;do
        printf -v _char "\\%03o" $((_i+32))
        printf -v RotString "%s%b" "$RotString" $_char
    done
}
function rotIO() {
    local _line _i _idx _key _cidx _ckey _o _cchar _kcnt=0
    while read -r _line ;do
        _o=""
        for (( _i=0 ; _i < ${#_line} ; _i++)) ;do
            ((_kcnt++ ))
            _cchar="${_line:_i:1}"
            [ "${_cchar//\(}" ] || _cchar="\("
            [ "${_cchar//\*}" ] || _cchar="\*"
            [ "${_cchar//\?}" ] || _cchar="\?"
            [ "${_cchar//\[}" ] || _cchar="\["
            [ "${_cchar//\\}" ] || _cchar='\\'
            if [ "${RotString//${_cchar}*}" == "$RotString" ] ;then
                _o+="${_line:_i:1}"
            else
                _kchar="${1:_kcnt%${#1}:1}"
                [ "${_kchar//\(}" ] || _kchar="\("
                [ "${_kchar//\*}" ] || _kchar="\*"
                [ "${_kchar//\?}" ] || _kchar="\?"
                [ "${_kchar//\[}" ] || _kchar="\["
                [ "${_kchar//\\}" ] || _kchar='\\'
                _key="${RotString//${_kchar}*}"
                _ckey=${#_key}
                _idx="${RotString//${_cchar}*}"
                _cidx=$(((1+_ckey+${#_idx})%94))
                _o+=${RotString:_cidx:1}
            fi; done
        if [ "$_o" ] ; then
            echo "$_o"
        fi; done
}
function rle() {
    local _out="" _c=1 _l _a=$1
    while [ "${_a}" ] ; do
        printf -v _l "%${_a:0:1}s" ""
        _out+="${_l// /$_c}"
        _a=${_a:1} _c=$((1-_c))
        done
    printf ${2+-v} $2 "%s" $_out
}
function binToChar() {
    local _i _func="local _c;printf -v _c \"\\%o\" \$(("
    for _i in {0..7} ;do
        _func+="(\${1:$_i:1}<<$((7-_i)))+"
        done
    _func="${_func%+}));printf \${2+-v} \$2 \"%b\" \$_c;"

    eval "function ${FUNCNAME}() { $_func }"
    $FUNCNAME $@
}

initRotString

for bunch in "${BUNCHS[@]}" ; do
    out=""
    bunchArray=($bunch)
    for ((k=0;k<${#bunchArray[@]};k++)) ; do
        enum=1
        if [ "${bunchArray[$k]:0:1}" == "-" ];then
            enum=${bunchArray[$k]:1}
            ((k++))
        fi
        ltr=${bunchArray[$k]}
        rle $ltr binltr
        printf -v bin8ltr "%08d" $binltr
        binToChar $bin8ltr outltr
        printf -v mult "%${enum}s" ""
        out+="${mult// /$outltr}"
    done
    rotIO "$MKey" <<< "$out"
done

একই কী ব্যবহার করা এবং এর মতো কিছু রেন্ডার হতে পারে:

              _   _      _ _                            _     _ _
             | | | | ___| | | ___   __      _____  _ __| | __| | |
             | |_| |/ _ \ | |/ _ \  \ \ /\ / / _ \| '__| |/ _` | |
             |  _  |  __/ | | (_) |  \ V  V / (_) | |  | | (_| |_|
             |_| |_|\___|_|_|\___/    \_/\_/ \___/|_|  |_|\__,_(_)
 
▐▌ █                    ▐▙ █             █ █                ▗▛▀▙ ▟▜▖ ▗█  ▗█▌ ▗█▖
▐▙▄█ ▀▜▖▝▙▀▙▝▙▀▙▐▌ █    ▐▛▙█▗▛▀▙▐▌▖█     ▜▄▛▗▛▀▙ ▀▜▖▝▙▛▙      ▄▛▐▌▖█  █ ▗▛▐▌ ▝█▘
▐▌ █▗▛▜▌ █▄▛ █▄▛▝▙▄█    ▐▌▝█▐▛▀▀▐▙▙█      █ ▐▛▀▀▗▛▜▌ █       ▟▘▄▝▙▗▛  █ ▝▀▜▛  ▀
▝▘ ▀ ▀▘▀▗█▖ ▗█▖ ▗▄▄▛    ▝▘ ▀ ▀▀▘ ▀▝▘     ▝▀▘ ▀▀▘ ▀▘▀▝▀▘     ▝▀▀▀ ▝▀  ▀▀▀  ▀▀  ▀
 
  ▟▙█▖▟▙█▖                ▜▌           █   █   ▝▘  █       ▝█         ▟▙█▖▟▙█▖
  ███▌███▌    ▟▀▟▘▟▀▜▖▟▀▜▖▐▌▟▘    ▝▀▙ ▀█▀ ▀█▀  ▜▌ ▀█▀ █ █ ▟▀█ ▟▀▜▖    ███▌███▌
  ▝█▛ ▝█▛     ▜▄█ █▀▀▘█▀▀▘▐▛▙     ▟▀█  █▗▖ █▗▖ ▐▌  █▗▖█ █ █ █ █▀▀▘    ▝█▛ ▝█▛
   ▝   ▝      ▄▄▛ ▝▀▀ ▝▀▀ ▀▘▝▘    ▝▀▝▘ ▝▀  ▝▀  ▀▀  ▝▀ ▝▀▝▘▝▀▝▘▝▀▀      ▝   ▝
 
... And thank you for reading!!

Comments

... তবে এটি এতটা জটিল নয় ! আমি অনেক খারাপ করতে পারি: - >>

— এফ হৌরি

Answer 6

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

যেহেতু আমি জাভা লিখছি, তাই কাউকে এলিস কোডটি অনুলিপি করে আটকে দেওয়া মূর্খবাদী, তাই আমি http://lwjgl.org/wiki/index.php?title=Sum_Example ব্যবহার করেছি

package magic;
import org.lwjgl.opencl.Util;
import org.lwjgl.opencl.CLMem;
import org.lwjgl.opencl.CLCommandQueue;
import org.lwjgl.BufferUtils;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.CLProgram;
import org.lwjgl.opencl.CLKernel;

import java.nio.IntBuffer;
import java.util.List;

import org.lwjgl.opencl.CL;
import org.lwjgl.opencl.CLContext;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.CLPlatform;

import static org.lwjgl.opencl.CL10.*;

public class OpenCLHello {
static String letters = "HeloWrd ";

// The OpenCL kernel
static final String source =
    ""
    + "kernel void decode(global const int *a, global int *answer) { "
    + "  unsigned int xid = get_global_id(0);"
    + "  answer[xid] = a[xid] -1;" 
    + "}";

// Data buffers to store the input and result data in
static final IntBuffer a = toIntBuffer(new int[]{1, 2, 3, 3, 4, 8, 5, 4, 6, 3, 7});
static final IntBuffer answer = BufferUtils.createIntBuffer(11);

public static void main(String[] args) throws Exception {
    // Initialize OpenCL and create a context and command queue
    CL.create();
    CLPlatform platform = CLPlatform.getPlatforms().get(0);
    List<CLDevice> devices = platform.getDevices(CL_DEVICE_TYPE_GPU);
    CLContext context = CLContext.create(platform, devices, null, null, null);
    CLCommandQueue queue = clCreateCommandQueue(context, devices.get(0), CL_QUEUE_PROFILING_ENABLE, null);

    // Allocate memory for our input buffer and our result buffer
    CLMem aMem = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, a, null);
    clEnqueueWriteBuffer(queue, aMem, 1, 0, a, null, null);

    CLMem answerMem = clCreateBuffer(context, CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR, answer, null);
    clFinish(queue);

    // Create our program and kernel
    CLProgram program = clCreateProgramWithSource(context, source, null);
    Util.checkCLError(clBuildProgram(program, devices.get(0), "", null));
    // sum has to match a kernel method name in the OpenCL source
    CLKernel kernel = clCreateKernel(program, "decode", null);

    // Execution our kernel
    PointerBuffer kernel1DGlobalWorkSize = BufferUtils.createPointerBuffer(1);
    kernel1DGlobalWorkSize.put(0, 11);
    kernel.setArg(0, aMem);
    kernel.setArg(1, answerMem);
    clEnqueueNDRangeKernel(queue, kernel, 1, null, kernel1DGlobalWorkSize, null, null, null);

    // Read the results memory back into our result buffer
    clEnqueueReadBuffer(queue, answerMem, 1, 0, answer, null, null);
    clFinish(queue);
    // Print the result memory

    print(answer);

    // Clean up OpenCL resources
    clReleaseKernel(kernel);
    clReleaseProgram(program);
    clReleaseMemObject(aMem);
    clReleaseMemObject(answerMem);
    clReleaseCommandQueue(queue);
    clReleaseContext(context);
    CL.destroy();
}





/** Utility method to convert int array to int buffer
 * @param ints - the float array to convert
 * @return a int buffer containing the input float array
 */
static IntBuffer toIntBuffer(int[] ints) {
    IntBuffer buf = BufferUtils.createIntBuffer(ints.length).put(ints);
    buf.rewind();
    return buf;
}


/** Utility method to print an int buffer as a string in our optimized encoding
 * @param answer2 - the int buffer to print to System.out
 */
static void print(IntBuffer answer2) {
    for (int i = 0; i < answer2.capacity(); i++) {
        System.out.print(letters.charAt(answer2.get(i) ));
    }
    System.out.println("");
}

}

Answer 7

সমাবেশ (x86, লিনাক্স / এলএফ 32): 55 পয়েন্ট

সবাই জানেন যে আপনি যখন একটি দ্রুত প্রোগ্রাম চান, আপনার সমাবেশে লিখতে হবে।

কখনও কখনও আমরা ldএর কাজটি সঠিকভাবে করার উপর নির্ভর করতে পারি না - সর্বোত্তম পারফরম্যান্সের জন্য, আমাদের হ্যালো ওয়ার্ল্ড এক্সিকিউটেবলের জন্য নিজস্ব এলফ শিরোনাম তৈরি করা ভাল। এই কোডটি কেবল nasmনির্মাণের প্রয়োজন , তাই খুব বহনযোগ্য। এটি কোনও বাহ্যিক গ্রন্থাগার বা রানটাইমের উপর নির্ভর করে।

প্রতিটি লাইন এবং বিবৃতি প্রোগ্রামের সঠিক কাজকর্মের জন্য একেবারে গুরুত্বপূর্ণ - কোনও ক্রাফ্ট নেই, কিছুই বাদ দেওয়া যায় না।

তদুপরি, লিঙ্কারটি ব্যবহার না করেই এটি করা সবচেয়ে সংক্ষিপ্ততম উপায় - উত্তরটি ফুটিয়ে তোলার জন্য কোনও অপ্রয়োজনীয় লুপ বা ঘোষণা নেই।

BITS 32

              org     0x08048000

ehdr:                                                 ; Elf32_Ehdr
              db      0x7F, "ELF", 1, 1, 1, 0         ;   e_ident
times 8       db      0
              dw      2                               ;   e_type
              dw      3                               ;   e_machine
              dd      1                               ;   e_version
              dd      _start                          ;   e_entry
              dd      phdr - $$                       ;   e_phoff
              dd      0                               ;   e_shoff
              dd      0                               ;   e_flags
              dw      ehdrsize                        ;   e_ehsize
              dw      phdrsize                        ;   e_phentsize
              dw      1                               ;   e_phnum
              dw      0                               ;   e_shentsize
              dw      0                               ;   e_shnum
              dw      0                               ;   e_shstrndx

ehdrsize      equ     $ - ehdr

phdr:                                                 ; Elf32_Phdr
              dd      1                               ;   p_type
              dd      0                               ;   p_offset
              dd      $$                              ;   p_vaddr
              dd      $$                              ;   p_paddr
              dd      filesize                        ;   p_filesz
              dd      filesize                        ;   p_memsz
              dd      5                               ;   p_flags
              dd      0x1000                          ;   p_align

phdrsize      equ     $ - phdr

section .data
msg     db      'hello world', 0AH
len     equ     $-msg

section .text
global  _start
_start: mov     edx, len
        mov     ecx, msg
        mov     ebx, 1
        mov     eax, 4
        int     80h

        mov     ebx, 0
        mov     eax, 1
        int     80h

filesize      equ     $ - $$

স্কোরিং

• "বিবৃতি" (চলমান চলমান, অন্তর্ভুক্ত): 8
• "ফাংশন, ধরনের, ভেরিয়েবল" (কাউন্টিং org, db, dw, dd, equ, global _start): 37
• "উত্স ফাইল": 1
• "এগিয়ে ঘোষণা" (কাউন্টিং dd _start, dd filesize, dw ehdrsize, dw phdrsize: 4
• "কন্ট্রোল স্ট্রাকচার" (কাউন্টিং ehdr:, phdr:, section .data, ,section .text, _start:): 5

Answer 8

পিএইচপি / এইচটিএমএল / সিএসএস (88pts)

সমস্ত কোড এখানে উপলভ্য: https://github.com/martin-damien/code-golf_hello-world

• এই "হ্যালো ওয়ার্ল্ড" পিএইচপি (http://twig.sensiolabs.org/) এর জন্য টুইগ টেম্পলেট ভাষা ব্যবহার করে।
• আমি কেবল ফ্লাইতে ক্লাস লোড করতে একটি অটোলোড মেকানিজম ব্যবহার করি।
• আমি এমন একটি পৃষ্ঠা শ্রেণি ব্যবহার করি যা বহু ধরণের উপাদান (এক্সএমলেমেন্ট ইন্টারফেস প্রয়োগ করে) পরিচালনা করতে পারে এবং সেই সমস্ত ক্ষতিকে একটি সঠিক এক্সএমএল ফর্ম্যাটে ফিরিয়ে দেয়।
• অবশেষে, আমি একটি বিউটিফুল "হ্যালো ওয়ার্ল্ড" প্রদর্শন করতে চকচকে সিএসএস ব্যবহার করি :)

index.php

<?php

/*
 * SCORE ( 18 pts )
 *
 * file : 1
 * statements : 11
 * variables : 6 (arrays and class instance are counted as a variable)
 */

/*
 * We use the PHP's autoload function to load dynamicaly classes.
 */
require_once("autoload.php");

/*
 * We use a template engine because as you know it is far better
 * to use MVC :-)
 */
require_once("lib/twig/lib/Twig/Autoloader.php");
Twig_Autoloader::register();

/*
 * We create a new Twig Environment with debug and templates cache.
 */
$twig = new Twig_Environment(

    new Twig_Loader_Filesystem(

        "design/templates" /* The place where to look for templates */

    ),
    array(
        'debug' => true,
        'cache' => 'var/cache/templates'
    )

);
/* 
 * We add the debug extension because we should be able to detect what is wrong if needed
 */
$twig->addExtension(new Twig_Extension_Debug());

/*
 * We create a new page to be displayed in the body.
 */
$page = new Page();

/*
 * We add our famous title : Hello World !!!
 */
$page->add( 'Title', array( 'level' => 1, 'text' => 'Hello World' ) );

/*
 * We are now ready to render the content and display it.
 */
$final_result = $twig->render(

    'pages/hello_world.twig',
    array(

        'Page' => $page->toXML()

    )

);

/*
 * Everything is OK, we can print the final_result to the page.
 */
echo $final_result;

?>

autoload.php

<?php

/*
 * SCORE ( 7 pts )
 *
 * file : 1
 * statements : 4
 * variables : 1
 * controls: 1
 */

/**
 * Load automaticaly classes when needed.
 * @param string $class_name The name of the class we try to load.
 */
function __hello_world_autoload( $class_name )
{

    /*
     * We test if the corresponding file exists.
     */
    if ( file_exists( "classes/$class_name.php" ) )
    {
        /*
         * If we found it we load it.
         */
        require_once "classes/$class_name.php";
    }

}

spl_autoload_register( '__hello_world_autoload' );

?>

ক্লাস / Page.php

<?php

/*
 * SCORE ( 20 pts )
 *
 * file : 1
 * statements : 11
 * variables : 7
 * controls : 1
 */

/**
 * A web page.
 */
class Page
{

    /**
     * All the elements of the page (ordered)
     * @var array
     */
    private $elements;

    /**
     * Create a new page.
     */
    public function __construct()
    {
        /* Init an array for elements. */
        $this->elements = array();
    }

    /**
     * Add a new element to the list.
     * @param string $class The name of the class we wants to use.
     * @param array $options An indexed array of all the options usefull for the element.
     */
    public function add( $class, $options )
    {
        /* Add a new element to the list. */
        $this->elements[] = new $class( $options );
    }

    /**
     * Render the page to XML (by calling the toXML() of all the elements).
     */
    public function toXML()
    {

        /* Init a result string */
        $result = "";

        /*
         * Render all elements and add them to the final result.
         */
        foreach ( $this->elements as $element )
        {
            $result = $result . $element->toXML();
        }

        return $result;

    }

}

?>

ক্লাস / Title.php

<?php

/*
 * SCORE ( 13 pts )
 *
 * file : 1
 * statements : 8
 * variables : 4
 *
 */

class Title implements XMLElement
{

    private $options;

    public function __construct( $options )
    {
        $this->options = $options;
    }

    public function toXML()
    {

        $level = $this->options['level'];
        $text = $this->options['text'];

        return "<h$level>$text</h$level>";

    }

}

?>

ক্লাস / XMLElement.php

<?php

/*
 * SCORE ( 3 pts )
 *
 * file : 1
 * statements : 2
 * variables : 0
 */

/**
 * Every element that could be used in a Page must implements this interface !!!
 */
interface XMLElement
{

    /**
     * This method will be used to get the XML version of the XMLElement.
     */
    function toXML();

}

?>

ডিজাইন / স্টাইলশীট / hello_world.css

/*
 * SCORE ( 10 pts )
 *
 * file : 1
 * statements : 9
 */

body
{
    background: #000;
}

h1
{
    text-align: center;
    margin: 200px auto;
    font-family: "Museo";
    font-size: 200px; text-transform: uppercase;
    color: #fff;
    text-shadow: 0 0 10px #fff, 0 0 20px #fff, 0 0 30px #fff, 0 0 40px #ff00de, 0 0 70px #ff00de, 0 0 80px #ff00de, 0 0 100px #ff00de, 0 0 150px #ff00de;
}

ডিজাইন / টেমপ্লেট / লেআউট / pagelayout.twig

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">

    <!--

        SCORE ( 11 pts )

        file: 1
        statements: html, head, title, css,  body, content, block * 2 : 8
        variables : 2 blocks defined : 2

    -->

    <head>

        <title>{% block page_title %}{% endblock %}</title>
        <link href="design/stylesheets/hello_world.css" rel="stylesheet" type="text/css" media="screen" />

    </head>

    <body>
        <div id="content">
            {% block page_content %}{% endblock %}
        </div>
    </body>

</html>

ডিজাইন / টেমপ্লেট / পৃষ্ঠাগুলি / hello_world.twig

{#

    SCORE ( 6 pts )

    file : 1
    statements : 4
    variables : 1

#}

{% extends 'layouts/pagelayout.twig' %}

{% block page_title %}Hello World{% endblock %}

{% block page_content %}
    {# Display the content of the page (we use raw to avoid html_entities) #}
    {{ Page|raw }}
{% endblock %}

Answer 9

Brainfuck

369 এক্সপ্রেশন, 29 যখন লুপ = 398

> ; first cell empty
;; All the chars made in a generic way
;; by first adding the modulus of char by
;; 16 and then adding mutiples of 16
;; This simplifies adding more characters 
;; for later versions
------>>++++[-<++++>]<[-<+>]        ; CR
+>>++++[-<++++>]<[-<++>]            ; !
++++>>++++[-<++++>]<[-<++++++>]     ; d
---->>++++[-<++++>]<[-<+++++++>]    ; l
++>>++++[-<++++>]<[-<+++++++>]      ; r
->>++++[-<++++>]<[-<+++++++>]       ; o
+++++++>>++++[-<++++>]<[-<+++++++>] ; w
>>++++[-<++++>]<[-<++>]             ; space
---->>++++[-<++++>]<[-<+++>]        ; comma
->>++++[-<++++>]<[-<+++++++>]       ; o
---->>++++[-<++++>]<[-<+++++++>]    ; l
---->>++++[-<++++>]<[-<+++++++>]    ; l
+++++>>++++[-<++++>]<[-<++++++>]    ; e
-------->>++++[-<++++>]<[-<+++++++>]; h
<[.<] ; print until the first empty cell

কেএন্ডআর থেকে প্রাপ্ত ফলাফল সি প্রোগ্রামিং ভাষার উদাহরণ:

hello, world!

Answer 10

টিআই-বেসিক 84, 1 পয়েন্ট

:Disp "HELLO WORLD!"

টিআই-বেসিক বেশ বেসিক। তবে আপনি যদি সত্যিই ন্যায়সঙ্গত ব্যাখ্যা চান তবে এটি এখানে:

: প্রতিটি কমান্ড, ফাংশন, বিবৃতি, কাঠামো, উপ-প্রোগ্রাম শুরু করে, আপনি এটি নাম দিন

Disp একটি পূর্বনির্ধারিত ফাংশন যা স্ক্রিনে একটি পরামিতি প্রদর্শন করে

ওরফে whitespaceফাংশনটি Dispজানতে দেয় যে এটি বলা হয়েছে এবং পরামিতিটি সাদা বাক্সের একক অক্ষরটি অনুসরণ করা উচিত যা আসলে বরাবর প্রবেশ করানো হয়Disp

" আক্ষরিক স্ট্রিং সংজ্ঞা দেওয়া শুরু করে

HELLO WORLD আক্ষরিক স্ট্রিংয়ের পাঠ্যের অংশ

! যদিও এটি একটি ফ্যাকটোরিয়াল গণিত অপারেটর, তবুও এটি মূল্যায়ন করা হয়নি কারণ এটি একটি স্ট্রিং আক্ষরিক অভ্যন্তরে

" আক্ষরিক স্ট্রিংয়ের সংজ্ঞাটি শেষ করে

Answer 11

সুতরাং, আমার কাছে খুব ... ... ... অদ্ভুত পরিচালক have তাঁর এই আশ্চর্য ধারণা রয়েছে যে কোনও প্রোগ্রাম যত সহজ, যত সুন্দর, তত বেশি শৈল্পিক হওয়া উচিত। যেহেতু Hello Worldযুক্তিটি যুক্তিযুক্তভাবে লেখার পক্ষে একটি সহজ প্রোগ্রাম, তাই তিনি প্রাচীরের সাথে ঝুলতে পারে এমন দুর্দান্ত কিছু চেয়েছিলেন। কিছু গবেষণা করার পরে, তিনি জোর দিয়েছিলেন যে জিনিসটি পিটে লেখা উচিত।

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

Comments

রহস্যজনক হওয়ার জন্য প্লাস ওয়ান। এছাড়াও, পিটে কয়েক ডজন অনন্য "হ্যালো ওয়ার্ল্ড" প্রোগ্রাম রয়েছে, আমার প্রিয় অ্যানিমেটেড ।

— ড্রাকো 18

Answer 12

সি তে একটি লাইপোগ্রাম :

int main(){
    printf("H%cllo World\n", 'd'+1);
}

আমার কম্পিউটারের উপর কি কে বিটিউএন 'ডাব্লু' এবং 'আর' ব্রাউন হয়েছে। এটি সোমাল লুয়াগগুলি নিয়ে সমস্যায় পড়ে। আমাদের সাথে সিটিতে প্রায় সমস্ত প্রাইম-কম্পাইলার ডার্কটিভস এলটিটিআর। থম অ্যাভোভ কোড প্রিন্টফ () এর অন্তর্নিহিত বিবরণ সম্পর্কে সতর্কবার্তা ছুঁড়েছে, আমি আমাদের # সংযুক্ত করতে পারি না (স্টাডিও এইচ), তবে এটি ফিন করে।

Comments

আপনি "ব্যবহার" টাইপ করেছেন, যদিও ...

— সুপুস্তার

Answer 13

আমি এটি সম্প্রদায় উইকি হিসাবে রেফারেন্সের জন্য রেখেছি। এটি খারাপ অভ্যাস সহ সি # এক। আমি আমার নিজের ascii ডেটা কাঠামো সংজ্ঞায়িত করি। আমি এটিকে প্রতিদ্বন্দ্বী হতে চাই না, বরং "কিড'স, আপনি সেই লোকটিকে দেখেন ... আপনি যদি আপনার শাকসব্জি না খেয়ে থাকেন তবে আপনি তাঁর মতো হয়ে উঠবেন" ধরনের উদাহরণ।

আপনি যদি খুব সহজেই খারাপ কোডের দ্বারা নিরস্ত হয়ে থাকেন তবে এখনই দেখুন

আমি সাধারণত হ্যালোইনে বাচ্চাদের ভয় দেখানোর জন্য এটি ব্যবহার করি। আপনার এও লক্ষ্য করা উচিত যে আমি এখানে আমার সমস্ত 256 এসকি অক্ষর ফিট করতে পারি না কারণ মোট চরগুলি প্রায় 40,000 এর কাছাকাছি চলেছে। এটি 2 কারণে এটিকে পুনরুত্পাদন করার চেষ্টা করবেন না:

• এটি গল্ফ কোড কোডের চেয়ে ভয়ানক, ভয়ঙ্কর worse
• এর বেশিরভাগটা লিখতে আমি একটি প্রোগ্রাম লিখেছি।

তাই আহ ... হ্যাঁ "উপভোগ করুন!"। এছাড়াও যদি আপনি কোড কাশি কোড পর্যালোচনা কাশি পরিষ্কার এবং উন্নত করে উপভোগ করেন তবে আপনি যদি অলাভজনক পেশা খুঁজছেন তবে এটি আপনাকে কিছু সময়ের জন্য ব্যস্ত রাখতে পারে।

namespace System
{
    class P
    {
        static void Main()
        {
            Bit t = new Bit { State = true };
            Bit f = new Bit { State = false };

            Nybble n0 = new Nybble() { Bits = new Bit[4] { f, f, f, f } };
            Nybble n1 = new Nybble() { Bits = new Bit[4] { f, f, f, t } };
            Nybble n2 = new Nybble() { Bits = new Bit[4] { f, f, t, f } };
            Nybble n3 = new Nybble() { Bits = new Bit[4] { f, f, t, t } };
            Nybble n4 = new Nybble() { Bits = new Bit[4] { f, t, f, f } };
            Nybble n5 = new Nybble() { Bits = new Bit[4] { f, t, f, t } };
            Nybble n6 = new Nybble() { Bits = new Bit[4] { f, t, t, f } };
            Nybble n7 = new Nybble() { Bits = new Bit[4] { f, t, t, t } };
            Nybble n8 = new Nybble() { Bits = new Bit[4] { t, f, f, f } };
            Nybble n9 = new Nybble() { Bits = new Bit[4] { t, f, f, t } };
            Nybble n10 = new Nybble() { Bits = new Bit[4] { t, f, t, f } };
            Nybble n11 = new Nybble() { Bits = new Bit[4] { t, f, t, t } };
            Nybble n12 = new Nybble() { Bits = new Bit[4] { t, t, f, f } };
            Nybble n13 = new Nybble() { Bits = new Bit[4] { t, t, f, t } };
            Nybble n14 = new Nybble() { Bits = new Bit[4] { t, t, t, f } };
            Nybble n15 = new Nybble() { Bits = new Bit[4] { t, t, t, t } };

            HByte b0 = new HByte() { Nybbles = new Nybble[2] { n0, n0 } };
            HByte b1 = new HByte() { Nybbles = new Nybble[2] { n0, n1 } };
            HByte b2 = new HByte() { Nybbles = new Nybble[2] { n0, n2 } };
            HByte b3 = new HByte() { Nybbles = new Nybble[2] { n0, n3 } };
            HByte b4 = new HByte() { Nybbles = new Nybble[2] { n0, n4 } };
            HByte b5 = new HByte() { Nybbles = new Nybble[2] { n0, n5 } };
            HByte b6 = new HByte() { Nybbles = new Nybble[2] { n0, n6 } };
            HByte b7 = new HByte() { Nybbles = new Nybble[2] { n0, n7 } };
            HByte b8 = new HByte() { Nybbles = new Nybble[2] { n0, n8 } };
            HByte b9 = new HByte() { Nybbles = new Nybble[2] { n0, n9 } };
            HByte b10 = new HByte() { Nybbles = new Nybble[2] { n0, n10 } };
            HByte b11 = new HByte() { Nybbles = new Nybble[2] { n0, n11 } };
            HByte b12 = new HByte() { Nybbles = new Nybble[2] { n0, n12 } };
            HByte b13 = new HByte() { Nybbles = new Nybble[2] { n0, n13 } };
            HByte b14 = new HByte() { Nybbles = new Nybble[2] { n0, n14 } };
            HByte b15 = new HByte() { Nybbles = new Nybble[2] { n0, n15 } };
            HByte b16 = new HByte() { Nybbles = new Nybble[2] { n1, n0 } };
            HByte b17 = new HByte() { Nybbles = new Nybble[2] { n1, n1 } };
            HByte b18 = new HByte() { Nybbles = new Nybble[2] { n1, n2 } };
            HByte b19 = new HByte() { Nybbles = new Nybble[2] { n1, n3 } };
            HByte b20 = new HByte() { Nybbles = new Nybble[2] { n1, n4 } };
            HByte b21 = new HByte() { Nybbles = new Nybble[2] { n1, n5 } };
            HByte b22 = new HByte() { Nybbles = new Nybble[2] { n1, n6 } };
            HByte b23 = new HByte() { Nybbles = new Nybble[2] { n1, n7 } };
            HByte b24 = new HByte() { Nybbles = new Nybble[2] { n1, n8 } };
            HByte b25 = new HByte() { Nybbles = new Nybble[2] { n1, n9 } };
            HByte b26 = new HByte() { Nybbles = new Nybble[2] { n1, n10 } };
            HByte b27 = new HByte() { Nybbles = new Nybble[2] { n1, n11 } };
            HByte b28 = new HByte() { Nybbles = new Nybble[2] { n1, n12 } };
            HByte b29 = new HByte() { Nybbles = new Nybble[2] { n1, n13 } };
            HByte b30 = new HByte() { Nybbles = new Nybble[2] { n1, n14 } };
            HByte b31 = new HByte() { Nybbles = new Nybble[2] { n1, n15 } };
            HByte b32 = new HByte() { Nybbles = new Nybble[2] { n2, n0 } };
            HByte b33 = new HByte() { Nybbles = new Nybble[2] { n2, n1 } };
            HByte b34 = new HByte() { Nybbles = new Nybble[2] { n2, n2 } };
            HByte b35 = new HByte() { Nybbles = new Nybble[2] { n2, n3 } };
            HByte b36 = new HByte() { Nybbles = new Nybble[2] { n2, n4 } };
            HByte b37 = new HByte() { Nybbles = new Nybble[2] { n2, n5 } };
            HByte b38 = new HByte() { Nybbles = new Nybble[2] { n2, n6 } };
            HByte b39 = new HByte() { Nybbles = new Nybble[2] { n2, n7 } };
            HByte b40 = new HByte() { Nybbles = new Nybble[2] { n2, n8 } };
            HByte b41 = new HByte() { Nybbles = new Nybble[2] { n2, n9 } };
            HByte b42 = new HByte() { Nybbles = new Nybble[2] { n2, n10 } };
            HByte b43 = new HByte() { Nybbles = new Nybble[2] { n2, n11 } };
            HByte b44 = new HByte() { Nybbles = new Nybble[2] { n2, n12 } };
            HByte b45 = new HByte() { Nybbles = new Nybble[2] { n2, n13 } };
            HByte b46 = new HByte() { Nybbles = new Nybble[2] { n2, n14 } };
            HByte b47 = new HByte() { Nybbles = new Nybble[2] { n2, n15 } };
            HByte b48 = new HByte() { Nybbles = new Nybble[2] { n3, n0 } };
            HByte b49 = new HByte() { Nybbles = new Nybble[2] { n3, n1 } };
            HByte b50 = new HByte() { Nybbles = new Nybble[2] { n3, n2 } };
            HByte b51 = new HByte() { Nybbles = new Nybble[2] { n3, n3 } };
            HByte b52 = new HByte() { Nybbles = new Nybble[2] { n3, n4 } };
            HByte b53 = new HByte() { Nybbles = new Nybble[2] { n3, n5 } };
            HByte b54 = new HByte() { Nybbles = new Nybble[2] { n3, n6 } };
            HByte b55 = new HByte() { Nybbles = new Nybble[2] { n3, n7 } };
            HByte b56 = new HByte() { Nybbles = new Nybble[2] { n3, n8 } };
            HByte b57 = new HByte() { Nybbles = new Nybble[2] { n3, n9 } };
            HByte b58 = new HByte() { Nybbles = new Nybble[2] { n3, n10 } };
            HByte b59 = new HByte() { Nybbles = new Nybble[2] { n3, n11 } };
            HByte b60 = new HByte() { Nybbles = new Nybble[2] { n3, n12 } };
            HByte b61 = new HByte() { Nybbles = new Nybble[2] { n3, n13 } };
            HByte b62 = new HByte() { Nybbles = new Nybble[2] { n3, n14 } };
            HByte b63 = new HByte() { Nybbles = new Nybble[2] { n3, n15 } };
            HByte b64 = new HByte() { Nybbles = new Nybble[2] { n4, n0 } };
            HByte b65 = new HByte() { Nybbles = new Nybble[2] { n4, n1 } };
            HByte b66 = new HByte() { Nybbles = new Nybble[2] { n4, n2 } };
            HByte b67 = new HByte() { Nybbles = new Nybble[2] { n4, n3 } };
            HByte b68 = new HByte() { Nybbles = new Nybble[2] { n4, n4 } };
            HByte b69 = new HByte() { Nybbles = new Nybble[2] { n4, n5 } };
            HByte b70 = new HByte() { Nybbles = new Nybble[2] { n4, n6 } };
            HByte b71 = new HByte() { Nybbles = new Nybble[2] { n4, n7 } };
            HByte b72 = new HByte() { Nybbles = new Nybble[2] { n4, n8 } };
            HByte b73 = new HByte() { Nybbles = new Nybble[2] { n4, n9 } };
            HByte b74 = new HByte() { Nybbles = new Nybble[2] { n4, n10 } };
            HByte b75 = new HByte() { Nybbles = new Nybble[2] { n4, n11 } };
            HByte b76 = new HByte() { Nybbles = new Nybble[2] { n4, n12 } };
            HByte b77 = new HByte() { Nybbles = new Nybble[2] { n4, n13 } };
            HByte b78 = new HByte() { Nybbles = new Nybble[2] { n4, n14 } };
            HByte b79 = new HByte() { Nybbles = new Nybble[2] { n4, n15 } };
            HByte b80 = new HByte() { Nybbles = new Nybble[2] { n5, n0 } };
            HByte b81 = new HByte() { Nybbles = new Nybble[2] { n5, n1 } };
            HByte b82 = new HByte() { Nybbles = new Nybble[2] { n5, n2 } };
            HByte b83 = new HByte() { Nybbles = new Nybble[2] { n5, n3 } };
            HByte b84 = new HByte() { Nybbles = new Nybble[2] { n5, n4 } };
            HByte b85 = new HByte() { Nybbles = new Nybble[2] { n5, n5 } };
            HByte b86 = new HByte() { Nybbles = new Nybble[2] { n5, n6 } };
            HByte b87 = new HByte() { Nybbles = new Nybble[2] { n5, n7 } };
            HByte b88 = new HByte() { Nybbles = new Nybble[2] { n5, n8 } };
            HByte b89 = new HByte() { Nybbles = new Nybble[2] { n5, n9 } };
            HByte b90 = new HByte() { Nybbles = new Nybble[2] { n5, n10 } };
            HByte b91 = new HByte() { Nybbles = new Nybble[2] { n5, n11 } };
            HByte b92 = new HByte() { Nybbles = new Nybble[2] { n5, n12 } };
            HByte b93 = new HByte() { Nybbles = new Nybble[2] { n5, n13 } };
            HByte b94 = new HByte() { Nybbles = new Nybble[2] { n5, n14 } };
            HByte b95 = new HByte() { Nybbles = new Nybble[2] { n5, n15 } };
            HByte b96 = new HByte() { Nybbles = new Nybble[2] { n6, n0 } };
            HByte b97 = new HByte() { Nybbles = new Nybble[2] { n6, n1 } };
            HByte b98 = new HByte() { Nybbles = new Nybble[2] { n6, n2 } };
            HByte b99 = new HByte() { Nybbles = new Nybble[2] { n6, n3 } };
            HByte b100 = new HByte() { Nybbles = new Nybble[2] { n6, n4 } };
            HByte b101 = new HByte() { Nybbles = new Nybble[2] { n6, n5 } };
            HByte b102 = new HByte() { Nybbles = new Nybble[2] { n6, n6 } };
            HByte b103 = new HByte() { Nybbles = new Nybble[2] { n6, n7 } };
            HByte b104 = new HByte() { Nybbles = new Nybble[2] { n6, n8 } };
            HByte b105 = new HByte() { Nybbles = new Nybble[2] { n6, n9 } };
            HByte b106 = new HByte() { Nybbles = new Nybble[2] { n6, n10 } };
            HByte b107 = new HByte() { Nybbles = new Nybble[2] { n6, n11 } };
            HByte b108 = new HByte() { Nybbles = new Nybble[2] { n6, n12 } };
            HByte b109 = new HByte() { Nybbles = new Nybble[2] { n6, n13 } };
            HByte b110 = new HByte() { Nybbles = new Nybble[2] { n6, n14 } };
            HByte b111 = new HByte() { Nybbles = new Nybble[2] { n6, n15 } };
            HByte b112 = new HByte() { Nybbles = new Nybble[2] { n7, n0 } };
            HByte b113 = new HByte() { Nybbles = new Nybble[2] { n7, n1 } };
            HByte b114 = new HByte() { Nybbles = new Nybble[2] { n7, n2 } };
            HByte b115 = new HByte() { Nybbles = new Nybble[2] { n7, n3 } };
            HByte b116 = new HByte() { Nybbles = new Nybble[2] { n7, n4 } };
            HByte b117 = new HByte() { Nybbles = new Nybble[2] { n7, n5 } };
            HByte b118 = new HByte() { Nybbles = new Nybble[2] { n7, n6 } };
            HByte b119 = new HByte() { Nybbles = new Nybble[2] { n7, n7 } };
            HByte b120 = new HByte() { Nybbles = new Nybble[2] { n7, n8 } };

            HChar c0 = new HChar() { Code = b0 };
            HChar c1 = new HChar() { Code = b1 };
            HChar c2 = new HChar() { Code = b2 };
            HChar c3 = new HChar() { Code = b3 };
            HChar c4 = new HChar() { Code = b4 };
            HChar c5 = new HChar() { Code = b5 };
            HChar c6 = new HChar() { Code = b6 };
            HChar c7 = new HChar() { Code = b7 };
            HChar c8 = new HChar() { Code = b8 };
            HChar c9 = new HChar() { Code = b9 };
            HChar c10 = new HChar() { Code = b10 };
            HChar c11 = new HChar() { Code = b11 };
            HChar c12 = new HChar() { Code = b12 };
            HChar c13 = new HChar() { Code = b13 };
            HChar c14 = new HChar() { Code = b14 };
            HChar c15 = new HChar() { Code = b15 };
            HChar c16 = new HChar() { Code = b16 };
            HChar c17 = new HChar() { Code = b17 };
            HChar c18 = new HChar() { Code = b18 };
            HChar c19 = new HChar() { Code = b19 };
            HChar c20 = new HChar() { Code = b20 };
            HChar c21 = new HChar() { Code = b21 };
            HChar c22 = new HChar() { Code = b22 };
            HChar c23 = new HChar() { Code = b23 };
            HChar c24 = new HChar() { Code = b24 };
            HChar c25 = new HChar() { Code = b25 };
            HChar c26 = new HChar() { Code = b26 };
            HChar c27 = new HChar() { Code = b27 };
            HChar c28 = new HChar() { Code = b28 };
            HChar c29 = new HChar() { Code = b29 };
            HChar c30 = new HChar() { Code = b30 };
            HChar c31 = new HChar() { Code = b31 };
            HChar c32 = new HChar() { Code = b32 };
            HChar c33 = new HChar() { Code = b33 };
            HChar c34 = new HChar() { Code = b34 };
            HChar c35 = new HChar() { Code = b35 };
            HChar c36 = new HChar() { Code = b36 };
            HChar c37 = new HChar() { Code = b37 };
            HChar c38 = new HChar() { Code = b38 };
            HChar c39 = new HChar() { Code = b39 };
            HChar c40 = new HChar() { Code = b40 };
            HChar c41 = new HChar() { Code = b41 };
            HChar c42 = new HChar() { Code = b42 };
            HChar c43 = new HChar() { Code = b43 };
            HChar c44 = new HChar() { Code = b44 };
            HChar c45 = new HChar() { Code = b45 };
            HChar c46 = new HChar() { Code = b46 };
            HChar c47 = new HChar() { Code = b47 };
            HChar c48 = new HChar() { Code = b48 };
            HChar c49 = new HChar() { Code = b49 };
            HChar c50 = new HChar() { Code = b50 };
            HChar c51 = new HChar() { Code = b51 };
            HChar c52 = new HChar() { Code = b52 };
            HChar c53 = new HChar() { Code = b53 };
            HChar c54 = new HChar() { Code = b54 };
            HChar c55 = new HChar() { Code = b55 };
            HChar c56 = new HChar() { Code = b56 };
            HChar c57 = new HChar() { Code = b57 };
            HChar c58 = new HChar() { Code = b58 };
            HChar c59 = new HChar() { Code = b59 };
            HChar c60 = new HChar() { Code = b60 };
            HChar c61 = new HChar() { Code = b61 };
            HChar c62 = new HChar() { Code = b62 };
            HChar c63 = new HChar() { Code = b63 };
            HChar c64 = new HChar() { Code = b64 };
            HChar c65 = new HChar() { Code = b65 };
            HChar c66 = new HChar() { Code = b66 };
            HChar c67 = new HChar() { Code = b67 };
            HChar c68 = new HChar() { Code = b68 };
            HChar c69 = new HChar() { Code = b69 };
            HChar c70 = new HChar() { Code = b70 };
            HChar c71 = new HChar() { Code = b71 };
            HChar c72 = new HChar() { Code = b72 };
            HChar c73 = new HChar() { Code = b73 };
            HChar c74 = new HChar() { Code = b74 };
            HChar c75 = new HChar() { Code = b75 };
            HChar c76 = new HChar() { Code = b76 };
            HChar c77 = new HChar() { Code = b77 };
            HChar c78 = new HChar() { Code = b78 };
            HChar c79 = new HChar() { Code = b79 };
            HChar c80 = new HChar() { Code = b80 };
            HChar c81 = new HChar() { Code = b81 };
            HChar c82 = new HChar() { Code = b82 };
            HChar c83 = new HChar() { Code = b83 };
            HChar c84 = new HChar() { Code = b84 };
            HChar c85 = new HChar() { Code = b85 };
            HChar c86 = new HChar() { Code = b86 };
            HChar c87 = new HChar() { Code = b87 };
            HChar c88 = new HChar() { Code = b88 };
            HChar c89 = new HChar() { Code = b89 };
            HChar c90 = new HChar() { Code = b90 };
            HChar c91 = new HChar() { Code = b91 };
            HChar c92 = new HChar() { Code = b92 };
            HChar c93 = new HChar() { Code = b93 };
            HChar c94 = new HChar() { Code = b94 };
            HChar c95 = new HChar() { Code = b95 };
            HChar c96 = new HChar() { Code = b96 };
            HChar c97 = new HChar() { Code = b97 };
            HChar c98 = new HChar() { Code = b98 };
            HChar c99 = new HChar() { Code = b99 };
            HChar c100 = new HChar() { Code = b100 };
            HChar c101 = new HChar() { Code = b101 };
            HChar c102 = new HChar() { Code = b102 };
            HChar c103 = new HChar() { Code = b103 };
            HChar c104 = new HChar() { Code = b104 };
            HChar c105 = new HChar() { Code = b105 };
            HChar c106 = new HChar() { Code = b106 };
            HChar c107 = new HChar() { Code = b107 };
            HChar c108 = new HChar() { Code = b108 };
            HChar c109 = new HChar() { Code = b109 };
            HChar c110 = new HChar() { Code = b110 };
            HChar c111 = new HChar() { Code = b111 };
            HChar c112 = new HChar() { Code = b112 };
            HChar c113 = new HChar() { Code = b113 };
            HChar c114 = new HChar() { Code = b114 };
            HChar c115 = new HChar() { Code = b115 };
            HChar c116 = new HChar() { Code = b116 };
            HChar c117 = new HChar() { Code = b117 };
            HChar c118 = new HChar() { Code = b118 };
            HChar c119 = new HChar() { Code = b119 };
            HChar c120 = new HChar() { Code = b120 };

            //72 101 108 108 111 32 87 111 114 108 100 
            Console.WriteLine(c72.ToChar() + "" + c101.ToChar() + c108.ToChar() + c108.ToChar() + c111.ToChar() + c32.ToChar() + c87.ToChar() + c111.ToChar() + c114.ToChar() + c108.ToChar() + c100.ToChar());
            Console.ReadLine();
        }

        public static string FixString(string s, int length)
        {
            return s.Length < length ? FixString("0" + s, length) : s;
        }

    }

    class HChar
    {
        private HByte code;

        public HChar()
        {
            code = new HByte();
        }

        public HByte Code
        {
            get
            {
                return code;
            }
            set
            {
                code = value;
            }
        }

        public char ToChar()
        {
            return (char)Convert.ToUInt32(code + "", 2);
        }

        public override string ToString()
        {
            return base.ToString();
        }

    }

    struct Bit
    {
        private bool state;

        public bool State
        {
            get
            {
                return state;
            }
            set
            {
                state = value;
            }
        }

        public override string ToString()
        {
            return state ? "1" : "0";
        }
    }

    class Nybble
    {
        private Bit[] bits;

        public Nybble()
        {
            bits = new Bit[4];
        }

        public Bit[] Bits
        {
            get
            {
                return bits;
            }
            set
            {
                bits = value;
            }
        }

        public static Nybble Parse(string s)
        {
            s = P.FixString(s, 4);

            Nybble n = new Nybble();

            for (int i = 0; i < 4; i++)
            {
                n.bits[i].State = s[i] == '1';
            }

            return n;
        }


        public override string ToString()
        {
            Text.StringBuilder sb = new Text.StringBuilder();

            foreach (Bit b in bits )
            {
                sb.Append(b + "");
            }

            return sb + "";
        }
    }

    class HByte
    {
        private Nybble[] nybbles;

        public HByte()
        {
            nybbles = new Nybble[2];
        }

        public Nybble[] Nybbles
        {
            get
            {
                return nybbles;
            }
            set
            {
                nybbles = value;
            }
        }

        public static HByte SetAsByte(byte b)
        {
            var hb = new HByte();
            hb.Nybbles[0] = Nybble.Parse(Convert.ToString((byte)(b << 4) >> 4, 2));
            hb.Nybbles[1] = Nybble.Parse(Convert.ToString((b >> 4), 2));
            return hb;
        }

        public static HByte Parse(string s)
        {
            s = P.FixString(s, 8);
            var hb = new HByte();
            for (int i = 0; i < 2; i++)
                hb.Nybbles[i] = Nybble.Parse(s.Substring(i * 4, 4));
            return hb;
        }

        public override string ToString()
        {
            return nybbles[0] + "" + nybbles[1];
        }
    }
}

Comments

প্রযোজনায় থাকা সাধারণ সি #

— -কোডের

Answer 14

package my.complex.hello.world;

/**
 * Messages have the purpose to be passed as communication between
 * different parts of the system.
 * @param <B> The type of the message content.
 */
public interface Message<B> {

    /**
     * Returns the body of the message.
     * @return The body of the message.
     */
    public B getMessageBody();

    /**
     * Shows this message in the given display.
     * @param display The {@linkplain Display} where the message should be show.
     */
    public void render(Display display);
}

package my.complex.hello.world;

/**
 * This abstract class is a partial implementation of the {@linkplain Message}
 * interface, which provides a implementation for the {@linkplain #getMessageBody()}
 * method.
 * @param <B> The type of the message content.
 */
public abstract class AbstractGenericMessageImpl<B> implements Message<B> {

    private B messageBody;

    public GenericMessageImpl(B messageBody) {
        this.messageBody = messageBody;
    }

    public void setMessageBody(B messageBody) {
        this.messageBody = messageBody;
    }

    @Override
    public B getMessageBody() {
        return messageContent;
    }
}

package my.complex.hello.world;

public class StringMessage extends AbstractGenericMessageImpl<String> {

    public StringText(String text) {
        super(text);
    }

    /**
     * {@inheritDoc}
     * @param display {@inheritDoc}
     */
    @Override
    public void render(Display display) {
        if (display == null) {
            throw new IllegalArgumentException("The display should not be null.");
        }
        display.printString(text);
        display.newLine();
    }
}

package my.complex.hello.world;

import java.awt.Color;
import java.awt.Image;

/**
 * A {@code Display} is a canvas where objects can be drawn as output.
 */
public interface Display {
    public void printString(String text);
    public void newLine();
    public Color getColor();
    public void setColor(Color color);
    public Color getBackgroundColor();
    public void setBackgroundColor(Color color);
    public void setXPosition(int xPosition);
    public int getXPosition();
    public void setYPosition(int yPosition);
    public int getYPosition();
    public void setFontSize(int fontSize);
    public int getFontSize();
    public void setDrawAngle(float drawAngle);
    public float getDrawAngle();
    public void drawImage(Image image);
    public void putPixel();
}

package my.complex.hello.world;

import java.awt.Color;
import java.awt.Image;
import java.io.PrintStream;

/**
 * The {@code ConsoleDisplay} is a type of {@linkplain Display} that renders text
 * output to {@linkplain PrintWriter}s. This is a very primitive type of
 * {@linkplain Display} and is not capable of any complex drawing operations.
 * All the drawing methods throws an {@linkplain UnsupportedOpeartionException}.
 */
public class ConsoleDisplay implements Display {

    private PrintWriter writer;

    public ConsoleDisplay(PrintWriter writer) {
        this.writer = writer;
    }

    public void setWriter(PrintWriter writer) {
        this.writer = writer;
    }

    public PrintWriter getWriter() {
        return writer;
    }

    @Override
    public void printString(String text) {
        writer.print(text);
    }

    @Override
    public void newLine() {
        writer.println();
    }

    @Override
    public Color getColor() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setColor(Color color) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public Color getBackgroundColor() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setBackgroundColor(Color color) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setXPosition(int xPosition) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public int getXPosition() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setYPosition(int yPosition) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public int getYPosition() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setFontSize(int fontSize) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public int getFontSize() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void setDrawAngle(float drawAngle) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public float getDrawAngle() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void drawImage(Image image) {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }

    @Override
    public void putPixel() {
        throw new UnsupportedOperationExcepion("The Console display can't operate with graphics.");
    }
}

package my.complex.hello.world;

/**
 * A {@linkplain Display} is a complex object. To decouple the creation of the
 * {@linkplain Display} from it's use, an object for it's creation is needed. This
 * interface provides a way to get instances of these {@linkplain Display}s.
 */
public interface DisplayFactory {
    public Display getDisplay();
}

package my.complex.hello.world;

/**
 * A {@linkplain DisplayFactory} that always produces {@linkplain ConsoleDisplay}s
 * based on the {@linkplain System#out} field. This class is a singleton, and instances
 * should be obtained through the {@linkplain #getInstance()} method.
 */
public final class ConsoleDisplayFactory implements DisplayFactory {
    private static final ConsoleDisplayFactory instance = new ConsoleDisplayFactory();

    private final ConsoleDisplay display;

    public static ConsoleDisplayFactory getInstance() {
        return instance;
    }

    private ConsoleDisplayFactory() {
        display = new ConsoleDisplay(System.out);
    }

    @Override
    public ConsoleDisplay getDisplay() {
        return display;
    }
}

package my.complex.hello.world;

public class Main {
    public static void main(String[] args) {
        Display display = ConsoleDisplay.getInstance().getDisplay();
        StringMessage message = new StringMessage("Hello World");
        message.render(display);
    }
}

আমি পরে কিছু মন্তব্য যুক্ত করব।

Comments

"আমি পরে কিছু মন্তব্য যুক্ত করব।" কত পরে?

— celtschk

ফাংশনে mainক্লাসের Main: ConsoleDisplayসদস্য নামে নেই getInstance। মানে ConsoleDisplayFactory? বিটিডাব্লু, দয়া করে স্পষ্টভাবে ভাষাটি (জাভা আমার অনুমান) এবং পয়েন্টগুলি লিখুন।

— celtschk

@ এসলেটস্ক্ক: অনেক পরে

— সিলভিউ বুর্সিয়া

Answer 15

পয়েন্ট: 183

• 62 বিবৃতি *
• 10 ক্লাস + 25 পদ্ধতি (বৈশিষ্ট্য 'প্রাপ্তকারী এবং সেটারগুলি পৃথক) + 8 ভেরিয়েবল ঘোষণা (আমার মনে হয়) = কোনও কিছুর 43 টি ঘোষণা
• কোনও মডিউল ব্যবহারের বিবৃতি নেই। যদিও এতে কিছু ডিফল্ট রয়েছে এবং পুরো যোগ্যতাটি ব্যবহার করা আমার বোলিংয়ের অংশ ছিল। তাহলে হয়ত 1 এর জন্য System? ঠিক আছে, যাইহোক, 0 বলা যাক।
• 1 উত্স ফাইল।
• ফরওয়ার্ড ডিক্লেয়ারেশন ব্যবহার করে এমন কোনও ভাষা নয়। ভাল, 1 MustOverride, যা আমি গণনা করব।
• 76 নিয়ন্ত্রণ বিবৃতি। ম্যানুয়ালি গণনা করা হয়নি তাই কিছুটা ভুল হতে পারে।

মোট: 62 + 43 + 0 + 1 + 1 + 76 = 183

প্রবেশ

Public NotInheritable Class OptimizedStringFactory
    Private Shared ReadOnly _stringCache As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.IEnumerable(Of Char)) = New System.Collections.Generic.List(Of System.Collections.Generic.IEnumerable(Of Char))

    Private Shared ReadOnly Property StringCache() As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.IEnumerable(Of Char))
        Get
            Debug.Assert(OptimizedStringFactory._stringCache IsNot Nothing)

            Return OptimizedStringFactory._stringCache
        End Get
    End Property

    Public Shared Function GetOrCache(ByRef s As System.Collections.Generic.IEnumerable(Of Char)) As String
        If s IsNot Nothing Then
            Dim equalFlag As Boolean = False

            For Each cachedStringItemInCache As System.Collections.Generic.IEnumerable(Of Char) In OptimizedStringFactory.StringCache
                equalFlag = True

                For currentStringCharacterIndex As Integer = 0 To cachedStringItemInCache.Count() - 1
                    If equalFlag AndAlso cachedStringItemInCache.Skip(currentStringCharacterIndex).FirstOrDefault() <> s.Skip(currentStringCharacterIndex).FirstOrDefault() Then
                        equalFlag = False
                    End If
                Next

                If Not equalFlag Then
                    Continue For
                End If

                Return New String(cachedStringItemInCache.ToArray())
            Next

            DirectCast(OptimizedStringFactory.StringCache, System.Collections.Generic.IList(Of System.Collections.Generic.IEnumerable(Of Char))).Add(s)

            Return OptimizedStringFactory.GetOrCache(s)
        End If
    End Function
End Class

Public MustInherit Class ConcurrentCharacterOutputter
    Public Event OutputComplete()

    Private _previousCharacter As ConcurrentCharacterOutputter
    Private _canOutput, _shouldOutput As Boolean

    Public WriteOnly Property PreviousCharacter() As ConcurrentCharacterOutputter
        Set(ByVal value As ConcurrentCharacterOutputter)
            If Me._previousCharacter IsNot Nothing Then
                RemoveHandler Me._previousCharacter.OutputComplete, AddressOf Me.DoOutput
            End If

            Me._previousCharacter = value

            If value IsNot Nothing Then
                AddHandler Me._previousCharacter.OutputComplete, AddressOf Me.DoOutput
            End If
        End Set
    End Property

    Protected Property CanOutput() As Boolean
        Get
            Return _canOutput
        End Get
        Set(ByVal value As Boolean)
            Debug.Assert(value OrElse Not value)

            _canOutput = value
        End Set
    End Property

    Protected Property ShouldOutput() As Boolean
        Get
            Return _shouldOutput
        End Get
        Set(ByVal value As Boolean)
            Debug.Assert(value OrElse Not value)

            _shouldOutput = value
        End Set
    End Property

    Protected MustOverride Sub DoOutput()

    Public Sub Output()
        Me.CanOutput = True

        If Me.ShouldOutput OrElse Me._previousCharacter Is Nothing Then
            Me.CanOutput = True
            Me.DoOutput()
        End If
    End Sub

    Protected Sub Finished()
        RaiseEvent OutputComplete()
    End Sub
End Class

Public NotInheritable Class HCharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.Write("H"c)
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class ECharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.Write("e"c)
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class WCharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.Write("w"c)
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class OCharacter
    Inherits ConcurrentCharacterOutputter

    Private Shared Called As Boolean = False

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            If OCharacter.Called Then
                Console.Write("o"c)
            Else
                Console.Write("o ")
                OCharacter.Called = True
            End If
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class RCharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.Write("r"c)
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class LCharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.Write("l"c)
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public NotInheritable Class DCharacter
    Inherits ConcurrentCharacterOutputter

    Protected Overrides Sub DoOutput()
        If Me.CanOutput Then
            Console.WriteLine("d")
            Me.Finished()
        Else
            Me.ShouldOutput = True
        End If
    End Sub
End Class

Public Module MainApplicationModule
    Private Function CreateThread(ByVal c As Char) As System.Threading.Thread
        Static last As ConcurrentCharacterOutputter

        Dim a As System.Reflection.Assembly = System.Reflection.Assembly.GetExecutingAssembly()
        Dim cco As ConcurrentCharacterOutputter = DirectCast(a.CreateInstance(GetType(MainApplicationModule).Namespace & "."c & Char.ToUpper(c) & "Character"), ConcurrentCharacterOutputter)
        cco.PreviousCharacter = last
        last = cco

        Return New System.Threading.Thread(AddressOf cco.Output) With {.IsBackground = True}
    End Function

    Public Sub Main()
        Dim threads As New List(Of System.Threading.Thread)

        For Each c As Char In "Helloworld"
            threads.Add(MainApplicationModule.CreateThread(c))
        Next

        For Each t As System.Threading.Thread In threads
            t.Start()
        Next

        For Each t As System.Threading.Thread In threads
            t.Join()
        Next
    End Sub
End Module

নথিপত্র

• কোডটিতে কোনও মন্তব্য নেই। এটি বিশৃঙ্খলা হ্রাস করতে সহায়তা করে এবং মন্তব্যগুলি অপ্রয়োজনীয় কারণ নির্বিশেষে আমিই একমাত্র বিকাশকারী এবং আমাদের কাছে এই আশ্চর্যজনক, বিস্তারিত ডকুমেন্টেশন রয়েছে - আবারও সত্যই আপনার লেখা।
• OptimizedStringFactoryঅপ্টিমাইজ স্ট্রিং ঝুলিতে। এটিতে একটি ক্যাশে রয়েছে যা রেফারেন্সগুলির IEnumerable(Of Char)অন্তর্নিহিত সমস্যাগুলি এড়িয়ে চলাকালীন দক্ষ to এটি আমার নজরে আনা হয়েছে যে। নেট মধ্যে কিছু ধরণের স্ট্রিং পুল রয়েছে। যাইহোক, অন্তর্নির্মিত ক্যাচিং আমরা যে জিনিসগুলি ব্যবহার করছি তা সম্পর্কে যথেষ্ট পরিমাণে জানে না - এটি অবিশ্বাস্য, তাই আমি আমার নিজস্ব সমাধান তৈরি করেছি।
• ConcurrentOutputCharacterবর্গ মাল্টি, একক-অক্ষর আউটপুট সহজ সিঙ্ক্রোনাইজেশন জন্য করতে পারবেন। এটি আউটপুট গার্ফ হয়ে যাওয়া বন্ধ করে। অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিংয়ের সর্বোত্তম অনুশীলনে এটি ঘোষিত হয় MustInheritএবং প্রতিটি চরিত্র বা আউটপুট থেকে স্ট্রিং এখান থেকে উদ্ভূত হয় এবং ঘোষিত হয় NotInheritable। এটিতে বৈধ ডেটা উত্তীর্ণ হওয়ার আশ্বাসের জন্য বেশ কয়েকটি যুক্তি রয়েছে।
• *Characterস্ট্রিং আউটপুট সম্পর্কিত আমাদের নির্দিষ্ট ক্ষেত্রে প্রতিটি ক্ষেত্রে একটি একক অক্ষর থাকে।
• মূল মডিউলটিতে থ্রেডগুলি তৈরি করার কোড রয়েছে। থ্রেডিং একটি খুব নতুন বৈশিষ্ট্য যা আমাদের মাল্টিকোর প্রসেসরের সুবিধা নিতে এবং আরও দক্ষতার সাথে আউটপুট প্রসেস করতে দেয়। কোড সদৃশতা রোধ করতে, আমি অক্ষরগুলি তৈরি করতে একটি লুপ ব্যবহার করেছি।

সুন্দর, না?

পূর্বোক্ত লুপগুলি এবং উত্তরাধিকারের কারণে গতিশীল, প্রতিবিম্ব-ভিত্তিক শ্রেণীর লোডের কারণে এটি এমনকি বর্ধমান। এটি অত্যধিক হিংস্র অবসন্নতা রোধ করে, তাই কেউ আমাদের কোডটি অবলম্বন করে দাবি করতে পারে না। স্ট্রিংগুলি পরিবর্তন করতে, কেবল একটি অভিধান তৈরি করুন যা প্রতিফলন কোডটি গতিশীলভাবে লোড করার আগে বিভিন্ন আউটপুট অক্ষরের শ্রেণিতে ইনপুট অক্ষরকে মানচিত্র করে।

Comments

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

— celtschk

এটি কোন ভাষা, ভিবি? আমি কি এটি লিনাক্সে চালাতে পারি?

— ব্যবহারকারী অজানা

@ ব্যবহারকারী-অজ্ঞাত: ভিবি.এনইটি। আপনি এটি লিনাক্সে চালানোর জন্য মনো ব্যবহার করতে পারেন।

— রাই-

@ এসলেটস্ক্ক: এখনই সংশোধন করা হয়েছে। এটি সর্বোপরি এক্সটেনসিবল;)

— রাই-

এখনও গণনা প্রক্রিয়া চলছে?

— ব্যবহারকারী অজানা

Answer 16

জাভাস্ক্রিপ্ট, প্রচুর পয়েন্ট

• সম্পূর্ণরূপে সংহত i18n সমর্থন n
• মাল্টিপ্লাটফর্ম জেএস, অনুকূলিতযোগ্য প্রসঙ্গে নোড এবং ওয়েব ব্রাউজারগুলিতে চলতে পারে (ব্রাউজারগুলিকে "উইন্ডো" ব্যবহার করা উচিত)
• কনফিগারযোগ্য ডেটা উত্স, স্থির "হ্যালো ওয়ার্ল্ড" বার্তাটি ডিফল্ট হিসাবে ব্যবহার করে (পারফরম্যান্সের জন্য)
• পুরোপুরি অ্যাসিঙ্ক, দুর্দান্ত সম্মতি
• কোড ডাকে সময় বিশ্লেষণ সহ ভাল ডিবাগিং মোড।

এখানে আমরা যাচ্ছি:

(function(context){
    /**
     * Basic app configuration
    */
    var config = {
        DEBUG:            true,
        WRITER_SIGNATURE: "write",
        LANGUAGE:         "en-US" // default language
    };

    /**
     * Hardcoded translation data
    */
    var translationData = {
        "en-US": {
            "hello_world":       "Hello World!", // greeting in main view
            "invocation":        "invoked", // date of invokation
            "styled_invocation": "[%str%]" // some decoration for better style
        }
    };

    /**
     * Internationalization module
     * Supports dynamic formatting and language pick after load
    */
    var i18n = (function(){
        return {
            format: function(source, info){ // properly formats a i18n resource
                return source.replace("%str%", info);
            },
            originTranslate: function(origin){
                var invoc_stf = i18n.translate("invocation") + " " + origin.lastModified;
                return i18n.format(i18n.translate("styled_invocation"), invoc_stf);
            },
            translate: function(message){
                var localData = translationData[config.LANGUAGE];
                return localData[message];
            },
            get: function(message, origin){
                var timestamp = origin.lastModified;
                if(config.DEBUG)
                    return i18n.translate(message) + " " + i18n.originTranslate(origin);
                else
                    return i18n.translate(message);
            }
        };
    }());

    /**
     * A clone of a document-wrapper containing valid, ready DOM
    */
    var fallbackDocument = function(){
        var _document = function(){
            this.native_context = context;
            this.modules = new Array();
        };
        _document.prototype.clear = function(){
            for(var i = 0; i < this.modules.length; i++){
                var module = this.modules[i];
                module.signalClear();
            };
        };

        return _document;
    };

    /**
     * Provides a native document, scoped to the context
     * Uses a fallback if document not initialized or not supported
    */
    var provideDocument = function(){
        if(typeof context.document == "undefined")
            context.document = new fallbackDocument();
        context.document.lastModified = new context.Date();
        context.document.exception = function(string_exception){
            this.origin = context.navigator;
            this.serialized = string_exception;
        };

        return context.document;
    };

    /**
     * Sends a data request, and tries to call the document writer
    */
    var documentPrinter = function(document, dataCallback){
        if(dataCallback == null)
            throw new document.exception("Did not receive a data callback!");
        data = i18n.get(dataCallback(), document); // translate data into proper lang.
        if(typeof document[config.WRITER_SIGNATURE] == "undefined")
            throw new document.exception("Document provides no valid writer!");

        var writer = document[config.WRITER_SIGNATURE]; 
        writer.apply(document, [data]); //apply the writer using correct context
    };

    /**
     * Produces a "Hello world" message-box
     * Warning! Message may vary depending on initial configuration
    */
    var HelloWorldFactory = (function(){
        return function(){
            this.produceMessage = function(){
                this.validDocument = provideDocument();
                new documentPrinter(this.validDocument, function(){
                    return "hello_world";
                });
            };
        };
    }());

    context.onload = function(){ // f**k yeah! we are ready
        try{
        var newFactory = new HelloWorldFactory();
        newFactory.produceMessage();
        } catch(err){
            console.log(err); // silently log the error
        };
    };
}(window || {}));

Answer 17

হ্যালো ওয়ার্ল্ডের জন্য সি প্রোগ্রাম: 9 (?)

#include<stdio.h>
void main(){
char a[100]={4,1,8,8,11,-68,19,11,14,8,0,0};
for(;a[12]<a[4];a[12]++)
 {
    printf("%c",sizeof(a)+a[a[12]]);
 }
}

ASCII অক্ষর এবং অক্ষরের অ্যারের সংমিশ্রণটি পূর্ণসংখ্যা সহ! মূলত, প্রতিটি অঙ্ক অক্ষর বিন্যাসে মুদ্রণ।

Comments

এটি +1 হ'ল কারণ এটি বেশ দুর্দান্ত, তবে আপনি কীভাবে আমাকে ন্যায়সঙ্গত করবেন?

— ইজাবেরের

উফ! লুপের কাউন্টার হিসাবে আমি ব্যবহার করছিলাম it'sএর ঘোষণাটি সরাতে ফটোগুলি। লক্ষ্য করার জন্য ধন্যবাদ।

— সুশান্ত পরব

Answer 18

পাইথন যদি-অন্য বিবৃতি ব্যবহার করে

from itertools import permutations
from sys import stdout, argv

reference = { 100: 'd', 101: 'e', 104: 'h', 108: 'l', 111: 'o', 114: 'r', 119: 'w' }
vowels = [ 'e', 'o' ]
words = [ 
    { 'len': 5, 'first': 104, 'last': 111, 'repeat': True, 'r_char': 108 }, 
    { 'len': 5, 'first': 119, 'last': 100, 'repeat': False, 'r_char': None }
    ]
second_last = 108

def find_words(repeat, r_char):
    output = []
    chars = [ y for x, y in reference.iteritems() ]
    if repeat:
        chars.append(reference[r_char])
    for value in xrange(0, len(chars)):
        output += [ x for x in permutations(chars[value:]) ]
    return output

def filter_word(value, first, last, repeat, r_char):
    output = False
    value = [ x for x in value ]
    first_char, second_char, second_last_char, last_char = value[0], value[1], value[-2], value[-1]
    if first_char == first and last_char == last and second_char != last_char and ord(second_last_char) == second_last:
        if second_char in vowels and second_char in [ y for x, y in reference.iteritems() ]:
            string = []
            last = None
            for char in value:
                if last != None:
                    if char == last and char not in vowels:
                        string.append(char)
                    elif char != last:
                        string.append(char)
                else:
                    string.append(char)
                last = char
            if len(string) == len(value):
                if repeat:
                    last = None
                    for char in value:
                        if last != None:
                            if char == last:
                                output = True
                        last = char
                else:
                    third_char = value[2]
                    if ord(third_char) > ord(second_last_char) and ord(second_char) > ord(second_last_char):
                        output = True
    return output

def find_word(values, first, last, length, repeat, r_char):
    first, last, output, items, count = reference[first], reference[last], [], [], 0
    if repeat:
        r_char = reference[r_char]
    for value in values:
        count += 1
        for item in [ x[:length] for x in permutations(value) ]:
            item = ''.join(item)
            if item not in items and filter_word(value=item, first=first, last=last, r_char=r_char, repeat=repeat):
                items.append(item)
        if debug:
            count_out = '(%s/%s) (%s%%) (%s found)' % (count, len(values), (round(100 * float(count) / float(len(values)), 2)), len(items))
            stdout.write('%s%s' % (('\r' * len(count_out)), count_out))
            stdout.flush()
        if len(items) >= 1 and aggressive:
            break
    for item in items:
        output.append(item)
    return output

if __name__ == '__main__':
    debug = 'debug' in argv
    aggressive = 'aggressive' not in argv
    if debug:
        print 'Building string...'
    data = []
    for word in words:
        repeat = word['repeat']
        r_char = word['r_char']
        length = word['len']
        first_letter = word['first']
        last_letter = word['last']
        possible = find_words(repeat=repeat, r_char=r_char)
        data.append(find_word(values=possible, first=first_letter, last=last_letter, length=5, repeat=repeat, r_char=r_char))
    print ' '.join(x[0] for x in data)

ব্যাখ্যা

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

এটি সম্পন্ন করার পরে, আমরা শব্দের দৈর্ঘ্য, এর প্রথম, শেষ এবং পুনরাবৃত্তি অক্ষরগুলি নির্ধারণ করে এমন নিয়মের সাথে অভিধানের একটি তালিকা তৈরি করি এবং তারপরে পুনরাবৃত্তিগুলি পরীক্ষা করা উচিত কিনা এর জন্য একটি সত্য / মিথ্যা বিবৃতিও সেট করি।

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

এরপরে, এটি দ্বিতীয় ফাংশনের মাধ্যমে খাওয়ানো হয় যা প্রতিটি অনুক্রমের জন্য আরও বেশি ক্রমান্বয়ে তৈরি করে তবে সর্বোচ্চ দৈর্ঘ্য নির্ধারণ করে। আমরা যে শব্দগুলি চিবাতে চাই তা আমরা খুঁজে পাই তা নিশ্চিত করার জন্য এটি করা হয়। এই প্রক্রিয়া চলাকালীন, এটি এর পরে এটি এমন কোনও ফাংশনের মাধ্যমে ফিড দেয় যা যদি-অন্য বিবৃতিগুলির সংমিশ্রণ ব্যবহার করে যা নির্ধারণ করে যে এটি স্পট আউট হওয়ার যোগ্য কিনা। যদি বিবৃতিগুলির জন্য যা চাওয়া হয় তা যদি ক্রমটির সাথে মিলে যায়, তবে এটি একটি সত্য / মিথ্যা বিবৃতি এবং যে ফাংশন এটি বলে তাকে এটি একটি তালিকায় যুক্ত করে sp

এটি হয়ে গেলে, স্ক্রিপ্টটি প্রতিটি তালিকা থেকে প্রথম আইটেম নেয় এবং তাদেরকে "হ্যালো ওয়ার্ল্ড" বর্ণিত করে।

আমি কতটা ডিবাগ বৈশিষ্ট্য যুক্ত করেছি তা আপনাকে জানাতে যে এটি কী ধীরে চলছে। বাক্যটি কীভাবে বানানো যায় তা যদি আপনি জানেন তবে "হ্যালো ওয়ার্ল্ড" লেখার জন্য আপনার "হ্যালো ওয়ার্ল্ড" লেখার দরকার নেই বলে আমি এটি করার জন্য বেছে নিয়েছি।

Answer 19

ভাল, এটা ভাল।

[
  uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
  ]
  library LHello
  {
      // bring in the master library
      importlib("actimp.tlb");
      importlib("actexp.tlb");

      // bring in my interfaces
      #include "pshlo.idl"

      [
      uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
      ]
      cotype THello
   {
   interface IHello;
   interface IPersistFile;
   };
  };

  [
  exe,
  uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
  ]
  module CHelloLib
  {

      // some code related header files
      importheader(<windows.h>);
      importheader(<ole2.h>);
      importheader(<except.hxx>);
      importheader("pshlo.h");
      importheader("shlo.hxx");
      importheader("mycls.hxx");

      // needed typelibs
      importlib("actimp.tlb");
      importlib("actexp.tlb");
      importlib("thlo.tlb");

      [
      uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
      aggregatable
      ]
      coclass CHello
   {
   cotype THello;
   };
  };


  #include "ipfix.hxx"

  extern HANDLE hEvent;

  class CHello : public CHelloBase
  {
  public:
      IPFIX(CLSID_CHello);

      CHello(IUnknown *pUnk);
      ~CHello();

      HRESULT  __stdcall PrintSz(LPWSTR pwszString);

  private:
      static int cObjRef;
  };


  #include <windows.h>
  #include <ole2.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include "thlo.h"
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"

  int CHello::cObjRef = 0;

  CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
  {
      cObjRef++;
      return;
  }

  HRESULT  __stdcall  CHello::PrintSz(LPWSTR pwszString)
  {
      printf("%ws
", pwszString);
      return(ResultFromScode(S_OK));
  }


  CHello::~CHello(void)
  {

  // when the object count goes to zero, stop the server
  cObjRef--;
  if( cObjRef == 0 )
      PulseEvent(hEvent);

  return;
  }

  #include <windows.h>
  #include <ole2.h>
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"

  HANDLE hEvent;

   int _cdecl main(
  int argc,
  char * argv[]
  ) {
  ULONG ulRef;
  DWORD dwRegistration;
  CHelloCF *pCF = new CHelloCF();

  hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

  // Initialize the OLE libraries
  CoInitializeEx(NULL, COINIT_MULTITHREADED);

  CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
      REGCLS_MULTIPLEUSE, &dwRegistration);

  // wait on an event to stop
  WaitForSingleObject(hEvent, INFINITE);

  // revoke and release the class object
  CoRevokeClassObject(dwRegistration);
  ulRef = pCF->Release();

  // Tell OLE we are going away.
  CoUninitialize();

  return(0); }

  extern CLSID CLSID_CHello;
  extern UUID LIBID_CHelloLib;

  CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
      0x2573F891,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };

  UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
      0x2573F890,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };

  #include <windows.h>
  #include <ole2.h>
  #include <stdlib.h>
  #include <string.h>
  #include <stdio.h>
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "clsid.h"

  int _cdecl main(
  int argc,
  char * argv[]
  ) {
  HRESULT  hRslt;
  IHello        *pHello;
  ULONG  ulCnt;
  IMoniker * pmk;
  WCHAR  wcsT[_MAX_PATH];
  WCHAR  wcsPath[2 * _MAX_PATH];

  // get object path
  wcsPath[0] = '\0';
  wcsT[0] = '\0';
  if( argc > 1) {
      mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
      wcsupr(wcsPath);
      }
  else {
      fprintf(stderr, "Object path must be specified\n");
      return(1);
      }

  // get print string
  if(argc > 2)
      mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
  else
      wcscpy(wcsT, L"Hello World");

  printf("Linking to object %ws\n", wcsPath);
  printf("Text String %ws\n", wcsT);

  // Initialize the OLE libraries
  hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);

  if(SUCCEEDED(hRslt)) {


      hRslt = CreateFileMoniker(wcsPath, &pmk);
      if(SUCCEEDED(hRslt))
   hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

      if(SUCCEEDED(hRslt)) {

   // print a string out
   pHello->PrintSz(wcsT);

   Sleep(2000);
   ulCnt = pHello->Release();
   }
      else
   printf("Failure to connect, status: %lx", hRslt);

      // Tell OLE we are going away.
      CoUninitialize();
      }

  return(0);
  }

Answer 20

গল্ফ-বেসিক 84, 9 পয়েন্ট

i`I@I:1_A#:0_A@I:0_A#:Endt`Hello World"

ব্যাখ্যা

i`I

ব্যবহারকারী যদি তারা প্রস্থান করতে চান তবে জিজ্ঞাসা করুন

@I:1_A#0_A

তাদের উত্তর রেকর্ড করুন

@I:0_A#:End

যদি তারা বাস্তবে শেষ করতে চায় তবে এটি সমাপ্ত হবে

t`Hello World"

যদি তারা শেষ না করে, এটি হ্যালো ওয়ার্ল্ড প্রিন্ট করে।

Answer 21

"হ্যালো, ওয়ার্ল্ড!" এর জন্য অক্ষরগুলি হ্যাশগুলি এবং তারপরে নৃশংস বাহিনী ডি-হ্যাশগুলি এটিকে যুক্ত করে এবং লগারের সাহায্যে StringBuilderলগ করে।

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.security.provider.SHA2;

/**
 * ComplexHelloWorld, made for a challenge, is copyright Blue Husky Programming ©2014 GPLv3<HR/>
 *
 * @author Kyli Rouge of Blue Husky Programming
 * @version 1.0.0
 * @since 2014-02-19
 */
public class ComplexHelloWorld
{
    private static final SHA2 SHA2;
    private static final byte[] OBJECTIVE_BYTES;
    private static final String OBJECTIVE;
    public static final String[] HASHES;
    private static final Logger LOGGER;

    static
    {
        SHA2 = new SHA2();
        OBJECTIVE_BYTES = new byte[]
        {
            72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33
        };
        OBJECTIVE = new String(OBJECTIVE_BYTES);
        HASHES = hashAllChars(OBJECTIVE);
        LOGGER = Logger.getLogger(ComplexHelloWorld.class.getName());
    }

    public static String hash(String password)
    {
        String algorithm = "SHA-256";
        MessageDigest sha256;
        try
        {
            sha256 = MessageDigest.getInstance(algorithm);
        }
        catch (NoSuchAlgorithmException ex)
        {
            try
            {
                LOGGER.logrb(Level.SEVERE, ComplexHelloWorld.class.getName(), "hash", null, "There is no such algorithm as " + algorithm, ex);
            }
            catch (Throwable t2)
            {
                //welp.
            }
            return "[ERROR]";
        }
        byte[] passBytes = password.getBytes();
        byte[] passHash = sha256.digest(passBytes);
        return new String(passHash);
    }

    public static void main(String... args)
    {
        StringBuilder sb = new StringBuilder();
        allHashes:
        for (String hash : HASHES)
            checking:
            for (char c = 0; c < 256; c++)
                if (hash(c + "").equals(hash))
                    try
                    {
                        sb.append(c);
                        break checking;
                    }
                    catch (Throwable t)
                    {
                        try
                        {
                            LOGGER.logrb(Level.SEVERE, ComplexHelloWorld.class.getName(), "main", null, "An unexpected error occurred", t);
                        }
                        catch (Throwable t2)
                        {
                            //welp.
                        }
                    }
        try
        {
            LOGGER.logrb(Level.INFO, ComplexHelloWorld.class.getName(), "main", null, sb + "", new Object[]
            {
            });
        }
        catch (Throwable t)
        {
            try
            {
                LOGGER.logrb(Level.SEVERE, ComplexHelloWorld.class.getName(), "main", null, "An unexpected error occurred", t);
            }
            catch (Throwable t2)
            {
                //welp.
            }
        }
    }

    private static String[] hashAllChars(String passwords)
    {
        String[] ret = new String[passwords.length()];
        for (int i = 0; i < ret.length; i++)
            ret[i] = hash(passwords.charAt(i) + "");
        return ret;
    }
}

Answer 22

সি # - 158

আমি আপনাকে কী বলছি, আজকাল বিকাশকারীরা সলিড নীতিগুলিতে কোন মনোযোগ দিচ্ছেন না। এমনকি সাধারণ কাজগুলি সঠিকভাবে করা কীভাবে গুরুত্বপূর্ণ তা এই দিনগুলিতে অবহেলা করে People

প্রথমত, আমাদের প্রয়োজনীয়তা দিয়ে শুরু করতে হবে:

• কনসোলে নির্দিষ্ট স্ট্রিং মুদ্রণ করে
• স্থানীয়করণের জন্য অনুমতি দেয়
• সলিড নীতি অনুসরণ করে

প্রথমে স্থানীয়করণ দিয়ে শুরু করা যাক। স্ট্রিংগুলিকে যথাযথভাবে স্থানীয়করণ করতে, প্রোগ্রামের মধ্যে স্ট্রিংটি ব্যবহারের জন্য আমাদের একটি এলিফ প্রয়োজন এবং আমরা যে স্ট্রিংটি স্ট্রিংটি চাই সেগুলিতে আমাদের স্পষ্টতই এই ডেটাটি একটি সহজেই ইন্টারঅ্যাপেবল বিন্যাসে, এক্সএমএল সংরক্ষণ করতে হবে। এবং এক্সএমএলটি সঠিকভাবে করার জন্য আমাদের একটি স্কিমা দরকার।

StringDictionary.xsd

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="StringDictionary"
targetNamespace="http://stackoverflow.com/StringDictionary.xsd"
elementFormDefault="qualified"
xmlns="http://stackoverflow.com/StringDictionary.xsd"
xmlns:mstns="http://stackoverflow.com/StringDictionary.xsd"
xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="stringDictionary" type="localizedStringDictionary"/>

<xs:complexType name="localizedStringDictionary">
    <xs:sequence minOccurs="1" maxOccurs="unbounded">
        <xs:element name="localized" type="namedStringElement"></xs:element>
    </xs:sequence>
</xs:complexType>

<xs:complexType name="localizedStringElement">
    <xs:simpleContent>
        <xs:extension base="xs:string">
            <xs:attribute name="locale" type="xs:string"/>
        </xs:extension>
    </xs:simpleContent>
</xs:complexType>

<xs:complexType name="namedStringElement">
    <xs:sequence minOccurs="1" maxOccurs="unbounded">
        <xs:element name="translated" type="localizedStringElement"></xs:element>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string"></xs:attribute>
</xs:complexType>

এটি আমাদের এক্সএমএল কাঠামো সংজ্ঞায়িত করে এবং আমাদের একটি ভাল সূচনায় নামায়। এরপরে, আমাদের নিজস্ব এক্সএমএল ফাইলের স্ট্রিং রয়েছে containing আপনার প্রকল্পে এই ফাইলটিকে একটি এম্বেডেড রিসোর্স করুন।

<?xml version="1.0" encoding="utf-8" ?>
<stringDictionary xmlns="http://stackoverflow.com/StringDictionary.xsd">
    <localized name="helloWorld">
        <translated locale="en-US">Hello, World</translated>
        <translated locale="ja-JP">こんにちは世界</translated>
    </localized>
</stringDictionary>

উপায়টি অতিক্রম করে, একটি জিনিস যা আমরা একেবারেই চাই না তা হ'ল আমাদের প্রোগ্রামের কোনও হার্ড কোডিং স্ট্রিং। আপনার প্রকল্পে সংস্থান তৈরি করতে ভিজ্যুয়াল স্টুডিও ব্যবহার করুন যা আমরা আমাদের স্ট্রিংয়ের জন্য ব্যবহার করব। XmlDictionaryNameআপনার এক্সএমএল স্ট্রিং ফাইলটির নামটি আগে সংজ্ঞায়িত করতে পরিবর্তন করতে নিশ্চিত করুন ।

যেহেতু আমরা নির্ভরতা বিপরীতমুখী, তাই আমাদের নিবন্ধগুলি নিবন্ধন করতে এবং তৈরি করতে আমাদের নির্ভরশীল ধারক প্রয়োজন।

IDependencyRegister.cs

public interface IDependencyRegister
{
    void Register<T1, T2>();
}

IDependencyResolver.cs

public interface IDependencyResolver
{
    T Get<T>();
    object Get(Type type);
}

আমরা উভয় ইন্টারফেসের একসাথে এক শ্রেণিতে কার্যকর প্রয়োগ করতে পারি।

DependencyProvider.cs

public class DependencyProvider : IDependencyRegister, IDependencyResolver
{
    private IReadOnlyDictionary<Type, Func<object>> _typeRegistration;

    public DependencyProvider()
    {
        _typeRegistration = new Dictionary<Type, Func<object>>();
    }

    public void Register<T1, T2>()
    {
        var newDict = new Dictionary<Type, Func<object>>((IDictionary<Type, Func<object>>)_typeRegistration) { [typeof(T1)] = () => Get(typeof(T2)) };
        _typeRegistration = newDict;
    }

    public object Get(Type type)
    {
        Func<object> creator;
        if (_typeRegistration.TryGetValue(type, out creator)) return creator();
        else if (!type.IsAbstract) return this.CreateInstance(type);
        else throw new InvalidOperationException("No registration for " + type);
    }

    public T Get<T>()
    {
        return (T)Get(typeof(T));
    }

    private object CreateInstance(Type implementationType)
    {
        var ctor = implementationType.GetConstructors().Single();
        var parameterTypes = ctor.GetParameters().Select(p => p.ParameterType);
        var dependencies = parameterTypes.Select(Get).ToArray();
        return Activator.CreateInstance(implementationType, dependencies);
    }
}

সর্বনিম্ন স্তরের থেকে শুরু করে আমাদের এগিয়ে চলার জন্য, আমাদের এক্সএমএল পড়ার একটি উপায় প্রয়োজন। SOLID এ Sএবং অনুসরণ করে Iআমরা একটি ইন্টারফেসটি সংজ্ঞায়িত করি যা আমাদের এক্সএমএল স্ট্রিং অভিধান কোড ব্যবহার করে:

public interface IStringDictionaryStore
{
    string GetLocalizedString(string name, string locale);
}

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

IStringHasher.cs

public interface IStringHasher
{
    string HashString(string name, string locale);
}

Sha512StringHasher.cs

public class Sha512StringHasher : IStringHasher
{
    private readonly SHA512Managed _sha;
    public Sha512StringHasher()
    {
        _sha = new SHA512Managed();
    }
    public string HashString(string name, string locale)
    {
        return Convert.ToBase64String(_sha.ComputeHash(Encoding.UTF8.GetBytes(name + locale)));
    }
}

এটির সাহায্যে আমরা আমাদের এক্সএমএল স্ট্রিং স্টোরটিকে সংজ্ঞায়িত করতে পারি যা এমবেডেড রিসোর্স থেকে একটি এক্সএমএল ফাইল পড়ে এবং স্ট্রিং সংজ্ঞা সম্বলিত একটি অভিধান তৈরি করে

EmbeddedXmlStringStore.cs

public class EmbeddedXmlStringStore : IStringDictionaryStore
{
    private readonly XNamespace _ns = (string)Resources.XmlNamespaceName;

    private readonly IStringHasher _hasher;
    private readonly IReadOnlyDictionary<string, StringInfo> _stringStore;
    public EmbeddedXmlStringStore(IStringHasher hasher)
    {
        _hasher = hasher;
        var resourceName = this.GetType().Namespace + Resources.NamespaceSeperator + Resources.XmlDictionaryName;
        using (var s = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
        {
            var doc = XElement.Load(s);

            _stringStore = LoadStringInfo(doc).ToDictionary(k => _hasher.HashString(k.Name, k.Locale), v => v);
        }
    }

    private IEnumerable<StringInfo> LoadStringInfo(XElement doc)
    {
        foreach (var e in doc.Elements(_ns + Resources.LocalizedElementName))
        {
            var name = (string)e.Attribute(Resources.LocalizedElementNameAttribute);
            foreach (var e2 in e.Elements(_ns + Resources.TranslatedElementName))
            {
                var locale = (string)e2.Attribute(Resources.TranslatedElementLocaleName);
                var localized = (string)e2;
                yield return new StringInfo(name,locale,localized);
            }
        }
    }

    public string GetLocalizedString(string name, string locale)
    {
        return _stringStore[_hasher.HashString(name, locale)].Localized;
    }
}

এবং সম্পর্কিত StringInfoস্ট্রিং তথ্য ধারণ করার কাঠামো:

StringInfo.cs

public struct StringInfo
{
    public StringInfo(string name, string locale, string localized)
    {
        Name = name;
        Locale = locale;
        Localized = localized;
    }

    public string Name { get; }
    public string Locale { get; }
    public string Localized { get; }
}

যেহেতু আমাদের কাছে স্ট্রিংগুলি সন্ধান করার বিভিন্ন উপায় থাকতে পারে তাই আমাদের বাকি প্রোগ্রামগুলি কীভাবে স্ট্রিংগুলি পুনরুদ্ধার করা হয় তা থেকে উত্তোলন করা দরকার, এটি করার জন্য, আমরা সংজ্ঞা দিচ্ছি IStringProvider, যা স্ট্রিংগুলি সমাধান করার জন্য প্রোগ্রামের বাকী অংশে ব্যবহৃত হবে:

ILocaleStringProvider.cs

public interface ILocaleStringProvider
{
    string GetString(string stringName, string locale);
}

একটি বাস্তবায়ন সহ:

StringDictionaryStoreLocaleStringProvider.cs

public class StringDictionaryStoreLocaleStringProvider: ILocaleStringProvider
{
    private readonly IStringDictionaryStore _dictionaryStore;

    public StringDictionaryStoreStringProvider(IStringDictionaryStore dictionaryStore)
    {
        _dictionaryStore = dictionaryStore;
    }

    public string GetString(string stringName, string locale)
    {
        return _dictionaryStore.GetLocalizedString(stringName, locale);
    }
}

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

ILocaleProvider.cs

public interface ILocaleProvider
{
    string GetCurrentLocale();
}

এবং একটি ডিফল্ট বাস্তবায়ন যা প্রক্রিয়াটির বর্তমান সংস্কৃতি ব্যবহার করে, যেহেতু এই নমুনাটি একটি কনসোল অ্যাপ্লিকেশন:

class DefaultLocaleProvider : ILocaleProvider
{
    public string GetCurrentLocale()
    {
        return CultureInfo.CurrentCulture.Name;
    }
}

আমাদের স্থানীয় প্রোগ্রামগুলি সত্যিই যত্ন করে না যদি আমরা স্থানীয়করণের স্ট্রিংগুলি পরিবেশন করি বা না করি, তাই আমরা একটি ইন্টারফেসের পিছনে স্থানীয়করণের লুকোচুরিটি লুকিয়ে রাখতে পারি:

IStringProvider.cs

public interface IStringProvider
{
    string GetString(string name);
}

আমাদের স্ট্রিংপ্রোভাইডার বাস্তবায়ন স্থানীয়করণের স্ট্রিংয়ের সরবরাহিত বাস্তবায়ন ব্যবহারের জন্য ILocaleStringProviderএবং তার ILocaleProviderজন্য ফিরে আসে

DefaultStringProvider.cs

public class DefaultStringProvider : IStringProvider
{
    private readonly ILocaleStringProvider _localeStringProvider;
    private readonly ILocaleProvider _localeProvider;
    public DefaultStringProvider(ILocaleStringProvider localeStringProvider, ILocaleProvider localeProvider)
    {
        _localeStringProvider = localeStringProvider;
        _localeProvider = localeProvider;
    }

    public string GetString(string name)
    {
        return _localeStringProvider.GetString(name, _localeProvider.GetCurrentLocale());
    }
}

অবশেষে, আমাদের কাছে আমাদের প্রোগ্রামের প্রবেশের পয়েন্ট রয়েছে যা রচনাটি মূল সরবরাহ করে এবং স্ট্রিংটি পেয়ে এটি কনসোলে মুদ্রণ করে:

Program.cs

class Program
{
    static void Main(string[] args)
    {
        var container = new DependencyProvider();

        container.Register<IStringHasher, Sha512StringHasher>();
        container.Register<IStringDictionaryStore, EmbeddedXmlStringStore>();
        container.Register<ILocaleProvider, DefaultLocaleProvider>();
        container.Register<ILocaleStringProvider, StringDictionaryStoreLocaleStringProvider>();
        container.Register<IStringProvider, DefaultStringProvider>();

        var consumer = container.Get<IStringProvider>();

        Console.WriteLine(consumer.GetString(Resources.HelloStringName));
    }
}

এবং এভাবেই আপনি একটি এন্টারপ্রাইজ মাইক্রোসার্ভিস প্রস্তুত, স্থানীয় সচেতন, হ্যালো ওয়ার্ল্ড প্রোগ্রাম লিখেন।

স্কোর: ফাইল: 17 নেমস্পেস অন্তর্ভুক্ত: 11 ক্লাস: 14 ভেরিয়েবল: 26 পদ্ধতি: 17 বিবৃতি: 60 কন্ট্রোল ফ্লো: 2 ফরোয়ার্ড ঘোষণা (ইন্টারফেস সদস্য, এক্সএসডি কমপ্লেক্স টাইপস): 11 মোট: 158

Answer 23

iX2Web

**iX2001B2 A1CAA3MwlI ZWxsbyBXb3 JsZHxfMAkw DQo==*