How can you accomplish merging two strings?
For example, you may want to combine two multi-line strings to make ASCII art.
HEAD = \
"""
O
"""
BODY = \
r"""
/|\
/ \
"""
STICKMAN = merge(HEAD, BODY) # this function will return the merged string
STICKMAN would contain this:
O
/|\
/ \
I tried doing STICKMAN = HEAD + BODY. It ovbiously didn't work.
Any answers will be appreciated. Thanks for helping!
The hard part about your example strings is that they are not the same size (stackoverflow markdown is making them appear in my codeblock just as problematically). If you pad them with spaces you can just pick whichever character isn't a space. You have to favor one or the other in the case that neither is a space though
HEAD = """
O
"""
BODY = r"""
/|\
/ \
"""
def overlap(s1, s2):
return ''.join([c2 if c1.isspace() else c1 for c1, c2 in zip(s1, s2)])
print(overlap(HEAD, BODY))
for a version you can copy paste and have it work
HEAD = (
' O \n'
' \n'
' \n'
)
BODY = (
' \n'
'/|\\\n'
'/ \\\n'
)
def overlap(s1, s2):
return ''.join([c2 if c1.isspace() else c1 for c1, c2 in zip(s1, s2)])
print(overlap(HEAD, BODY))
"".join(map(max,HEAD,BODY)) would work if all strings were of the same length.
Here is how I would approach the problem*:
Consider that each multi-line string is a list of strings (it can be easily converted as such)
The string split function is useful for this task.
For each line in the "HEAD" list of strings and the "BODY" list of strings, select the [first] line which is not blank.
A simple for loop "iterating over each index" will work here, and would be good practice, as will something like zip. Functions like zip are handy in that they establish pairings without care about indexes..
This will meet the question asked although other 'merge' rules could be applied: in particular, adding the "|" part of the body to a left-arm "/" needs to have the same concept applied at a character level within the string - but that should be easy to accomplish now, using the approach above, as a string is effectively a list of characters.
(Taking a step back, one could even consider both multiline inputs a lists of characters, but this requires that there are "space" characters in the strings such that every row is the same length.)
Convert the resulting list of strings - which now contains some lines from the "HEAD" and "BODY" lists - back to a multiline string.
See join, which is the opposite of split.
(*it became a bit too big to fit nicely in a comment, but is not meant to be "an answer" per se; SO usually works best when bringing some code/attempt to the table so specifics can be addressed.. since there was no specifics asked, only an approach of how one could start to approach the problem is provided.)
Just joining the parts doesn't quite work because of blank lines in the various body parts.
>>> HEAD = \
... """
... O
...
...
... """
>>>
>>> BODY = \
... r"""
...
... /|\
... / \
... """
>>> print(HEAD+BODY)
O
/|\
/ \
>>>
One solution to that is easy: don't put extra blank lines in the body part. If you really must do that, then you can have a function rewrite the part without the extra empty lines.
>>> def strip_empty(part):
... lines = part.split('\n')
... return "\n".join(line for line in lines if line.strip())
...
>>> stickman = "\n".join(strip_empty(part) for part in parts)
>>>
>>> print(stickman)
O
/|\
/ \
>>>
print (HEAD+BODY).replace("\n\n","")
It worked for me.
HEAD + BODYnot work. Besides stripping whitespace and adding a new line, it looks right to me.