ছাঁচনির্মাণ ASCII শিল্প

Question

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

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

---

স্ট্রিং / ছাঁচ উদাহরণ (স্ট্রিং খুব দীর্ঘ, কাটা):

Loremipsumdolorsitamet,consecteturadipiscingelit.Namsuscipitmagnanoneratgravidacondimentum.Vestibulumnecnisllorem.Fuscemolestieviverranibh,eueleifendnislplaceratnon.Namblanditturpislacus,vitaemolestielacusimperdietquis.Nullapulvinar,exquissollicitudinfacilisis,eratnullavolutpatlectus,etluctusenimvelitegetex.Inhachabitasseplateadictumst.Donecinterdumnullalacinia,sodalesloremin,eleifendturpis.Pellentesqueanisimi.Aeneannonlobortisdiam,quisaliquetquam.Aeneanaugueipsum,imperdietsedaliquetnon,volutpategetsapien.Nullampharetranullaquispretiumornare.Aliquamfermentumvestibulummassavitaevehicula.
###########################################################
##### ##############   ###### ###### ######################
#####  ##   ######   #  ##### ###### ########        ######
###### #  #  ####  #### ##### ###### #######  ######  #####
######   ###  ###       ##### ###### ####### #######  #####
######  ##### ### ########### ###### #######   ###   ######
###### ###### ###  ########## ######      #####   #########
##################       ####    ##########################
###########################################################

উদাহরণ আউটপুট:

Loremipsumdolorsitamet,consecteturadipiscingelit.Namsuscipi
tmagn anoneratgravid   acondi mentum .Vestibulumnecnisllore
m.Fus  ce   molest   i  evive rranib h,euelei        fendni
slplac e  r  atno  n.Na mblan dittur pislacu  s,vita  emole
stiela   cus  imp       erdie tquis. Nullapu lvinar,  exqui
ssolli  citud inf acilisis,er atnull avolutp   atl   ectus,
etluct usenim vel  itegetex.I nhacha      bitas   seplatead
ictumst.Donecinter       dumn    ullalacinia,sodalesloremin
,eleifendturpis.Pellentesqueanisimi.Aeneannonlobortisdiam,q

স্ট্রিং / ছাঁচ উদাহরণ (স্ট্রিং খুব সংক্ষিপ্ত, আউটপুট বন্ধ):

This probably won't look good.
### ### ### ###
# # # # #   #
### ### #   # #
#   #   #   # #
#   #   ### ###

সংশ্লিষ্ট আউটপুট:

Thi s p rob abl
y   w o n   '
t l ook     g o
o   d   .   

---

বাইটস মধ্যে সংক্ষিপ্ত কোড।

^{এই ওয়েবসাইটটিতে ধারণার জন্য ক্রেডিট ।}

Comments

ইনপুট লাইনে হ্যাশ থাকতে পারে? (যদি তা হয় তবে এটি একটি পরীক্ষার

— কেসটি

ইনপুট লাইনে স্পেস থাকতে পারে?

— manatwork

ইনপুটটিতে নেতৃস্থানীয় / পিছনে স্থান / নিউলাইন থাকতে পারে?

— Sp3000

@ মান্যাট ওয়ার্ক দ্বিতীয় পরীক্ষার ক্ষেত্রে এটি করে।

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

@ মার্টিনবাটনার হ্যাঁ, ইনপুট কেসে হ্যাশ থাকতে পারে।

— orlp

Answer 1

সিজেম, 16 14 বাইট

2 বাইট সংরক্ষণের জন্য Sp3000 ধন্যবাদ।

lq{s'#-\+(\}/;

স্ট্রিং খুব ছোট থাকলে ত্রুটি দিয়ে শেষ করে তবে ত্রুটিটি STDERR এ মুদ্রিত হয়।

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

বিকল্পভাবে (একই বাইট গণনা):

lq{SN+&\+(\}/;

ব্যাখ্যা

l       e# Read the input line.
q       e# Read the grid.
{       e# For each character in the grid...
  s     e#   Convert to string.
  '#-   e#   Remove "#" from it.
  \+    e#   Prepend it to the input line (this is a no-op for "#"s in the grid).
  (     e#   Pull off the first character from the input line. This will terminate the
        e#   program with an error once the input line is empty.
  \     e#   Swap the character with the input line.
}/
;       e# Discard the remainder of the input line if there is any.

Answer 2

ল্যাবভিউ, 37 ল্যাবভিউ পুরষ্কার

স্ট্রিংটিকে টেক্সট এবং মোল্ডে বিভক্ত করে তারপরে এটিকে অ্যারে রূপান্তরিত করে। যদি # টি থাকে এবং ছাঁচটি পাঠ্য থেকে কোনও চাপ দেয় অন্যথায় এটি কিছুই করে না the যদি পাঠ্য বা ছাঁচটি ফাঁকা হয় তবে লুপটি প্রস্থান করুন

Comments

আপনি ল্যাবভিউ ফুঁ দিয়ে এই কাজটি করেছেন

— মস্তিষ্ক গাইড

এবং এটি দেখতে মজা!

— Draco18s

Answer 3

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

"(স্ট্রিং সহ প্রতিস্থাপন) # (হ্যাশমার্কের স্ট্রিং)" "এর মতো":

[]#_=[]
(r:t)#('#':s)=r:t#s
r#(c:s)=c:r#s
_#_=[]

কম গল্ফড:

combine replacements slots | null replacements = []
                           | null slots        = []
                           | head slots == '#' = head replacements : combine (tail replacements) (tail slots)
                           | otherwise         = head slots        : combine       replacements  (tail slots)

Comments

দুর্দান্ত, তবে আপনি যদি আই / ও যোগ না করেন তবে এটি কী অবৈধ? উদাimport Control.Applicative;main=liftA2(#)getLine getContents>>=putStrLn

— কিউবিক

@ কিউবিক সমস্যার বিবৃতিতে আইও (বা এমনকি একটি সম্পূর্ণ প্রোগ্রাম) এবং পাইথন 3 এর একটি সহ অন্যান্য সমাধানের প্রয়োজন হয় না, আইও অন্তর্ভুক্ত করবেন না।

— মাইকেল ক্লেইন

Answer 4

রেটিনা , 42 40 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

T`#`×`¶.+
+`^(.)([^×]+)×
$2$1
^.*¶|×\D*

পেছনের লাইনফিডটি তাৎপর্যপূর্ণ।

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

ব্যাখ্যা

T`#`×`¶.+

আমরা প্রথমে #যেগুলি গ্রিডের অংশ নন-এএসসিআইআই (তবে বর্ধিত এএসসিআইআই) অক্ষরের সাথে প্রতিস্থাপন ×করি যাতে আমরা তাদের #প্রথম লাইনে উপস্থিত হতে পারে এমন কোনও কারণে বিভ্রান্ত করি না ।

+`^(.)([^×]+)×
$2$1

এখন আমরা ×প্রথম লাইনটি বারবার প্রথম প্রতিস্থাপনের মাধ্যমে প্রথম লাইনের ×প্রথম অক্ষরটি (যা প্রক্রিয়াতে সরিয়ে ফেলা হয়) এর মাধ্যমে যথাযথ পূরণ করি fill

^.*¶|×\D*

অবশেষে, আমরা প্রথম লাইনে যা কিছু ×রেখেছি তেমনি উভয় দিক থেকে ইনপুট কেটে ফেলতে প্রথম থেকে যে কোনও কিছু থেকে মুক্তি পেয়েছি ।

Answer 5

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

(s,m)=>m.replace(x=/[^]/g,c=>c-1?x&&c:x=s[i++]||"",i=0)

@ নীলকে ধন্যবাদ 1 বাইট সংরক্ষিত !

ব্যাখ্যা

ইনপুট স্ট্রিংয়ে হ্যাশগুলির সাথে কাজ করে এবং ইনপুট স্ট্রিংটি শেষ হওয়ার পরে সাদা স্থান স্থান অনুসরণ করে tra

var solution =

(s,m)=>
  m.replace(x=/[^]/g,c=> // for each character c of the mold, initialise x to true
    c-1?                 // if c is a space or newline:
      x&&c               // if x is truthy, return c
                         // else if the string has ended, x will equal "" (false), return x
    :                    // else if c is a hash:
      x=                 // set x to the character of the input string
        s[i++]||"",      // return the input string character (or "" if finished)
    i=0                  // initialise i to 0
  )

<input type="text" id="input" value="This probably won't look good." /><br>
<textarea id="mold" rows="6" cols="40">### ### ### ###
# # # # #   #
### ### #   # #
#   #   #   # #
#   #   ### ###</textarea><br>
<button onclick="result.textContent=solution(input.value,mold.value)">Go</button>
<pre id="result"></pre>

Comments

ভাল অ্যালগরিদম, তবে m.replace(/./g,c=>...)সংক্ষিপ্ত।

— নিল

@ নীল আপনি ঠিক বলেছেন আপনার উত্তরটি হাহাকার থেকে আলাদা হওয়ার জন্য আমি খুব চেষ্টা করছিলাম!

— ব্যবহারকারী 81655

আর না, যেহেতু আপনি /[^]/পরিবর্তে ব্যবহার করতে পারেন /.|\n/। (ভুলভাবে পরামর্শ দেওয়ার জন্য ক্ষমাও চাই/./

— নিল

Answer 6

পাইথন 3, 69 68 67 বাইট

def f(s,m):s=iter(s);return''.join(n<'#'and n or next(s)for n in m)

Ideone

ফ্রাইআম দ্য এজম্যানকে ধন্যবাদ, বাইট অফের জন্য চিল টেন ব্রিনকে। বিকল্পভাবে, আমি পাইথন 2 একটি অতিরিক্ত ( printবিনা ()) জন্য ব্যবহার করতে পারি ।

Comments

এর printসাথে প্রতিস্থাপন করে আপনি একটি বাইট সংরক্ষণ করতে পারেন return।

— চিয়েল টেন ব্রিনকে

Answer 7

পিবি , 359 বাইট

^w[B!0]{w[B=10]{t[T+1]b[0]}>}<w[T!0]{w[B!0]{<}>^b[T]vw[B!0]{t[B]b[0]^v[B]v<[X]w[B!0]{>}b[T]<[X]^[Y+2]w[B=0]{>}t[B]b[0]>b[T]v}^t[B-1]vw[B=0]{<}}>b[10]t[X]w[X!-2]{w[B!0]{v}<}w[X!T]{b[35]>}^[Y]^<[X]w[B!10]{t[B]b[0]w[T=35]{t[10]}v<[X]w[B!35]{w[B=0]{v<[X]<b[1]}>}b[T]^[Y]^<[X]w[B=0]{>}}<[X+2]w[B=0]{v}w[B!0]{b[0]>}w[Y!-1]{<[X]^w[B!0]{w[B=35]{b[0]}w[B=10]{b[35]}>}}

পিবিতে ইনপুটটি কঠোরভাবে এক মাত্রিক। এটি বুঝতে পারে না যে আপনি নিজের ইনপুট দিয়ে কোনও আকার আঁকছেন, এটি কেবল একটি দীর্ঘ লাইন দেখতে পেয়েছে যেখানে সেখানে ফেলে দেওয়া 10 এর মান সহ কিছু বাইট রয়েছে। এই প্রোগ্রামটি প্রথম কাজটি করে যা ছাঁচের আকৃতি তৈরি করতে Y = 0, Y = 1, ইত্যাদিতে ইনপুটটির প্রথম "লাইন" ব্যতীত সমস্ত অনুলিপি করে।

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

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

অবশ্যই, এটি সমস্ত হ্যাশগুলি কেবল ধ্বংস করার জন্য অনুমানের লঙ্ঘন করবে। সর্বোপরি, ইনপুট স্ট্রিংয়ে একটি হ্যাশ থাকতে পারে! এটি পরিচালনা করতে, আমি অনুমানের আরও একটি অংশ উল্লেখ করি:

আপনাকে কোনও একক মুদ্রণযোগ্য এএসসিআইআই স্ট্রিং দেওয়া হবে যাতে কোনও নিউলাইন নেই

(আমার উপর জোর দিন।) স্ট্রিংয়ের সাথে আমরা যখন কাজ করছি তখন আমরা এতে নতুন লাইনগুলি আছে কিনা তা সত্যিই চিন্তা করি না, তবে আমরা জানি যে কোনওটি নেই। সুতরাং, ছাঁচে ফেলার আগে সমস্ত হ্যাশগুলি নতুন লাইনের সাথে প্রতিস্থাপন করা হয়! সমস্ত হ্যাশগুলি ধ্বংস হওয়ার পরে, সমস্ত নতুনলাইনগুলি আবার হ্যাশগুলির সাথে প্রতিস্থাপন করা হয়। এটি পুরো আউটপুটটিকে একটি একক হ্যাশ-বিস্মৃত লাইনে রূপান্তরিত করে না কারণ pb এর 2D আউটপুটের প্রকৃতির অর্থ এটি প্রতিটি লাইনের শেষে কখনই নতুন লাইন রাখেনি, এটি কেবল পরবর্তী লাইনে চলে গেছে।

Ungolfed:

# Start by copying down the mold
^
# (B means "the character under the cursor")
w[B!0]{       # While B isn't a null byte:
    w[B=10]{    # While B IS a newline:
            t[T+1]    # Increase T by 1
                      # (`T` is the only variable that can be modified directly)
            b[0]      # Overwrite with 0 to break out of inner loop
    }
    >           # Move to the right
                # (dodge the 0 we wrote and progress towards the end of input)
}

# Brush is now at the end of the input, T contains number of lines

<             # Make sure the brush is actually /on/ the input
w[T!0]{       # While T isn't 0:
    w[B!0]{<}>  # Go to the first character of the last line
    ^b[T]       # Place a flag above current character
                # Also a convenient way to get the value of T back later
    vw[B!0]{    # While the character under the flag isn't 0:
            t[B]b[0]  # Put it in T, overwrite with 0
            ^v[B]v    # Go down by the amount written in the space above
            <[X]      # Go left by the amount right the brush is (i.e. go to X=0)
            w[B!0]{>} # Find first empty space
            b[T]      # Write the value of T
            <[X]      # Go left by the amount right the brush is
            ^[Y+2]    # Go up by the amount down the brush is plus 2 (above input)
            w[B=0]{>} # Find flag
            t[B]b[0]  # Pick it up, overwrite with 0
            >b[T]     # Place it to the right
    v}
    ^t[B-1]v    # Collect flag - 1
    w[B=0]{<}   # Go to end of previous line
}

# Mold is placed, all that's left is placing the string
>b[10]        # Put a newline at the end, guaranteed to not be in the string
t[X]          # Save current X value in T

# Add more hashes, guaranteed to fit the input and findable later
w[X!-2]{       # While X!=-2:
    w[B!0]{v}    # Move down until hitting a null byte
    <            # Move left
}
w[X!T]{        # While not at the X value we saved earlier:
    b[35]>       # Travel right, leaving hashes
}

^[Y]^<[X]     # Go to (0, -1)

w[B!10]{      # Until hitting the newline at the end:
    t[B]b[0]    # Pick up character, overwrite with 0
    w[T=35]{    # If it's a hash...
            t[10]     # Make it a newline so we remember, deal with it later
    }
    v<[X]       # Go to (0, 0)
    w[B!35]{    # While B is not a hash:
            w[B=0]{   # While B IS null:
                    v       # Go down
                    <[X]<   # Go to X=-1
                    b[1]    # Print a 1 to break loop (it won't be rendered anyway)
            }
            >           # Go right, either ignore a non hash or go to X=0
    }
    b[T]        # Overwrite hash with picked up character
    ^[Y]^<[X]   # Go to (0, -1)
    w[B=0]{>}   # Go to first character of it to restart loop
}

<[X+2]        # Go to (-2, -1)
w[B=0]{v}     # Go down until finding the row of added hashes
w[B!0]{b[0]>} # Wipe it out unconditionally
w[Y!-1]{      # For every remaining line on the screen:
    <[X]^       # Go to the beginning
    w[B!0]{     # For each character in it:
            w[B=35]{  # If it's a hash:
                    b[0]    # Destroy it
            }
            w[B=10]{  # If it's a newline:
                    b[35]   # Write a hash (after the check to destroy hashes!)
            }
    >}
}

Comments

দুর্দান্ত, দেখতে অনেকটা কাজের মতো।

— Rɪᴋᴇʀ

Answer 8

ES6, 59 বাইট

(t,m)=>m.replace(/#/g,h=>t[i++]||h,i=0).replace(/#[^]*/,'')

পাঠ্যে হ্যাশ থাকতে পারে যদি 70 বাইট:

(t,m)=>m.replace(/#/g,(_,n)=>t[i]&&(j=++n)&&t[i++],i=0,j=0).slice(0,j)

Comments

হ্যাশ অক্ষরগুলি প্রতিস্থাপন করে ঠিক ইনপুট স্ট্রিং সহ, পেছনের সাদা স্থানটি সরিয়ে ফেলুন না the

— orlp

@ অরલ્પ ধন্যবাদ আমি আবার সেই সংস্করণটি সম্পাদনা করব।

— নিল

Answer 9

পার্ল, 53 51 42 + 2 = 44 বাইট

@a=/./g;$/="";$_=<>;s/#/shift@a/ge;s/\s+$//

প্রয়োজন -pচালানোর জন্য। ব্যাখ্যা:

@a=/./g; # Split first line into an array of characters
$/=""; # Enable slurp mode (read the rest of lines in one go)
$_=<>;
s/#/shift@a/ge;
s/\s+$//
# With '-p' auto print is enabled

Comments

আউটপুট লাইনের শুরুতে আমি কিছু কুরুচিপূর্ণ "1" পাই। একটি পরিষ্কার আউটপুট জন্য এটি চেষ্টা করুন:$a=<>;$/="";say<>=~s/#/substr$a,$i++,1/ger

— manatwork

@ মান্যাটওয়ার্ক আমি বুঝতে পেরেছিলাম যে, $/যোগদানের পরিবর্তে ব্যবহারের সাথে চালাক

— andlrc

Answer 10

জেলি, 10 8 বাইট

¹ƈ<”#$?€

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

Comments

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

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

Answer 11

পার্ল 6 , 72 বাইট

my@a=get.comb;say(S:g/\#/{@a.shift//''}/~~{S/\s+$//}),@a||last for lines

Answer 12

ES6, 47 বাইট

সম্ভবত সবচেয়ে সহজ সমাধান।

(S,R)=>(i=-1,S.replace(/#/g,_=>R[++i]||R[i=0]))

এই কোডটি একটি বেনামী ফাংশন তৈরি করে যা 2 টি প্যারামিটার গ্রহণ করে এবং চূড়ান্ত ফলাফল প্রদান করে।

প্রথম প্যারামিটারটি Sআপনার সাথে "মানচিত্র" স্ট্রিং "#", অন্যদিকে প্যারামিটারটি Rতাদের "প্রতিস্থাপন" "#"।

Answer 13

পাইথন ঘ

152 127 বাইট

একটি সম্পূর্ণ প্রোগ্রাম।

from sys import stdin as S
s=list(S.readline())
print(''.join([''if not s else(s.pop(0)if m=='#'else m)for m in S.read()]))

106 বাইট

স্ট্রিমটিকে ইনপুট হিসাবে গ্রহণ করে এমন একটি ফাংশন।

def f(S):s=list(S.readline());return''.join([''if not s else(s.pop(0)if m=='#'else m)for m in S.read()])

Comments

আমাদের কাছে ইতিমধ্যে একটি পাইথন উত্তর রয়েছে যা অনেক খাটো এবং আউটপুট তৈরির জন্য একই পদ্ধতি ব্যবহার করে।

— মেগো

আমি দেখি. আমি গতকাল এটি লিখেছিলাম, যখন উত্তর এখনও ছিল না। এত দেরিতে পোস্ট করার জন্য দুঃখিত

— চিয়েল টেন ব্রিনকে

আপনি দেরিতে পোস্ট করছেন না, প্রচুর লোক সম্ভবত এখনও এই প্রশ্নটি দেখেনি (আমি অবশ্যই এই পোস্টটি না দেখলে আগে পর্যন্ত দেখিনি)

— ব্লু