Objectif

Créer une fonction pour inverser la concaténation de chaînes

Contribution

Deux chaînes (alphanumériques + espaces), où l’une doit être soustraite pour l’autre.

• Vous pouvez supposer que la chaîne à soustraire ne sera jamais plus grande que l'autre.

Sortie

Le résultat de la soustraction

Soustraction

Vous devez supprimer une chaîne du début ou de la fin d'une autre chaîne. Si la chaîne est présente au début et à la fin, vous ne pouvez en supprimer qu'une, celle qui sera supprimée dépend de vous.
Si la chaîne n'est pas au début ou à la fin, ou n'est pas une correspondance exacte, il s'agit d'une soustraction non valide et vous devez générer la chaîne d'origine.

Cas de test

Soustraction valide

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

Soustraction non valide (retourne la chaîne d'origine)

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

Entrée invalide (ne doit pas être traitée)

'','a' -> ''

C'est du code-golf , donc le code le plus court en octets gagne!

Java 8, 46 45 44 40 octets

-1 octet grâce à TheLethalCoder

-1 octet parce que je suis idiot (merci Rod!)

-4 octets grâce à Kevin Cruijssen

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

Essayez-le en ligne! (inclut tous les cas de test)

Une réponse Java bat en réalité quelques autres langages pratiques. Des sourires. (Et maintenant, il bat JS!)

JavaScript (ES6), 41 octets

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

Accepte les entrées via la syntaxe de currying, c'est-à-dire f("abab")("ab").

Brachylog (Essayez-le en ligne!), 12 octets

~cpĊh.∧Ċtw|w

Essayez-le en ligne!

Prend la chaîne à soustraire de l'entrée standard et la chaîne à soustraire en tant qu'argument de ligne de commande.

Explication

~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}.

Retina , 21 octets

1 octet grâce à Martin Ender.

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

Essayez-le en ligne!

JavaScript (ES6), 76 70 45 41 octets

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

L'essayer

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 octets

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

L'essayer

Étendu:

-> $_, $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 octets

k"^|$"¬qV

Essayez-le en ligne!

TI-Basic (TI-84 Plus CE), 63 octets

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 octets

(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)&

test du style d'entrée ["abcde", "ab"]

Python, 69 68 64 57 51 45 octets

Cela a fini par être une solution complètement différente avec Regex.

Merci à Value Ink pour -2 octets!
et Felipe Nardi Batista pour l’énorme -6 octets!

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

Essayez-le en ligne!

Bash ,66 61 49 octets

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

Essayez-le en ligne!

moins golfé:

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

Utilise la casse pour tester le début ou la fin et la soustraction du préfixe / suffixe du tableau (% / #)

APL (Dyalog) , 31 à 30 octets

-1 grâce à Zacharý .

Ceci utilise en fait la concaténation inverse (c'est-à-dire l'inverse de)! Prend la chaîne d'origine comme argument de gauche et ce qu'il faut soustraire comme argument de droite.

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

Essayez-le en ligne!

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
}

Légende:

{… } Fonction anonyme

⍺ argument gauche de la fonction courante

⍵ bon argument de la fonction courante

0::… Si une erreur se produit, exécutez ceci, sinon…

⍣¯1⊢ inverse

,∘⍵ concaténer ⍵ à droite

⍵, concaténer ⍵ à gauche

PHP, 54 octets

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

Testcases

Python 2 , 68 octets

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

Essayez-le en ligne!

Haskell , 49 octets

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

Essayez-le en ligne! Utilisation: f"" "abcdef" "ab". Alternativement, définir (-)=f""et utiliser comme "abcdef" - "ab".

Cette solution sans regex fonctionne en scindant de manière récursive la chaîne dans tous ses préfixes et postfixes et en vérifiant si la chaîne à soustraire correspond à l'un d'entre eux.

Python 2 , 72 65 octets

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

Essayez-le en ligne!

-7 octets grâce à @FelipeNardiBatista

C #, 88 octets

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

Compile a Func<string, Func<string, string>>.

Ruby (expression lambda), 29 octets

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

Yay pour l'interpolation regex! Requiert des soustraits regex-safe, mais cela ne pose pas de problème selon le défi.

Tcl , 37 octets

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

Essayez-le en ligne! (exécute maintenant tous les tests)

Tcl est simple. proc s {a b}définit une fonction nommée squi prend des paramètres aet b. regsubsubstitutes {}, qui est une chaîne vide, pour la valeur du bdébut ou de la fin de a. Le retour est implicite.

C, 96 octets

Il est de notoriété publique que la manipulation des cordes en C est lourde, car une extension de golf serait limite masochiste. Cela me va.

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);}

L'un des programmes les moins lisibles que j'ai écrits. Prend deux entrées (quelle que soit l'apparence de la fonction), un char**pointant sur la chaîne à déconcaténer et un char*qui est la chaîne à supprimer. Le pointeur d'entrée est édité à la place et devient la sortie (qui parle quand même des fuites de mémoire).

Exemple d'utilisation:

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 octets

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

Essayez-le en ligne!

La soumission originale a naïvement remplacé le texte dans la première chaîne, pas seulement au début ou à la fin.

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

Essayez-le en ligne!

A l'origine essayé sans accolades, mais il fallait des astuces pour imprimer des lignes vides et / ou des non-correspondances qui ont fini par ajouter plus d'octets que cette version.

R, 20 42 41 octets

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

-1 octet grâce à MickyT!

Retourne une fonction anonyme (qui a des arguments dans l'ordre b,a). Calcule la différence de chaîne a-b. subest une simple substitution qui permute la première occurrence du motif avec, dans ce cas, la chaîne vide ''. Construit l’expression rationnelle avec sprintfpour qu’elle ne corresponde qu’au début et à la fin de la chaîne. Nécessite l' pryrinstallation du package.

Sur le lien TIO, utilise la function(a,b)définition plus détaillée de la fonction pour quatre octets supplémentaires.

Essayez-le en ligne!

Common Lisp, 121 octets

(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)))

Essayez-le en ligne!

Le common Lisp habituel verbeux!

Version non-golfée:

(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

Kotlin , 91 octets

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

Essayez-le en ligne!

Powershell, 34 à 40 octets

+6 octets lorsque Invalid Subtractiondes cas de test sont ajoutés

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

Commentaire:

L’expression regexp ^$t|$t$ne fonctionne pas comme prévu: elle remplace les deux correspondances au lieu d’une (flagg toujours activé). Nous sommes donc obligés d’utiliser le groupe de surveillance négatif.

Script de test:

$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"
}

Sortie:

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

QBIC , 57 octets

Whegh, c'est un gâchis dans 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$

Lua , 71 65 octets

Accepter les suggestions

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

Essayez-le en ligne!

Au début, j'ai mal lu les instructions. Merci, Ørjan Johansen d' avoir signalé mon erreur!

PowerShell , 46 à 51 octets

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

Essayez-le en ligne!

Excel, 129 octets

=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 octets

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

Essayez-le en ligne!