Rimuovi più di n vocali consecutive dalla stringa di input

19

Non mi piacciono le corde con più di tre vocali di fila. Puoi scrivere un programma che rimuove dalle parole tutte le vocali che non voglio?

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

L'input è una stringa contenente solo caratteri ASCII stampabili (da 0x20 a 0x7E, inclusi).

L'output è una stringa contenente solo corse di al massimo 3 vocali consecutive. Se nella stringa di input sono presenti più di 3 vocali consecutive, il programma dovrebbe produrre una stringa di output che includa le prime tre vocali rilevate in quella corsa, eliminando eventuali vocali consecutive.

Y non è una vocale ai fini di questa sfida.

Questo è il codice golf, quindi vince il codice più breve (in byte).

Casi test

"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."
code-golf  string 
— Joseph Weissman
fonte
2
Dovresti includere altri test con casi misti, come aaYYAAaaaAERGH.
— Zgarb,

Risposte:

5

Pyth, 21 byte

sfg3=Z&}rT0"aeiou"hZz

Provalo online: Dimostrazione o Test Suite

Spiegazione:

Esamino tutti i caratteri e tengo traccia di quante vocali ho passato usando un contatore. Ogni volta che passo un carattere, che non è una vocale, reimposto il contatore a 0. Ricomincio i caratteri, ogni volta che il contatore è> 4.

sfg3=Z&}rT0"aeiou"hZz   implicit: z = input string
                                  Z = 0
 f                  z   test every char T in z; keep chars, that return true:
        rT0                convert T to lower
       }   "aeiou"         test if T is a vowel
      &           hZ       logical and with Z+1, 
                           gives 0 if ^ is false, otherwise Z+1
    =Z                     update Z with this value
  g3                       test if 3 >= Z
s                       sum up all remaining chars and print
— Jakube
fonte
10

Illeggibile , 1647 byte

' '' '' ' ' '''' '' '' ' ' '' ' ' '' '' '''' ' ' '''' '''' '' '' '' '' "'" "" "" "" "" ' '' '' '' '' ' ' '' '' '''' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' ''""" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '' ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' ''""" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' ''"" ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '' ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' '''"" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' ''" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" ' '' "' '' '' ''" "" ' '' '' ''' "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" """" "' '' '' ''" ' '' ' ' '' '' '' '' ' ' '' '' '''' '''' '' '' '' "' '' '' "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' "' '' "' '' '' '' ''"' '' ''" "' '' ' ' '' '' '' '''' '' '' '' ' ' '' '' '' '''' '' '' ''"' '' ''"" "" ' '' '' '' ''' "" "" "" " ' '' ' ' '' '' '' '' ' ' '' '' '''' '''' '' "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '' ' '' '' '' "' '' ' ' '' '' '' '' ' ' '' '' '''' '''' '' '' '' "' ''""" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '' ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "' '' ' ' '' '' '' '' ' ' '' '' '''' '''' '' '' ''"' '' '' '' ''' '' '' '' ''' "" "" "" "" ' '' '' '' "' '' "' '' '' '' '' ' ' '' '' ''''" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" "' '' '' ''" ' '' "' "" "" "" "" " ' '' '' '''" "" ' '' '' '' ''' "" "" "" "" ' '' '' ''"" ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" ' '' "' '' '' '' ''" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ''' "" "" "" "" ' '' '' '' ' ' '' ' ' '' '' '' '''' '''' ''' "" "' ''" ' '' "'"" "' ''" ' '' "' '' "' ''" ' ''"' '' '' '' '' ' ' '''' ' ' '''' " ' '' '' "" ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' "" "'" ' '' '' '' ' ' '''' "' "" " ' '' '' '''" " ' '' ' ' '''' '' '' '''" " ' '' ' ' '' '''''" "" """" ' ''' "" ' '' ' ' '' '' '''' "' '' ' ' '' '' '' '''' ''

Spiegazione

Questo programma equivale a pseudocodice in questo modo:

while (cp = (ch = read)) + 1 {
    (
        (cp -= 65) ?    // A
            (cp -= 4) ?     // E
                (cp -= 4) ?     // I
                    (cp -= 6) ?     // O
                        (cp -= 6) ?     // U
                            (cp -= 12) ?    // a
                                (cp -= 4) ?     // e
                                    (cp -= 4) ?     // i
                                        (cp -= 6) ?     // o
                                            (cp - 6) ?      // u
                                                0
                                            : 1
                                        : 1
                                    : 1
                                : 1
                            : 1
                        : 1
                    : 1
                : 1
            : 1
        : 1
    ) ? ((--vs)+4) ? print(ch) : (++vs) : {
        print(ch)
        vs = 0
    }
}

con le seguenti assegnazioni variabili:

0   (unused)   (13 bytes)
1   cp         ( 4 bytes; occurs 20× in the code)
2   vs         ( 7 bytes; occurs  5× in the code)
3   ch         (10 bytes; occurs  3× in the code)

Come puoi vedere, ho evitato lo slot variabile 0 perché 0è una costante così lunga da scrivere.

Quindi leggiamo ogni personaggio e memorizziamo il valore in entrambi cpe ch. Modificheremo cpma ci terremo in chgiro in modo da poterlo stampare se necessario. Sottraggiamo successivamente i numeri 65, 4, 4, 6, ecc. cpPer verificare se si tratta di ciascuno dei 10 possibili caratteri vocali in ASCII (nota che l'ultimo non deve essere un compito).

vscontiene sempre 3 in meno del numero di vocali che è ancora possibile stampare. Inizia da 0, quindi è possibile stampare 3 vocali. Quando raggiunge -3, smettiamo di stampare vocali.

Se incontriamo una non vocale (incluso lo spazio), eseguiamo print(ch)seguito da vs = 0. Come probabilmente hai indovinato, questo azzera il contatore delle vocali.

Se incontriamo una vocale , eseguiamo ((--vs)+4) ? print(ch) : (++vs). Analizziamo questo:

  • decremento vs;
  • se il valore è ora -4, siamo andati troppo lontano, quindi non stampare nulla, ma incrementare di vsnuovo in -3modo che continueremo a rifiutare di stampare vocali;
  • altrimenti, stampa il personaggio.
— Timwi
fonte
1
Questa lingua è fedele al suo nome.
— bkul,
2
Mi chiedo sempre in queste lingue ... "In realtà l'hanno scritto a mano? In tal caso, li compatisco ..." +1
— Addison Crump,
9

Retina , 25 byte

i`([aeiou]{3})[aeiou]+
$1

Provalo online.

Sostituzione regex abbastanza semplice. Questo funziona anche per lo stesso conteggio byte:

Ri`(?<=[aeiou]{3})[aeiou]
— Martin Ender
fonte
3
Infine! Un interprete online! Dovresti prendere in considerazione il collegamento ad esso sulla tua pagina github.
— mbomb007,
6

JavaScript (ES6), 42

Come una funzione anonima

s=>s.replace(/[aeiou]+/gi,v=>v.slice(0,3))
— edc65
fonte
4

Perl, 27 caratteri

(Codice 26 caratteri + opzione riga comandi 1 carattere)

s/[aeiou]{3}\K[aeiou]+//gi

Non è un grosso problema, solo un'occasione rara che ricordo \Kesiste.

Esecuzione di esempio:

bash-4.3$ perl -pe 's/[aeiou]{3}\K[aeiou]+//gi' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.
— uomo al lavoro
fonte
2
Quando ho scritto la risposta Retina ho pensato "Vorrei che regex .NET avesse \K". :)
— Martin Ender il
Interessante, @ MartinBüttner. Ho avuto la sensazione che quelle espressioni regolari fossero messe a dieta con steroidi. Per curiosità, hanno un subpattern ricorsivo? Può aiutare a ricambio enumerazione una vocale, anche se il risultato è più lungo: s/([aeiou]{1,3})(?1)+/$1/gi.
— arte
Sfortunatamente, non hanno nemmeno il riutilizzo dei modelli. Queste sono le due cose che occasionalmente mi fanno passare a Perl o PCRE. Quando cerco di applicare alcune semplici cose al sapore regex di Retina, penso che le aggiungerò (non una vera ricorsione, ma almeno un riutilizzo del modello e una ricorsione finita).
— Martin Ender,
2

Scherzi a parte, 34 byte

,;ù0╗`Ok"aeiou"Okd-Y;╜+*;╗4>`M@░εj

Dump esadecimale:

2c3b9730bb604f6b226165696f75224f6b
642d593bbd2b2a3bbb343e604d40b0ee6a

Provalo online

Utilizza lo stesso algoritmo della risposta Pyth, mappando sulla stringa tenendo traccia della lunghezza della corsa corrente delle vocali in un registro, incrementandola ogni volta che il carattere corrente è una vocale e controllando se ha superato la lunghezza consentita, restituendo 0 in tal caso, quindi filtrando la stringa originale con questo filtro generato. Sarà molto più breve una volta che possiamo usare la sottrazione impostata sulle stringhe. (È Okpossibile eliminare e Okdsostituire con solo @). Ho sentito che questa funzione arriverà nel prossimo aggiornamento ....

— quintopia
fonte
2

C, 166 byte

non è la risposta più breve di gran lunga ma piacevolmente giocata a golf penso ..

#define V v[1][i]!=
#define P printf("%c",v[1][i]),j
j;main(i,v)char**v;{for(i=0;V 0;i++)(V 97&V 'e'&V 'i'&V 'o'&V 'u'&V 65&V 69&V 73&V 79&V 85)?P=0:j>3?j++:P++;}

caso di prova:

$ a.exe "We're queueing up for the Hawaiian movie."

We're queung up for the Hawaiin movie.

$ wc -c vowels.c 

166 vowels.c
— cleblanc
fonte
2

Mathematica, 68 byte

a=Characters@"aeiouAEIOU";StringReplace[#,b:a~Repeated~{3}~~a..:>b]&

La risposta regex sarebbe della stessa lunghezza, ma chi usa regex?

— LegionMammal978
fonte
2

Java, 115 byte

class a{public static void main(String[] a){System.out.println(a[0].replaceAll("(?i)([aeiou]{3})[aeiou]*","$1"));}}

Prevede input come parametro del programma.

Uscita test unitario:

Aei
screeen
We're queung up for the Hawaiin movie.
— Tomas Langer
fonte
Salvare un byte rimuovendo lo spazio tra String[]e a. String[]a
— Colpisci il
Salva 2 byte usando printanziché println. Non credo che le specifiche richiedano una nuova riga finale.
— Colpisci il
2

APL, 40 caratteri

{⍵/⍨1↓4≠⊃+/(1-⍳4)⌽¨⊂'aeiouAEIOU'∊⍨' ',⍵}

In inglese:

  • 'aeiouAEIOU'∊⍨' ',⍵: trova le vocali (e anteponi uno spazio per interrompere la rotazione);
  • (1-⍳4)⌽¨⊂: ruota 0, 1, 2, 3 volte (con avvolgimento) spingendo a destra il vettore booleano;
  • ⊃+/ sum: le rotazioni e unbox
  • 1↓4≠: trova il diverso da 4, e rimuovi il primo (per cercare lo spazio che abbiamo anteposto)
  • ⍵/⍨: nell'argomento, mantenere solo l'elemento in cui la somma era diversa da 4.
— lstefano
fonte
1

Perl 6 ,  36  35 byte

{S:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/} # 36 bytes

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' # 34 + 1 = 35 bytes

utilizzo:

$ perl6 -pe 's:g:i/(<[aeiou]>**3)<[aeiou]>+/$0/' <<< "
> Aeiou
> screeeen
> We're queueing up for the Hawaiian movie.
> Spaces break runs: aei iou."
Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.
— Brad Gilbert b2gills
fonte
1

C (205 byte)

#include <stdio.h>
#define T(x)for(i=0;i<10;++i){if(v[i]==x){b=x;m=1;break;}}putchar(c);
main(b,c,i,m){char v[]="aeiouAEIOU";
while((c=getchar())!=EOF){if(!m){T(c);}else{if(b==c)continue;else{m=0;T(c);}}}}

(Una interruzione di riga aggiunta per maggiore chiarezza)

— musarithmia
fonte
1

Scala, 107 byte

readLine.foldLeft("",0)((a,n)=>if(!"aeiou".contains(n|32))a._1+n->0 else if(a._2>2)a else(a._1+n,a._2+1))_1
— Ruslan
fonte
1

Javascript ES6, 43 caratteri

s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")

Test:

f=s=>s.replace(/([aeiou]{3})[aeiou]*/gi,"$1")
;`"Aeiou" => "Aei"
"screeeen" => "screeen"
"We're queueing up for the Hawaiian movie." => "We're queung up for the Hawaiin movie."
"Spaces break runs: aei iou." => "Spaces break runs: aei iou."`
.replace(/"/g,"").split("\n").every(s=>f((s=s.split(" => "))[0])==s[1])
— Qwertiy
fonte
1

File .COM MS-DOS x86 , 44 byte 36 byte

I file .COM sono ampiamente supportati da MS-DOS 1 fino ad oggi --- Sto correndo in Dosemu, usando solo i comandi 8086.

Ridotto da 44 a 36 byte usando REPNE SCASB per testare le vocali invece di usare un comando separato per testare ogni vocale.

Hex dump, reversible using `xxd -r -seek -256`:
0100: b3 03 43 b4 08 cd 21 88 c2 24 df b1 05 bf 1f 01   ..C...!..$......
0110: f2 ae 74 02 b3 05 4b 74 e9 b4 02 cd 21 eb e4 41   ..t...Kt....!..A
0120: 45 49 4f 55                                       EIOU

Unassembled using debug:
0100 B303    MOV BL,03     ; initialize counter to 3 (will increment by 1 to be 4)
0102 43      INC BX        ; increment counter--runs each time it hits 0 so it never goes <0
0103 B408    MOV AH,08     ; 
0105 CD21    INT 21        ; with AH=8, read 1 char without echo
0107 88C2    MOV DL,AL     ; copy input for potential output
0109 24DF    AND AL,DF     ; make input uppercase for testing
010B B105    MOV CL,05     ; count of 5 vowels to test against
010D BF1F01  MOV DI,011F   ; location of first vowel to test against
0110 F2AE    REPNE SCASB   ; test input against each vowel
0112 7402    JZ 0116       ; if input was not a vowel:
0114 B305    MOV BL,05     ;    reset counter to 5 (will decrement by 1 to be 4)
0116 4B      DEC BX        ; decrement counter regardless
0117 74E9    JZ 0102       ; if hit 0 (fourth or later vowel): goto 102
0119 B402    MOV AH,02     ; 
011B CD21    INT 21        ; with AH=2, print char
011D EBE4    JMP 0103      ; go to 103 for next character

bytes 011f-0123 contain the uppercase vowels AEIOU
— krubo
fonte
1

Matlab / Octave, 54 byte

@(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

Esempio:

>> @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')
ans = 
    @(s)regexprep(s,'(?<=[aeiouAEIOU]{3})[aeiouAEIOU]','')

>> ans('We''re queueing up for the Hawaiian movie.')
ans =
We're queung up for the Hawaiin movie.

Provalo su ideone .

— Luis Mendo
fonte
1

V , 21 byte (non competitivo)

ñ[aeiou]ñÍãqû3}úsq*

Provalo online!

Spiegazione:

ñ[aeiou]ñ                     "Assign the string `[aeiou]` to register 'q'
         Íã                   "Search and replace on multiple lines (case insensitive):
           <C-r>q             "Register 'q'
                 û3}          "Repeated 3 times
                    ús        "Mark the following to be removed:
                      <C-r>q* "Register 'q' repeated any number of times

Questo è appena più breve della soluzione più semplice:

Íã[aeiou]û3}ús[aeiou]*

(22 byte)

— DJMcMayhem
fonte
0

Rubino, 44 ​​byte

><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')

Esempio:

% ruby -e "$><<$<.read.gsub(/([aeiou]{3})[aeiou]+/i,'\1')" <<< "
Aeiou
screeeen
We're queueing up for the Hawaiian movie.
Spaces break runs: aei iou."

Aei
screeen
We're queung up for the Hawaiin movie.
Spaces break runs: aei iou.
— Joseph Weissman
fonte
L'hai scritto: "L'input è una stringa che contiene solo caratteri ASCII stampabili (da 0x20 a 0x7E, inclusi)." Allora perché spendere caratteri extra $<.readper farlo gestire input multilinea (contenente quindi il carattere fuori campo 0x0a) invece di gets?
— arte
@manatwork è davvero un buon punto, grazie! Penso che potrebbe salvare 2-3 byte :)
— Joseph Weissman,
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.