Rimuovere il caso duplicato e cambiato

27

Obbiettivo

L'obiettivo di questa sfida è: data una stringa come input, rimuovere coppie duplicate di lettere, se il secondo elemento nella coppia è di maiuscole opposte. (ad esempio, le lettere maiuscole diventano minuscole e viceversa).

Le coppie devono essere sostituite da sinistra a destra. Ad esempio, aAadovrebbe diventare aae non aA.

esempi

Entrate uscite:

Input:         Output:  
bBaAdD         bad     
NniIcCeE       Nice    
Tt eE Ss tT    T e S t 
sS Ee tT       s E t   
1!1!1sStT!     1!1!1st!
nN00bB         n00b    
(eE.gG.)       (e.g.)  
Hh3lL|@!       H3l|@!
Aaa            Aa
aaaaa          aaaaa
aaAaa          aaaa

L'input è costituito da simboli ASCII stampabili.

Non dovresti rimuovere cifre duplicate o altri caratteri non di lettere.

Riconoscimento

Questa sfida è l'opposto di "Duplicate & switch case" di @nicael . Puoi invertirlo?

Grazie per tutti i collaboratori della sandbox!

Catalogare

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  string 
— aloisdg dice Reinstate Monica
fonte
4
Haha, questo è NniIcCeE :)
— nicael,
@nicael Sono felice che tu approvi :)
— aloisdg dice Reinstate Monica il
qual è l'output per abB:? abBo ab?
— Downgoat,
@Downgoat abBdovrebbe uscireab
— aloisdg dice Reinstate Monica il
1
@raznagul perché dovrebbe? Dividerlo: aa; aA; AA, solo la coppia centrale corrisponde allo schema e diventa a, quindi aa; a; AA
— LLlAMnYP,

Risposte:

12

Gelatina , 8 byte

ṛŒsḟḟȧµ\

Provalo online! o verifica tutti i casi di test .

Come funziona

ṛŒsḟḟȧµ\  Main link. Argument: s (string)

      µ   Convert all links to the left into a chain (unknown arity) and begin a
          new chain.
       \  Do a cumulative reduce by the chain to the left.
          Left argument:   r (previous result or first character)
          Right argument:  c (next character)
ṛ           Set the return value to c.
 Œs         Swap c's case.
    ḟ       Remove c from r (if present).
            This yields an empty string if c and r are identical (repeated letter
            with the same case or non-letter) and r otherwise.
            Note that r will be empty if the previous character has been removed.
   ḟ        Remove the resulting characters (if any) from c with swapped case.
            This yields c with swapped case if the result to the right does not
            contain c; otherwise, it yields the empty string.
     ȧ      Flat logical AND with c.
            Replace swapped case c with c; do not modify an empty string.
— Dennis
fonte
Più corto del dannato Regex!
— aloisdg dice Reinstate Monica il
2
Batti Retina in una sfida con archi ._.
— TuxCrafting
11

Retina , 18 byte

(.)(?!\1)(?i)\1
$1

Provalo online!

Spiegazione

Questa è una sostituzione singola (e abbastanza semplice) che corrisponde alle coppie rilevanti e le sostituisce con solo il primo carattere. Le coppie sono abbinate attivando l'insensibilità maiuscole / minuscole a metà del modello:

(.)     # Match a character and capture it into group 1.
(?!\1)  # Use a negative lookahead to ensure that the next character *isn't* the same
        # as the character we just captured. This doesn't advance the position of the
        # regex engine's "cursor".
(?i)    # Now activate case-insensitivity for the remainder of the pattern.
\1      # Match the second character with a backreference to the first. With the i
        # modifier activated, this will match if the two characters only differ
        # by case.

La sostituzione riscrive semplicemente il personaggio che abbiamo già catturato in gruppo 1comunque.

— Martin Ender
fonte
1
Bella risposta! Debuggex funziona alla grande con questo!
— aloisdg dice Reinstate Monica il
5

Brachylog , 44 byte

.v|.l1|hA,?bhB(@uA;A@uB),?bb&~b.hA|?b&~b.h~h?

Brachylog non ha espressioni regolari.

Spiegazione

    .v          Input = Output = ""
|               OR
    .l1         Input = Output = string of one character
|               OR
    hA,         A is the first char or the Input
    ?bhB        B is the second char of the Input
    (
        @uA         B uppercased is A
        ;           OR
        A@uB        A uppercased is B
    ),
    ?bb&        Call recursively on Input minus the first two elements
    ~b.hA       Output is the result of that call with A appended before it
|               OR
    b&          Call recursively on Input minus the first element
    ~b.h~h?     Output is the result of that call with the first element of Input appended
                  before it
— Fatalize
fonte
5

C #, 87 75 byte

s=>System.Text.RegularExpressions.Regex.Replace(s,@"(.)(?!\1)(?i)\1","$1");

Con la potente regex di Martin Ender. C # lambda dove si trovano l'input e l'output string.

12 byte salvati da Martin Ender e TùxCräftîñg.

C #, 141 134 byte

s=>{var r="";for(int i=0,l=s.Length;i<l;i++){var c=s[i];r+=c;if(char.IsLetter(c)&i+1<l&&(c|32)==(s[i+1]|32)&c!=s[i+1])i++;}return r;};

C # lambda dove si trovano l'input e l'output string. L'algoritmo è ingenuo. Questo è quello che uso come riferimento.

Codice:

s=>{
    var r = "";
    for(int i = 0; i < s.Length; i++)
    {
        r+=s[i];
        if (char.IsLetter(s[i]) & i+1 < s.Length)
            if (char.ToLower(s[i])==char.ToLower(s[i+1])
              & char.IsLower(s[i])!=char.IsLower(s[i+1]))
                i += 1;
    }       
    return r;
};

7 byte grazie a Martin Ender!

Provali online!

— aloisdg dice Reinstate Monica
fonte
@ TùxCräftîñg In effetti, ma è facile da leggere in questo modo. Controlla la mia versione golfata per una risposta meno dettagliata :)
— aloisdg dice Reinstate Monica il
4

Perl, 40 24 + 1 = 25 byte

Usa lo stesso regex di Martin.
Usa la -pbandiera

s/(.)(?!\1)(?i)\1/\1/g

Provalo su ideone

— TuxCrafting
fonte
Se usi il flag -p, puoi rimuovere quasi tutto il tuo codice tranne la s /// per un buon salvataggio!
— Dom Hastings,
4

C, 66 byte

l;main(c){for(;~(c=getchar());)l=l^c^32|!isalpha(c)?putchar(c):0;}
— orlp
fonte
3

Pyth, 24 20 byte

4 byte grazie a @Jakube.

Questo utilizza ancora regex, ma solo per la tokenizzazione.

shM:zj\|+s_BVGrG1\.1

Suite di test.

shM:zj\|+s_BVGrG1\.1   input as z
         s_BVGrG1      generate ['aA', 'Aa', 'bB', 'Bb', ..., 'zZ', 'Zz']
        +        \.    add "." to the back of the array
     j\|               insert "|" between every element of the array,
                       forming a new long string, which will be our
                       tokenizer: "aA|Aa|bB|Bb|cC|Cc|...|yY|Yy|zZ|Zz|."
                       the "." at the end is to capture the remaining characters
  :z               1   return all matches of z against that regex
                       this is effectively a tokenizer
 hM                    take the first character of each token
s                      join all the transformed tokens together, and then
                       implicitly print to STDOUT.
  • Versione a 24 byte qui .
— Perdente Suora
fonte
3

JavaScript (ES6), 71 68 byte

s=>s.replace(/./g,c=>l=c!=l&&c>'0'&&parseInt(c+l,36)%37<1?'':c,l='')

Spiegazione:

s=>s.replace(/./g,c=>   Loop over each character in the string
 l=                     Save result for next loop
  c!=l&&                Check whether characters differ
  c>'@'&&               Check minimum character code
  parseInt(c+l,36)%37<1 Check if characters have same value
  ?'':c,                If so then delete this character
 l='')                  Initial empty previous character

Dato c>'@', l'unico modo per parseInt(c+l,36)essere un multiplo di 37 è per entrambi ce lavere lo stesso valore (non possono avere valore zero perché abbiamo escluso spazio e zero, e se non hanno valore allora l'espressione valuterà NaN<1quale è false) è per loro essere la stessa lettera. Tuttavia, sappiamo che non sono la stessa lettera sensibile al maiuscolo / minuscolo, quindi devono essere la stessa distinzione tra maiuscole e minuscole.

Nota che questo algoritmo funziona solo se controllo tutti i personaggi; se provo a semplificarlo abbinando le lettere, fallirà su cose del genere "a+A".

Modifica: salvato 3 byte grazie a @ edc65.

— Neil
fonte
Usa sostituisci invece di mappa. 68. Ma sono troppo pigro per capire come inserire '' 'all'interno di un commento (bel trucco mod 37)
— edc65
@ edc65 Non ho bisogno di nessun `se lo uso replace. (Li avevo solo prima per cercare di essere coerenti, ma poi ho golfato la mia risposta mentre la modificavo per l'invio e sono diventato di nuovo incoerente. Sospiro ...)
— Neil
3

C, 129 127 125 107 106 105 93 92 90 88 85 78 byte

c;d;f(char*s){for(;putchar(c=*s);)s+=isalpha(c)*(d=*++s)&&(!((c^d)&95)&&c^d);}

Porta AC della mia risposta C # . La mia C potrebbe essere un po 'male. Non uso più la lingua molto. Qualsiasi aiuto è il benvenuto!

  • 1 byte salvato grazie al trucco di Lowjacker : a!=b=a^b
  • 1 byte salvato grazie al trucco di Walpen : a&&b=a*b
  • 12 byte salvati dal trucco di Lynn e ispirati qui da TùxCräftîñg
  • 1 byte salvato grazie al trucco di Joey Adams e ispirato qui da orlp: spostamento della variabile in globale
  • 2 byte salvati da SEJPM risolvendo il mio (c|32)==(d|32)problema bit a bit
  • 5 byte salvati da Pietu1998

Codice:

c;d;f(char*s) {
    for(;putchar(c=*s);)
        s+=isalpha(c)*(d=*++s)&&(!((c^d)&95)&&c^d);
}

Provalo online!

— aloisdg dice Reinstate Monica
fonte
1
Penso che puoi aumentare il puntatore per salvare alcuni byte. Ho trovato questo (non testato):f(char*s){while(*s) {char c=*s,d=s+1;putchar(c);s+=isalpha(c)&&d&&((c|32)==(d|32)&&c!=d);}}
— TuxCrafting
@ TùxCräftîñg Mi sono dimenticato di questo. Ho corretto la tua proposta in base alla risposta di Lynn. Grazie per l'aiuto!
— aloisdg dice Reinstate Monica il
1
Penso che tu possa cambiare s+++1in ++s.
— PurkkaKoodari,
@ Pietu1998 In effetti posso!
— aloisdg dice Reinstate Monica il
1
ce dsarà sempre stampabile ASCII, quindi 95dovrebbe funzionare al posto di ~32. Inoltre, penso c;d;f(char*s){for(;*s;){putchar(c=*s);s+=isalpha(c)*(d=*(++s))&&(!((c^d)&95)&&c^d);}}che funzionerebbe (ma non testato).
— PurkkaKoodari,
3

MATL , 21 byte

"Kk@k=K@XK=>?4XKx}K&h

Provalo online! . Oppure verifica tutti i casi di test .

Spiegazione

Questo elabora ogni personaggio in un ciclo. Ogni iterazione confronta il carattere corrente con il carattere precedente. Quest'ultimo è memorizzato negli Appunti K, che è inizializzato per 4impostazione predefinita.

Il carattere attuale viene confrontato due volte con il precedente: prima senza distinzione tra maiuscole e minuscole e poi con distinzione tra maiuscole e minuscole. Il carattere corrente dovrebbe essere eliminato se e solo se il primo confronto fosse vero e il secondo fosse falso. Nota che, poiché gli appunti K inizialmente contengono 4, il primo carattere verrà sempre mantenuto.

Se il carattere corrente viene cancellato, gli Appunti K devono essere ripristinati (quindi il carattere successivo verrà mantenuto); altrimenti dovrebbe essere aggiornato con il carattere corrente.

"            % Take input string implicitly. For each char from this string:
  K          %   Push previous char, initiallized to number 4
  k          %   Convert to lower case. For numbers it rounds down
  @          %   Push current char
  k          %   Convert to lower case. 
  =          %   True if current and previous chars are (case-insensitively) equal
  K          %   Push previous char
  @          %   Push current char
  XK         %   Update clipboard K with current char. This doesn't affect the stack
  =          %   True if current and previous chars are (case-sensitively) equal
  >?         %   If first comparison was true and second was false
    4XKx     %     Reset clipboard K to 4
  }          %   Else
    K        %     Push previous char
    &h       %     Concatenate horizontally to gradually build the output string
— Luis Mendo
fonte
2

Java 7, 66 byte

String c(String i){return i.replaceAll("(.)(?!\\1)(?i)\\1","$1");}

Ho usato la regex di Martin Ender dalla sua risposta Retina .

Codice non testato e test:

Provalo qui.

class Main{
  static String c(String i){
    return i.replaceAll("(.)(?!\\1)(?i)\\1", "$1");
  }

  public static void main(String[] a){
    System.out.println(c("bBaAdD"));
    System.out.println(c("NniIcCeE"));
    System.out.println(c("Tt eE Ss tT"));
    System.out.println(c("sS Ee tT"));
    System.out.println(c("1!1!1sStT!"));
    System.out.println(c("nN00bB"));
    System.out.println(c("(eE.gG.)"));
    System.out.println(c("Hh3lL|@!"));
    System.out.println(c("Aaa"));
    System.out.println(c("aaaaa"));
    System.out.println(c("aaAaa"));
  }
}

Produzione:

bad
Nice
T e S t
s E t
1!1!1st!
n00b
(e.g.)
H3l|@!
Aa
aaaaa
aaaa
— Kevin Cruijssen
fonte
2

JavaScript (ES6), 61 byte , 57 byte

s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')

Grazie a Neil per aver salvato 5 byte.

— CPU1
fonte
1
Cattive notizie: hai contato male, e in realtà sono 62 byte. Buone notizie: posso salvarti cinque byte! s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')
— Neil,
Oh, scusa, ho contato usando "code".length, non mi ero reso conto che ci fosse una sequenza di fuga lì dentro. Grazie
— cPu1
Prova a usare (code).toString().length.
— Neil,
Sì, oppure(code+"").length
— cPu1
1

JavaScript (ES6) 70

(s,p,q)=>s.replace(/./g,c=>p!=c&q===(d=parseInt(c,36))?q='':(q=d,p=c))

f=(s,p,q)=>s.replace(/./g,c=>p!=c&q===(d=parseInt(c,36))?q='':(q=d,p=c))

;
[['bBaAdD','bad']
,['NniIcCeE','Nice']
,['Tt eE Ss tT','T e S t']
,['sS Ee tT','s E t']
,['1!1!1sStT!','1!1!1st!']
,['nN00bB','n00b']
,['(eE.gG.)','(e.g.)']
,['Hh3lL|@!','H3l|@!']
,['Aaa','Aa']
,['aaaaa','aaaaa']
,['aaAaa','aaaa']]
.forEach(
  x=>
  {
    var i=x[0],k=x[1],r=f(i)
    console.log(k==r?'OK':'KO',i,r)
  }
)
Espandi frammento

— edc65
fonte
OK, ti mordo. Perché il ===?
— Neil,
0==""ma non 0===""@Neil
— edc65,
1

Convesso, 18 byte

V±V.+'.+'|*\ô{0=}%

Provalo online!

Approccio simile alla risposta Pyth di @Leaky Nun . Costruisce l'array ["aA" "bB" ... "zZ" "Aa" "Bb" ... "Zz" '.], si unisce al '|carattere e verifica l'input in base a quel regex. Quindi prende il primo personaggio di ogni partita.

— GamrCorps
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.