পটভূমি

প্রতিটি পিপিসিজি চ্যালেঞ্জ জয়ের জন্য অ্যালিস এবং বব একটি গল্ফিং ভাষা তৈরি করছে। অ্যালিস> <> এর মতো একটি দ্বি-মাত্রিক ভাষা তৈরি করতে চায় তবে বব জে-র মতো একটি উপসর্গ-ইনফিক্স সিনট্যাক্স পছন্দ করে a পার্সারটি লেখার জন্য একটি ব্যথা এবং তাদের আপনার সহায়তা প্রয়োজন!

সিনট্যাক্স স্পেসিফিকেশন

অ্যালিস এবং ববের ভাষায়, ভেরিয়েবলগুলি রয়েছে , যা ছোট হাতের ASCII বর্ণগুলি a-zএবং ফাংশনগুলি দ্বারা উপস্থাপিত হয়, যা বড় হাতের ASCII অক্ষর দ্বারা প্রতিনিধিত্ব করা হয় A-Z। একটি বা দুটি আর্গুমেন্টের সাহায্যে একটি ফাংশন শুরু করা যেতে পারে। একটি প্রোগ্রাম হ'ল অক্ষর a-zA-Zএবং স্পেসগুলির একটি আয়তক্ষেত্রাকার গ্রিড এবং উপরের বাম কোণে কোনও স্থান থাকতে হবে না। এটি একটি বৈধ প্রোগ্রামের একটি উদাহরণ:

F Gy
H   
R x

যখন প্রোগ্রাম পার্স করা হয়, এটি একটি সি-শৈলী ভাষা (সি, জাভা, পাইথন ...) বিন্যাসে একক অক্ষর ভেরিয়েবল এবং ফাংশন কল ধারণকারী একটি অভিব্যক্তি রুপান্তরিত হচ্ছে <func>(<arg>)বা <func>(<arg1>,<arg2>)। উদাহরণস্বরূপ, উপরোক্ত প্রোগ্রামের ফলাফলটি এই অভিব্যক্তিটিতে:

F(H(R(x)),G(x,y))

পার্সিং প্রক্রিয়া সম্পর্কিত বিশদটি নিম্নরূপ:

স্পেসগুলি কেবল ফিলার, তাই তাদের পার্স করা হয় না।
প্রতিটি পরিবর্তনশীল a-zসর্বদা নিজের হিসাবে পার্স করা হয়।
প্রতিটি ফাংশন A-Zএকটি ফাংশন কল হিসাবে পার্স করা হয়। এর তর্কগুলি হ'ল এটির নীচে এবং গ্রিডের ডানদিকে, এই ক্রমে নিকটতম অভিব্যক্তি। যদি এর মধ্যে কেবল একটি উপস্থিত থাকে তবে এটি একক যুক্তি হিসাবে দেওয়া হয়। আপনি ধরে নিতে পারেন যে সমস্ত ফাংশনের গ্রিডে কমপক্ষে একটি যুক্তি রয়েছে।

উপরের উদাহরণে, ভেরিয়েবলগুলি xএবং yতাদের নিজের হিসাবে পার্স করা হয়। ফাংশনটির Rনীচে এবং xএর ডানদিকে কিছুই নেই , সুতরাং এটি এক-যুক্তির অনুরোধ হিসাবে পার্স করা হয়েছে R(x)। তেমনিভাবে, Hএটি যেমন পার্স করা হয় H(R(x)), যেহেতু এটির Rনীচে রয়েছে । ফাংশন Gরয়েছে xএটা নিচে এবং yতাই এটি যেমন পার্স, তার ডান দিকে G(x,y), এবং একইভাবে জন্য F। উপরের বাম কোণে পার্স করা প্রকাশটি পার্সিং প্রক্রিয়াটির ফলাফল।

ইনপুট এবং আউটপুট

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

বিধি এবং স্কোরিং

আপনি কোনও ফাংশনের পুরো প্রোগ্রাম লিখতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়।

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

এগুলি grid <newline> expressionকেসগুলির ---মধ্যে হাইফেন সহ বিন্যাসে দেওয়া হয় । এসই ফর্ম্যাটটি কিছু লাইন ফাঁকা ছেড়ে দেয় তবে সেগুলি শূন্যস্থান দিয়ে পূর্ণ করা উচিত।

x
x
---
x y
z  
x
---
Fx
F(x)
---
Fx
y 
F(y,x)
---
ABu
A(B(u))
---
G
H
k
G(H(k))
---
ABCA
x xs
 DFk
A(x,B(D(F(k)),C(x,A(s))))
---
A  B  

C  D x
A(C(D(x)),B(D(x)))
---
RT Hq 
I xR k
R(I(x),T(H(R(k),q)))
---
A A  A a 
 S A  b  
B  C   Dx
d X  u f 
A(B(d,C(D(f,x))),A(X(u),A(u,a)))

code-golf grid parsing

— Zgarb
সূত্র

একটি আউটপুট মত (A (B (D x)) (C (D x)))উপযুক্ত হবে বা বিন্যাস ঠিক আছে?

— coredump

1

@ কর্ডাম্প এই চ্যালেঞ্জে আউটপুট ফর্ম্যাট কঠোর; অ্যালিস এবং বব সরাসরি পার্সড এক্সপ্রেশনটি ব্যবহার করতে সক্ষম হতে চান।

— জাগারব

ভাষার "ইনফিক্স" অংশটি কোথায়? আমি কেবল উপসর্গটি দেখতে পাচ্ছি।

— পাওলো ইবারম্যান

6

আপনি কি দয়া করে এই বাক্য গঠনটি দিয়ে একটি ভাষা তৈরি করতে পারেন? :)

— মার্টিন এন্ডার

4

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

— মার্টিন এন্ডার

8

সিজেম, 67 62 60 58 57 54 বাইট

4 বাইট সঞ্চয় করার জন্য ডেনিসকে ধন্যবাদ।

{:Gsc_32&{"()"[GGz2{1m<_{S#}#>W<\}*z]{},{J}%',**+}|}:J

এটি একটি নামকৃত ব্লক (ফাংশন) সংজ্ঞায়িত Jকরে এবং স্ট্যাকের উপরে রেখে দেয়। ফাংশনটি নিজেই স্ট্যাকের স্ট্রিংগুলির একটি অ্যারের প্রত্যাশা করে, যা ইনপুট গ্রিড উপস্থাপন করে এবং পছন্দসই স্ট্রিংটিকে তার স্থানে ছেড়ে দেয়।

এটি এখানে পরীক্ষা করুন।

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

ব্যাখ্যা

সমাধানটি অবশ্যই পুনরাবৃত্ত এবং ধীরে ধীরে স্ট্রিং তৈরি করে।

{
  :G       e#  Store the current grid in G.
  sc       e#  Convert the grid to a string, flattening it, then to a character, which
           e#  discards everything but the first character. This is a golfed 0=0=.
           e#  This character will either be an upper-case letter (function) or a lower-
           e#  case letter (variable).
  _32&     e#  Make a copy of the character and take bitwise AND with 32. This gives a
           e#  NULL character for functions and a space for variables.
  {        e#  If the result is falsy... (i.e. NULL, i.e. we have a function)
    "()"   e#   Push parentheses for later use.
    [      e#   Remember the current stack depth.
    GGz    e#   Push an array which contains the grid and its transpose.
    2{     e#   Run this block twice... (it will be applied once to each grid)
      1m<  e#    Rotate the rows. This has two effects: a) It removes the first row
           e#    from the front such that we can go looking for the next non-space
           e#    character down the first column from the start. b) It places a row
           e#    at the end which we know doesn't start with a space, which acts as
           e#    a guard in case there are no further letters below the current one.
      _    e#    Duplicate this grid.
      {    e#    Find the first index where this block yields something truthy...
        S# e#     Find the index of the first space in the current row. If the row
           e#     starts with a space, this is 0, i.e. falsy and the search continues.
           e#     If there is a space in any later position, that will be positive and
           e#     truthy, so this index gets returned. If there is no space at all,
           e#     the result is -1 which is also truthy and ends the search.
      }#        
      >    e#     Discard all lines up to (but not including) the found index.
      W<   e#     Discard the guard row at the end.
      \    e#     Swap the grids so that the next pass processes the other grid.
    }*       
    z      e#    Transpose the second grid back to its original orientation.
    ]      e#    Wrap both processed grids in an array.
    {},    e#    Remove a grid if it's empty.
    {J}/   e#    For each remaining grid, call J recursively.
    ',*    e#    Join the grids with commas if there are still two of them.
    *      e#    Wrap this string in the parentheses below on the stack.
    +      e#    Prepend the function name.
  }|
}:J

— মার্টিন ইন্ডার
সূত্র

5

পাইথন 2, 227 223 192 182 179 177 বাইট

def r(i,y=0,x=0):
 c=i[y][x];z=[]
 for t in"pq":
    p=q=0
    try:
     while" "==i[y+p][x+q]or 1>p+q:exec t+"+=1"
     z+=[r(i,y+p,x+q)]
    except:1
 return c+"(%s)"%",".join(z)*c.isupper()

(চারটি স্থান সত্যই ট্যাবগুলি রয়েছে)

আর এর প্রথম যুক্তি হিসাবে অক্ষরের একটি 2d তালিকা নেয়।

— নীল
সূত্র

5

পাইথ, 97 বাইট

D:TkdI}p@@QTkGR)=Z0p\(V2JK0W|q\ @@Q=b+TJ=H+kK!+JK=J+NJ=K+!NK)I!|gblQgHl@Q0p*Z\,:bH+=Z1d))p\);:000

আমার godশ্বর যা তৈরি করতে দীর্ঘ সময় নিয়েছিল (প্রায় 5/6 ঘন্টা?) পাইথটি আসলে এর জন্য ডিজাইন করা হয়নি ...

এখানে চেষ্টা করুন ।

অজগর সমতুল্য ব্যাখ্যার চেষ্টা করুন

Q = literal_eval(input())

def at_slice(T,k,d):
  if Pprint(Q[T][k]) in "abcdefghijklmnopqrstuvwxyz": return 
  Z = 0
  Pprint("(")
  for N in range(2):
    J=K=0
    while " "==Q[assign('b',T+J)][assign('H',k+K)] or not J+K:
      J+=N
      K+=not N
    if not (b>=len(Q) or H>=len(Q[0])):
      Pprint(Z*",")
      at_slice(b,H,assign('Z',1)+d)
   Pprint(")")
at_slice(0,0,0)

যেখানে ফাংশন Pprintএবং assignযা দেওয়া হচ্ছে তা ফিরিয়ে দিন।

— নীল
সূত্র

অনেক সংক্ষিপ্ত। এ রকম বাহ!

— অ্যাডিসন ক্রম্প 21

5

হাস্কেল, 124 122 120 119 বাইট

r@((c:_):_)#g|c>'_'=[c]|c<'!'=g%r|1<2=c:'(':(tail%r)!(map tail%r)++")"
_#_=""
g%r=g r#g
a!b=a++[','|a>"",b>""]++b
(#id)

ব্যবহারের উদাহরণ: (#id) ["RT Hq ","I xR k"]-> "R(I(x),T(H(R(k),q)))"।

এটি কীভাবে কাজ করে: ইনপুট গ্রিডের পাশাপাশি r, ফাংশনটি আর্গুমেন্ট হিসাবে #অন্য ফাংশন নেয় gযা rযখনই উপরের বাম অক্ষরটি একটি স্থান থাকে তখন প্রয়োগ করা হয়। পরিবর্তে এটি যদি ছোট হাতের চর হয় তবে এটি ফিরিয়ে দিন। অন্যথায় এটি অবশ্যই বড় হাতের অক্ষর হতে হবে এবং একবার নামার সাথে একবার ডানদিকে যেতে #ডেকে আনা হয় rec প্রয়োজনে একটি সাথে পুনরাবৃত্ত কলগুলি থেকে ফলাফলগুলিতে যোগদান করে । সমস্ত ইনপুট গ্রিড এবং পরিচয় ফাংশন দিয়ে শুরু হয়।tailmap tail!,

— nimi
সূত্র

0

পাইথন 3, 187 বাইট

এখনও এটিকে গল্ফ করার উপায়গুলি খুঁজছি, তবে আমি সন্তুষ্ট হয়েছি আমি এটিকে একটি ওলাইনারে পরিণত করতে পেরেছি।

lambda g,r=0,c=0:g[r][c]+'(%s)'%','.join([p(g,R,c)for R in range(r+1,len(g))if c<len(g[R])and' '!=g[R][c]][:1]+[p(g,r,C)for C in range(c+1,len(g[r]))if' '!=g[r][C]][:1])*g[r][c].isupper()

— টিম পেডারিক
সূত্র

একটি দ্বি-মাত্রিক সিনট্যাক্স পার্স করুন