Je suis tombé sur cette question, car il semble que ce soit un cas d'utilisation très courant pour trouver des caractères uniques dans une chaîne. Mais que faire si on veut s'en débarrasser?

L'entrée ne contient que des alphabets en minuscules. Seules les lettres de a à z sont utilisées. La longueur d'entrée peut être comprise entre 1 et 1 000 caractères.

Exemple:
entrée: helloworld
sortie: llool

Objectif: Le code le plus court gagne
Langue: N'importe lequel des 20 meilleurs langages TIOBE

Perl, 28 24 caractères (dont 1 pour l'option 'p')

s/./$&x(s!$&!$&!g>1)/eg

Usage:

> perl -pe 's/./$&x(s!$&!$&!g>1)/eg'
helloworld
llool

Au début, je pensais que je pouvais le faire avec un regard négatif et un regard négatif derrière, mais il s'avère que les regards négatifs doivent avoir une longueur fixe. J'ai donc opté pour des expressions rationnelles imbriquées à la place. Merci à mob pour l' $&astuce.

(GolfScript, 15 13 caractères)

:;{.;?);>?)},

GolfScript n'est pas l'un des 20 meilleurs, mais un golf de code sans GolfScript ... ( exécutez-le vous-même )

Version précédente: ( exécuter le script )

1/:;{;\-,;,(<},

J, 12 caractères

Après avoir entré une réponse Perl valide, voici une réponse invalide (langue qui ne fait pas partie du top 20 de TIOBE).

a=:#~1<+/@e.

Usage:

   a 'helloworld'
llool

Déclare un verbe aqui ne produit que des éléments non uniques.

GolfScript (14 caractères)

:x{{=}+x\,,(},

Démo en ligne

Peut-être pas qualifié pour gagner, mais il est utile d'avoir un critère.

Rubis 46 40 36

gets.chars{|c|$><<c if$_.count(c)>1}

Perl 44

$l=$_;print join"",grep{$l=~/$_.*$_/}split""

Exécution:

perl -lane '$l=$_;print join"",grep{$l=~/$_.*$_/}split""' <<< helloworld
llool

K, 18

{x@&x in&~1=#:'=x}

Python 2.7 ( 52 51), Python 3 (52)

Je ne m'attendais pas à ce que ce soit si court.

2.7: a=raw_input();print filter(lambda x:a.count(x)>1,a)

3.0: a=input();print''.join(i for i in a if a.count(x)>1)

raw_input(): stocke l'entrée sous forme de chaîne ( input()= eval(raw_input()))
(Python 3.0: input()a été transformé en raw_input())

filter(lambda x:a.count(x)>1,a): Filtrez tous les personnages à l'intérieur as'ils se trouvent dans aplusieurs fois ( a.count(x)>1).

sed et coreutils (128)

Certes, cela ne fait pas partie de la liste TIOBE, mais c'est amusant (-:

<<<$s sed 's/./&\n/g'|head -c -1|sort|uniq -c|sed -n 's/^ *1 (.*)/\1/p'|tr -d '\n'|sed 's:^:s/[:; s:$:]//g\n:'|sed -f - <(<<<$s)

Version sans golf:

s=helloworld
<<< $s sed 's/./&\n/g'        \
| head -c -1                  \
| sort                        \
| uniq -c                     \
| sed -n 's/^ *1 (.*)/\1/p'   \
| tr -d '\n'                  \
| sed 's:^:s/[:; s:$:]//g\n:' \
| sed -f - <(<<< $s)

Explication

Le premier sed convertit l'entrée en un caractère par ligne. Le deuxième sed trouve des personnages qui n'apparaissent qu'une seule fois. Troisième sed écrit un script sed qui supprime des caractères uniques. Le dernier sed exécute le script généré.

Brachylog (v2), 8 octets

⊇.oḅlⁿ1∧

Essayez-le en ligne!

Soumission de fonction. Techniquement non compétitif car la question a une limite sur les langages autorisés à concourir (cependant, plusieurs autres réponses ont déjà ignoré la restriction).

Explication

⊇.oḅlⁿ1∧
⊇         Find {the longest possible} subset of the input
  o       {for which after} sorting it,
   ḅ        and dividing the sorted input into blocks of identical elements,
    lⁿ1     the length of a resulting block is never 1
 .     ∧  Output the subset in question.

Japt , 6 5 octets

ÆèX É

-1 octet grâce à @Oliver

Essayez-le en ligne!

Python (56)

Voici une autre alternative (quelques caractères de plus) en Python:

a=raw_input();print''.join(c for c in a if a.count(c)>1)

Si vous acceptez la sortie sous forme de liste (par exemple ['l', 'l', 'o', 'o', 'l']), nous pourrions la résumer à 49 caractères:

a=raw_input();print[c for c in a if a.count(c)>1]

Mathematica 72 63

Ok, Mathematica ne fait pas partie des 20 meilleures langues, mais j'ai quand même décidé de rejoindre la fête.

x est la chaîne d'entrée.

"" <> Select[y = Characters@x, ! MemberQ[Cases[Tally@y, {a_, 1} :> a], #] &]

Perl (55)

@x=split//,<>;$s{$_}++for@x;for(@x){print if($s{$_}>1)}

Lit à partir de stdin.

C # - 77 caractères

Func<string,string>F=s=>new string(s.Where(c=>s.Count(d=>c==d)>1).ToArray());

Si vous acceptez la sortie sous forme de tableau, elle se résume à 65 caractères:

Func<string,char[]>F=s=>s.Where(c=>s.Count(d=>c==d)>1).ToArray();

Ocaml, 139 133

Utilise ExtString.String d'ExtLib

open ExtString.String
let f s=let g c=fold_left(fun a d->a+Obj.magic(d=c))0 s in replace_chars(fun c->if g c=1 then""else of_char c)s

Version non golfée

open ExtString.String
let f s =
  let g c =
    fold_left
      (fun a c' -> a + Obj.magic (c' = c))
      0
      s
  in replace_chars
  (fun c ->
    if g c = 1
    then ""
    else of_char c)
  s

La fonction grenvoie le nombre d'occurrences de c dans la chaîne s. La fonction fremplace tous les caractères par la chaîne vide ou la chaîne contenant le caractère en fonction du nombre d'occurrences. Edit: j'ai raccourci le code de 6 caractères en abusant de la représentation interne des bools :-)

Oh, et ocaml est 0 sur l'indice TIOBE ;-)

PHP - 70

while($x<strlen($s)){$c=$s[$x];echo substr_count($s,$c)>1?$c:'';$x++;}

avec une hypothèse $ s = 'helloworld'.

Java 8, 90 octets

s->{for(char c=96;++c<123;s=s.matches(".*"+c+".*"+c+".*")?s:s.replace(c+"",""));return s;}

Explication:

Essayez-le en ligne.

s->{                         // Method with String as both parameter and return-type
  for(char c=96;++c<123;     //  Loop over the lowercase alphabet
    s=s.matches(".*"+c+".*"+c+".*")?
                             //   If the String contains the character more than once
       s                     //    Keep the String as is
      :                      //   Else (only contains it once):
       s.replace(c+"",""));  //    Remove this character from the String
  return s;}                 //  Return the modified String

PowerShell , 59 octets

"$args"-replace"[^$($args|% t*y|group|?{$_.Count-1}|% n*)]"

Essayez-le en ligne!

Moins golfé:

$repeatedСhars=$args|% toCharArray|group|?{$_.Count-1}|% name
"$args"-replace"[^$repeatedСhars]"

Remarque: $repeatedCharsest un tableau. Par défaut, un Powershell joint les éléments du tableau par un caractère d'espace tout en convertissant le tableau en chaîne. Ainsi, l'expression rationnelle contient des espaces (dans cet exemple, [^l o]). Les espaces n'affectent pas le résultat car la chaîne d'entrée contient uniquement des lettres.

APL (Dyalog Extended) , 8 octets ^SBCS

Fonction de préfixe tacite anonyme.

∊⊢⊆⍨1<⍧⍨

Essayez-le en ligne!

⍧⍨ compte selfie (compte les occurrences des éléments d'argument dans l'argument lui-même)

1< Masque booléen où l'on est inférieur à celui

⊢⊆⍨ partitionner l'argument par ce masque (en commençant une nouvelle partition sur 1s et en supprimant sur 0s)

∊ ϵ nlist (aplatir)

JavaScript, 45 octets

s=>[...s].filter(c=>s.match(c+'.*'+c)).join``

R , 70 octets

a=utf8ToInt(scan(,''));intToUtf8(a[!a%in%names(table(a)[table(a)<2])])

Essayez-le en ligne!

Une mauvaise tentative, même à partir d'un top 20 des langues TIOBE. Je sais que quelque chose peut être fait au cours de la seconde moitié, mais pour le moment, aucun golf ne m'échappe.

JavaScript, 34 octets

Entrée sous forme de chaîne, sortie sous forme de tableau de caractères.

s=>[...s].filter(x=>s.split(x)[2])

Essayez-le en ligne!

JavaScript (Node.js) , 82 octets

p=>[...p].map((v,i,a)=>a.filter(f=>f==v).length).reduce((a,c,i)=>c>1?a+=p[i]:a,[])

Essayez-le en ligne!

PHP - 137

Code

implode('',array_intersect(str_split($text),array_flip(array_filter(array_count_values(str_split($text)),function($x){return $x>=2;}))));

Code normal

$text   = 'helloworld';
$filter = array_filter(array_count_values(str_split($text)), function($x){return $x>=2;});
$output = implode('',array_intersect(str_split($text),array_flip($filter)));

echo $output;

PHP - 83 78

<?for($a=$argv[1];$i<strlen($a);$r[$a[$i++]]++)foreach($ras$k=>$c)if($c>1)echo$k

Version améliorée:

<?for($s=$argv[1];$x<strlen($s);$c=$s[$x++]) echo substr_count($s,$c)>1?$c:'';

Bien sûr, cela nécessite la désactivation des notifications

Éditer: Amélioration inspirée par @hengky mulyono

Je suis si mauvais au codegolf :)

C ++, 139 octets

string s;cin>>s;string w{s}; auto l=remove_if(begin(s),end(s),[&w](auto&s){return count(begin(w),end(w),s)==1;});s.erase(l,end(s));cout<<s;

non golfé:

#include <algorithm>
#include <string>
#include <iostream>

int main() {
  using namespace std;
  string s;
  cin >> s;
  const string w{s};
  auto l = remove_if(begin(s), end(s), [&w](auto& s) {
                                         return count(begin(w), end(w), s) == 1;
                                       });
  s.erase(l, end(s));
  cout << s;
  return 0;
}