Sstrhsrtj

Is there a way to split a python string without using a for loop that basically splits a string in the middle to the closest delimiter.

Like:

The cat jumped over the moon very quickly.

The delimiter would be the space and the resulting strings would be:

The cat jumped over

the moon very quickly.

I see there is a count where I can see how many spaces are in there (Don't see how to return their indexes though). I could then find the middle one by dividing by two, but then how to say split on this delimiter at this index. Find is close but it returns the first index (or right first index using rfind) not all the indexes where " " is found. I might be over thinking this.

how about something like this:

s = "The cat jumped over the moon very quickly"



l = s.split()



s1 = ' '.join(l[:len(l)//2])

s2 = ' '.join(l[len(l)//2 :])



print(s1)

print(s2)

This should work:

def split_text(text):

    middle = len(text)//2

    under = text.rfind(" ", 0, middle)

    over = text.find(" ", middle)

    if over > under and under != -1:

        return (text[:,middle - under], text[middle - under,:])

    else:

        if over is -1:

              raise ValueError("No separator found in text '{}'".format(text))

        return (text[:,middle + over], text[middle + over,:])

it does not use a for loop, but probably using a for loop would have better performance.

I handle the case where the separator is not found in the whole string by raising an error, but change raise ValueError() for whatever way you want to handle that case.

I'd just split then rejoin:

text = "The cat jumped over the moon very quickly"

words = text.split()

first_half = " ".join(words[:len(words)//2])

I think the solutions using split are good. I tried to solve it without split and here's what I came up with.

sOdd = "The cat jumped over the moon very quickly."

sEven = "The cat jumped over the moon very quickly now."



def split_on_delim_mid(s, delim=" "):

  delim_indexes = [

      x[0] for x in enumerate(s) if x[1]==delim

  ] # [3, 7, 14, 19, 23, 28, 33]



  # Select the correct number from delim_indexes

  middle = len(delim_indexes)/2

  if middle % 2 == 0:

    middle_index = middle

  else:

    middle_index = (middle-.5)



  # Return the separated sentances

  sep = delim_indexes[int(middle_index)]

  return s[:sep], s[sep:]



split_on_delim_mid(sOdd) # ('The cat jumped over', ' the moon very quickly.')

split_on_delim_mid(sEven) # ('The cat jumped over the', ' moon very quickly now.')

The idea here is to:

• Find the indexes of the deliminator.


• Find the median of that list of indexes


• Split on that.

You can use min to find the closest space to the middle and then slice the string.

s = "The cat jumped over the moon very quickly."



mid = min((i for i, c in enumerate(s) if c == ' '), key=lambda i: abs(i - len(s) // 2))



fst, snd = s[:mid], s[mid+1:]



print(fst)

print(snd)

Output

The cat jumped over

the moon very quickly.

Solutions with split() and join() are fine if you want to get half the words, not half the string (counting the characters and not the words). I think the latter is impossibile without a for loop or a list comprehension (or an expensive workaround such a recursion to find the indexes of the spaces maybe).

But if you are fine with a list comprehension, you could do:

phrase = "The cat jumped over the moon very quickly."



#indexes of separator, here the ' '

sep_idxs = [i for i, j in enumerate(phrase) if j == ' ']



#getting the separator index closer to half the length of the string

sep = min(sep_idxs, key=lambda x:abs(x-(len(phrase) // 2)))



first_half = phrase[:sep]

last_half = phrase[sep+1:]



print([first_half, last_half])

Here first I look for the indexes of the separator with the list comprehension. Then I find the index of the closer separator to the half of the string using a custom key for the min() built-in function. Then split.

The print statement prints ['The cat jumped over', 'the moon very quickly.']