ডায়েট হাস্কেল তৈরি করা যাক


21

হাস্কেলের এমন টিপল রয়েছে যা লিখতে পারে

(a,b,c)

তবে এটি কেবল সিনট্যাকটিক চিনি

(,,)a b c

সাধারণভাবে একটি এন টুপল এন -1 , এস এর সাথে গঠিত হতে পারে (... এর )পরে স্পেস দ্বারা পৃথক পৃথক উপাদানগুলি অনুসরণ করা যেতে পারে । উদাহরণস্বরূপ, 7-টিপল (1,2,3,4,5,6,7)দ্বারা গঠিত হতে পারে

(,,,,,,)1 2 3 4 5 6 7

যেহেতু হাস্কেলের কাছে 1 টি টিপলস নেই সেগুলি তৈরি করা যায় না। খালি tuples জন্য আপনি দায়ী করা হবে না।

ক্রিয়াকলাপের ক্রমটিকে ওভাররাইড করতে পেরেন ব্যবহার করে নেস্টেড টিউপস গঠিত হতে পারে।

((1,2),3) == (,)((,)1 2)3

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

আপনার প্রোগ্রামে একটি টুপল, একটি অ্যারে, বা চিনিযুক্ত টিউপলের প্রতিনিধিত্বকারী একটি স্ট্রিং নেওয়া উচিত এবং "চিনি-মুক্ত" টুপলের প্রতিনিধিত্ব করে একটি স্ট্রিং আউটপুট করা উচিত। ইনপুট টিপলগুলিতে কেবল ইতিবাচক পূর্ণসংখ্যা বা অন্যান্য টিপল থাকে।

যেহেতু আমরা এখানে গল্ফ করছি আপনার আউটপুট ছোট হওয়া উচিত। এটি অপ্রয়োজনীয় থাকা উচিত নয়

  • শূন্যস্থানের। স্পেসগুলি কেবলমাত্র একটি টিউপল ফাংশনগুলির আর্গুমেন্ট পৃথক করতে ব্যবহার করা উচিত এবং এ এর )আগে বা এর আগে উপস্থিত হওয়া উচিত নয়(

  • বন্ধনী। প্যারেন্টিসগুলি কেবলমাত্র টিউপল ফাংশন গঠনের সময় বা টিপলস নেস্ট করার সময় ব্যবহার করা উচিত।

এটি একটি প্রশ্ন তাই কম বাইট ভাল হওয়ার সাথে বাইটে উত্তরগুলি দেওয়া হবে।

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

(1,2)     -> (,)1 2
(1,2,3)   -> (,,)1 2 3
((1,2),3) -> (,)((,)1 2)3
(1,2,3,4) -> (,,,)1 2 3 4
(1,(2,3)) -> (,)1((,)2 3)
(10,1)    -> (,)10 1

আমি যদি কিছু মিস করছি না, আপনি 1 টি-টিপলস কভার করেন তবে ফাঁকা টিপলস না ..? খালি tuples বৈধ ইনপুট কি?
সম্পূর্ণমানবিক

3
@totallyhuman আপনি খালি tuples পরিচালনা করতে হবে না।
গম উইজার্ড

5 তম টেস্ট-কেসের একটি অতিরিক্ত রয়েছে,
এইচপিউইজ

2
"সংখ্যা" দ্বারাও কি আপনি "ধনাত্মক পূর্ণসংখ্যার" বলতে চান?
এরিক আউটগলফার

2
প্রস্তাবিত পরীক্ষার ক্ষেত্রে: ((1,(2,3)),4,(5,6))এবং (1,(2,3),4)
janrjan জোহানসেন

উত্তর:


17

হাস্কেল , 169 148 বাইট

init.tail.fst.([]%)
p:k="(,"
l%('(':r)|(y,x:s)<-[]%r,m<-y:l=last$m%(p:s):[(p:p:(l>>k)++x:foldl(\r x->x++[' '|x>k,r>k]++r)[x]m,s)|x<',']
l%r=lex r!!0

এটি অনলাইন চেষ্টা করুন! একটি স্ট্রিং হিসাবে tuple লাগে। init.tail.fst.([]%)বেনামে প্রধান কাজ। উদাহরণস্বরূপ এটিকে আবদ্ধ করুন fএবং ব্যবহার করুন f "(3,(14,1),4,7)"যা ফল দেয় "(,,,)3((,)14 1)4 7"

আপনি জিজ্ঞাসা করেছেন কেন হাস্কেল টিউপল হিসাবে ইনপুট সরবরাহ করা হয়নি? যেহেতু হাস্কেল দৃ strongly়ভাবে টাইপ করা হয়েছে, একটি টিপল (1,2)টাইপ (Int,Int)1 এবং একটি টিপলের (1,(2,3))টাইপ রয়েছে (Int,(Int,Int))। সুতরাং একটি ফাংশন যা প্রথম ধরণের টিউপল গ্রহণ করে দ্বিতীয় ধরণের ক্ষেত্রে প্রয়োগ করা যায় না এবং বিশেষত কোনও ফাংশন হতে পারে না যা একটি স্বেচ্ছাসেবী tuple 2 লাগে ।

ব্যাখ্যা:

  • p:k="(,"দায়িত্ব অর্পণ করা একটি সংক্ষিপ্ত পথ pথেকে '('এবং kথেকে ","
  • (%)recursive পার্সিং এবং রূপান্তর ফাংশন। প্রথম যুক্তি হ'ল ইতিমধ্যে পার্সড টুপল এন্ট্রিগুলির একটি তালিকা, দ্বিতীয় যুক্তিটি মূল স্ট্রিংয়ের বাকী। প্রতিটি কল বর্তমান রূপান্তরিত টিপল (একটি স্ট্রিং হিসাবে এবং বন্ধনী মধ্যে আবদ্ধ) এবং স্ট্রিংয়ের বাকী অংশের একটি দ্বিগুণ ফিরিয়ে দেয়।
    • l%('(':r)যদি স্ট্রিংটি একটি খোলার বন্ধনী দিয়ে শুরু হয়, আমাদের একটি নতুন টিপল এন্ট্রি পার্স করতে হবে।
      (y,x:s)<-[]%rআমরা পুনরাবৃত্তভাবে প্রয়োগ করি %এবং একটি টিউপল এন্ট্রি পাই yএবং বাকী স্ট্রিংটি পরবর্তী অক্ষর xএবং বাকী স্ট্রিংয়ে বিভক্ত হয়ে যায় s
      m<-y:lআমরা yইতিমধ্যে পাওয়া এন্ট্রিগুলির বর্তমান তালিকায় নতুন এন্ট্রি যুক্ত করি lএবং ফলাফলটি কল করি m
    • পরবর্তী অক্ষরটি xএখন হয় কমা ,বা একটি বন্ধনী বন্ধনী )last$ <B> :[ <A> |x<',']শুধু লেখার একটি সংক্ষিপ্ত পথ if x == ')' then <A> else <B>
    • সুতরাং যদি একটি ,এর পরের হয় তবে আমাদের পরের প্রবেশটি পুনরাবৃত্তভাবে পার্স করতে হবে: m%(p:s)সঠিক ক্ষেত্রে শেষ হতে এবং ইতিমধ্যে পাওয়া এন্ট্রিগুলির তালিকাটি পাস করার জন্য আমরা একটি খোলার বন্ধনী প্রস্তুত করি m
    • অন্যথায় x == ')', আমরা বর্তমান টিপলটি শেষ করেছি এবং প্রয়োজনীয় রূপান্তরটি করা দরকার:(p:p:(l>>k)++x:foldl(\r x->x++[' '|x>k,r>k]++r)[x]m,s)
      • p:p:(l>>k)++x:যদি আমরা এন এন্ট্রি পেয়েছি তবে mতার মধ্যে এন উপাদান রয়েছে এবং yসর্বাধিক সন্ধান পাওয়া উপাদান যুক্ত করার আগে তালিকায় এন -1 এন্ট্রি রয়েছে। এটি একটি কার্যকর টিউপলের জন্য আমাদের n-1 প্রয়োজন এবং এটি তালিকাগুলিতে " উপাদানগুলির সাথে যতবার সংখ্যক নিজের সাথে তাল মিলিয়ে যায় " হিসাবে কাজ করে এটি কার্যকর হয় । সুতরাং এই প্রথম অংশে কিছু স্ট্রিং ফলন ।,nl>>kky"((,,,)"
      • foldl(\r x->x++[' '|x>k,r>k]++r)[x]mউপাদানগুলি m(বিপরীত ক্রমে, কারণ সামনে নতুন এন্ট্রি যুক্ত mকরে বিপরীত ক্রমে তৈরি করা হয়েছিল) দুটি উপাদানগুলির মধ্যে কেবল দুটি ফাঁক যোগ করার সময় তারা দুটি সংখ্যা রয়েছে: [' '|x>k,r>k]আমরা বর্তমান পরীক্ষাগুলি পরীক্ষা করে xএবং rঅভিধানের সাথে তুলনা করে সংখ্যাগুলি দেখছি তাদের কাছে ","- যদি তারা সংখ্যা না হয় তবে তারা ইতিমধ্যে বন্ধনীতে আবদ্ধ একটি টুপল উপস্থাপনা এবং '(' < ','ধরে রেখেছে।
    • প্যাটার্ন মেলে তাহলে l%('(':r)শুরুতে অধিকার ব্যর্থ হয়, তাহলে আমরা শেষ লাইনে শেষ: l%r=lex r!!0। এর অর্থ আমাদের একটি সংখ্যাকে বিশ্লেষণ করতে হবে এবং স্ট্রিংয়ের সংখ্যা এবং বাকী অংশটি ফিরিয়ে আনতে হবে। ভাগ্যক্রমে এখানে lexফাংশন রয়েছে যা হুবহু এটি করে (এটি কেবলমাত্র সংখ্যার পরিবর্তে পরবর্তী বৈধ হাস্কেল টোকেনকে পার্স করে)। তবে ফলস্বরূপ টিপল একটি তালিকাতে আবৃত থাকে, সুতরাং আমরা তালিকার !!0প্রথম উপাদানটি পেতে ব্যবহার করি ।
  • init.tail.fst.([]%)এটি মূল ফাংশন যা একটি স্ট্রিং নেয় এবং %এটিতে একটি খালি তালিকা প্রয়োগ করে। যেমন একটি ইনপুট হিসাবে "(1,2)", ([]%)ফলন প্রয়োগ করে ("((,)1 2)",""), তাই বাইরের টিপল এবং বন্ধনীগুলি সরানো দরকার। fstটিউপলের প্রথম উপাদান পায়, tailবন্ধনী বন্ধনী এবং initপ্রারম্ভিকটিকে সরিয়ে দেয় ।

সম্পাদনা: মোট 21 বাইট গল্ফ করার জন্য @ Ørjan জোহানসেনকে অনেক ধন্যবাদ !


1 প্রকৃতপক্ষে, প্রকারটি (Num t1, Num t) => (t, t1) , তবে এটি একটি বিচ্ছিন্ন গল্প।

2 আইডি এর মতো পলিমারফিক ফাংশন উপেক্ষা করা যা আসলে তাদের ইনপুট দিয়ে কাজ করতে পারে না।


1
একজন টাইপক্লাস ব্যবহার করে পলিমারফিক ফাংশন লিখতে পারে Desugarableতবে একটির জন্য উদাহরণগুলি Intএবং সমস্ত ধরণের ধরণের ঘোষণা করতে হবে ।
বার্গি

1
gসংক্ষিপ্ত foldr1(\x r->x++[' '|x>k,r>k]++r)এবং ইনলাইন করা যেতে পারে ।
janrjan জোহানসেন

@ বার্গি: ... এবং সত্যই সমস্ত ধরণের ধরণের জন্য উদাহরণগুলি ঘোষণা করতে পারে না । :-) ( show (1,2,3,4,5,6,7,8,9,0,1,2,3,4,5)GHCi এ চেষ্টা করুন , তারপরে একটি যুক্ত করুন ,6এবং আবার চেষ্টা করুন))
wchargin

1
আরও ছয়টি বাইটের জন্য অন্তর্নিহিত উন্নতি করা: m<-y:lডান পরিবর্তে বামদিকে ভাঁজ করুন , এবং [x]প্রাথমিক মান হিসাবে ব্যবহার করুন । এটি অনলাইন চেষ্টা করুন!
janrjan Johansen

1
fবেনামী হতে পারে: init.tail.fst.([]%)
janrjan জোহানসেন

11

Haskell,, 141 বাইট138 বাইট (অর্জান জোহানসেনকে ধন্যবাদ)

import Language.Haskell.TH
f(TupE l)='(':tail(","<*l)++')':""%l
q%(LitE(IntegerL i):l)=q++show i++" "%l
_%(e:l)='(':f e++')':""%l
_%[]=[]

fটাইপ আছে Exp -> String

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

  • আউটপুট: এই টিউপল এক্সপ্রেশনটির জন্য পছন্দসই সিনট্যাক্সযুক্ত একটি স্ট্রিং।

ডেমো:

$ ghci TupDesugar.hs 
GHCi, version 8.3.20170711: http://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from /home/sagemuej/.ghc/ghci.conf
Loaded GHCi configuration from /home/sagemuej/.ghci
[1 of 1] Compiling Main             ( TupDesugar.hs, interpreted )
Ok, 1 module loaded.
*Main> :set -XTemplateHaskell -XQuasiQuotes
*Main> f <$> runQ [|(1,2)|]
"(,)1 2"
*Main> f <$> runQ [|(1,2,3)|]
"(,,)1 2 3"
*Main> f <$> runQ [|((1,2),3)|]
"(,)((,)1 2)3"
*Main> f <$> runQ [|(1,2,3,4)|]
"(,,,)1 2 3 4"
*Main> f <$> runQ [|(1,(2,3))|]
"(,)1((,)2 3)"
*Main> f <$> runQ [|(10,1)|]
"(,)10 1"

2
আপনি দুটি জায়গায় পরিবর্তন ")"++করতে পারেন ')':, এবং tailপেরেসেসিসের বাইরে স্থান সরিয়ে স্থানটি সংরক্ষণ করতে পারেন।
janrjan জোহানসেন

7

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

data T=I Int|U[T]
f(U t)="(("++init(t>>",")++')':foldr(\x y->f x++[' '|f x>",",y>","]++y)")"t
f(I n)=show n
init.tail.f

এটি অনলাইন চেষ্টা করুন! এটি Tটিপলগুলি উপস্থাপন করতে একটি কাস্টম ডেটা ধরণ ব্যবহার করে , এটি একটি টিপল ((1,2),3)হিসাবে উপস্থাপিত হয় U[U[I 1,I 2],I 3]। ব্যবহারের উদাহরণ: init.tail.f $ U[U[I 1,I 2],I 3]ফলন (,)((,)1 2)3



4

জিএনইউ সেড, 149 82 + 2 = 84 বাইট

-rপতাকা জন্য +2 বাইট ।

y/(),/<>'/
:
s/([^<>']+)'/,\1 /
t
s/ ?<(,+)([^>]+)>/((\1)\2)/
t
s/^.|(\)) |.$/\1/g

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

ব্যাখ্যা

y/(),/<>'/                   # Replace parens and commas with brackets and apostrophes
:
  s/([^<>']+)'/,\1 /.          # Remove each apostrophe and insert comma after <
  t                            # Branch to : if substitution was made
  s/ ?<(,+)([^>]+)>/((\1)\2)/  # Change <,,,...> to ((,,,)...)
  t                            # Branch to : if substitution was made
s/^.|(\)) |.$/\1/g           # Remove outermost ()s and extra spaces

এটি আরও কিছু জটিল ক্ষেত্রে ব্যর্থ হয়: ((1,(2,3)),4,(5,6))এবং (1,(2,3),4)
janrjan জোহানসেন

@ JanrjanJohansen ভাল ক্যাচ প্রাতঃরাশের পরে একটু নজর রাখব।
জর্ডান

3

জাভাস্ক্রিপ্ট, 75 বাইট

f=a=>`(${t=a.map(x=>'')})${a.map(v=>t=1/v?1/t?' '+v:v:`(${f(v)})`).join``}`

সংখ্যার ইনপুট অ্যারে | আউটপুট স্ট্রিং।

নীলকে ধন্যবাদ, 2 বাইট সংরক্ষণ করুন


(1/t?' ':0)+vহতে পারে 1/t?' '+v:v
নিল

2

গণিত, 94 বাইট

{"(",","&/@Most@#,")",c=1>0;(xIf[j=ListQ@x,c=j;"("<>#0@x<>")",If[c,c=j;x," "<>x]])/@#}<>""&

একটি অপ্রিন্টযোগ্য U+F4A1, একটি বিল্টিন Functionফাংশন রয়েছে।

Listপূর্ণসংখ্যার একটি গ্রহণ করে String। যদি এটি অনুমোদিত না হয় তবে এটি আরও 10 টি বাইট যোগ করে স্থির করা যেতে পারে (এই সংস্করণটি বেশ Listকয়েকটি ক্ষেত্রে List/ Integerগুলি সময় নেয় ):

{"(",","&/@Most@#,")",c=1>0;(xIf[j=ListQ@x,c=j;"("<>#0@x<>")",If[c,c=j;""," "]<>ToString@x])/@#}<>""&

2

পিপ , 45 বাইট

{Y"()"b:yJ',X#a-1Fcab.:c>0?s.cyJ(fc)bR") "')}

এটি একটি ফাংশন যা যুক্তি হিসাবে একটি তালিকা গ্রহণ করে। এটি অনলাইন চেষ্টা করুন!

মন্তব্য করা সংস্করণ

; Define an anonymous function (the argument is available inside as the variable a)
{
  ; Yank the string "()" into y variable
  Y "()"
  ; Create a string of len(a)-1 commas, join y on it, and assign to b
  b: y J ',X#a-1
  ; For each item c in a
  F c a
    ; Concatenate to b the following expression
    b .:
      ; Is c integer or list?
      ; (If c is a positive integer, c>0 is true; but if c is a list, c>0 is false)
      c>0 ?
        ; If c is integer, concatenate space followed by c
        s.c
        ; If c is list, call function recursively on c and use the result to join y
        yJ(fc)
  ; Replace ") " with ")" in b and return the resulting string
  b R ") " ')
}

2

জাভাস্ক্রিপ্ট (ES6), 88 84 বাইট

f=a=>a.reduce((s,e)=>s+=e[0]?`(${f(e)})`:/\)$/.test(s)?e:' '+e,`(${[...a].fill``})`)

পূর্ণসংখ্যা এবং অ্যারেগুলির একটি অ্যারে নেয়। সম্পাদনা: s+=দুটি পৃথক ব্যবহারের পরিবর্তে ব্যবহার করে 1 বাইট সংরক্ষণ করা হয়েছে s+। এখন আরও 3 বাইট সংরক্ষণ করা হয়েছে যে আমি অভ্যন্তরীণ টার্নারিটি সহজ করতে পারি। আমি যদি @ টিএসএসের ধারণাগুলি চুরি করি তবে আমি এটিকে 76 বাইটে নামাতে পারি:

f=a=>a.reduce((s,e)=>s+=t=1/e?1/t?' '+e:e:`(${f(e)})`,`(${t=a.map(_=>``)})`)

Your program should take either a tuple or a string representing a sugary tupleআমি অনুমান করি যে অ্যারে / পূর্ণসংখ্যার একটি অ্যারে ভাল হওয়া উচিত।
জংহওয়ান মিন

1
নিশ্চিত যে এটি অনুমোদিত
গম উইজার্ড

1

আর, 316 বাইট?

(বেরিয়ে যেতে হবে এবং বাইটস গণনা করার সঠিক উপায়টি নিশ্চিত করা উচিত নয় ... প্লাস এটি কোনও দুর্দান্ত সমাধান নয় তবে এটি তৈরি করতে সময় কাটিয়েছি তাই এটি পোস্ট করতে চেয়েছিলেন ...)

p=function(x){
x=eval(parse(text=gsub("\\(","list(",x)))
f=function(j,r=T){
p=paste
s=if(r){"("}else{"(("}
o=paste0(s,p(rep(",",length(j)-1),collapse=""),")")
n=lengths(j)
for(i in seq_along(n)){
v=j[[i]]
if(n[i]>1){v=f(v,F)}
o=p(o,v)}
if(!r){o=p(o,")")}
o=gsub(" *([()]) *","\\1",o)
return(o)}
f(x)
}

পরীক্ষার কেস:

> p("(1,2)")
[1] "(,)1 2"
> p("(1,2,3)")
[1] "(,,)1 2 3"
> p("((1,2),3)")
[1] "(,)((,)1 2)3"
> p("(1,2,3,4)")
[1] "(,,,)1 2 3 4"
> p("(1,(2,3))")
[1] "(,)1((,)2 3)"
> p("(10,1)")
[1] "(,)10 1"


2
261 বাইট Golfed । আমি কি পরিবর্তিত জন্য একটি ব্যাখ্যা ছেড়ে অনুভব করি, কিন্তু হাস্যকর ভাবে, আমি এছাড়াও যেতে হবে ... কিন্তু + 1, আমি এই প্রায় আমার মাথা মোড়ানো করতে পারিনি; চমৎকার কাজ!
জিউসেপে

0

জাভাস্ক্রিপ্ট (ES6), 72 বাইট

f=(a,b="",c="")=>a.map?b+"("+a.map(x=>'')+")"+a.map(x=>f(x,"(",")"))+c:a

ইনপুট: সংখ্যা এবং / অথবা অ্যারে সমন্বিত অ্যারে

আউটপুট: STRING

ব্যবহার: চ ([...])

সমস্ত পরীক্ষার কেস সম্পন্ন করে, উন্নতিগুলি স্বাগত


0

সি, 308 বা 339 বাইট

#include <ctype.h>
#define p putchar
f(s,e,c,i,l)char*s,*e,*c;{i=1,l=40;if(*s++==l){p(l);for(c=s;i;i+=*c==l,i-=*c==41,i+*c==45&&p(44),c++);p(41);}for(;s<e;s=c){for(i=0;isdigit(*s);s+=*s==44)for(i&&p(32),i=1;isdigit(*s);s++)p(*s);*s==l&&p(l);for(c=s,i=1;++c,c<=e&&i;i+=*c==l)i-=*c==41;f(s,c-1);*s==l&&p(41);}}
#define g(x) f(x, x+strlen(x))

308 বা 339 বাইট, ইনপুট স্ট্রিংয়ের শেষে কোনও পয়েন্টারটি পাস করার অনুমতি রয়েছে কিনা তার উপর নির্ভর করে; শেষ লাইনটি কেবল সেখানে তার দৈর্ঘ্য গণনা না করে সরাসরি স্ট্রিং আক্ষরিক পাশ করার অনুমতি দেয়।

ব্যাখ্যা

একটি দুর্দান্ত সরল অ্যালগরিদম। এটি বর্তমান গভীরতায় কমা সংখ্যার গণনা করে, এগুলিকে টিউপল কনস্ট্রাক্টর হিসাবে মুদ্রণ করে, তারপরে টিপলের যুক্তি অনুসরণ করে পালিয়ে যায় (সংখ্যার মধ্যে ফাঁকা স্থান, প্রথম বন্ধনীগুলির মধ্যে নেস্টেড টুপলস), পুনরাবৃত্তভাবে।

#include <stdio.h>
#include <ctype.h>
typedef enum { false, true } bool;

void tup2ptsfree(char *s, char *e)
{
  int depth;
  char *c;

  if (*s++ == '(') { /* If we are at the start of a tuple, write tuple function `(,,,)` (Otherwise, we are at a closing bracket or a comma) */
    putchar('(');
    /* do the search for comma's */
    c=s; /* probe without moving the original pointer */
    for (depth=1; depth != 0; c++) {
      if (*c == '(') depth++;
      if (*c == ')') depth--;
      if (*c == ',' && depth == 1) putchar(','); /* We have found a comma at the right depth, print it */
    }
    putchar(')');
  }
  while (s < e) { /* The last character is always ')', we can ignore it and save a character. */
    bool wroteNumber;
    for (wroteNumber=false; isdigit(*s); wroteNumber = true) {
      if (wroteNumber) p(' ');           /* If this is not the first number we are writing, add a space */
      while (isdigit(*s)) putchar(*s++); /* Prints the entire number */
      if (*s == ',') s++;                /* We found a ',' instead of a ')', so there might be more numbers following */
    }
    /* Add escaping parenthesis if we are expanding a tuple (Using a small if statement instead of a large branch to prevent doing the same thing twice, since the rest of the code is essentially the same for both cases). */
    if (*s == '(') putchar('(');
    /* Find a matching ')'... */
    c=s+1;
    for (depth=1; c <= e && depth != 0; c++) {
      if (*c == '(') depth++;
      if (*c == ')') depth--;
    }
    /* Found one */
    /* Note how we are looking for a matching paren twice, with slightly different parameters. */
    /* I couldn't find a way to golf this duplication away, though it might be possible. */
    /* Expand the rest of the tuple */
    tup2ptsfree(s, c-1);
    /* idem */
    if (*s == '(') putchar(')');
    /* Make the end of the last expansion the new start pointer. */
    s=c;
  }
}

#define h(x) tup2ptsfree(x, x+strlen(x))

পরীক্ষার মামলা এবং আবেদন

#include <stdio.h>

#define ARRAYSIZE(arr) (sizeof(arr)/sizeof(*arr))
static char *examples[] = {
  "(1,2)",
  "(10,1)",
  "(1,2,3)",
  "(1,2,3,4)",
  "((1,2),3)",
  "(1,(2,3))",
  "(1,(2,3),4)",
  "((1,2),(3,4))",
  "((1,(2,3)),4,(5,6))",
  "((1,((2,3), 4)),5,(6,7))",
  "(42,48)",
  "(1,2,3,4,5,6,7)"
};

int main(void)
{
  int i;
  for (i=0; i < ARRAYSIZE(examples); i++) {
    printf("%-32s | \"", examples[i]);
    g(examples[i]); /* Test with golfed version */
    printf("\"\n");
    printf("%-32s | \"", examples[i]);
    h(examples[i]); /* Test with original version */
    printf("\"\n");
  }
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.