এন (ই (এস (টি))) একটি স্ট্রিং


77

একটি স্ট্রিং "ফাংশন নেস্ট" করতে, আপনাকে অবশ্যই:

  • প্রথম চরিত্রটিকে একটি ফাংশন হিসাবে এবং নীচের অক্ষরগুলিকে সেই ফাংশনের আর্গুমেন্ট হিসাবে বিবেচনা করুন। উদাহরণস্বরূপ, যদি ইনপুট স্ট্রিংটি হয় Helloতবে প্রথম ধাপটি হ'ল :

    H(ello)
    
  • তারপরে, প্রতিটি স্ট্রিংয়ের জন্য একই পদক্ষেপটি পুনরাবৃত্তি করুন। সুতরাং আমরা পেতে:

    H(ello)
    H(e(llo))
    H(e(l(lo)))
    H(e(l(l(o))))
    

আপনার কাজটি এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা একটি স্ট্রিং "ফাংশন বাসা" করে। উদাহরণস্বরূপ, যদি ইনপুট স্ট্রিংটি ছিল Hello world!তবে আপনার আউটপুট করা উচিত:

H(e(l(l(o( (w(o(r(l(d(!)))))))))))

ইনপুটটিতে কেবল প্রিন্টযোগ্য এএসসিআইআই থাকবে এবং আপনি ইনপুট এবং আউটপুটটিকে কোনও যুক্তিসঙ্গত বিন্যাসে নিতে পারেন। উদাহরণস্বরূপ, STDIN / STDOUT, ফাংশন আর্গুমেন্ট এবং রিটার্ন মান, একটি ফাইলে পড়া এবং লেখা ইত্যাদি

সরলতার জন্য, আপনি ধরে নিতে পারেন ইনপুটটিতে প্রথম বন্ধনী থাকবে না এবং খালি থাকবে না।

Input:
Nest a string
Output:
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))

Input:
foobar
Output:
f(o(o(b(a(r)))))

Input:
1234567890
Output:
1(2(3(4(5(6(7(8(9(0)))))))))

Input:
code-golf
Output:
c(o(d(e(-(g(o(l(f))))))))

Input:
a
Output:
a

Input:
42
Output:
4(2)

যথারীতি, আমাদের সমস্ত ডিফল্ট নিয়ম এবং লুফোলগুলি প্রয়োগ হয় এবং বাইটে জয়লাভ করা সংক্ষিপ্ত উত্তর!


21
আহেম: এই বার্তাটি কি চ্যালেঞ্জের সাথে কিছু করার আছে? :-)
wizzwizz4


ইনপুট স্ট্রিংয়ের সর্বোচ্চ দৈর্ঘ্য কত? রিকার্সিভ পদ্ধতিগুলির ক্ষেত্রে
ফেরিবিগ

1
@ কামোরসো94 You may take the input and the output in any reasonable format.অক্ষরের একটি তালিকা আমার কাছে পুরোপুরি যুক্তিসঙ্গত বলে মনে হচ্ছে।
ডিজেএমসিএমহেম

1
সুতরাং লিস্প কোডটি দেখতে
এমনই

উত্তর:


63

পাইথন, 41 39 34 বাইট

lambda e:"(".join(e)+")"*~-len(e)

এটি আদর্শ

বেশ স্ব স্ব বর্ণনাকারী।

এটি প্রতিটি অন্যান্য চরিত্রের মধ্যে একটি প্রথম বন্ধনী রাখে তারপরে শেষে দৈর্ঘ্য বন্ধনীর চেয়ে কম যোগ করে।


13
~ - কৌশলটি দুর্দান্ত, আমার এটি মনে রাখা দরকার।
স্কাইলার

t -ট্রিক কীভাবে কাজ করে?
ShadowFlame

1
@ শ্যাডোফ্লেম -নম্বরটি নেতিবাচক করে তোলে এবং এটি বিটকে ~সরিয়ে দেয়। টিপস পৃষ্ঠায় আপনি এটি সম্পর্কে আরও কিছুটা পড়তে পারেন ।
শ্রুতচিলিজম ও'জাইক

1
@ShadowFlame। এর মেকানিক্স হ'ল হুইটওয়াইডার্ড বলেছে। এটি এমন সিস্টেমে কাজ করে যা নেতিবাচক সংখ্যাগুলি সঞ্চয় করতে দ্বিগুণ-পরিপূরক মোড ব্যবহার করে (যা আজকাল বেশিরভাগ সিস্টেম)।
ম্যাড পদার্থবিজ্ঞানী

1
পাইথনের সাথে ম্যাড ফিজিসিস্ট, এটি সর্বদা কাজ করে, কারণ x -x-1 হিসাবে সংজ্ঞায়িত করা হয়েছে
মেগা ম্যান

45

এমএস-ডস। কম ফাইল, 30 বাইট

0000   fc be 82 00 b4 02 ac 88 c2 cd 21 ac 3c 0d 74 0d
0010   b2 28 50 cd 21 5a e8 f0 ff b2 29 cd 21 c3

কমান্ড লাইন ব্যবহার করে স্ট্রিংটি এক্সিকিউটেবলের কাছে প্রেরণ করা হয়। (.COM ফাইলের নাম এবং স্ট্রিংয়ের মধ্যে একটি স্পেস অক্ষর)।

ফলাফল স্ট্যান্ডার্ড আউটপুট লিখিত হয়।

বিচ্ছিন্নতা এখানে:

  fc          cld              ; Make sure DF is not set (lodsb!)
  be 82 00    mov    si,0x82   ; First character of command line args
  b4 02       mov    ah,0x2    ; AH=2 means output for INT 21h
  ac          lodsb            ; Load first character
  88 c2       mov    dl,al     ; Move AL to DL (DL is written to output)
recursiveFunction:
  cd 21       int    0x21      ; Output
  ac          lodsb            ; Get the next character
  3c 0d       cmp    al,0xd    ; If it is "CR" (end of command line) ...
  74 0d       je     doReturn  ; ... return from the recursive function
  b2 28       mov    dl,0x28   ; Output "(" next...
  50          push   ax        ; ... but save character read first
  cd 21       int    0x21      ; (Actual output)
  5a          pop    dx        ; Restore character (but in DL, not in AL)
  e8 f0 ff    call   recursiveFunction  ; Recursively enter the function
doReturn:
  b2 29       mov    dl,0x29   ; Output ")"
  cd 21       int    0x21
  c3          ret              ; Actually return

দ্রষ্টব্য: আপনি একটি "RET" নির্দেশিকা ব্যবহার করে একটি ডস .কম ফাইল (EXE শিরোনামযুক্ত ফাইলগুলির বিপরীতে) প্রস্থান করতে পারবেন।


যেহেতু আমি কোনও প্রকৃত নথিপত্র বা সন্তোষজনক তথ্য খুঁজে পাচ্ছি না: কেন call 0xfoff? প্রোগ্রামটি 0যতদূর আমি বলতে পারি ঠিকানায় মেমরিতে লোড করা হয় (বা 0x100সিপি / এম-ডসগুলিতে তবে এটি x86 নির্দেশাবলী হিসাবে প্রদর্শিত হয়), recursiveFunctionহঠাৎ কেন অবস্থিত 0xffof? এটি প্রোগ্রামের শুরু হওয়ার পরে 9 বাইট থেকে শুরু হবে বলে মনে হয় এবং এক্সিকিউটেবলের মধ্যে কোনও ভার্চুয়ালাইজেশন বা মেটাডেটা নেই।
বিড়াল

6
ডস লোড করে .কম ফাইলগুলি সম্বোধনের জন্য ফাইলগুলি 0x100যদিও এই প্রোগ্রামটি কোনও ঠিকানায় চালিত হবে: e8 f0 ffএটি একটি আপেক্ষিক কল নির্দেশ: এটি callনির্দেশ বিয়োগ 0x10 অনুসরণ করে নির্দেশের ঠিকানায় যায় ।
মার্টিন রোজনউ

32

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

ETH প্রডাকশনগুলির জন্য 6 বাইট সংরক্ষণ করা হয়েছে

একটি পুনরাবৃত্তি ফাংশন।

f=([c,...s])=>s+s?c+`(${f(s)})`:c

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


1
সাথে দুর্দান্ত কৌশল 1/s
ইটিএইচ প্রডাকশনগুলি

([c,...s])আপনার সাথে দুর্দান্ত সুন্দর কৌশলটি একটি টিপ লিখতে হবে
edc65

@ edc65 ঠিক স্পষ্টতার জন্য, এটি একটি ইটিএইচ প্রডাকশন দ্বারা প্রস্তাবিত হয়েছিল।
আর্নৌল্ড

ও ঠিক আছে, যে কোনওভাবেই কোনও টিপ লিখতে হবে
edc65

1
@ জিমিংভ আপনাকে ধন্যবাদ জানায়, আমি জানি। এখানে বিন্দুটি খুব সংক্ষিপ্ত উপায়ে স্ট্রাইস টুকরো করতে ডিএ ব্যবহার করছে (.স্লাইসের চেয়ে খুব ছোট)
edc65

26

ব্রেইনফাক, 42 40 বাইট

>+[-->+[<]>-]>+>>,.,[<+<.>>.,]<<+>[-<.>]

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

Ungolfed:

>+[-->+[<]>-]>+     # count to 40 (ASCII for open paren)
>>                  # move to the input holder
,.                  # input the first byte and output it
,                   # input the next byte
[                   # while it's not zero
  <+                # move to the input counter and increment it
  <.                # move to the open paren and output it
  >>.               # move to the input holder and output it
  ,                 # input the next byte
]
<<+                 # move to the open paren and increment it to a close
>                   # move to the input counter
[                   # while it's not zero
  -                 # decrement it
  <.                # move to the close paren and output it
  >                 # move to the input counter
]


আহ ভাল, ধন্যবাদ। এটি আমার প্রথম বিএফ জমা ছিল (আমার প্রথম বিএফ প্রোগ্রামটি আদৌ, সত্যই) তাই আমি নিশ্চিত যে আরও অনেক সম্ভাব্য উন্নতি হয়েছে।
অ্যালেক্স হাওয়ানস্কি 18:58

আপনি এক জোড়া বন্ধনী পেয়েছেন !?
ভ্লুএক্সএক্সটি

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

আহ ব্যাগার, আপনি ঠিক বলেছেন। আমি যথেষ্ট মনোযোগ সহকারে পড়িনি এবং শেষ চিঠিটি অন্যদের মতো ফাংশন কল করেছি।
অ্যালেক্স হাওয়ানস্কি


17

ব্রেইনফাক, 44 বাইট

>+++++[-<++++++++>],.,[<.>.>+<,]<+>>[-<<.>>]

একটি সময়ে বাইট পড়ে, প্রথমটি বাদে প্রতিটিের সামনে একটি খোলা-প্যারেন রাখে, শেষে সমান সংখ্যক নিকট-পেরেন রাখে।


+++++[->++++++++<],.,[>.>+<<.,]>+>[-<.>]সামান্য খাটো হয়।
টেসেরাক্ত

16

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

f[x]=[x]
f(a:b)=a:'(':f b++")"

ব্যবহারের উদাহরণ: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))"

পরের চরটি ধরুন, এর পরে ক (, তারপরে প্রথমে প্রথমে চার ছাড়া একটি পুনরাবৃত্ত কল, তারপরে এ )


2
যদি আমরা উত্তরগুলি হাস্কেল হিসাবে ব্যাখ্যা করি তবে আমরা এটিকে স্রেফ সমাধান করতে পারি f=Data.List.intersperse '$'! যে আমাদের দেয় f "Nest a string"-> "N$e$s$t$ $a$ $s$t$r$i$n$g"
পোরগলজম্প

কেবলমাত্র আপনাকে জানাতে চেয়েছিলেন যে @fornit (মন্তব্য করার মতো যথেষ্ট উত্তর নেই) f[]=[]আপনার ইনস্ট্যানডের বেস কেস হিসাবে ব্যবহার করার পরামর্শ দিয়েছেন f[x]=[x]। আমি হাস্কেলের সাথে পরিচিত নই তাই এটি বৈধ কিনা তা আমি জানি না, আমি আপনাকে বিচার করতে দেব।
দাদা

@ দাদা: এটি কাজ করবে না, কারণ এটি ()শেষ অক্ষরের পিছনে একটি অতিরিক্ত রাখবে, যেমন f "abc"-> "a(b(c()))"
নিমি

এটি খালি ইনপুট পরিচালনা করে না। সবচেয়ে কম সঠিক সংস্করণ আমি সাথে আসতে পারেন 44, একটি বিভিন্ন কৌশল নিয়ে: f=(++).intersperse '('<*>drop 1.map(\_->')')
জন পুরি

@ জোনপুর্ডি: আমাদের খালি ইনপুট পরিচালনা করতে হবে না। আরও 17 বাইটের জন্য intersperseপ্রয়োজন import Data.List
নিমি

16

জেলি , 9 8 বাইট

-1 বেনাইট @ ডেনিসকে ধন্যবাদ (ছাঁচ ব্যবহার করুন, দৈর্ঘ্যের জায়গায় L, এবং পুনরাবৃত্তি করুন x)

j”(³”)ṁṖ

TryItOnline

কিভাবে?

j”(³”)ṁṖ - Main link: s     e.g. "code-golf"           printed output:
j        - join s with
 ”(      - literal '('           "c(o(d(e(-(g(o(l(f"
    ”)   - literal ')'
      ṁ  - mould like
   ³     - first input, s        ")))))))))"
         - causes print with no newline of z:          c(o(d(e(-(g(o(l(f
       Ṗ - pop (z[:-1])          "))))))))"            c(o(d(e(-(g(o(l(f
         - implicit print                              c(o(d(e(-(g(o(l(f))))))))

3
বিটিডব্লিউ, ³আসলে জেলিকে বর্তমান রিটার্ন মানটি মুদ্রণ করে তোলে , তাই আপনার কাছে অক্ষরের দুটি তালিকা কখনও নেই।
ডেনিস

13

রেটিনা , 22 17 বাইট

\1>`.
($&
T`(p`)_

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

বিকল্পভাবে:

S_`
\`¶
(
T`(p`)_

ব্যাখ্যা

আমি সর্বদা ভুলে যাই যে সবকিছুকে চূড়ান্ত পরিণতিতে রূপান্তরিত করা এবং একসাথে আউটপুট করার পরিবর্তে পথে স্টাফগুলি মুদ্রণ করা সম্ভব ...

\1>`.
($&

এখানে \রেটিনাকে বলছে কোনও পেছনের লাইনফিড ছাড়াই এই পর্যায়ের ফলাফল মুদ্রণ করতে। 1>একটা সীমা যার অর্থ হল যে Regex প্রথম ম্যাচে উপেক্ষা করা উচিত নয়। মঞ্চ হিসাবে নিজেই, এটি কেবল প্রতিটি অক্ষর ( .) এর পরিবর্তে প্রথমটি বাদ দিয়ে (অক্ষরটি অনুসরণ করে। অন্য কথায়, এটি (প্রতিটি জোড়া অক্ষরের মধ্যে সন্নিবেশ করায় । ইনপুট জন্য abc, এটি এটিকে রূপান্তরিত করে (এবং মুদ্রণ)

a(b(c

যা যা অবশিষ্ট রয়েছে তা হ'ল বন্ধ বন্ধনীগুলি মুদ্রণ করা:

T`(p`)_

এটি একটি ট্রান্সপ্লিটের মাধ্যমে সম্পন্ন হয় যা স্ট্রিং থেকে অন্য সমস্ত মুদ্রণযোগ্য ASCII অক্ষরকে প্রতিস্থাপন (করে )এবং মুছে দেয়।


ধূর. এত দ্রুত ...
mbomb007

@ mbomb007 ... এবং সর্বোত্তম থেকে অনেক দূরে। ;)
মার্টিন ইন্ডার

13

> <> , 19 18 বাইট

io8i:&0(.')('o&!
o

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

ব্যাখ্যা

প্রথম লাইনটি একটি ইনপুট লুপ যা ইনপুটটির সর্বশেষ অক্ষর পর্যন্ত সমস্ত কিছু মুদ্রণ করে (সমস্তগুলি সহ () এবং )স্ট্যাকের সঠিক পরিমাণ রেখে দেয় :

io                 Read and print the first character.
  8                Push an 8 (the x-coordinate of the . in the program).
   i               Read a character. Pushes -1 at EOF.
    :&             Put a copy in the register.
      0(           Check if negative. Gives 1 at EOF, 0 otherwise.
        .          Jump to (8, EOF?). As long as we're not at EOF, this is
                   a no-op (apart from popping the two coordinates). At EOF
                   it takes us to the second line.
         ')('      Push both characters.
             o     Output the '('.
              &    Push the input character from the register.
               !   Skip the 'i' at the beginning of the line, so that the next
                   iteration starts with 'o', printing the last character.

আমরা যখন ইওএফ-তে আঘাত করি, তখন নির্দেশ পয়েন্টারটি দ্বিতীয় লাইনে শেষ হয় এবং স্ট্যাকটি খালি না হওয়া পর্যন্ত এবং প্রোগ্রামটি ত্রুটি না হয়ে যাওয়া পর্যন্ত আমরা কেবল oএকটি লুপে কার্যকর করব all)


12

সি #, 32 বাইট

F=s=>*s+++(0<*s?$"({F(s)})":"");

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

/*unsafe delegate string Function(char* s);*/ // Lambda signature
/*static unsafe Function*/ F = s =>
    *s++                               // Take first char and increment pointer to next one
    + (0 < *s                          // Check if any chars left
        ? $"({F(s)})"                  // If so concat surrounding parens around recursion
        : ""                           // Otherwise done
    )
;

সংজ্ঞা ঘোষিত ও গণনা হিসাবে চালানো উচিত
বিড়াল

11

জে, 13 বাইট

(,'(',,&')')/

জে ডান থেকে বাম থেকে চালায় তাই সন্নিবেশকরণ বিশেষণটি /ব্যবহার করে ইনপুট স্ট্রিংয়ের অক্ষরগুলি হ্রাস করতে একটি ক্রিয়া ব্যবহার করা যেতে পারে।

ব্যবহার

   f =: (,'(',,&')')/
   f 'Nest a string'
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))
   f 'foobar'
f(o(o(b(a(r)))))
   f '1234567890'
1(2(3(4(5(6(7(8(9(0)))))))))
   f 'code-golf'
c(o(d(e(-(g(o(l(f))))))))

আপনি প্রতিটি হ্রাস মধ্যে আংশিক ফলাফল পর্যবেক্ষণ করতে পারেন।

   |. f\. 'Hello'
o            
l(o)         
l(l(o))      
e(l(l(o)))   
H(e(l(l(o))))

ব্যাখ্যা

(,'(',,&')')/  Input: string S
(          )/  Insert this verb between each char and execute (right-to-left)
      ,&')'      Append a ')' to the right char
  '(',           Prepend a '(' to that
 ,               Append to the left char

9

আর, 61 বাইট

cat(gsub("(?<=.)(?=.)","(",x,F,T),rep(")",nchar(x)-1),sep="")

রেজেক্স অক্ষরগুলির মধ্যে ফাঁকা স্থানগুলি "("। দিয়ে catএবং rep"" যোগ ")" শেষে এন-1 বারের সাথে সন্ধান করে।


আসলে 1 বাইট এখানে এফ দূর দ্বারা বিয়োগ করতে পারেন তাই মত , এই প্রতিটি প্রবেশ ইতিমধ্যে একটি ডিফল্ট সেটিং আছে, তাই কমা মধ্যে একটি খালি চরিত্র তার ডিফল্ট ব্যবহার করতে ignore.case বিকল্প কারণ হবে ছাড়ার কারণ। তবে আপনি সম্ভবত জানতেন যে ... কাজটি ভাল হয়েছে!
Sumner18

8

পাওয়ারশেল ভি 2 +, 46 বাইট

param([char[]]$a)($a-join'(')+')'*($a.count-1)

ইনপুট স্ট্রিং নেয়, - অ্যারে charএটি হয়, -joinওপেন পেরেনগুলির সাথে একসাথে অ্যারে তৈরি করা হয় (, তারপরে বন্ধ হওয়া পেরেনগুলির যথাযথ সংখ্যায় সম্মতি দেয় )


8

Acc !! , 129 বাইট

মোটামুটি ভার্জোজ টিউরিং টারপিটের জন্য খারাপ নয় ...

N
Count i while _%128-9 {
Count x while _/128%2 {
Write 40
_+128
}
Write _%128
_+128-_%128+N
}
Count j while _/256-j {
Write 41
}

(হ্যাঁ, সমস্ত সাদা স্থান বাধ্যতামূলক)

দ্রষ্টব্য: AC এর ইনপুট সীমাবদ্ধতার কারণে !! , কিছু শেষ সীমানা ছাড়াই অক্ষরের একটি নির্বিচারে স্ট্রিং পড়া অসম্ভব impossible অতএব, এই প্রোগ্রামটি ট্যাব অক্ষর দ্বারা অনুসরণ করা একটি স্ট্রিং হিসাবে ইনপুট (স্টিডিনে) প্রত্যাশা করে।

Acc !! ?

এটি এমন একটি ভাষা যা আমি তৈরি করেছি যা কেবল ব্যবহারযোগ্য হবে না । একমাত্র ডেটা টাইপটি পূর্ণসংখ্যা, একমাত্র নিয়ন্ত্রণ প্রবাহ Count x while yরচনাটি লুপ এবং ডেটা সংরক্ষণের একমাত্র উপায় হ'ল একক সঞ্চালক _। বিশেষ মান Nএবং Writeবিবৃতি ব্যবহার করে ইনপুট এবং আউটপুট একবারে একটি করে অক্ষর সম্পন্ন হয় । এই সীমাবদ্ধতা সত্ত্বেও, আমি নিশ্চিত যে এ্যাক !! টুরিং-সম্পূর্ণ।

ব্যাখ্যা

এ্যাক মৌলিক কৌশল !! প্রোগ্রামিং হ'ল সংযোজককে ধারণামূলকভাবে বিভাজন করতে মোড %এবং পূর্ণসংখ্যা বিভাগ ব্যবহার করে /এটি একসাথে একাধিক মান সংরক্ষণ করতে দেয়। এই প্রোগ্রামে, আমরা এই জাতীয় তিনটি বিভাগ ব্যবহার করি: সর্বনিম্ন-অর্ডার সাত বিট ( _%128) ইনপুট থেকে একটি ASCII কোড সঞ্চয় করে; পরবর্তী বিট ( _/128%2) একটি পতাকা মান সংরক্ষণ করে; এবং অবশিষ্ট বিটস ( _/256) আমাদের প্রয়োজন নিকট-পেরেনগুলির সংখ্যা গণনা করুন।

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

_%128সর্বাধিক পঠিত অক্ষর সংরক্ষণ করবে। সুতরাং প্রথম লুপটি _%128-9ননজারো চলাকালীন চলবে - যা বর্তমান অক্ষরটি একটি ট্যাব না হওয়া পর্যন্ত।

লুপের অভ্যন্তরে, আমরা প্রথম পুনরাবৃত্তিতে ( না থাকলে আমরা মুদ্রণ করতে চাই । এসি থেকে !! যদি বিবৃতি নেই, শর্তসাপেক্ষে আমাদের লুপ ব্যবহার করতে হবে। আমরা 128 এর বিটটি সঞ্চয়ীটির _/128%2একটি পতাকা মান হিসাবে ব্যবহার করি । প্রথম পাসে, সঞ্চয়ের একমাত্র জিনিসটি ASCII মান <128, সুতরাং পতাকা 0 হয় এবং লুপটি এড়িয়ে যায়। পরবর্তী প্রতিটি পাসে, আমরা পতাকাটি 1 হ'ল তা নিশ্চিত করব।

Count xলুপের অভ্যন্তরে (যখনই পতাকাটি 1 থাকে), আমরা একটি খোলা পেরেন (এএসসিআইআই 40) লিখি এবং সঞ্চয়ের সাথে 128 যুক্ত করি, যার ফলে পতাকাটি 0 এ সেট করা হয় এবং লুপটি প্রস্থান করা হয়। এটির মান বাড়ানোর ক্ষেত্রেও এটি ঘটে _/256, যা আমরা আউটপুট হওয়ার জন্য আমাদের নিকটবর্তী প্যারেনগুলির টেলি হিসাবে ব্যবহার করব।

পতাকার মান নির্বিশেষে, আমরা সর্বাধিক সাম্প্রতিক ইনপুট চর লিখি _%128

পরবর্তী অ্যাসাইনমেন্ট ( _+128-_%128+N) দুটি কাজ করে। প্রথমত, 128 যোগ করে এটি লুপের মাধ্যমে পরবর্তী বারের জন্য পতাকা সেট করে। দ্বিতীয়ত, এটি _%128স্লটটি জিরোস করে, অন্য একটি চরিত্র পড়ে এবং এটি সেখানে সংরক্ষণ করে। তারপরে আমরা লুপ করি।

যখন Count iলুপটি প্রস্থান করে, আমরা কেবল একটি ট্যাব অক্ষরটি পড়েছি, এবং সঞ্চয়ের মানটি এইভাবে ভেঙে যায়:

  • _%128: 9(ট্যাব অক্ষর)
  • _/128%2: 1(পতাকা)
  • _/256: পঠিত অক্ষরের সংখ্যা, বিয়োগ 1

(বিয়োগ 1 টি হ'ল মূল লুপটি দিয়ে প্রথম পাসের সময় আমরা কেবল একবার সঞ্চয়ের সাথে 128 যোগ করি)) এখন আমাদের যা দরকার তা হল নিকটতম প্যারেনস। Count j while _/256-jলুপ _/256বার, 41প্রতিবার একটি ঘনিষ্ঠ-পেরেন (ASCII ) লেখা । ভাল খবর!


8

জাভা 7,81 79 বাইট

সংরক্ষিত 1কেভিন করার byte.Thanks।

String f(char[]a,String b,int l){return l<a.length?f(a,b+'('+a[l],++l)+')':b;}

চমৎকার পুনরাবৃত্তি পদ্ধতির। লুপটির চেয়ে কম আমি পোস্ট করতে চলেছিলাম। +1 দুটি জিনিস আপনি গল্ফ করতে পারেন যদিও: l!=a.length-> l<a.lengthএবং b=b+'('+a[l],++l)+')'-> b+="("+a[l],++l)+")"( -2 বাইট )
কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন b+="("+a[l],++l)+")"আপনাকে 144141148 % দেয়)), এবং বিটিডাব্লু b+"("+a[l],++l)+")"সঠিক। এবং এটি আমার ( !=) ভুল নিরীহ ভুল ছিল ।
সংখ্যাটি নোট

না, b+='('+a[l],++l)+')'দেয় 144141148, কিন্তু b+="("+a[l],++l)+")"দেয় না। প্রথম বন্ধনীগুলি চার-কোটের পরিবর্তে স্ট্রিং-কোট দ্বারা বেষ্টিত।
কেভিন ক্রুইজসেন

আমি আমার সংস্করণটি পোস্ট করি (জাভা 7 এ 82 ​​বাইট) প্যারামিটার হিসাবে কেবল ইনপুট স্ট্রিং ব্যবহার করে। ভার্বোস তবে এটি খারাপ নয়;) যদি আপনি কিছু বদলাতে পান: কোডগলফ.স্ট্যাকেক্সেঞ্জারওয়ে
96745

7

এপিএল, 19 বাইট

{∊('(',¨⍵),')'⍴⍨⍴⍵}

ব্যাখ্যা:

{
  ('(',¨⍵)          ⍝ join a ( to each character in ⍵          
          ,')'⍴⍨⍴⍵  ⍝ for each character in ⍵, add an ) to the end
 ∊                  ⍝ flatten the list 
                   }

বিকল্প সমাধান, এছাড়াও 19 বাইট:

{⊃{∊'('⍺⍵')'}/⍵,⊂⍬}

ব্যাখ্যা:

{              
              ⍵,⊂⍬  ⍝ add an empty list behind ⍵ (as a base case)
  {         }/      ⍝ reduce with this function:
    '('⍺⍵')'        ⍝   put braces around input
   ∊                ⍝   flatten the list
 ⊃                  ⍝ take first item from resulting list
                   }

6
এই জাতীয় ভাষার জন্য আপনি কীবোর্ডগুলি কোথায় কিনবেন !!!
রোনান দেঝেরো

@ রোনানডেজেরো সম্ভবত কেবল ক্লিটার, শিফট, এলইটি, ক্যাপস্লক, নামলক ইত্যাদি ব্যবহার করে কী রিম্যাপিং করতে পারেন
অ্যারিয়ানা

7

এমএটিএল , 16 বাইট

t~40+v3L)7MQ3L)h

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

ব্যাখ্যা

t     % Implicit input. Duplicate
      % STACK: 'foobar', 'foobar'
~     % Negate. Transforms into an array of zeros
      % STACK: 'foobar', [0 0 0 0 0 0]
40+   % Add 40, element-wise. Gives array containing 40 repeated
      % STACK: 'foobar', [40 40 40 40 40 40]
v     % Concatenate vertically. Gives a two-row char array, with 40 cast into '('
      % STACK: ['foobar'; '((((((']
3L)   % Remove last element. Converts to row vector
      % STACK: 'f(o(o(b(a(r'
7M    % Push array containing 40 again
      % STACK: 'f(o(o(b(a(r', [40 40 40 40 40 40]
Q     % Add 1, element-wise 
      % STACK: 'f(o(o(b(a(r', [41 41 41 41 41 41]
h     % Concatenate horizontally, with 41 cast into ')'
      % STACK: 'f(o(o(b(a(r)))))'
      % Implicit display

7

পার্ল, 25 বাইট

4 টু বাইট গলফ করার জন্য @ টন হসপেলকে ধন্যবাদ ।

24 কোডের বাইট -F

$"="(";say"@F".")"x$#F

প্রয়োজন -Fএবং -Eপতাকা:

echo -n "I love lisp" | perl -F -E '$"="(";say"@F".")"x$#F'

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


আর একটি আকর্ষণীয় উপায় (যদিও খানিকটা বেশি দীর্ঘ: 28 বাইট):
টোন হসপেলকে আবারও ধন্যবাদ এটি আমাকে সঠিক হতে সাহায্য করার জন্য।

#!/usr/bin/perl -p
s/.(?=.)/s%\Q$'%($&)%/reg

(এটি ব্যবহার করতে, কোনও ফাইলের মধ্যে কোডটি রেখে দিন এবং এটি দিয়ে কল করুন echo -n "Hello" | perl nest.pl)


আপনার ""পরে এর দরকার নেই -F। আপনি -lযদি চূড়ান্ত নিউলাইন ছাড়াই ইনপুট স্ট্রিং প্রবেশ করানোর দাবি করেন তবে আপনার প্রয়োজনও হবে না :echo -n Hello | program
টন হসপেল

@ টনহসপেল রাইট -F, ধন্যবাদ যে আচরণের সম্পর্কে আমি ভুলে গেছি (বা জানি না, নিশ্চিত ছিলাম) না । (আমি ভাবছিলাম কীভাবে চূড়ান্ত নিউলাইন ছাড়াই ইনপুটটি পাব, তার জন্যও ধন্যবাদ)
দাদা

perl -F -E '$"="(";say"@F".")"x$#F'
টন হসপেল

আপনি আপনার অন্যান্য ধারণাটির মতো কিছু নিয়ে কাজ করতে পারেন s/.(?=.)/s%$'%($&)%/regতবে এটি অবশ্যই রেজেক্স
মেটাচার্যাক্টরযুক্ত

@ টনহোপেল এই সকলের জন্য অনেক অনেক ধন্যবাদ! (দ্বিতীয়টি সম্পর্কে, আমি \Qরেজেক্স মেটাচার্যাক্টরগুলিতে সমর্থন যোগ করেছি ) :-)
দাদা

6

রুবি, 27 বাইট

->s{s.chars*?(+?)*~-s.size}

ব্যাখ্যা

->s{                       # Declare anonymous lambda taking argument s
    s.chars                # Get the array of chars representing s
           *?(             # Join the elements back into a string using "("s as separators
              +?)*~-s.size # Append (s.size - 1) ")"s to the end

6

পার্ল, 24 23 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

নিউলাইন ছাড়াই STDIN এ স্ট্রিং দিন (বা -lপ্রোগ্রামে একটি বিকল্প যুক্ত করুন )

echo -n Hello | nest.pl

nest.pl:

#!/usr/bin/perl -p
$\=")"x s/.(?=.)/$&(/g

6

জিএনইউ সেড, 37 35 31 বাইট ( -rযুক্তির জন্য 30 +1 )

খাঁটি লিনাক্স সেড দ্রবণ

:;s/([^(])([^()].*)$/\1(\2)/;t
  1. চাঁদার নামকরণ :; তারপরে এটি পুনরাবৃত্তির সাথে ডাকছেt
  2. ২ টি রেজেক্স গ্রুপ তৈরি করা:
    • প্রথম গোষ্ঠীটি টানা দুটি চরিত্রের প্রথম চর যা প্রথম বন্ধনী নয়
    • দ্বিতীয় গ্রুপটি টানা দ্বিতীয় অক্ষর এবং রেখার শেষ অবধি স্ট্রিংয়ের বাকী অংশ
  3. দ্বিতীয় গোষ্ঠীর চারপাশে প্রথম বন্ধন যুক্ত করুন \1 ( \2 )

সম্পাদনা করুন : 4 টি অক্ষর অপসারণে সহায়তার জন্য @ মান্যাটওয়ার্ককে ধন্যবাদ!

অনলাইন পরীক্ষক


2
কেবল 2 টি গ্রুপ ব্যবহার করা যথেষ্ট বলে মনে হচ্ছে। ২ য় এবং ৩ য় এক সাথে ক্যাপচার করুন।
manatwork

ওহ, এবং দুঃখিত, তবে আপনার কোডটি কাজ করার জন্য দোভাষীের ডিফল্ট আচরণ পরিবর্তন করার জন্য কমান্ড লাইন বিকল্পগুলি আকার আকারে অন্তর্ভুক্ত করতে হবে। -eদোভাষীর কাছে কোডটি পাস করার জন্য সবেমাত্র প্রয়োজনীয় । (ঠিক আছে, sedএটি ছাড়াও খুশি।) সুতরাং আপনার জন্য sed -re '…'+1 গণনা করুন।
manatwork

1
ফাঁকা লেবেলগুলি একটি GNU সেড বৈশিষ্ট্য / বাগ, তাই সম্ভবত শিরোনামটি GNU সেড হওয়া উচিত।
রিলে

6

জেলিফিশ , 19 18 বাইট

P
,+>`
_  {I
/'␁'(

অক্ষরটি বাইট মান সহ অপ্রিন্টযোগ্য নিয়ন্ত্রণ চরিত্র 0x1এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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

  • I কাঁচা ইনপুট, স্ট্রিং হিসাবে STDIN থেকে পড়ুন।
  • '(আক্ষরিক চরিত্র (
  • {(বাম পরিচয়) লাগে '(এবং Iইনপুট, এবং আয় যেমন '(। রিটার্ন মান আসলে ব্যবহার করা হয় না।
  • `থ্রেড হয়। এটি প্রতিটি {চরিত্রের (জন্য চরিত্রটি ফিরিয়ে আনা পরিবর্তন করে Iযার ফলস্বরূপ (একই দৈর্ঘ্যের একটি স্ট্রিং হয় I
  • >লেজ হয়; এটি (ইনপুট হিসাবে স্ট্রিং নেয় এবং প্রথম অক্ষরটি ছড়িয়ে যায়।
  • +আর্গুমেন্টগুলির স্ট্রিং (এবং অপ্রিন্টযোগ্য বাইট হিসাবে গ্রহণ করে এবং প্রতিটি অক্ষরে বাইট মান (1) যুক্ত করে। এটি একটি সমান দৈর্ঘ্যের স্ট্রিং দেয় )। চরিত্রটি ব্যবহার করা গ্যারান্টি দেয় যে রিটার্ন মানটি একটি স্ট্রিং, এবং পূর্ণসংখ্যার তালিকা নয়।
  • নীচের বাম কোণে, /অ-প্রিন্টেবল বাইট নেয় এবং একটি ফাংশন দেয় যা দুটি আর্গুমেন্ট গ্রহণ করে এবং প্রথম যুক্তির সাথে দ্বিতীয় যুক্তিতে যোগ দেয় (যেহেতু বাইট মানটি 1)।
  • _এই ফাংশনটি গ্রহণ করে, নিম্নের আর্গুমেন্টগুলি ধরেছিল {(যা ছিল '(এবং I) এবং তাদের সাথে মজাদার কল দেয়। এটি (প্রতিটি জুটির মধ্যে অক্ষর সন্নিবেশ করায় I
  • ,এর স্ট্রিংয়ের সাথে এই স্ট্রিংটিকে যুক্ত করে )এবং Pফলাফলটি মুদ্রণ করে।

5

05 এ বি 1 ই , 22 21 19 18 বাইট

¤Ug<©FN¹è'(}X®')×J

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

ব্যাখ্যা:

¤Ug<©FN¹è'(}X®')×J #implicit input, call it A                                 
¤U                 #push the last letter of A, save it to X
  g<©              #push the length of A, subtract 1, call it B and save it to register_c
     F     }       #repeat B times
      N¹è          #push the Nth char of A
         '(        #push '('
            X      #push X
             ®')×  #push ')' repeated B times
                 J #join together
                   #implicit print

5

পিএইচপি, 63 বাইট

<?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")‌​");

পূর্ববর্তী সংস্করণ 64 বাইট

<?=join("(",$s=str_split($argv[1])).str_pad("",count($s)-1,")");

1
আপনি যদি পরিবর্তে কলটির ফলাফলের জন্য সেট করে থাকেন <?=তার পরিবর্তে echo এবং অন্যটি ব্যবহার করে দুটি বাইট সংরক্ষণ করতে পারেন এবং তার পরিবর্তে ব্যবহার করতে পারেনstr_split$argv[1]count($s)strlen($s)
অ্যালেক্স হাওয়ানস্কি

2
By৩ বাইট: <?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")");- wordwrapবিভক্তটিকে পরাজিত করবে / সংযুক্ত হতে পারে তবে দুর্ভাগ্যক্রমে ব্যর্থ হয় যদি ইনপুটটিতে সাদা স্থান থাকে।
তিতাস

@ টিটাস চমৎকার বিকল্প আপনাকে ধন্যবাদ
জার্গ হালসারম্যান

4

ভিম, 17 বাইট

$qqha(<Esc>A)<Esc>%h@qq@q

প্রান্ত থেকে শুরু পর্যন্ত চলে যায়, কারণ অন্যথায় আপনি )ইতিমধ্যে লিখেছেন সেগুলির উপরে ট্রিপ করে । এটি শুরুতে পৌঁছলে ব্যর্থ হওয়ার haপরিবর্তে ব্যবহার করে i

সাধারণত, আপনি এর মতো দুটি পৃথক সন্নিবেশ করতেন না; আপনি C()<Esc>Pস্ট্রোক বাঁচানোর মতো কিছু করতে চান তবে পজিশনিংটি এখনকার মতো কাজ করে না।


আপনি <End>সন্নিবেশ মোডটি রেখে সন্নিবেশ মোডে কীটি ব্যবহারের পরিবর্তে ব্যবহার করতে পারেনA
ব্ল্যাকক্যাপ

@ ব্ল্যাকক্যাপ এটি কোনও বাইট নয়। আমার বাইটের পরিবর্তে স্ট্রোক গণনা করা দরকার। (এবং আপনি যখন কার্সার কীগুলি নিষিদ্ধ করেন তখন ভিগল্ফ একটি ভাল খেলা, যদিও এখানে পার্থক্যটি তুচ্ছ
ial

4

মস্তিষ্ক-ফ্লাক 103 97 বাইট

-C এর জন্য +3 অন্তর্ভুক্ত

{({}<><(((((()()){}()){}){}){})>)<>}<>({}<([][()]){({}[()()]<(({})()<>)<>>)}{}>){({}<>)<>}<>{}

অনলাইনে চেষ্টা করে দেখুন!


ব্যাখ্যা:

#reverse the stack and put a 40 between every number
{({}<><(((((()()){}()){}){}){})>)<>}<>
{                                  }   #repeat this until the stack is empty
 ({}                            )      #pop the top and push it after
    <>                                 #switching stacks and
      <(((((()()){}()){}){}){})>       #pushing a 40 (evaluated as 0) 
                                 <>    #switch back to the first stack
                                    <> #switch to the stack that everything is on now    

#put as many )s on the other stack as needed
({}                                      ) #pop the top letter and put it  back
                                           #after doing the following
                                           #This leaves ( on the top
   <                                    >  #evalute this part as 0
    ([][()])                               #push the height of the stack minus one
            {                        }    #repeat until the "height" is 0
             ({}[()()]              )     #pop the "height" and push is minus two
                      <            >      #evaluate to 0
                       (        )         #push:
                        ({})              #the top of the stack (putting it back on)
                            ()            #plus one onto
                              <>          #the other stack
                                 <>       #switch back to the other stack

                                      {}  #pop what was the height of the stack

#move the string of letters and (s back, reversing the order again
{        }     # repeat until all elements are moved
 (    )        # push:
  {}           # the top of the stack after
    <>         # switching stacks
       <>      # switch back to the other stack
          <>   # switch to the stack with the final string
            {} #pop the extra (

আমাকে এটি মারধর। +1
ডিজেএমসিএমহেম

হুম। আমি ভেবেছিলাম যে একটি বড় পূর্ণসংখ্যার পুনরায় চাপ এড়াতে 40 কে পুনরায় ব্যবহার করা আপনার প্রচুর বাইটকে বাঁচাতে পারে, তবে আমি {({}<><(((((()()){}()){}){}){})>)<>}<>({}<(({})<>())><>)([]){({}[()()]<(<>({})<>)>)}{}{}{({}<>)<>}<>{}যে
সেরাটি সামনে

40 টি পুনরায় ব্যবহার করার ধারণা দেওয়ার জন্য ধন্যবাদ I আমি এটি 95 + 3 এ নামিয়েছি। এটি -aযাইহোক ব্রেন-ফ্লাকের জন্য 3 বাইট কেন?
রিলে 21

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

এটি কি সাধারণত 2 বাইট হয় না? একটি জন্য -এবং একটি পতাকা জন্য? পার্লের মতো সাধারণ সম্পাদনের জন্য আপনার কাছে একটি পতাকা থাকতে পারে -e। এইভাবে এটি কেবল 1 অতিরিক্ত বাইট হবে।
রিলে 21

4

ডায়ালগ এপিএল , 14 বাইট

⊃{⍺,1⌽')(',⍵}/

এই একটি হল উপরে এর এবং{ }/

(প্রথম উপাদান পান) পরে প্রয়োগ করা হবে { }/(একটি ল্যাম্বডা হ্রাস)

⍺,1⌽')(',⍵- বাম আর্গুমেন্ট ( ) সাথে ( ,) সাথে একটি উপাদান দিয়ে ঘূর্ণনটি 1⌽স্ট্রিংয়ের বাম দিকে ( ) ডান আর্গুমেন্ট ( ) ')('দিয়ে সংহত করা হয়েছে ,( )

এখানে প্রয়োজনীয় হিসাবে ডান থেকে বামে এপিএল ভাঁজ হ্রাস



3

> <> , 37 বাইট

i:0(?\'('
$,2l~/~
/?(2:<-1$')'
>~ror:

সারি সারি সারি

  1. ইনপুট থেকে প্রতিটিের পরে খোলার প্রথম বন্ধনীর সাহায্যে প্রতিটি চরকে চাপ দেয়
  2. ইওএফ এবং শেষ খোলার প্রথম বন্ধনী সরায় এবং স্ট্যাকের দৈর্ঘ্যকে ধাক্কা দেয়
  3. ক্লোজিং বন্ধনীর দিকে এগিয়ে যাওয়ার জন্য স্ট্যাকের দৈর্ঘ্যের অর্ধেকের সাথে তুলনা ব্যবহার করে
  4. স্ট্যাকের সামগ্রী মুদ্রণ করে

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

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.