Descrizione del compito

A volte, devi davvero adattare qualcosa che stai scrivendo in un piccolo spazio. Potrebbe essere allettante lasciare cadere le vocali e scriverle - e, in mancanza, chi ha davvero bisogno di spazi? Thssprfctlrdbl! ^†

Scrivere una funzione o un programma che rimuova le vocali minuscole aeiou, quindi gli spazi e quindi tutti i caratteri da una stringa di input . Inoltre, ogni volta che rimuovi un personaggio, questo deve essere il personaggio più a destra idoneo per la rimozione. Deve ripetere questo processo fino a quando la stringa non è più lunga di una determinata lunghezza di input .

^{† "Questo è perfettamente leggibile!" Ma se stai leggendo questa nota, probabilmente non lo è, davvero ... :)}

Esempi

Qui puoi vedere questo processo applicato per dimensioni di input successivamente inferiori:

23: Hello, Code Golf World!
22: Hello, Code Golf Wrld!
21: Hello, Code Glf Wrld!
20: Hello, Cod Glf Wrld!
19: Hello, Cd Glf Wrld!
18: Hell, Cd Glf Wrld!
17: Hll, Cd Glf Wrld!
16: Hll, Cd GlfWrld!
15: Hll, CdGlfWrld!
14: Hll,CdGlfWrld!
13: Hll,CdGlfWrld
12: Hll,CdGlfWrl
11: Hll,CdGlfWr
(etc.)

Dopo aver schiacciato la stringa fino a 17 caratteri, esauriamo le vocali da rimuovere, quindi il carattere successivo che rimuoviamo è lo spazio più a destra; quando colpiamo 14 caratteri, abbiamo rimosso tutte le vocali e gli spazi, quindi iniziamo semplicemente a sgranocchiare la corda da destra a sinistra.

Ecco alcuni pseudocodici codice Python che risolve questa sfida:

def crunch_string(string, to_length):
    while len(string) > to_length:
        # Store the best candidate index for deletion here.
        best = None

        # First, find the rightmost vowel's index.
        for i in range(len(string)):
            if string[i] in 'aeiou':
                best = i

        # If there were no vowels, find the rightmost space's index.
        if best is None:
            for i in range(len(string)):
                if string[i] == ' ':
                    best = i

        # If there were no spaces either, use the final index.
        if best is None:
            best = len(string) - 1

        # Remove the selected character from the string.
        string = string[:best] + string[best + 1:]

    # Return the string once `len(string) <= to_length`.
    return string

Regole

• Questo è code-golf , quindi vince il codice più breve in byte.

• La stringa di input sarà composta dai caratteri ASCII stampabili dallo spazio ( , decimale 32) fino alla tilde inclusa ( ~, decimale 126). Non ci saranno vocali maiuscole AEIOUnella stringa. In particolare, non ci saranno Unicode, tab o newline coinvolti.

• Chiamare la stringa di input s e la lunghezza target di input t . Quindi è garantita 0 <t ≤ lunghezza ( s ) ≤ 10000. (In particolare, la stringa di input non sarà mai vuota. Se t = length ( s ), dovresti semplicemente restituire la stringa non modificata.)

Casi test

Input:  50, Duis commodo scelerisque ex, ac consectetur metus rhoncus.
Output: Duis commodo scelerisque ex, ac cnscttr mts rhncs.

Input:  20, Maecenas tincidunt dictum nunc id facilisis.
Output: Mcnstncdntdctmnncdfc

Input:  150, golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf
Output: glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glfglfglfglfglfglfglfglfglfglf

MATL , 20 byte

t11Y2mEG32=+K#Si:)S)

Provalo online!

t       % implicitly input string. Duplicate
11Y2    % predefined literal 'aeiou'
m       % ismember. Gives true for input characters that are vowels
E       % multiply by 2
G       % push input string again
32      % ASCII for space
=       % gives true for input characters that are spaces
+       % add: gives 2 for vowels, 1 for space, 0 for non-vowels-and-non space
K#S     % sort and push only the indices of the sorting. Sorting is stable, so first 
        % will be non-vowels-and-non space characters in their original order, then
        % spaces in their original order, then vowels in their original order
i       % input number n of characters that should be kept
:       % range [1,2,...,n]
)       % index with that: keep first n indices of the sorting
S       % sort those indices to restore their original order
)       % index into input string to keep only those characters. Implicitly display

Perl, 48 45 43 byte

Include +4 per -Xlpi(-X può essere lasciato fuori ma lascia brutti avvertimenti su STDERR)

Esegui con il numero dopo l' -iopzione e l'input su STDIN (supporta anche più righe). per esempioperl -Xlpi50 crunch.pl <<< "Duis commodo scelerisque ex, ac consectetur metus rhoncus."

crunch.pl:

s/.*\K[aeiou]|.*\K |.$// while pos=-$^I

JavaScript (ES6), 66 61 byte

5 byte salvati grazie a @Neil

f=(s,n)=>s[n]?f(s.replace(/(.*)[aeiou]|(.*) |.$/,"$1$2"),n):s

Non credo che il regex sia ulteriormente giocabile a golf. Sorprendentemente, il più breve che posso trovare per rimuovere front-to-back è un byte più lungo:

f=(s,n)=>s[n]?f(s.replace(/(.*?)[aeiou]|(.*?) |./,"$1$2"),n):s

Tentativo più interessante (ES7), 134 byte

(s,n,i=0)=>[for(c of s)[/[aeiou]/.test(c)*2+(c<'!'),i++,c]].sort(([x],[y])=>x-y).slice(0,n).sort(([,x],[,y])=>x-y).map(x=>x[2]).join``

Questo utilizza un approccio simile alla risposta MATL.

sh + gnu sed, 78 61

Fornire la stringa a STDIN, la lunghezza come primo argomento.

rev|sed -r ":                       # reverse + invoke sed + jump label ":"
/..{$1}/!q                          # if the length is not greater $1, quit
p                                   # print
s/[aeiou]//                         # delete the first vowel
t                                   # if successful, start over at ":"
s/ //                               # delete the first space
t                                   # if successful, start over at ":"
s/.//                               # delete the first character
t"|rev                              # if successful, start over at ":" + reverse

Lua, 120 byte

s=arg[2]:reverse()a=s:len()-arg[1]s,n=s:gsub('[aeiou]','',a)s,m=s:gsub(' ','',a-n)print(s:gsub('.','',a-n-m):reverse())

Accetta input come argomenti della riga di comando, nel formato lua crunch.lua 10 "This is a string", con output Ths sstrng.

Spiegazione:

-- Set 's' to the reverse of the string
s=arg[2]:reverse()
-- Set 'a' to the number of characters to be removed
a=s:len()-arg[1]
-- Remove 'a' vowels, set 'b' to the number of substitutions
s,b=s:gsub('[aeiou]','',a)
-- Remove 'a-b' spaces, set 'c' to the number of substitutions
s,c=s:gsub(' ','',a-b)
-- Remove 'a-b-c' characters, and print the now un-reversed string
print(s:gsub('.','',a-b-c):reverse())

Perl, 68

La rimozione da destra aggiunge una tonnellata di personaggi, forse c'è un modo migliore per farlo.

$_=reverse;while(length>$^I){s/[aeiou]//||s/ //||s/.//}$_=reverse

Utilizzare -iper inserire il numero. Si tratta di 65 caratteri più 3 per il i, pe lsulla linea di comando.

Corri con:

echo 'Hello, Code Golf World!' | perl -i13 -ple'$_=reverse;while(length>$^I){s/[aeiou]//||s/ //||s/.//}$_=reverse'

Java 8, 303 byte

(s,j)->{String t="";for(int i=s.length()-1;i>=0;t+=s.charAt(i--));while(t.length()>j&&t.matches(".*[aeiou].*"))t=t.replaceFirst("[aeiou]","");while(t.length()>j&&t.contains(" "))t=t.replaceFirst("\\s","");s="";for(int i=t.length()-1;i>=0;s+=t.charAt(i--));return s.substring(0,Math.min(t.length(),j));};

Questo è MODO troppo lungo. Cercherò di accorciarlo presto. Sarebbe molto più breve se java avesse un metodo per invertire le stringhe e le sostituzioni all'indietro.

Prova con quanto segue:

public class StringCruncher {
    public static void main(String[] args) {
        Tester test = (s,j)->{String t="";for(int i=s.length()-1;i>=0;t+=s.charAt(i--));while(t.length()>j&&t.matches(".*[aeiou].*"))t=t.replaceFirst("[aeiou]","");while(t.length()>j&&t.contains(" "))t=t.replaceFirst("\\s","");s="";for(int i=t.length()-1;i>=0;s+=t.charAt(i--));return s.substring(0,Math.min(t.length(),j));};
        System.out.println(test.crunch("golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf", 150));
    }
}
interface Tester {
    String crunch(String s, int j);
}

C #, 180 byte

string c(int l,string s){while(s.Length>l){int i=0;Func<string,bool>f=t=>(i=s.LastIndexOfAny(t.ToCharArray()))!=-1;if(!(f("aeiou")||f(" ")))i=s.Length-1;s=s.Remove(i,1);}return s;}

Tester:

using System;
class Crunch
{
    static int Main()
    {
        var x = new Crunch();
        Console.WriteLine(x.c(50, "Duis commodo scelerisque ex, ac consectetur metus rhoncus."));
        Console.WriteLine(x.c(20, "Maecenas tincidunt dictum nunc id facilisis."));
        Console.WriteLine(x.c(150, "golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf"));
        Console.Read();
        return 0;
    }
    string c(int l,string s){while(s.Length>l){int i=0;Func<string,bool>f=t=>(i=s.LastIndexOfAny(t.ToCharArray()))!=-1;if(!(f("aeiou")||f(" ")))i=s.Length-1;s=s.Remove(i,1);}return s;}

    static string crunch(int len, string str)
    {
        Console.WriteLine($"{str.Length}: {str}");
        while (str.Length > len) {
            int idx=0;
            Func<string,bool> f = s => (idx = str.LastIndexOfAny(s.ToCharArray()))!= -1;
            if (!(f("aeiou") || f(" "))) idx = str.Length-1;
            str = str.Remove(idx,1);
            Console.WriteLine($"{str.Length}: {str}");
        }
        return str;
    }
}

Scala, 160 byte

type S=String;def f(s:S,l:Int)={def r(s:S,p:S):S=if(s.size>l){val j=s.replaceFirst("(?s)(.*)"+p,"$1");if(j==s)s else r(j,p)}else s;r(r(r(s,"[aeiou]")," "),".")}

Tester:

val t="Hello, Code Golf World!"
println((t.size to 11 by -1).map(f(t,_)).mkString("\n"))

Dyalog APL, 77 45 42 byte

t[⌽i~⌽⎕↓⌽∪∊(t∊'aeiou')(' '=t)1/¨⊂i←⍳⍴t←⌽⍞]

t[... ]lettere di t con indici ...
t←⌽⍞ t ottiene l'input di testo invertito
i←⍳⍴t i ottiene indici di lunghezza di t
/¨⊂i multipli (3) selezioni booleane di elementi di i :
1. (t∊'aeiou')booleano dove vocale
2. (' '=t)booleano dove spazio
3. 1tutto ∪∊unico degli arruolati ( appiattito) 3 selezioni
⌽⎕↓⌽rilasciano gli ultimi caratteri inseriti (identici a (-⎕)↓)
⌽i~invertono gli indici rimanenti dopo averne rimosso alcuni

Risposta originale:

⎕{⍺≥≢⍵:⌽⍵⋄∨/⍵∊⍨v←'aeiou':⍺∇⍵/⍨~<\(⍳⍴⍵)∊⍵⍳v⋄' '∊⍵:⍺∇⍵/⍨~<\(⍳⍴⍵)=⍵⍳' '⋄⍺∇1↓⍵}⌽⍞

Ehm, sì, è un po 'difficile da leggere. Fondamentalmente la traduzione diretta di OP in APL:

1. Ingresso inverso.
2. Se la lunghezza richiesta è maggiore o uguale al conteggio della stringa di input (invertita), restituisce l'argomento invertito (invertito).
3. Altrimenti, se l'argomento ha una vocale, rimuovi il primo (cioè l'ultimo) e chiama ricorsivamente su ciò che rimane.
4. Altrimenti, se l'argomento ha spazio, rimuovi il primo (cioè l'ultimo) e chiama ricorsivamente su ciò che rimane.
5. Altrimenti, rimuovi il primo (cioè l'ultimo) carattere e chiama ricorsivamente su ciò che rimane.

Mathematica, 201 byte

f@x_:=StringReplaceList[x,"a"|"e"|"i"|"o"|"u"->""];g@x_:=StringReplaceList[x," "->""];x_~l~y_:=NestWhile[If[f@#!={},Last@f@#,If[g@#!={},Last@g@#,Last@StringReplaceList[#,_->""]]]&,x,StringLength@#!=y&]

Deve esserci un modo migliore di questo ..

R, 169 143 byte

function(x,y){d=utf8ToInt(x);o=c(rev(which(d%in%utf8ToInt('aeiou'))),rev(which(d==32)));intToUtf8(d[sort(tail(c(o,setdiff(nchar(x):1,o)),y))])}

* modifica 36 byte salvati mediante riscrittura con utf8ToInt->intToUtf8 conversioni no strstplitepaste0(...,collapse)

non golfato con spiegazione

function(x,y){d=utf8ToInt(x);         # convert string (x) to integer
o=c(
 rev(which(d%in%utf8ToInt('aeiou'))), # index of vowels (reversed)
 rev(which(d==32)));                  # index of spaces
 intToUtf8(d[                         # convert subset back to character
   sort(tail(                         # return the first y index of 
                                      # "left over" characters
   c(o,setdiff(nchar(x):1,o))         # combine vowels, spaces and 
                                      # other indices in appropriate order
  ,y))])}