Eu me deparei com essa pergunta, porque parece ser um caso de uso muito comum encontrar caracteres únicos na string. Mas e se quisermos nos livrar deles?

A entrada contém apenas letras minúsculas. Somente letras de a a z são usadas. O comprimento da entrada pode ter de 1 a 1000 caracteres.

Exemplo:
input: helloworld
output: llool

Objetivo: o menor código vence
Idioma: qualquer um dos 20 principais idiomas do TIOBE

Perl, 28 24 caracteres (inclui 1 para a opção 'p')

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

Uso:

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

No começo, pensei que poderia fazer isso com um look-ahead negativo e um look-behind negativo, mas acontece que os look-behind negativos devem ter um comprimento fixo. Então, eu fui para expressões regulares aninhadas. Com agradecimentos ao mob pela $&dica.

(GolfScript, 15 13 caracteres)

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

O GolfScript não é um dos 20 principais, mas um codegolf sem o GolfScript ... ( execute você mesmo )

Versão anterior: ( executar script )

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

J, 12 caracteres

Depois de inserir uma resposta Perl válida, eis uma resposta inválida (o idioma não está no top 20 do TIOBE).

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

Uso:

   a 'helloworld'
llool

Declara um verbo aque gera apenas itens não exclusivos.

GolfScript (14 caracteres)

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

Demonstração online

Pode não se qualificar para ganhar, mas é útil ter um critério.

Rubi 46 40 36

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

Perl 44

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

Execução:

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)

Eu não esperava que fosse tão curto.

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(): armazena a entrada como uma string ( input()= eval(raw_input()))
(Python 3.0: input()foi transformado em raw_input())

filter(lambda x:a.count(x)>1,a): Filtre todos os caracteres contidos ase forem encontrados amais de uma vez ( a.count(x)>1).

sed e coreutils (128)

Concedido que isso não faz parte da lista TIOBE, mas é divertido (-:

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

Versão descolada:

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)

Explicação

O primeiro sed converte a entrada em um caractere por linha. O segundo sed encontra caracteres que ocorrem apenas uma vez. O terceiro sed grava um script sed que exclui caracteres únicos. O último sed executa o script gerado.

Brachylog (v2), 8 bytes

⊇.oḅlⁿ1∧

Experimente online!

Envio de função. Tecnicamente não competitivo, porque a pergunta tem uma limitação sobre quais idiomas podem competir (no entanto, várias outras respostas já ignoraram a restrição).

Explicação

⊇.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.

Japonês , 6 5 bytes

ÆèX É

-1 byte graças a @Oliver

Experimente online!

Python (56)

Aqui está outra alternativa (alguns caracteres a mais) no Python:

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

Se você aceitar a saída como uma lista (por exemplo ['l', 'l', 'o', 'o', 'l']), poderemos reduzi-la para 49 caracteres:

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

Mathematica 72 63

Ok, o Mathematica não está entre os 20 principais idiomas, mas decidi me juntar à festa de qualquer maneira.

x é a sequência de entrada.

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

Perl (55)

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

Lê de stdin.

C # - 77 caracteres

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

Se você aceitar a saída como uma matriz, ela se resumirá a 65 caracteres:

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

Ocaml, 139 133

Usa ExtString.String do 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

Versão sem golfe

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

A função gretorna o número de ocorrências de c na sequência s. A função fsubstitui todos os caracteres pela string vazia ou pela string que contém o char, dependendo do número de ocorrências. Edit: Reduzi o código em 6 caracteres abusando da representação interna de bools :-)

Ah, e ocaml é 0 no índice TIOBE ;-)

PHP - 70

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

com suposição $ s = 'helloworld'.

Java 8, 90 bytes

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

Explicação:

Experimente online.

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 bytes

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

Experimente online!

Menos golfe:

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

Nota: $repeatedCharsé uma matriz. Por padrão, um PowerShell junta elementos da matriz por espaço, enquanto converte a matriz em string. Portanto, o regexp contém espaços (neste exemplo [^l o]). Os espaços não afetam o resultado porque a sequência de entrada contém apenas letras.

APL (Dyalog Extended) , ^{SBCS de} 8 bytes

Função de prefixo tácito anônimo.

∊⊢⊆⍨1<⍧⍨

Experimente online!

⍧⍨ selfie de contagem (contagem de ocorrências de elementos de argumento no próprio argumento)

1< Máscara booleana em que um é menor que isso

⊢⊆⍨ particione o argumento por essa máscara (iniciando uma nova partição em 1s e removendo em 0s)

∊ ε nlist (achatar)

JavaScript, 45 bytes

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

R , 70 bytes

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

Experimente online!

Uma péssima tentativa, mesmo em um dos 20 principais idiomas da TIOBE. Sei que algo pode ser feito no segundo tempo, mas, no momento, qualquer jogador de golfe me escapa.

JavaScript, 34 bytes

Entrada como uma string, saída como uma matriz de caracteres.

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

Experimente Online!

JavaScript (Node.js) , 82 bytes

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

Experimente online!

PHP - 137

Código

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

Código 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

Versão melhorada:

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

É claro que isso precisa ser desativado

Edit: Melhoria inspirada em @hengky mulyono

Eu sou tão ruim em codegolf :)

C ++, 139 bytes

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;

ungolfed:

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