সি ভেরিয়েবল ঘোষণাপত্রটি পড়ুন

41

পটভূমি

সি তে চলক ঘোষণাপত্র বিবৃতিতে তিনটি অংশ থাকে: ভেরিয়েবলের নাম , এর বেস টাইপ এবং টাইপ সংশোধক (গুলি) ।

তিন ধরণের টাইপ মডিফায়ার রয়েছে:

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

এবং স্বরলিপিগুলি পড়ার একটি উপায় নিম্নরূপ:

int i;             // i is an int
float *f;          // f is a pointer to a float
my_struct_t s[10]; // s is an array of 10 my_struct_t
int func();        // func is a function returning an int

ক্যাচটি হ'ল আমরা এগুলি সবগুলিকে আরও জটিল ধরণের তৈরি করতে পারি যেমন অ্যারের অ্যারে বা ফাংশন পয়েন্টারগুলির অ্যারে বা পয়েন্টারগুলির বিন্যাসে অ্যারে :

int arr[3][4];
// arr is an array of 3 arrays of 4 ints

int (*fptrs[10])();
// fptrs is an array of 10 pointers to functions returning an int

float *(*p)[16];
// p is a pointer to an array of 16 pointers to float

আমি এই জটিল বিবৃতিটি কীভাবে পড়লাম?

  1. পরিবর্তনশীল নাম থেকে শুরু করুন। (name) is ...
  2. সর্বোচ্চ অগ্রাধিকার সহ পরিবর্তনকারী নির্বাচন করুন।
  3. এটি পড়ুন:
    • * -> pointer to ...
    • [N] -> array of N ...
    • () -> function returning ...
  4. সংশোধকগুলি অবসন্ন না হওয়া পর্যন্ত 2 এবং 3 পুনরাবৃত্তি করুন।
  5. অবশেষে, বেস টাইপ পড়ুন। ... (base type).

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

সচিত্র উদাহরণ:

int (*fptrs[10])();
      fptrs           fptrs is ...
           [10]       array of 10 ... // [] takes precedence over *
    (*         )      pointer to ...
                ()    function returning ...
int                   int

কার্য

সি-তে লেখা ভেরিয়েবল ডিক্লেয়ারেশন স্টেটমেন্টের একটি লাইন দেওয়া, উপরে বর্ণিত পদ্ধতিটি ব্যবহার করে লাইনটি বর্ণনা করে এমন ইংলিশ এক্সপ্রেশন আউটপুট করুন।

ইনপুট

ইনপুটটি একটি একক সি স্টেটমেন্ট যা একটি একক বেস প্রকার, একক ভেরিয়েবল নাম, শূন্য বা আরও বেশি টাইপ সংশোধক এবং সমাপ্তি সেমিকোলন অন্তর্ভুক্ত করে। উপরে বর্ণিত সমস্ত সিনট্যাক্স উপাদানগুলি আপনাকে প্রয়োগ করতে হবে, এবং আরও:

  • বেস টাইপ এবং ভেরিয়েবল নাম উভয়ই নিয়মিত অভিব্যক্তির সাথে মেলে [A-Za-z_][A-Za-z0-9_]*।
  • তাত্ত্বিকভাবে, আপনার প্রোগ্রামের সীমাহীন সংখ্যক প্রকারের সংশোধককে সমর্থন করা উচিত।

আপনি নিম্নলিখিত উপায়ে অন্যান্য সি সিনট্যাক্স উপাদানগুলি সহজ করতে পারেন (সম্পূর্ণ বাস্তবায়নটিও স্বাগত):

  • বেস টাইপ সবসময় একটি একক শব্দ, যেমন int, float, uint32_t, myStruct। এরকম কিছু unsigned long longপরীক্ষা করা হবে না।
  • অ্যারে চিহ্নিতকরণের জন্য [N], সংখ্যাটি Nসর্বদা বেস 10 তে লিখিত একক ধনাত্মক পূর্ণসংখ্যার হবে be জিনিসগুলির মতো int a[5+5], int a[SIZE]বা int a[0x0f]পরীক্ষা করা হবে না।
  • ফাংশন স্বরলিপিটির জন্য (), উপরে উল্লিখিত অনুসারে কোনও পরামিতি নির্দিষ্ট করা হবে না।
  • সাদা স্থানগুলির জন্য, কেবলমাত্র স্থানের অক্ষর 0x20ব্যবহার করা হবে। আপনি আপনার প্রোগ্রামটি স্বেচ্ছাসেবীগুলির নির্দিষ্ট ব্যবহারের মধ্যে সীমাবদ্ধ করতে পারেন, যেমন
    • বেস প্রকারের পরে কেবল একটি স্থান ব্যবহার করুন
    • টোকেনের মাঝে সর্বত্র একটি স্থান ব্যবহার করুন
  • তবে আপনি টোকেন বিভাজক হওয়ার চেয়ে আরও বেশি তথ্য জানাতে দুটি বা ততোধিক স্পেস ব্যবহার করতে পারবেন না।

সি সিনট্যাক্স অনুসারে, নিম্নলিখিত তিনটি সংমিশ্রণ অবৈধ, এবং সুতরাং এটি পরীক্ষা করা হবে না:

  • f()() ফাংশন রিটার্ন ফাংশন
  • f()[] ফাংশন অ্যারে ফিরছে
  • a[]() এন ফাংশনগুলির অ্যারে

সি বিকাশকারীরা পরিবর্তে এই সমতুল্য ফর্মগুলি ব্যবহার করে (এবং এগুলি সব পরীক্ষার ক্ষেত্রে areাকা থাকে):

  • (*f())()ফাংশনে ফাংশন ফিরতে পয়েন্টার
  • *f()অ্যারের প্রথম উপাদানটিতে পয়েন্টার ফাংশন ফিরছে
  • (*a[])()এন পয়েন্টারগুলির অ্যারেটি কাজ করবে

আউটপুট

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

আবার, রূপান্তর প্রক্রিয়াটি এখানে:

  1. পরিবর্তনশীল নাম থেকে শুরু করুন। (name) is ...
  2. সর্বোচ্চ অগ্রাধিকার সহ পরিবর্তনকারী নির্বাচন করুন।
  3. এটি পড়ুন:
    • * -> pointer to ...
    • [N] -> array of N ...
    • () -> function returning ...
  4. সংশোধকগুলি অবসন্ন না হওয়া পর্যন্ত 2 এবং 3 পুনরাবৃত্তি করুন।
  5. অবশেষে, বেস টাইপ পড়ুন। ... (base type).

পরীক্ষার মামলা

int i;              // i is int
float *f;           // f is pointer to float
my_struct_t s[10];  // s is array of 10 my_struct_t
int func();         // func is function returning int
int arr[3][4];      // arr is array of 3 array of 4 int
int (*fptrs[10])(); // fptrs is array of 10 pointer to function returning int
float *(*p)[16];    // p is pointer to array of 16 pointer to float

_RANdom_TYPE_123 (**(*_WTH_is_TH15)())[1234][567];
/* _WTH_is_TH15 is pointer to function returning pointer to pointer to array of
   1234 array of 567 _RANdom_TYPE_123 */

uint32_t **(*(**(*(***p)[2])())[123])[4][5];
/* p is pointer to pointer to pointer to array of 2 pointer to function returning
   pointer to pointer to array of 123 pointer to array of 4 array of 5 pointer to
   pointer to uint32_t */

uint32_t (**((*(**(((*(((**(*p)))[2]))())))[123])[4])[5]);
// Same as above, just more redundant parens

some_type (*(*(*(*(*curried_func())())())())())();
/* curried_func is function returning pointer to function returning pointer to
   function returning pointer to function returning pointer to
   function returning pointer to function returning some_type */

স্কোরিং এবং জয়ের মানদণ্ড

এটি একটি কোড-গল্ফ চ্যালেঞ্জ। সবচেয়ে কম সংখ্যক বাইট বিজয়ী সহ প্রোগ্রামটি।

code-golf  parsing  c  syntax 
— Bubbler
সূত্র
9
সম্পর্কিত: cdecl.org
— ব্যবহারকারী 202729
int arr[3][4];হয় an array of 3 arrays of 4 ints(যেমন আপনি বলতে), অথবা an array of 4 arrays of 3 ints?
— চার্লি
1
@ চার্লি প্রাক্তনটি সঠিক is sizeof(arr[0]) == sizeof(int[4])সুতরাং একটি আইটেমের arrচারটি রয়েছে int।
— বুবলার
1
ইনপুটটিতে কি ;লাইনের শেষে থাকে ?
— কালো আউল কাই
2
কমলড্রাকারি "ফাংশন টু পয়েন্টারের অ্যারে" মূলত "পয়েন্টারের অ্যারে", যা সি তে পুরোপুরি বৈধ
— বুবলার

উত্তর:

17

পাইথন 3 , 331 312 294 261 240 বাইট

from re import*
class V(str):__pos__=lambda s:V(s+'pointer to ');__call__=lambda s:V(s+'function returning ');__getitem__=lambda s,i:V(s+'array of %i '%i)
t,e=input().split()
print(eval(sub('\*','+',sub('(\w+)',r'V("\1 is ")',e[:-1],1)))+t)

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

অজগর 2 এ সরিয়ে ক্লাসের সংজ্ঞাটিকে একটিতে বুনান 19 exec

থেকে Regex পরিবর্তন করে -18 বাইট [a-zA-Z_][a-zA-Z0-9_]*থেকে \\w+, কেভিন Cruijssen ধন্যবাদ

-৩৩ বাইট কিছু শ্রেণির সংজ্ঞা ম্যাজিক কাজ করে এবং স্ট্র ব্যবহার করে, লিনকে ধন্যবাদ, পাইথন 3 এ ফিরে

একাধিক রেজেক্স একসাথে মার্জ করে -21 বাইটস, ইনফ্যামাজিক 2047 ধন্যবাদ thanks

প্রয়োজনীয় যে ইনপুটে (টাইপ এবং এক্সপ্রেশনের মধ্যে) কেবলমাত্র একটি স্থান রয়েছে।

আমি মনে করি এটি সমস্যার একটি দুর্দান্ত অনন্য দৃষ্টিভঙ্গি। এটি বেশিরভাগ ক্ষেত্রে সত্যটি ব্যবহার করে যে পাইথন নিজেই স্ট্রিংগুলির মতো মূল্যায়ন করতে পারে (**((*(**(((*(((**(*p)))[2]))())))[123])[4])[5])এবং ফাংশন কল, অ্যারে সূচক এবং পয়েন্টারগুলির সঠিক ক্রম পায় - এবং ব্যবহারকারী এগুলি ওভারলোড করতে পারে।

— কালো পেঁচা কাই
সূত্র
1
ভাল পন্থা, আমার কাছ থেকে +1! আপনি কয়েকটি বাইট সংরক্ষণ করতে গল্ফ [a-zA-Z_][A-Za-z0-9_]*করতে [a-zA-Z_]\\w*পারেন। সম্পাদনা: আসলে, আমি মনে করি আপনি কেবল \\w+পরিবর্তে ব্যবহার করতে পারেন [a-zA-Z_][A-Za-z0-9_]*।
— কেভিন ক্রুইজসেন
আমি এই পদ্ধতির পছন্দ করি :) এখানে এটি 253 বাইটে রয়েছে
— লিন
1
এটা একটা ভাল দিক. 261 এটি হয়।
— লিন
1
পাইথন ৩.6 এর [0]পরিবর্তে আপনি ব্যবহার করতে পারেন .group()।
— infmagic2047
1
এবং এখানে একটি 240 বাইট সংস্করণ ।
— infmagic2047
13

রেটিনা 0.8.2 , 142 138 128 117 বাইট

(\w+) (.+);
($2) $1
\(\)
 function returning
\[(\d+)?]
 array of$#1$* $1
+`\((\**)(.+)\)
$2$1
\*
 pointer to
1` 
 is

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। ভাল ব্যাকরণ । সম্পাদনা করুন: @ ডিএলসকের পাইপ সমাধানটি পোর্ট করে 10 21 বাইট সংরক্ষণ করা হয়েছে। ব্যাখ্যা:

(\w+) (.+);
($2) $1

প্রকারটি প্রান্তে সরান এবং বাকী ঘোষণাপত্রের মধ্যে ()কোনও বহিরাগত থাকে সে ক্ষেত্রে মোড়ানো করুন *।

\(\)
 function returning

কোনও ফাংশন প্রক্রিয়া করুন।

\[(\d+)?]
 array of$#1$* $1

যে কোনও অ্যারে প্রক্রিয়া করুন।

+`\((\**)(.+)\)
$2$1

যে কোনও পয়েন্টারকে তাদের বন্ধনীগুলির শেষে নিয়ে যান এবং বন্ধনীগুলি মুছুন, বার বার বন্ধনীর বাহ্যিক সেট থেকে বারের দিকে কাজ করে।

\*
 pointer to

যে কোনও পয়েন্টার প্রসেস করুন।

1` 
 is

ঢোকান is।

— নিল
সূত্র
7

জাভা 11, 469 467 463 450 বাইট

s->{String r="",t,S[];for(s=s.replace("()","~");s.contains("(");s=s.replace(t,"").replace("()",""),r+=t+";")t=s.replaceAll(".*(\\([^()]+\\)).*","$1");S=s.split(" ");t=S[0];r+=r.isEmpty()?S[1]:s;S=r.split(";");r=S[0].replaceAll(".*?(\\w+).*","$1 is ");for(var p:S)r+=p.replaceAll("[A-Za-z_]+\\d+|[^\\[\\d]","").replaceAll("\\[(\\d+)","array of $1 ")+(p.contains("~")?"function returning ":"")+"pointer to ".repeat(p.split("\\*").length-1);return r+t;}

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

ব্যাখ্যা:

s->{               // Method with String as both parameter and return-type
  String r="",     //  Result-String, starting empty
         t,        //  Temp-String, starting uninitialized
         S[];      //  Temp String-array, starting uninitialized
  for(s=s.replace("()","~");
                   //  Replace all "()" in the input `s` with "~"
      s.contains("(");
                   //  Loop as long as the input `s` still contains "("
      ;            //    After every iteration:
       s=s.replace(t,"")
                   //     Remove `t` from `s`
          .replace("()",""),
                   //     And also remove any redundant parenthesis groups
       r+=t+";")   //     Append `t` and a semi-colon to the result-String
    t=s.replaceAll(".*(\\([^()]+\\)).*","$1");
                   //   Set `t` to the inner-most group within parenthesis
  S=s.split(" ");  //  After the loop, split the remainder of `s` on the space
  t=S[0];          //  Set `t` to the first item (the type)
  r+=              //  Append the result-String with:
    r.isEmpty()?   //   If the result-String is empty
                   //   (so there were no parenthesis groups)
     S[1]          //    Set the result-String to the second item
    :              //   Else:
     s;            //    Simple append the remainder of `s`
  S=r.split(";");  //  Then split `r` on semi-colons
  r=S[0].replaceAll(".*?(\\w+).*",
                   //  Extract the variable name from the first item
     "$1 is ");    //  And set `r` to this name appended with " is "
  for(var p:S)     //  Loop over the parts split by semi-colons:
    r+=            //   Append the result-String with:
      p.replaceAll("[A-Za-z_]+\\d+
                   //    First remove the variable name (may contain digits)
         |[^\\[\\d]","")
                   //    And then keep only digits and "["
       .replaceAll("\\[(\\d+)",
                   //    Extract the number after "["
         "array of $1 ")
                   //    And append the result-String with "array of " and this nr
      +(p.contains("~")?
                   //    If the part contains "~"
         "function returning "
                   //     Append the result-String with "function returning "
       :           //    Else:
        "")        //     Leave the result-String the same
      +"pointer to ".repeat(
                   //    And append "pointer to " repeated
         p.split("\\*").length-1);
                   //    the amount of "*" in the part amount of time
  return r         //  Then return the result-String
          +t;}     //  appended with the temp-String (type)
— কেভিন ক্রুইজসেন
সূত্র
অপ্রয়োজনীয় প্রথম বন্ধনীর সাথে পরীক্ষার ক্ষেত্রে ব্যর্থ।
— বুদ্বুদ
@ বুবলার আহ, নতুন পরীক্ষার কেসটি খেয়াল করেননি। ভাগ্যক্রমে এটি একটি সহজ ফিক্স।
— কেভিন ক্রুইজসেন
6

বাশ + সিডিকেল + জিএনইউ সেড , 180

cdeclএকটি উপভোগযোগ্য ইউনিক্স ইউটিলিটি যা এখানে যা প্রয়োজন তা বেশিরভাগ ক্ষেত্রেই করে তবে I / O প্রয়োজনীয়তার সাথে মিল রাখতে কিছু sedপ্রাক- এবং পোস্ট-প্রসেসিং প্রয়োজন:

sed -r 's/^/explain struct /;s/struct (int|char double|float|void) /\1 /;s/\bfunc/_func/g'|cdecl|sed -r 's/^declare //;s/as/is/;s/struct //g;s/([0-9]+) of/of \1/g;s/\b_func/func/g'
  • ব্যাকরণ সংশোধন করার জন্য কোনও প্রচেষ্টা করা হয়নি।

সেড প্রাক প্রক্রিয়াজাতকরণ:

  • s/^/explain struct /- প্রতিটি লাইনের শুরুতে "স্ট্র্যাফিক স্ট্রাক্ট" যুক্ত করুন
  • s/struct (int|char double|float|void) /\1 /- structসি ভাষার ধরণের সাথে কাজ করার সময় অপসারণ করুন
  • s/\bfunc/_func/g - "ফানক" সিডেকএল দ্বারা একটি কীওয়ার্ড হিসাবে স্বীকৃত - এটি দমন করুন

সেড পোস্ট-প্রসেসিং:

  • s/^declare // - লাইনের শুরুতে "ঘোষণা করুন" সরান
  • s/as/is/ - স্ব-ব্যাখ্যামূলক
  • s/struct //g - সমস্ত "স্ট্রাক্ট" কীওয়ার্ড মুছে ফেলুন
  • s/([0-9]+) of/of \1/g - "এর" সঠিক ক্রম
  • s/\b_func/func/g - প্রাক-প্রক্রিয়াকরণে প্রতিস্থাপিত যে কোনও "_ফুঙ্ক" ফিরিয়ে দিন

কর্মে:

$ < cdecls.txt sed -r 's/^/explain struct /;s/struct (int|char double|float|void) /\1 /;s/\bfunc/_func/g'|cdecl|sed -r 's/^declare //;s/as/is/;s/struct //g;s/([0-9]+) of/of \1/g;s/\b_func/func/g'
i is int
f is pointer to float
s is array of 10 my_struct_t
func is function returning int
arr is array of 3 array of 4 int
fptrs is array of 10 pointer to function returning int
p is pointer to array of 16 pointer to float
_WTH_is_TH15 is pointer to function returning pointer to pointer to array of 1234 array of 567 _RANdom_TYPE_123
p is pointer to pointer to pointer to array of 2 pointer to function returning pointer to pointer to array of 123 pointer to array of 4 array of 5 pointer to pointer to uint32_t
p is pointer to pointer to pointer to array of 2 pointer to function returning pointer to pointer to array of 123 pointer to array of 4 array of 5 pointer to pointer to uint32_t
curried_func is function returning pointer to function returning pointer to function returning pointer to function returning pointer to function returning pointer to function returning some_type
$
— ডিজিটাল ট্রমা
সূত্র
s/\bfu/_fu/gপুরো funcপ্রতিস্থাপনের বাইটগুলি করা এবং সংরক্ষণ করা কি যথেষ্ট হবে ?
— ডিএলকাস
এটি একটি বাস্তব ইউটিলিটি অপেক্ষা করুন? আমি সবসময়ই ভেবেছিলাম যে এটি ওয়েবসাইটটির নাম
— ফুক্লভ
@ ফুকলভি সিডিসিএল একটি সত্যিকারের ইউটিলিটি, এবং সি ঘোষণাগুলি যাচাইয়ের জন্য সত্যই কার্যকর।
— প্যাট্রিসিয়া শানাহান
— ডিজিটাল ট্রমা
নামের একটি ভেরিয়েবলের জন্য ব্যর্থ হয় as(স্থানগুলি ঠিক করার জন্য +4 বাইট)। আমার অ্যাক্সেস নেই cdeclতবে আমি মনে করি আপনি ব্যবহার করে 64 বাইট সংরক্ষণ করতে পারেন sed -r 's/^(\w+)(\W+)/explain struct \1_\2_/'|cdecl|sed -r 's/^declare struct _|_$//;s/ as / is /;s/([0-9]+) of/of \1/g'।
— নীল
6

পিপ -s , 152 150 148 139 137 126 125 123 বাইট

তৃতীয় পন্থা!

YaRs" ("R';')R`\[(\d+)]`` array of \1`R"()"" function returning"L#aYyR`\((\**)(.+)\)`{c." pointer to"X#b}{[b"is"g@>2a]}Vy^s

ঘোষণাটি কমান্ড-লাইন ইনপুট হিসাবে গ্রহণ করে। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কোডটি তিন ভাগে রয়েছে: ফাংশন এবং অ্যারেগুলির প্রাথমিক সেটআপ এবং পরিচালনা; একটি লুপ যা বন্ধনী এবং পয়েন্টার পরিচালনা করে; এবং একটি চূড়ান্ত পুনরুদ্ধার।

সেটআপ, ফাংশন এবং অ্যারে

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

Y                         Yank into y variable...
 a                        The result of a (the cmdline arg)...
  R s                     Replace the space
   " ("                    with " ("
  R ';                    Replace the semicolon
   ')                      with a closing paren
  R `\[(\d+)]`            Replace digits in square brackets
   ` array of \1`          with " array of <digits>"
  R "()"                  Replace function parens
   " function returning"   with " function returning"

যদি আমাদের মূল ইনপুটটি ছিল float *((*p()))[16];, এখন আমাদের রয়েছে float (*((*p function returning)) array of 16)।

অভিভাবক এবং পয়েন্টার

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

L#a                   Loop len(a) times (enough to complete all replacements):
 Y                    Yank into y variable...
  y                   The result of y...
   R `\((\**)(.+)\)`  Replace open paren, 0 or more asterisks (group 1), 1 or more
                      characters (group 2), and close paren
    {                  with this callback function (b = group 1, c = group 2):
     c .               The stuff in the middle, concatenated to...
      " pointer to"    that string
       X #b            repeated len(asterisks) times
    }

উদাহরণ পদক্ষেপগুলি:

float (*((*p function returning)) array of 16)
float ((*p function returning)) array of 16 pointer to
float (*p function returning) array of 16 pointer to
float p function returning pointer to array of 16 pointer to

পরিষ্কার কর

বাকিটি কেবলমাত্র টাইপটিকে শেষের দিকে নিয়ে যাওয়া এবং "হ'ল" যুক্ত করা:

{[b"is"g@>2a]}Vy^s
               y^s  Split y on spaces
{            }V     Use the resulting list as arguments to this function:
 [          ]        Return a list of:
  b                   2nd argument (the variable name)
   "is"               That string
       g@>2           All arguments after the 2nd
           a          1st argument (the type)
                    The resulting list is printed, joining on spaces (-s flag)

যেমন সংজ্ঞা জন্য int x;, এই পদ্ধতির ফলে একটি অতিরিক্ত স্থান তৈরি হবে, যা চ্যালেঞ্জের দ্বারা অনুমোদিত।

— DLosc
সূত্র
5

জাভাস্ক্রিপ্ট (ES6), 316 ... 268 253 বাইট

s=>(g=s=>[/\d+(?=])/,/\*/,/!/,/.+ /,/\w+/].some((r,i)=>(S=s.replace(r,s=>(O=[O+`array of ${s} `,O+'pointer to ','function returning '+O,O+s,s+' is '+O][i],'')))!=s)?g(S):'',F=s=>(O='',S=s.replace(/\(([^()]*)\)/,g))!=s?O+F(S):g(s)+O)(s.split`()`.join`!`)

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

মন্তব্য

সহায়ক ফাংশন

g = s =>                             // s = expression to parse
  [                                  // look for the following patterns in s:
    /\d+(?=])/,                      //   array
    /\*/,                            //   pointer
    /!/,                             //   function
    /.+ /,                           //   type
    /\w+/                            //   variable name
  ].some((r, i) =>                   // for each pattern r at index i:
    ( S = s.replace(                 //   S = new string obtained by removing
      r,                             //       the pattern matching r from s
      s => (                         //     using the first match s and the index i,
        O = [                        //     update the output O:
          O + `array of ${s} `,      //       array
          O + 'pointer to ',         //       pointer
          'function returning ' + O, //       function
          O + s,                     //       type
          s + ' is ' + O             //       variable name
        ][i],                        //
        ''                           //     replace the match with an empty string
    )))                              //   end of replace()
    != s                             //   make some() succeed if S is not equal to s
  ) ?                                // end of some(); if truthy:
    g(S)                             //   do a recursive call with S
  :                                  // else:
    ''                               //   stop recursion and return an empty string

প্রধান অংশ

s => (                 // s = input
  g = …,               // define the helper function g (see above)
  F = s => (           // F = recursive function, taking a string s
    O = '',            //   O = iteration output, initialized to an empty string
    S = s.replace(     //   S = new string obtained by removing the next expression from s
      /\(([^()]*)\)/,  //     look for the deepest expression within parentheses
      g                //     and process it with the helper function g
    )                  //   end of replace()
  ) != s ?             // if S is not equal to s:
    O + F(S)           //   append O to the final output and do a recursive call with S
  :                    // else (we didn't find an expression within parentheses):
    g(s) + O           //   process the remaining expression with g and return O
)(s.split`()`.join`!`) // initial call to F with all strings '()' in s replaced with '!'
— Arnauld
সূত্র
আমি ভাবছিলাম আপনি কেন ব্যবহার করা [...s.split`()`.join`!`]ঠিক পরিবর্তে [...s.replace('()','!')], কিন্তু আমি বুঝতে পেরেছি এটা সঠিক একই বাইট গোনা এর .. :)
— কেভিন Cruijssen
@ কেভিন ক্রুজসেন প্রাথমিক কারণটি হ'ল কেবল s.replace('()','!')প্রথম ঘটনাটি প্রতিস্থাপন করবে।
— আর্নৌল্ড
আহ, অবশ্যই ভুলে যাওয়া জেএস প্রতিস্থাপন জাভা-র মতো নয়। জাভাতে .replaceসমস্ত উপস্থিতি .replaceAllপ্রতিস্থাপন করে এবং সমস্ত ঘটনাকে রেগেক্স সক্ষম করে প্রতিস্থাপন করে। সর্বদা চিন্তা নামকরণ জাভা এই দুটি পদ্ধতি জন্য বেশ খারাপ ছিল, যেমন আমি তাদের মনোনীত করেছি হবে .replaceAllএবং .regexReplaceAllবা কিছু যারা লাইন বরাবর, কিন্তু আমি এটা খাটো codegolf জন্য অনুমান .replaceএবং .replaceAll।
— কেভিন ক্রুইজসেন
1
বিটিডাব্লু, আমি লক্ষ্য করেছি যে আপনি ~আমার নিজস্ব উত্তরের প্রথম সংস্করণ পোস্ট করার পরে একই কৌশলটি (সহ ) ব্যবহার করছেন । আমি মনে করি মহান মন এক মত মনে হয়। : পি
— আরনৌল্ড
3

পরিষ্কার , 415 বাইট

import StdEnv,Text
$s#(b,[_:d])=span((<>)' ')(init s)
=join" "(?d++[""<+b])
?[]=[]
?['()':s]=["function returning": ?s]
?['*':s]= ?s++["pointer to"]
?['[':s]#(n,[_:t])=span((<>)']')s
=["array of "<+n: ?t]
?s=case@0s of(['(':h],t)= ?(init h)++ ?t;(h,t)|t>[]= ?h++ ?t=[h<+" is"]
~c=app2((++)[c],id)
@n[c:s]=case c of'('= ~c(@(n+1)s);')'|n>1= ~c(@(n-1)s)=([c],s);_|n>0= ~c(@n s)=span(\c=c<>'('&&c<>'[')[c:s]
@_ e=(e,e)

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

— Οurous
সূত্র
3

আর , 225 218 বাইট

g=gsub
"&"="@"=paste
"["=function(a,b)a&"array of"&b
"+"=function(a)a&"pointer to"
eval(parse(t=g('\\(\\)','@"function returning"',g('(\\w+) (.*?)([A-Za-z_]\\w*)(.*);','\\2"\\3 is"\\4&"\\1"',g('\\*','+',readline())))))

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

একবারে সমস্ত পরীক্ষার কেসগুলির সুবিধাজনক পরীক্ষার জন্য টিআইওর একটি কার্যক্রমে মোড়ানো পুরো প্রোগ্রাম।

প্রথমত, আমরা Regex ব্যবহার ফর্ম ইনপুট রূপান্তর করতে type ...name...;করতে ..."name is"..."type"। ফাংশন স্বরলিপিটি ()তখন উচ্চ-অগ্রাধিকারের কনটেটেশন অপারেটরের সাথে পাঠ্যে রূপান্তরিত হয়। দুর্ভাগ্যক্রমে, আমাদেরও প্রতিস্থাপন *করতে হবে +কারণ পূর্বের একজন অ্যানারি অপারেটর হিসাবে গ্রহণযোগ্য নয়। বাকিগুলি evalওভারলোডেড অপারেটরগুলির সাথে আর এর দ্বারা সম্পন্ন হয় ।

— কিরিল এল।
সূত্র
1
চতুর সমাধান!
— J.Doe 15
3

পার্ল 6 , 209 190 171 162 153 বাইট

{~({(.[1]Z'is'),.<e>.&?BLOCK,('array of'X .[2]),('function returning','pointer to'Zxx.[3,0])if $_}(m:g/(\*)*[(\w+)+|\(<e=~~>.][\[(\d+).]*(\(.)*/[1]),$0)}

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

পুনরাবৃত্তিমূলক regex পদ্ধতির। কিছু অতিরিক্ত স্পেস অক্ষর তৈরি করে যা 3 বাইট ব্যয়ে এড়ানো যায় ।

ব্যাখ্যা

{     # Anonymous block
 ~(   # Convert list to string
   {  # Block converting a regex match to a nested list
     (.[1]            # Array of 0 or 1 variable names
       Z'is'),        # zipped with string "is"
     .<e>.&?BLOCK,    # Recursive call to block with subexpression
     ('array of'      # String "array of"
       X .[2]),       # prepended to each array size
     ('function returning',  # Strings "function returning"
      'pointer to'           # and "pointer to"
      Zxx             # zipped repetition with
      .[3,0])         # number of function and pointer matches
     if $_            # Only if there's an argument
   }
   (             # Call block
     m:g/        # Input matched against regex
      (\*)*      # Sequence of asterisks, stored in [0]
      [          # Either
       (\w+)+    # the variable name, stored as 1-element array in [1]
       |         # or
       \(        # literal (
         <e=~~>  # the same regex matched recursively, stored in <e>
       .         # )
      ]
      [\[(\d+).]*  # Sequence of "[n]" with sizes stored in [2]
      (\(.)*       # Sequence of "()" stored in [3]
     /
     [1]  # Second match
   ),
   $0     # First match (base type)
 )
}
— nwellnhof
সূত্র
2

জাভাস্ক্রিপ্ট 250 বাইট [249?]

এটি 250 বাইট ব্যবহার করে:

k=>(a=k.match(/\W|\w+/g),s=[v=j=r=""],f=y=>!j&!a[i+1]||(m=a[i],v?(r+=v=m=='['?`array of ${a[i+=3,i-2]} `:m<')'?(i+=2,"function returning "):s[j-1]=='*'?j--&&"pointer to ":""):m==')'?v=j--|i++:m<'+'?s[j++]=a[i++]:r+=a[v=i++]+" is ",f(),r+a[0]),f(i=2))

ব্যাখ্যা:

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

k=>( // k is input
    a=k.match(/\W|\w+/g), // split by symbol or word
    s=[v=j=r=""], // j=0, v=false, r="", s=[]
    // s is the stack, r is the return string,
    // v is true if we're in evaluation mode (Consume (), [], *)
    // v is false if we're waiting to see a ) or token, which triggers evaluation
    // j is the index of the top of the stack (Stack pointer)
    f=y=>!j&!a[i+1]||( // !j means stack is empty, !a[i+1] means we're at the ;
        m=a[i], // Save a[i] in a variable
        v // Are we evaluating?
        ?(
        r+=v=
            m=='[' // Array
            ?`array of ${a[i+=3,i-2]} ` // Skip three tokens: "[", "10", "]"
                                        // a[i-2] is the "10"
            :m<')' // m == '('
                ?(i+=2,"function returning ") // Skip two tokens: "(", ")"
                :s[j-1]=='*' // Stack has a pointer
                    ?j--&&"pointer to " // Pop the stack
                    :"" // Set v to be false, r+=""
        )
        :m==')'
            ?v=j--|i++ // Pop the '(', skip over the ')', v = Evaluation mode
            :m<'+' // m == '*' || m == '('
                ?s[j++]=a[i++] // push(s, pop(a))
                :r+=a[v=i++]+" is " // Otherwise we have the token
        , f(), r+a[0] // Recurse f(), and return r+a[0]. a[0] is the type.
    ),
    f(i=2) // Set i=2, and call f(), which returns the final value r + type
    // a = ["type", " ", ...], so i=2 give the first real token
    // This soln assumes there is only one space, which is an allowed assumption
)

বিঃদ্রঃ

যদি আমি বুঝতে পারি "টোকেনের মাঝখানে সর্বত্র একটি স্থান ব্যবহার করুন":

k=>(a=k.split(" "),s=[v=j=r=""],f=y=>!j&!a[i+1]||(v?(r+=v=a[i]=='['?`array of ${a[i+=3,i-2]} `:a[i]<')'?(i+=2,"function returning "):s[j-1]=='*'?j--&&"pointer to ":""):a[i]==')'?v=j--|i++:a[i]<'+'?s[j++]=a[i++]:r+=a[v=i++]+" is ",f(),r+a[0]),f(i=1))

প্রযুক্তিগতভাবে বৈধ, এবং ব্যবহার করে

249 বাইট

ধরে নিচ্ছি যে প্রতিটি টোকেনের মধ্যে একটি জায়গা আছে।

— নিকোলাস পাইপিটোন
সূত্র
2
সোজা দেখতে লাগলেও এটি আমাকে অনেক ঘন্টা সময় নিয়েছিল। আমি সম্ভবত 350 টি অক্ষর দিয়ে 5-10 বাইট / ঘন্টা ছিটকেছি। আমি সত্যিই কোন জীবন আছে।
— নিকোলাস পিপিটোন
2
আমি 325 সম্পর্কে যখন আমি ভেবেছিলাম "আমি আমার বর্তমান আলগোরিদিম সঙ্গে optimality আঘাত - চেরা" ছিল, কিন্তু তারপর কিছু কারণে আমি এখনও 5-10 / ঘন্টা কোপ করতে সক্ষম হন সত্ত্বেও প্রতিটি দ্বারা অনুসরণ করা হচ্ছে নক, "ঠিক আছে, এই হল স্পষ্টভাবে অনুকূল ফলাফল "। 250 কে আঘাত করা নির্বিচারে ছিল যেহেতু এটি প্রথম শাসনকাজ 253 কে পরাজিত করেছিল, তাই আমি এখনও "ঠিক আছে, এটি অবশ্যই সর্বোত্তম ফলাফল" বলছি , এখনও আরও অনুকূলিতকরণ হতে পারে।
— নিকোলাস পিপিটোন
1

লাল , 418 410 বাইট

func[s][n: t:""a: charset[#"a"-#"z"#"A"-#"Z"#"0"-#"9""_"]parse s[remove[copy x thru" "(t: x)]to a
change[copy x[any a](n: x)]"#"]b: copy[]until[c: next find s"#"switch c/1[#"("[append
b"function returning"take/part c 2]#"["[parse c[remove[skip copy d to"]"(append b
reduce["array of"d])skip]]]#")"#";"[take c c: back back c while[#"*"= c/1][take c
c: back c append b"pointer to"]take c]]s =""]reduce[n"is"b t]]

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

ব্যাখ্যা:

f: func [ s ] [
    n: t: 0                                         ; n is the name, t is the type
    a: charset [ #"a"-#"z" #"A"-#"Z" #"0"-#"9" "_" ]; characters set for parsing 
    parse s[                                        ; parse the input with the following rules
        remove [ copy x thru " " ](t: x)            ; find the type, save it to t and remove it from the string
        to a                                        ; skip to the next alphanumerical symbol
        change [ copy n [ any a ] (n: x) ] "#"      ; save it to n and replace it with '#'
    ]
    b: copy [ ]                                     ; block for the modifiers 
    until [                                         ; repeat 
       c: next find s "#"                           ; find the place of the name   
       switch c/1 [                                 ; and check what is the next symbol
           #"(" [ append b "function returning"     ; if it's a '('- it's a function - add the modifier       
                  take/part c 2                     ; and drop the "()"
                ]
           #"[" [ parse c [                         ; '[' - an array
                     remove [ skip copy d to "]"    ; save the number
                             (append b reduce [     ; and add the modifier 
                                  "array of" d
                              ] )                   
                             skip ]                 ; and remove it from the string
                     ]
                ]
           #")"                                     ; a closing bracket 
           #";" [ take c                            ; or ';' - drop it
                    c: back back c                  ; go to the left 
                    while [ #"*" = c/1 ]            ; and while there are '*'
                    [
                        take c                      ; drop them
                        c: back c                   ; go to the left
                        append b "pointer to"       ; add the modifier
                    ]
                    take c                          ; drop '(' (or space)
                 ]
       ]
       s = ""                                       ; until the string is exhausted
    ]
    reduce [ n "is" b t ]                     ; display the resul
]
— গ্যালেন ইভানভ
সূত্র
0

এপিএল (এনএআরএস), চারস 625, বাইট 1250

CH←⎕D,⎕A,⎕a,'_'⋄tkn←nm←∆←''⋄in←⍬⋄⍙←lmt←lin←0
eb←{∊(1(0 1 0)(0 1)(1 0))[⍺⍺¨⍵]}
tb←{x←({⍵='[':3⋄⍵=']':4⋄⍵∊CH,' ':1⋄2}eb⍵)\⍵⋄(x≠' ')⊂x}

gt
tkn←''⋄→0×⍳⍙>lin⋄tkn←∊⍙⊃in⋄⍙+←1⋄→0×⍳(⍙>lin)∨'('≠↑tkn⋄→0×⍳')'≠↑⍙⊃in⋄tkn←tkn,⍙⊃in⋄⍙+←1

r←dcl;n
   n←0
B: gt⋄→D×⍳'*'≠↑tkn⋄n+←1⋄→B×⍳tkn≢''
D: r←ddcl⋄∆←∆,∊n⍴⊂'pointer to '

r←ddcl;q
   r←¯1⋄→0×⍳0>lmt-←1
   →A×⍳∼'('=↑tkn⋄q←dcl⋄→F×⍳')'=↑tkn⋄→0
A: →B×⍳∼(↑tkn)∊CH⋄nm←tkn⋄→F
B: r←¯2⋄→0
F: gt⋄→G×⍳∼tkn≡'()'⋄∆←∆,'function that return '⋄→F
G: →Z×⍳∼'['=↑tkn⋄∆←∆,'array of ',{''≡p←(¯1↓1↓tkn):''⋄p,' '}⋄→F
Z: r←0

r←f w;q
   nm←∆←''⋄in←tb w⋄⍙←1⋄lin←↑⍴in⋄lmt←150⋄gt⋄→A×⍳∼0>q←dcl⋄r←⍕q⋄→0
A: r←nm,' is a ',∆,1⊃in

বইয়ের কোড থেকে সি ভাষা থেকে এপিএল পর্যন্ত এটি কেবল একটি ট্রান্সলেশন: ব্রায়ান ডাব্লু। কেরানিংহান এবং ডেনিস এম রিচির অধ্যায় 5.12 এর "লিঙ্গুয়াজিও সি"। আমি জানি না যে এগুলি কীভাবে হ্রাস করা যায় কারণ আমি সেই কোডটি 100% বুঝতে পারি নি, এবং কারণ আমি এপিএলে খুব বেশি জানি না ... অনুশীলনের জন্য এটি ফাংশনটি; আমি মনে করি যে ত্রুটির জন্য কেবল 150 নেস্টেড পেরেনটেসিস '(' ')' এর অনুমতি দেওয়া হয়েছে তবে তার মধ্যে একটি নেতিবাচক মান বা সমস্ত কিছু ঠিক আছে যদি স্ট্রিং ডেসক্রিটিশন দিয়ে ফিরে আসে। মনে হচ্ছে এটি অন্যান্য অক্ষরের চেয়ে ভাল নয় যদিও অন্যটি ত্রুটিগুলি আরও ভাল দেখায়। কিছু পরীক্ষা:

  f 'int f()()'
f is a function that return function that return int
  f 'int a[]()'
a is a array of function that return int
  f 'int f()[]'
f is a function that return array of int
  f 'int i;'
i is a int
  f 'float *f;'
f is a pointer to float
  f 'my_struct_t s[10];'
s is a array of 10 my_struct_t
  f 'int func();'
func is a function that return int
  f 'int arr[3][4];'
arr is a array of 3 array of 4 int
  f 'int (*fptrs[10])();'
fptrs is a array of 10 pointer to function that return int
  f 'float *(*p)[16]; '
p is a pointer to array of 16 pointer to float
  f '_RANdom_TYPE_123 (**(*_WTH_is_TH15)())[1234][567];'
_WTH_is_TH15 is a pointer to function that return pointer to pointe
  r to array of 1234 array of 567 _RANdom_TYPE_123
  f 'uint32_t (**((*(**(((*(((**(*p)))[2]))())))[123])[4])[5]);'
p is a pointer to pointer to pointer to array of 2 pointer to funct
  ion that return pointer to pointer to array of 123 pointer to
   array of 4 array of 5 pointer to pointer to uint32_t
— RosLuP
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.