Détripliquer une chaîne

39

Beaucoup de langues ont des méthodes intégrées pour se débarrasser des doublons, ou "dédupliquer" ou "déséquilibrer" une liste ou une chaîne. Une tâche moins courante consiste à "détripliquer" une chaîne. C'est-à-dire que pour chaque caractère qui apparaît, les deux premières occurrences sont conservées.

Voici un exemple où les caractères qui devraient être supprimés sont étiquetés avec ^:

aaabcbccdbabdcd
  ^    ^ ^^^ ^^
aabcbcdd

Votre tâche consiste à implémenter exactement cette opération.

Règles

L'entrée est une chaîne unique, éventuellement vide. Vous pouvez supposer qu'il ne contient que des lettres minuscules dans la plage ASCII.

La sortie doit être une chaîne unique avec tous les caractères supprimés qui sont déjà apparus au moins deux fois dans la chaîne (les deux occurrences les plus à gauche sont donc conservées).

Au lieu de chaînes, vous pouvez utiliser des listes de caractères (ou des chaînes singleton), mais le format doit être cohérent entre entrée et sortie.

Vous pouvez écrire un programme ou une fonction et utiliser l’une quelconque de nos méthodes standard de réception d’entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

C'est du code-golf , donc la réponse valide la plus courte - mesurée en octets - est gagnante.

Cas de test

Chaque paire de lignes correspond à un cas de test, une entrée suivie par une sortie.



xxxxx
xx
abcabc
abcabc
abcdabcaba
abcdabc
abacbadcba
abacbdc
aaabcbccdbabdcd
aabcbcdd

Classement

L'extrait de pile au bas de cet article génère un classement à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

## Perl, 43 + 3 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  string  counting 
— Martin Ender
source
5
Cordes Singleton ... stringetsons?
— dkudriavtsev

Réponses:

15

JavaScript (ES6), 42 48

Modifier 6 octets sauvés thx @Neil

s=>s.replace(k=/./g,c=>(k[c]+=c)[11]?'':c)

Explication: J'utilise les propriétés 'a' ... 'z' d'objet kpour stocker les informations relatives à chaque caractère (l'objet k est une expression rationnelle dans le cas présent uniquement pour enregistrer des octets). Ces propriétés sont initialement undefined. En javascript ajoutant un numéro undefineddonne NaN(tout à fait raisonnable), mais en ajoutant une chaîne « X » donne "undefinedX"- une chaîne de longueur 10 (stupide). Ajouter plus de caractères vous obtenez des chaînes plus longues. Si la chaîne obtenue pour un caractère donné est supérieure à 11, ce caractère n'est pas copié dans la sortie.

Tester

F=
s=>s.replace(k=/./g,c=>(k[c]+=c)[11]?'':c)

test=`

xxxxx
xx
abcabc
abcabc
abcdabcaba
abcdabc
abacbadcba
abacbdc
aaabcbccdbabdcd
aabcbcdd`.split`\n`
for(i=0;i<test.length;)
  a=test[i++],b=test[i++],r=F(a),
  console.log(r==b?'OK':'KO',a,'->',r,b)
Développer l'extrait

— edc65
source
Strictement parlant, une ligne vide est l’un des cas de test.
— Neil
@Neil ok a ajouté le test de chaîne vide
— edc65 le
Si vous passez en entrée et en sortie de matrice, vous pouvez utiliser .filter pour enregistrer 12 caractères supplémentaires. v=>v.filter(x=>!(v[x]+=x)[11]). Bravo au hack "indéfini".
— Grax32
@Grax thanx mais trop différent. Devrait le poster vous
— edc65
14

Python 2, 48 octets

lambda s:reduce(lambda r,c:r+c*(r.count(c)<2),s)

c[r.count(c)/2:]est une alternative de même longueur à c*(r.count(c)<2).

49 octets:

r=''
for c in input():r+=c*(r.count(c)<2)
print r
— Xnor
source
12

Retina , 17 octets

(.)(?<=\1.*\1.+)

Essayez-le en ligne!

Regex simple replace - faites correspondre un caractère s'il est déjà apparu deux fois et supprimez-le.

— Kobi
source
J'ai aussi essayé une boucle et un groupe répété avec{2} , les deux avec 18 octets.
— Kobi
1
J'ai 14 en utilisant une fonctionnalité récemment ajoutée. ;)
— Martin Ender
Je savais qu'il y avait quelque chose. J'ai regardé les limites, probablement pas celle-là. Je vais vérifier à nouveau.
— Kobi
3
Ah, je pense avoir trouvé la réponse de Martin. J'ai eu quelques problèmes lorsque j'essayais avant, je pense parce que je n'ai pas envisagé la façon dont le déduplication fonctionnerait sur une entrée multiligne. Spoiler (avec 5 octets ajoutés pour activer le mode par ligne): retina.tryitonline.net/…
— FryAmTheEggman
@FryAmTheEggman - Nice, je n'ai pas trouvé celui-ci. N'hésitez pas à ajouter une réponse - je pense que cela est trop différent de ma réponse et je ne me sentais pas à l'aise pour la modifier :P. Merci!
— Kobi
6

Brachylog , 25 octets

.v|s.g:.z:1a
:2fl<3
he~t?

Essayez-le en ligne! ou vérifier tous les cas de test .

Explication

Cela fonctionne parce que s - Subsetl'unifiera d'abord avec les plus gros sous-ensembles, par exemple "aaa"il essaiera "aa"avant "a".

  • Prédicat principal:

      .v         input = Output = ""
|          Or
  s.         Output is an ordered subset of the input
  g:.z       Zip each character of the output with the output itself
  :1a        Apply predicate 1 on each element of the zip

  • Prédicat 1: Vérifiez que tous les caractères n'apparaissent qu'au plus deux fois. Entrée =[String:Char]

    :2f        Find all valid outputs of predicate 2 (i.e. one output per occurence
               of the char)
l<3        There are less than 3 occurences

  • Prédicat 2: Obtenir l'occurrence d'un personnage. Entrée =[String:Char]

    he         Take a character of the string in the input
  ~t?      That character is the char of the input
— Fataliser
source
6

> <> , 22 octets

i:0(?;::9g:}2(?o{1+$9p

Essayez-le en ligne! Utilise la boîte à code pour suivre les comptes jusqu'à présent.

i                       Read a char c of input
 :0(?;                  Halt if EOF
      :                 Make a copy - stack has [c c] at the top
       :9g              Get count stored at (c, 9)
          :}            Copy the count and move to bottom of stack
            2(?o        If the count is less than 2, output c
                {1+     Move the count back to the top of the stack and increment
                   $9p  Update cell at (c, 9)
                        [Instruction pointer moves to start as ><> is toroidal]
— Sp3000
source
6

J, 20 15 octets

#~(3>[+/@:={:)\

Ceci définit une fonction monadique qui prend et retourne une chaîne. Essayez-le ici . Usage:

   f =: #~(3>[+/@:={:)\
   f 'abaacbb'
abacb

Explication

Je suis passé au même algorithme que d'autres solutions, puisqu'il s'est avéré plus court ...

#~(3>[+/@:={:)\  Input is y.
  (          )\  For each prefix of y:
          =        compute the equality vector
     [     {:      of the prefix and its last element, and
      +/@:         take its sum. Now we have a vector r such that y[i] has its
                   r[i]'th occurrence at position i.
   3>              Mark those coordinates where r[i] < 3.
#~               Remove the non-marked characters from y.
— Zgarb
source
6

Haskell, 40 à 39 octets

foldl(\s c->s++[c|filter(==c)s<=[c]])""

Exemple d'utilisation: foldl(\s c->s++[c|filter(==c)s<=[c]])"" "aaabcbccdbabdcd"-> "aabcbcdd".

Conservez le prochain caractère csi la chaîne de tous les cs jusqu'à présent est lexicographique inférieure ou égale à la chaîne de singleton [c].

Edit: @xnor a sauvegardé un octet en passant de la compréhension de liste à filter. Merci!

— nimi
source
Votre alternative pourrait faire filter(==c)s<=[c]pour sauver un octet.
— xnor
5

Perl, 22 octets

Code 21 octets + 1 pour -p.

s/./$&x(2>${$&}++)/ge

Usage

perl -pe 's/./$&x(2>${$&}++)/ge' <<< 'aaabcbccdbabdcd'
aabcbcdd
— Dom Hastings
source
5

C, 57 octets

Appelez f()avec la chaîne à détruire. La fonction modifie son paramètre. Requiert C99 en raison de la fordéclaration -loop.

f(char*p){for(char*s=p,m[256]={0};*s=*p;s+=++m[*p++]<3);}
— owacoder
source
Tu ne peux pas mettre la déclaration de sdans la première déclaration de la for?
— Martin Ender
En C99, vous pouvez. Je ne l’ai pas fait parce que j’aime garder les golfs compatibles C89.
— owacoder
5

JavaScript (ES6), 35 octets

s=>s.filter(c=>(s[c]=(s[c]|0)+1)<3)

Prend un tableau de caractères en entrée et retourne le tableau détruit.

— cPu1
source
Agréable. Vous pourriez faire c=>(s[c]=-~s[c])<3pour sauver quelques octets.
— ETHproductions
J'avais manqué le fait que vous puissiez utiliser des tableaux en entrée et avoir écrit une fonction en utilisant map. Golfé, il ressemblait essentiellement au vôtre. la principale différence était l'affectation qui, si vous la permutez, économisera quelques octets. Essayez s.filter(c=>(s[c]=s[c]+1|0)<3)33 octets. EDIT: Whoops, a raté le commentaire ci - dessus moi, qui est encore mieux :)
— Jan
4

PowerShell v2 +, 31 octets

$args-replace'(.)(?<=\1.*\1.+)'

Utilise la même expression rationnelle que dans la réponse Retina de Kobi , qui vient d'être encapsulée dans l' -replaceopérateur PowerShell . Fonctionne parce que les deux utilisent .NET -avor regex en arrière-plan.

Sinon, sans regex, 56 octets

$b=,0*200;-join([char[]]$args[0]|%{"$_"*($b[$_]++-lt2)})

Crée un tableau d'assistance $bpré-rempli avec 0s. Jette la chaîne d'entrée$args[0] tant que char-array, la dirige au travers d'une boucle |%{...}. Chaque itération génère le caractère actuel $_sous forme de chaîne "$_"multipliée par un booléen qui est uniquement $TRUE(implicitement converti 1ici) si le point approprié dans le tableau d'assistance est inférieur à 2(nous n'avons pas déjà vu ce caractère deux fois). La collection résultante de chaînes est encapsulée dans des parenthèses et -joinédité ensemble pour ne former qu'une seule chaîne de sortie. Cela reste sur le pipeline et la sortie est implicite.

— AdmBorkBork
source
regex est imbattable. :) Je beleave une table de hachage est mieux alors un tableau pour la variante sans regex: $b=@{};-join($args|% t*y|?{++$b.$_-lt3}).
— mazzy
1
@mazzy Pour la variante sans regex et votre code, il faudrait une version plus récente que PowerShell 2. Par conséquent, je pense que je conserverai cette réponse sans changement. Vous pouvez cependant poster votre code en tant que réponse séparée!
— AdmBorkBork
la table de hachage est-elle apparue dans la version 3.0? D'accord. Merci.
— mazzy
4

Mathematica, 39 octets

Fold[If[Count@##<2,Append@##,#]&,{},#]&

Fonction anonyme. Prend une liste de caractères en entrée et renvoie la liste détaillée en sortie. Utilise la méthode de replier la liste et de rejeter les éléments en triple, ce n'est pas trop compliqué.

— LegionMammal978
source
4

05AB1E, 12 octets

vyˆ¯y¢O3‹iy?

Explication

v            # for each char in input
 yˆ          # push to global array
   ¯y¢O3‹i   # if nr of occurrences are less than 3
          y? # print it

Essayez-le en ligne

— Emigna
source
4

MATL , 8 octets

t&=Rs3<)

Essayez-le en ligne!

Explication

t      % Input string implicitly. Push another copy
&=     % Matrix of all pairwise equality comparisons of string elements
R      % Keep only upper triangular part, making the rest of the entries zero
s      % Sum of each column. This gives a vector with number of occurrences
       % of the current character up to the current position
3<     % True for entries that are less than 3
)      % Use as logical index into initial copy of the input. Display implicitly

Exemple

En supposant une entrée 'aaababbc', la pile contient les éléments suivants après les instructions indiquées:

  • t

    'aaababbc'
'aaababbc'

  • t&=

    'aaababbc'
[ 1 1 1 0 1 0 0 0;
  1 1 1 0 1 0 0 0;
  1 1 1 0 1 0 0 0;
  0 0 0 1 0 1 1 0;
  1 1 1 0 1 0 0 0;
  0 0 0 1 0 1 1 0;
  0 0 0 1 0 1 1 0;
  0 0 0 0 0 0 0 1 ]

  • t&=R

    'aaababbc'
[ 1 1 1 0 1 0 0 0;
  0 1 1 0 1 0 0 0;
  0 0 1 0 1 0 0 0;
  0 0 0 1 0 1 1 0;
  0 0 0 0 1 0 0 0;
  0 0 0 0 0 1 1 0;
  0 0 0 0 0 0 1 0;
  0 0 0 0 0 0 0 1 ]

  • t&=Rs

    'aaababbc'
[ 1 2 3 1 4 2 3 1 ]

  • t&=Rs3<

    'aaababbc'
[ true true false true false true false true ]

  • t&=Rs3<)

    'aabbc'
— Luis Mendo
source
4

Rétine , 14 octets

D`(.)(?<=\1.*)

Vérifier tous les cas de test. (Le% mode par ligne activé)

Utilise la nouvelle étape de "déduplication" pour économiser quelques octets sur l'approche de Kobi . Deduplicate rassemble une liste de toutes les correspondances dans la regex et remplace toutes les chaînes sauf la première par la chaîne vide. La regex correspond à un caractère qui apparaît déjà une fois dans la chaîne, ce qui signifie que les deux premiers seront conservés.

— FryAmTheEggman
source
3

K, 18 octets

  g:{x{?x@<x}@,/2#'=x}
  g "abc"
"abc"
  g "aaabcbccdbabdcd"
"aabcbcdd"

  /k4 request test vectors from internet
  R:"GET /raw/ftHe0bpE HTTP/1.0\r\nHost: pastebin.com\r\n\r\n"
  t:+0N 2#t@1_&|\(0=#:)'t:1_"\r\n"\:`:http://pastebin.com:80 R 

  /k4 no internet? use a file called "t.txt" in current directory
  t:+0N 2#0:`:t.txt

  /k6?
  t:+0N 2#0:"t.txt"

  /visually inspect test cases
  g't[0]
(();"xx";"abcabc";"abcdabc";"abacbdc";"aabcbcdd")

  /do all tests pass?
  |/ t[1] {$[0=#x;0=#y;x~y]}' g't[0]
1b

K4 est disponible en téléchargement gratuit ; K6 est en développement . Si vous avez téléchargé KDB, vous pouvez entrer dans K avec une barre oblique inverse .

Il est peut-être plus facile de voir cela en morceaux, mais d’abord une syntaxe: g:xdéfinit gà x. {x+1}est une fonction qui prend un argument x . En K, le premier argument d'une fonction estx (le second est yet le troisième estz . N'a pas besoin d'un quatrième).

À présent:

x:"aaabcbccdbabdcd"

=xsignifie groupe x , qui produit:

"abcd"!(0 1 2 10;3 5 9 11;4 6 7 13;8 12 14)

2#'signifie deux prises (de) chacune qui produit

"abcd"!(0 1;3 5;4 6;8 12)

Comme vous pouvez le constater, ce sont les décalages des deux premières correspondances de chaque personnage. le 2 pourrait être généralisé.

,/signifie se joindre à chacun et est souvent appelé raze . Cela ne nous apportera que les valeurs de notre dictionnaire. Ainsi, ,/"abcd"!(0 1;3 5;4 6;8 12)produit:

0 1 3 5 4 6 8 12

que nous devons trier. {x@<x}@est un idiome que les programmeurs voient souvent (Q l’appelle asc ), qui dit x à la montée de niveau x . Le briser:

  <0 1 3 5 4 6 8 12
0 1 2 4 3 5 6 7

retourné les index du tableau trié, que nous voulons prendre à partir du tableau original. x@ysignifie x en y donc ceci indexe le tableau avec les index de la sorte (si cela a un sens).

  {x@<x}@0 1 3 5 4 6 8 12
0 1 3 4 5 6 8 12

que nous indexons simplement maintenant dans notre tableau d'origine. Nous pourrions dire x@ici, mais K soutient un concept très puissant dont nous pouvons tirer avantage ici: l’application de fonction est l’indexation. Cela signifie que cela a[0]pourrait être la recherche de la fente zéro aou appliquer la 0à la fonction appelée a. La raison pour laquelle nous avions besoin de@ précédemment {x@<x}est parce que les x<ymoyennes xs sont inférieures à ys : les opérateurs de K ont une forme dyadique (deux arguments) et une forme monadique (un argument) qui provient de APL. Q n'a pas cette "ambivalence".

— géocar
source
Bienvenue chez PPCG! Super première réponse. :)
— Martin Ender
J'ai quelques questions. 1. K4 est-il la même langue que celle vers laquelle vous créez un lien (Q / kdb +)? 2. Pouvez-vous montrer comment appeler votre fonction sur une entrée ou comment les éléments de testVectors.txt doivent être formatés?
— Dennis
@ Dennis 1. Oui. Appuyez sur la barre oblique inversée pour passer de Q à K. 2. Exactement comme ils apparaissent dans la question: pastebin.com/ftHe0bpE Exemple d'appel:g"aaabcbccdbabdcd"
— geocar
OK merci. Impossible de faire fonctionner la partie de fichier, mais g"..."fait le tour. Malheureusement, votre code retourne aabbccpour la saisie abc.
— Dennis
@ Dennis Vous avez peut-être commis une erreur: {x{?x@<x}@,/2#'=x}"abc"un retour définitif "abc". Il reviendrait "aabbcc"si vous avez manqué le ?distinct.
— geocar
2

Python 2, 51 octets

f=lambda s:s and f(s[:-1])+s[-1]*(s.count(s[-1])<3)

Testez-le sur Ideone .

— Dennis
source
2

Java 8 lambda, 90 caractères

i->{int[]o=new int[128];String r="";for(char c:i.toCharArray())if(++o[c]<3)r+=c;return r;}

Version non-golfée:

public class Q86503 {

    static String detriplicate(String input) {
        int[] occurences = new int[128];
        String result = "";
        for (char c : input.toCharArray()) {
            if (++occurences[c] < 3) {
                result += c;
            }
        }
        return result;
    }
}

Crée un tableau pour tous les caractères ascii. Si un personnage apparaît, le compteur correspondant sera augmenté. S'il est supérieur à 2, le caractère ne sera pas ajouté à la chaîne de résultat. Très facile, très court;)

— Frozn
source
2

Perl 6, 27 octets

{.comb.grep({++%.{$_} <3})}

Explication:

{.comb.grep({++%.{$_} <3})}
{                         } # a function
 .comb                      # get all the characters in the argument
      .grep({           })  # filter
               %.           # an anonymous hash (shared between calls to grep)
             ++  {$_}       # increment the value at the current key (current letter).
                            # if the key doesn't exist, it defaults to 0 (then gets incremented)
                      <3    # return True if it wasn't seen 3 times

(Remarque: Perl 6 n'est pas aussi "orienté golf" que sa soeur Perl 5 ... Alors oui, cet espace avant <est nécessaire. Il %.{}s'agit d'un hachage anonyme).

— Ven
source
— Jo King le
2

SmileBASIC, 77 72 69 68 octets

DIM R[#Y]READ S$WHILE""<S$Q=ASC(S$)INC R[Q]?SHIFT(S$)*(R[Q]<3);
WEND

A expliqué:

DIM R[128] 'array to store letter frequencies
READ S$ 'get input string
WHILE""<S$ 'much shorter than LEN(S$)
 Q=ASC(S$) 'get ascii value of first character in S$
 INC R[Q]
 ?SHIFT(S$)*(R[Q]<3); 'remove the first character of S$, and print it if there are less than 3 occurrences.
WEND
— 12Me21
source
Bienvenue chez ppcg! Nice premier post!
— Rɪᴋᴇʀ
1

Common Lisp, 127

(lambda(s)(map()(lambda(x)(flet((p(b)(1+(position x s :start b))))(setf s(remove x s :start(p(p 0))))))(remove-duplicates s))s)

Joli imprimé

(lambda (s)
  (map nil
       (lambda (x)
         (flet ((p (b)
                  (1+ (position x s :start b))))
           (setf s (remove x s :start (p (p 0))))))
       (remove-duplicates s))
  s)
— coredump
source
1

Q , 52 octets

q)f2:{x asc raze{distinct 2#where x}each x~'/:distinct x}
q)f2 each testList
"xx"
"abcabc"
"abcdabc"
"abacbdc"
"aabcbcdd"
q)
— Chromozorz
source
1

K , 27 octets

    f:{x{x@<x}@,/{?2#&x}'x~'/:?x}
    testList:("xxxxx";"abcabc";"abcdabcaba";"abacbadcba";"aaabcbccdbabdcd")
    f'testList
("xx";"abcabc";"abcdabc";"abacbdc";"aabcbcdd")
— Chromozorz
source
1

Ruby , 79 62 57 octets

C'est assez difficile à manier, mais je ne suis pas sûr de pouvoir jouer au golf autant mieux pour le moment. Toutes les suggestions de golf sont les bienvenues. Essayez-le en ligne!

Éditer: -17 octets grâce à Value Ink en suggérant un moyen plus rapide de supprimer les caractères en triple. -5 octets de supprimer la .uniqméthode.

->s{s.chars.map{|a|s[s.rindex a]=""while s.count(a)>2};s}

Ungolfed:

def g(s)
 s.chars.each do |a|
  while s.count(a) > 2
   i = s.rindex(a)
   s[i] = ""
  end
 end
 return s
end
— Sherlock9
source
62 octets:->s{s.chars.uniq.map{|a|s[s.rindex a]=""while s.count(a)>2};s}
— Valeur Encre
1

JavaScript, 30 octets

v=>v.filter(x=>!(v[x]+=x)[11])

En utilisant la méthode que @ edc65 a conçue pour compter mais avec un filtre tableau. Le premier caractère apparaît, la valeur de l'objet devient "indéfini" plus le caractère ("indéfini"). La prochaine fois que la valeur de l'objet devient "undefinedxx".

Après cela, v [x] [11] renvoie true et, une fois combiné avec l'opérateur not, false, ce qui signifie que les caractères déjà apparus deux fois seront filtrés.

— Grax32
source
0

Javascript (en utilisant une bibliothèque externe) (80 octets)

C'était un bon! N'a pas gagné mais c'était amusant

n=>{a={};return _.From(n).Where(x=>{b=a[x]?a[x]++:a[x]=1;return b<2}).Write("")}

Lien vers lib: https://github.com/mvegh1/Enumerable/

Explication de code: La méthode accepte une chaîne, la bibliothèque l'analyse en tant que tableau de caractères et la clause Where est un prédicat de filtrage complexe qui vérifie si la table de hachage 'a' contient le caractère actuel. S'il existe, incrémente le compteur, sinon, mis à 1. Si <2, le prédicat (et le caractère actuel) passe, sinon échouera.

enter image description here

— applejacks01
source
Vous pouvez éviter d' utiliser , returnmais faire de votre fonction d' une liste séparée par des virgules d'une expressions entre parenthèses: n=>(a={},_From(n)....). La dernière expression est la valeur de retour. Dans votre Wherefonction, vous pouvez éliminer l'intermédiaire bentièrement en comparant contre le résultat de la cession ou augmentation: x=>(a[x]?a[x]++:a[x]=1)<2.
— apsillers
Enfin, vous pouvez éviter d' utiliser une bibliothèque externe du tout (et enregistrer octets) en utilisant le bouton de sélection string-split et filteravec join: [...n].filter(...).join(""). Retournez la logique vrai / faux lorsque vous passez Whereà filter.
— apsillers
Ahh bonnes observations! Je vais regarder de plus près votre suggestion de plus près
— applejacks01
0

Clojure, 72 octets

#(apply str(reduce(fn[r c](if(<(count(filter #{c}r))2)(conj r c)r))[]%))

Tant d'octets ...

— NikoNyrh
source
0

Pascal (FPC) , 103 octets

var a:array['a'..'z']of word;c:char;begin repeat read(c);inc(a[c]);if a[c]<3then write(c)until eof end.

Essayez-le en ligne!

Explication:

var a:array['a'..'z']of word; //used for counting occurences of characters in the input
                              //array indices are accessed by chars
    c:char;
begin
  repeat
    read(c);                  //read a character from input
    inc(a[c]);                //increment the count of that character (its number in array)
    if a[c]<3 then write(c)   //if this is character's 1st or 2nd occurence, output it
  until eof                   //go back to reading if input is not read completely
end.
— AlexRacer
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.