Задача

Создать функцию для обратного объединения строк

вход

Две строки (буквенно-цифровые + пробелы), где одна должна быть вычтена для другой.

• Вы можете предположить, что вычитаемая строка никогда не будет больше, чем другая.

Выход

Результат от вычитания

Вычитание

Вы должны удалить одну строку из начала или конца другой строки. Если строка присутствует в начале и в конце, вы можете удалить только одну, которая будет удалена на ваше усмотрение.
Если строка не находится в начале или в конце или не является точным соответствием, это недопустимое вычитание, и вы должны вывести исходную строку.

Тестовые случаи

Действительное вычитание

'abcde','ab' -> 'cde'
'abcde','cde' -> 'ab'
'abab','ab' -> 'ab'
'abcab','ab' -> 'abc' or 'cab'
'ababcde','ab' -> 'abcde'
'acdbcd','cd' -> 'acdb'
'abcde','abcde' -> ''
'abcde','' -> 'abcde'
'','' -> ''

Неверное вычитание (возвращает исходную строку)

'abcde','ae' -> 'abcde'
'abcde','aa' -> 'abcde'
'abcde','bcd' -> 'abcde'
'abcde','xab' -> 'abcde'
'abcde','yde' -> 'abcde'

Неверный ввод (не нужно обрабатывать)

'','a' -> ''

Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Java 8, 46 45 44 40 байт

-1 байт благодаря TheLethalCoder

-1 байт, потому что я тупой (спасибо, Род!)

-4 байта благодаря Кевину Круйссену

a->b->a.replaceFirst("^"+b+"|"+b+"$","")

Попробуйте онлайн! (включает все тестовые случаи)

Ответ Java на самом деле превосходит несколько других практических языков. Улыбки. (и теперь это бьет JS!)

JavaScript (ES6), 41 байт

s=>t=>s.replace(eval(`/^${t}|${t}$/`),'')

Принимает ввод через выделку синтаксиса, то есть f("abab")("ab").

Brachylog (попробуйте онлайн!), 12 байт

~cpĊh.∧Ċtw|w

Попробуйте онлайн!

Принимает строку для вычитания из стандартного ввода и строку для вычитания в качестве аргумента командной строки.

объяснение

~cpĊh.∧Ċtw|w
~c            Split {the input} into pieces
  p           and (possibly) rearrange those pieces
   Ċ          such that there are two pieces
    h         and the first
     .        matches the command line argument
      ∧       then
         w    print
        t     the last
       Ċ      piece.
          |   If all else fails,
           w  print {the input}.

Сетчатка , 21 байт

1 байт благодаря Мартину Эндеру.

(.*);(\1|(.*)\1$|)
$3

Попробуйте онлайн!

JavaScript (ES6), 76 70 45 41 байт

s=>t=>s.replace(RegExp(`^${t}|${t}$`),"")

Попытайся

f=
s=>t=>s.replace(RegExp(`^${t}|${t}$`),"")
o.innerText=f(i.value="abcde")(j.value="ab")
i.oninput=j.oninput=_=>o.innerText=f(i.value)(j.value)

<input id=i><input id=j><pre id=o>

Perl 6 , 21 байт

->$_,$b {S/^$b|$b$//}

Попытайся

Expanded:

-> $_, $b {   # pointy block lambda

  S/          # Str replace and return (implicitly against ｢$_｣)

  |   ^ $b    # starting with the second argument
  |     $b $  # or ending with the second argument

  //          # replace with nothing.

}

Japt , 11 9 байт

k"^|$"¬qV

Попробуйте онлайн!

TI-Basic (TI-84 Plus CE), 63 байта

Prompt Str0,Str2
inString(Str0,Str2
If Ans
sub(Str0,1,Ans-1)+sub(Str0,Ans+length(Str2),length(Str0)-Ans+1-length(Str2→Str0
Str0

Mathematica, 162 байта

(c=Characters;a=c@#;b=c@#2;l=Length;t={};If[l@Intersection[a,b]==l@b,If[MemberQ[Partition[a,l@b,1],b],t=a;Table[t=DeleteCases[t,b[[i]],1,1],{i,l@b}]],t=a];""<>t)&

тестовый стиль ввода ["abcde", "ab"]

Python, 69 68 64 57 51 45 байт

В итоге это стало совершенно другим решением с Regex.

Спасибо Value Ink за -2 байта!
и Фелипе Нарди Батиста за массивные -6 байт!

import re
lambda s,c:re.sub(c+'$|^'+c,'',s,1)

Попробуйте онлайн!

Баш ,66 61 49 байтов

case $1 in *$2)echo ${1%$2};;*)echo ${1#$2};;esac

Попробуйте онлайн!

меньше гольфа:

a=$1;
case $1 in 
    *$2)  c=${a%$2};;       
    $2*)  c=${a#$2};;
      *)  c=$1;;
esac;
echo $c

Использует регистр для проверки начала или конца и вычитание префикса / суффикса массива (% / #)

APL (Dyalog) , 31 30 байт

-1 спасибо Захари .

Это фактически использует обратную (то есть обратную) конкатенацию! Принимает исходную строку в качестве левого аргумента и что вычитать в качестве правого аргумента.

{0::⍺{0::⍺⋄,∘⍵⍣¯1⊢⍺}⍵⋄⍵,⍣¯1⊢⍺}

Попробуйте онлайн!

Ungolfed:

{
    0::⍺{         ⍝ if an error happens, apply the following function on the arguments
        0::⍺          ⍝ if an error happens, return the left argument unmodified
        ,∘⍵⍣¯1⊢⍺      ⍝ inverse-append right argument on left argument
        }⍵
    ⍵,⍣¯1⊢⍺      ⍝ inverse-prepend the right argument on the left argument
}

Условные обозначения:

{… } Анонимная функция

⍺ левый аргумент текущей функции

⍵ правильный аргумент текущей функции

0::... если произойдет какая-либо ошибка, выполните это, иначе ...

⍣¯1⊢ обратный

,∘⍵ сцепление ⍵ справа

⍵, сцепление ⍵ слева

PHP, 54 байта

[,$x,$y]=$argv;echo preg_replace("#^$y|$y$#","",$x,1);

Testcases

Python 2 , 68 байт

def f(s,c):v=len(c);print[s[v:],s[:-v],s][[s[:v],s[-v:],c].index(c)]

Попробуйте онлайн!

Haskell , 49 байтов

f s a b|s==b=a|a/=b,h:t<-a=f(s++[h])t b|1<3=s
f""

Попробуйте онлайн! Использование: f"" "abcdef" "ab". В качестве альтернативы, определите (-)=f""и используйте как "abcdef" - "ab".

Это решение без регулярных выражений работает путем рекурсивного разделения строки на все ее префиксы и постфиксы и проверки, соответствует ли строка, которая должна быть вычтена, одному из них.

Python 2 , 72 65 байт

a,b=input()
l=len(b)
print[[a,a[:-l]][b==a[-l:]],a[l:]][b==a[:l]]

Попробуйте онлайн!

-7 байт благодаря @FelipeNardiBatista

C #, 88 байт

s=>r=>s.StartsWith(r)?s.Substring(r.Length):s.EndsWith(r)?s.Substring(0,s.IndexOf(r)):s;

Компилирует в Func<string, Func<string, string>>.

Рубин (лямбда-выражение), 29 байт

->a,b{a.sub /^#{b}|#{b}$/,""}

Yay для регулярного выражения! Требуются вычитаемые безопасные регулярные выражения, но это нормально в соответствии с задачей.

Tcl , 37 байт

proc s {a b} {regsub "^$b|$b$" $a {}}

Попробуйте онлайн! (сейчас запускаются все тесты)

Tcl прост. proc s {a b}определяет функцию с именем, sкоторая принимает параметры aи b. regsubподставляет {}пустую строку для значения, bкогда она находится в начале или в конце a. Возврат неявный.

C 96 байтов

Общеизвестно, что манипулирование струнами в Си является громоздким, поскольку расширение игры в гольф будет граничить с мазохизмом. Звучит хорошо для меня.

f(a,b,t,l)char**a,*b,*t;{t=*a;l=strlen(b);bcmp(t,b,l)?bcmp(t+=strlen(t)-l,b,l)||(*t=0):(*a+=l);}

Одна из менее читаемых программ, которые я написал. Принимает два ввода (несмотря на то, как выглядит функция): char**указатель на деконкатенированную строку и char*строка, которую нужно удалить. Входной указатель редактируется на месте и становится выходным (в любом случае, в случае утечки памяти).

Пример использования:

char *a = malloc(6);
strcpy(a, "abcde");
char *b = malloc(4);
strcpy(b, "abc");
f(&a,b);
printf("%s\n", a); // "de"

AWK , 21 32 байта

{sub("^"$2"|"$2"$",z,$1);$0=$1}1

Попробуйте онлайн!

Исходное представление наивно заменяет текст в первой строке, а не только в начале или конце.

{sub($2,z,$1);$0=$1}1

Попробуйте онлайн!

Первоначально пытался без фигурных скобок, но он требовал хитрости для печати пустых строк и / или несоответствий, что в итоге добавило больше байтов, чем эта версия.

R, 20 42 41 байт

pryr::f(sub(sprintf('^%s|%s$',b,b),'',a))

-1 байт благодаря MickyT!

Возвращает анонимную функцию (которая имеет аргументы в порядке b,a). Вычисляет разницу строк a-b. subпростая замена, которая заменяет первое вхождение шаблона, в данном случае, пустой строкой ''. Создает регулярное выражение с, sprintfчтобы соответствовать только в начале и конце строки. Требуется pryrпакет для установки.

На ссылке TIO, используется более многословный function(a,b) определение для функции еще на четыре байта.

Попробуйте онлайн!

Common Lisp, 121 байт

(lambda(x y)(cond((equal(#1=subseq x 0 #3=(length y))y)(#1#x #3#))((equal(#1#x #2=(-(length x)#3#))y)(#1#x 0 #2#))(t x)))

Попробуйте онлайн!

Обычный многословный Common Lisp!

Безголовая версия:

(defun f(x y)
  (cond ((equal (subseq x 0 (length y)) y)               ; if x starts with y
         (subseq x (length y)))                          ; return rest of x
        ((equal (subseq x (- (length x) (length y))) y)  ; if x ends with x
         (subseq x 0 (- (length x) (length y))))         ; return first part of x
        (t x)))                                          ; else return x

Котлин , 91 байт

{a,b->val v=b.length
if(a.startsWith(b))a.drop(v)else if(a.endsWith(b))a.dropLast(v)else a}

Попробуйте онлайн!

Powershell, 34 40 байт

+6 байт при Invalid Subtractionдобавлении тестовых случаев

param($s,$t)$s-replace"^$t(?!.*$t$)|$t$"

Комментарий:

Выражение регулярного выражения ^$t|$t$не работает должным образом: оно заменяет оба совпадения вместо одного (флаг gвсегда включен). Таким образом, мы вынуждены использовать группу с негативным прогнозом.

Тестовый скрипт:

$f = {
    param($s,$t)$s-replace"^$t(?!.*$t$)|$t$"
}

@(
    ,('abcde','ab', 'cde')
    ,('abcde','cde', 'ab')
    ,('abab','ab', 'ab')
    ,('abcab','ab', 'abc', 'cab')
    ,('ababcde','ab', 'abcde')
    ,('acdbcd','cd', 'acdb')
    ,('abcde','abcde', '')
    ,('abcde','', 'abcde')
    ,('','', '')

    ,('abcde','ae', 'abcde')
    ,('abcde','aa', 'abcde')
    ,('abcde','bcd', 'abcde')
    ,('abcde','xab', 'abcde')
    ,('abcde','yde', 'abcde')

    ,('','a', '')
) | % {
    $s,$t,$e = $_
    $r = &$f $s $t
    "$($r-in$e): $r"
}

Выход:

True: cde
True: ab
True: ab
True: abc
True: abcde
True: acdb
True:
True: abcde
True:

QBIC , 57 байт

Хм, это беспорядок в QBIC / QBasic ...

B=@ `+B┘x=instr(;,;)~x|?_t_sB,x-1|+_sB,x+_lC|,_lB|||\?B

B=@ `+B          Prepend a string to B$. Thisis a hack to avoid errors with 
                 removing substrings stating at index 1
┘                Line-break in QBasic output
       (;,;)     Read the string (B$) and the to-be-removed substring (C$)
x=instr          And make x to be the starting index of the first C$ in B$
~x|              IF X <> 0 (ie C$ is present in B$)
?                PRINT
 _t                trimmed version (drops the prepended space)
  _sB,x-1|+        of a substring from 1 to x (the start of C$) -1
  _sB,x+_lC|,_lB   and the rest of the string, starting after C$
                     _l takes the length of a string
  |||              End TRIM, end Substring, end Length
\?B              When missing C$, just print B$

Луа , 71 65 байт

Принятие предложений

a,b=...p='(.*)'print(a:match('^'..b..p)or a:match(p..b..'$')or a)

Попробуйте онлайн!

Я изначально неправильно прочитал инструкцию. Спасибо, Орджан Йохансен за указание на мою ошибку!

PowerShell , 46 51 байт

Function F($o,$a){([regex]"^$a").replace($o,'',1);}

Попробуйте онлайн!

Excel, 129 байт

=IFERROR(IF(FIND(B1,A1)=1,SUBSTITUTE(A1,B1,"",1),IF(FIND(B1,A1,LEN(A1)-LEN(B1))>LEN(A1)-LEN(B1),LEFT(A1,LEN(A1)-LEN(B1)),A1)),A1)

sed , 56 53 bytes

s/^(.*),(.*)\1$/\2/
s/^(.*),\1(.*)$/\2/
s/.*,(.*)/\1/

Попробуйте онлайн!