Ispirazione : nel 1939, un uomo di nome Ernest Vincent Wright scrisse un romanzo chiamato Gadsby senza usare la lettera "e".

Il tuo compito è quello di scrivere una serie di (fino a 5) programmi in qualsiasi lingua (che abbia una sintassi basata su testo *) per produrre in ordine tutte le 26 lettere dell'alfabeto. Tuttavia, per ogni vocale aeiou, almeno uno dei programmi non deve includere alcuna occorrenza della vocale.

Quindi ci deve essere

• un programma che non utilizza " a " o " A " in nessun punto della sintassi del programma.
• un programma che non usa ' e ' o ' E ' in nessun punto della sintassi del programma.
• un programma che non utilizza " i " o " I " in nessun punto della sintassi del programma.
• un programma che non usa ' o ' o ' O ' in nessun punto della sintassi del programma.
• un programma che non usa ' u ' o ' U ' in nessun punto della sintassi del programma.

Tutti devono produrre abcdefghijklmnopqrstuvwxyz.

Il vincitore deve essere la soluzione in cui la lunghezza di tutti i programmi è la più breve.

_{* poiché il vincolo non rappresenterebbe una grande sfida in Piet o Whitespace}

Classifiche attuali (06 marzo 2014):

• A PL : 11
• B cenere : 31
• B efunge : 26
• B urlesque : 12
• B rainfuck : 38
• C : 84
• C # : 278/149
• Marmellata C : 6
• C lojure : 81
• D c : 18
• E rlang escript : 75
• F # : 96
• Attore F : 264
• Emissione F : 21
• F orto : 46
• G olfscript : 8
• H askell (interprete) : 12
• H TML : 50
• J : 17
• J ava : 137
• J avascript : 92

• K : 9

• K otlin : 112

• L ua : 57
• M arbelous : 96
• M ATLAB : 11
• P erl 5 (linea cmd) : 23
• P erl 5.10+ : 23
• P erl : 101
• P HP : 31
• P ostscript : 45
• P owershell : 62
• P shell ython : 48
• P ython : 83
• R : 36
• R ebmu : 15
• R uby : 20
• R uby 1.8 : 18
• S cala : 55
• CLI S age : 42
• T cl : 49
• T- SQL : 120
• V BA : 70

Golfscript - 8 caratteri

123,97>+

Brainfuck, 38 caratteri

++++++[->++++<]>[->+>++++<<]>++[->+.<]

Naturalmente non ci sono vocali (o altre lettere) nella sintassi del brainfuck .

PHP, 31 byte

No a, e, i, o, u:

<?=~žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…;

La stringa binaria dopo la tilde ha la seguente rappresentazione esadecimale:

\x9e\x9d\x9c\x9b\x9a\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90\x8f\x8e\x8d\x8c\x8b\x8a\x89\x88\x87\x86\x85

Dal momento che esiste un quadro di valutazione della lingua, posso anche inviare questo:

Ruby (v1.8) 18 byte

$><<[*97.chr..'z']

Ruby ( 24 22)

Modifica: le parentesi possono essere omesse, 2 caratteri in meno:

$><<'%c'*26%[*97..122]

24 caratteri in Ruby:

$><<('%c'*26)%[*97..122]

Come funziona

$>è un alias per $stdouto STDOUT. Puoi scriverci usando l' <<operatore. Il termine '%c'*26ripete la stringa '%c'26 volte. L' %operatore è definito su String come alias sprintf, quindi str % valequivale a scrivere sprintf(str,val). Il carattere di formato %cviene utilizzato per trasformare un valore char in char. Questi valori provengono da [*97..122]cui crea un array contenente i valori da 97 a 122. Et voilá!

Pyth , 1 personaggio

G

Pyth predefinisce alcune variabili. G è predefinito come alfabeto minuscolo. Pyth inoltre stampa implicitamente ogni riga con un valore di ritorno ragionevole.

JavaScript (100)

No 'aeou':

this['\x61l\x65rt']('\x61bcd\x65fghijklmn\x6fpqrst\x75vwxyz')

No "i":

alert('abcdefgh\x69jklmnopqrstuvwxyz')

K, 9

_26#.Q.b6

K, 10

"c"$97+!26

K, 14

.:".Q.","c"$97

J, 26 23 17 16 caratteri

Dopo un'ora o così rovistare nel cassetto della biancheria di J ho finalmente trovato un modo per eliminare l' a.e u:verbi.

2(3!:4)96+#\26$1

In precedenza:

a.{~96++/\26$1
u:97+i.26

grazie a randomra per il #\trucco.

R, 17 + 19 = 36 caratteri

no ae (17):

intToUtf8(97:122)

no iou (19):

cat(letters,sep="")

Bash (38)

Nessuna vocale.

/*/*/*ntf "/*/?ch? {\x61..z}"|/*/b?sh

C, 90 88 84 caratteri

Compilare usando gcc -nostartfiles

b;_exit(){for(;b<26;)printf("%c",b+++97);}    // 42 chars, works for a, u
b;_start(){putchar(b+++97)>121?:_start();}    // 42 chars, works for e, i, o

Golfscript, 10 caratteri

26,{97+}%+

Rubino, 20 caratteri

$><<[*97.chr..?z]*''

• 97.chr è un modo elaborato per dire "a"
• .. specifica un intervallo
• ?z è un modo più breve di dire "z"
• le [*range]cause della gamma di splat al suoi valori in un array
• *''è lo stesso di join(''); incolla tutti i valori di array insieme.
• $><< Perlicismo: stampa su stdout.

dc: 18 17 caratteri

97[dP1+dBD>m]dsmx

E lì morì un personaggio coraggioso.

Powershell, 75 62 caratteri

Modifica: usato -f (String.Format) e indicizzazione di array per ridurre significativamente la lunghezza del codice.

'{0}bcd{1}fgh{2}jklmn{3}pqrst{4}vwxyz'-f"$(1|gm)"[8,10,0,5,31]

Come funziona

gmè un alias per get-members, quindi 1|gmrestituisce membri del valore 1, che è del System.Int32tipo:

PS C:\> 1|gm
   TypeName: System.Int32
Name        MemberType Definition
----        ---------- ----------
CompareTo   Method     int CompareTo(System.Object value), int CompareTo(int value)
Equals      Method     bool Equals(System.Object obj), bool Equals(int obj)
GetHashCode Method     int GetHashCode()
...

"$(1|gm)"restituisce una rappresentazione in formato stringa dell'elenco precedente, che contiene tutte le vocali necessarie per completare l'alfabeto: " int C omp ar eTo (System.Object val ue) ..."

BASH: 40 caratteri

• No aeiou usato
• Nessun carattere jolly utilizzato.

`tr c-y '\141-w'<<<'rtkpvh %s c'` {b..z}

Haskell, 12

['\97'..'z']

O questo è barare? :)

MATLAB, 12 + 20 = 32 caratteri

No eiou (12):

char(97:122)

No aeou (20)

fprintf('%s',97:122)

In Perl,

è anche possibile senza vocali

ma molto più difficile che in Ruby ecc. Questo utilizza un totale di 101 caratteri ma non richiede l'invocazione della linea cmd (perl -e).

`\160\145\162\154\40\55\145\40\42\160\162\151\156\164\40\123\124\104\105\122\122\40\141\56\56\172\42`

=> Risultato: abcdefghijklmnopqrstuvwxyz

Contrariamente alla soluzione PHP dall'aspetto simile , questo è un vero programma . Il programma decodificato recita:

perl -e "print STDERR a..z"

Dopo la codifica in valori ottali, un altro interprete perl viene chiamato durante l'esecuzione da `` (backtick). I backtick consumerebbero l'output, quindi vengono stampati su STDERR.

La codifica viene eseguita da sprintf:

my $s = q{perl -e "print STDERR a..z"};
my $cmd = eval(
       '"' . join('', map sprintf("\\%o",ord $_), split //, $s) . '"'
       );

e la codifica eval'd è il programma pubblicato (all'interno di backtick):

"\160\145\162\154\40\55\145\40\42\160\162"
"\151\156\164\40\123\124\104\105\122\122"
"\40\141\56\56\172\42"

Saluti

RBO

Perl 5, 22 caratteri

(1) contiene solo ae e, 10 caratteri (richiede 5.10+, eseguito dalla riga di comando):

-Esay+a..z

(2) contiene solo 'i', 12 caratteri:

print v97..z

Se non è possibile eseguire dalla riga di comando, è necessario utilizzare use 5.01;say a..zper il primo, al costo di 7 caratteri e una vocale in più, ma non ha ancora 'i', quindi risulta una voce valida per 29 totali personaggi.

APL (Dyalog) ( 11 13)

Potrebbe essere necessario un carattere APL. Questo dovrebbe essere Unicode ma non c'è anteprima ...

Solo U(e forse ⍳se si contano le vocali greche):

⎕UCS 96+⍳26

(Questo è [quad]UCS 96+[iota]26:)

Solo A:

⎕A

Python 2, 83

No una , io , o o u ; 47 :

x=97;s='';exec"s+=chr(x);x+=1;"*26+"pr\x69nt s"

No e ; 36 :

print"abcd\x65fghijklmnopqrstuvwxyz"

Python 2, 175 caratteri

Nota: stampa in output a differenza della precedente risposta di Python .

Usa 'e', ​​ma no a, i, o, u - 63 61 59 65 (correggi lo ispostamento errato in minuscolo) 115 caratteri (elimina gli spazi).

exec('fr%cm sys %cmp%crt*\nf%cr x %cn r%cnge(97,123):std%c%ct.wr%cte(chr(x)),'%(111,105,111,111,105,97,111,117,105))

(In origine, utilizzava la stampa con una virgola che inseriva uno spazio; inoltre stampava lettere maiuscole. Ora vedeva rigorosi requisiti per "abcdefghijklmnopqrstuvwxyz" come output; quindi aggiungeva una dichiarazione di importazione).

Non usa 'e' (usa a, i, o, u; potrebbe banalmente sbarazzarsi di a, u per una piccola estensione) - 61 60 caratteri

import string
print string.__dict__['low%crcas%c'%(101,101)]

JavaScript (154)

(1) contiene solo i(99 caratteri):

t=this;s=-t+t+t.b;z=s[1]+'bcd'+s[7]+'fghijklmn'+s[4]+'pqrst'+s[21]+'vwxyz';t[s[1]+'l'+s[7]+'rt'](z)

(2) contiene solo aeou(55 caratteri):

t=0;s=''+t.b;alert('abcdefgh'+s[5]+'jklmnopqrstuvwxyz')

Demo: http://jsfiddle.net/SvN5n/

Pitone 159 117

Come menzionato nell'altro post di Python, la parte più difficile riguarda il fatto che l'unico modo per produrre è usare printo sys.stdout.write, entrambi i quali contengono i. Devo farlo con 2 programmi (che sono indipendenti e non usano la shell interattiva di Python per creare l'output):

Questo usa solo i per 55 caratteri:

print"%cbcd%cfghijklmn%cpqrst%cvwxyz"%(97,101,111,117)

Questo evita di usare i per 104 caratteri:

eval("sys.stdout.wr%cte"%105,{'sys':eval("__%cmport__('sys')"%105)})("%c"*26%tuple(range(97,123))+"\n")

MODIFICARE: enorme svolta !!! Pensavo che l'uso di eval (o anche exec) fosse un po 'un imbroglione e non proprio nello spirito della competizione. Ad ogni modo, navigando tra i builtin ho trovato un modo per ottenere la funzione di stampa senza usare i. Ecco quindi il programma avoid-i (e o) per 68 caratteri:

vars(vars().values()[0])['pr%cnt'%105]("%c"*26%tuple(range(97,123)))

Ma poiché ciò evita anche o, questo può essere accoppiato con uno che evita solo a, e, u per 49 caratteri:

print"%cbcd%cfghijklmnopqrst%cvwxyz"%(97,101,117)

Ruby 196 164 44 47

$><<"\x61bcd\x65fgh\x69jklmn\x6Fpqrst\x75vwxyz"

Ruby, 22

$><<[*?`..?{][1,26]*''

Nessuna lettera :)

VBA: 76 forza bruta, 116 senza "imbrogli" (98 se le nuove linee sono accettabili nell'output)

Funzioni standard

Grazie alla verbosità di VBA, non credo che ciò possa essere fatto senza "E" o "U" in un modulo di codice standard ...

• " E nd"
• "F u nzioni"
• "S u b"

Funzioni immediate

Funzionando con l'assunto di mellamokb, ecco senza la dichiarazione di funzione (tralasciando SUBe FUNCTION) ( 116 caratteri , 98 se le nuove righe sono accettabili nell'output):

Quanto segue non usa né 'e' né 'a' ( 43 caratteri , formattati per essere eseguiti nella finestra immediata):

b=65:Do:z=z+Chr(b):b=b+1:Loop Until b=91:?z

Quanto segue non utilizza né "i" né "a" né "u" ( 33 caratteri , formattati per essere eseguiti nella finestra immediata):

For b=65 To 90:z=z+Chr(b):Next:?z

Quanto segue non usa né "a" né "o" né "u" ( 40 caratteri , formattati per essere eseguiti nella finestra immediata):

b=65:While b<91:z=z+Chr(b):b=b+1:Wend:?z

Se nell'output sono consentiti caratteri di nuova riga, gli esempi precedenti possono essere più brevi:

( 37 caratteri )

b=65:Do:?Chr(b):b=b+1:Loop Until b=91

( 27 caratteri )

For b=65 To 90:?Chr(b):Next

( 34 caratteri )

b=65:While b<91:?Chr(b):b=b+1:Wend

Forza bruta

In esecuzione con la risposta Ruby di w0lf

( 76 caratteri , formattati per l'esecuzione nella finestra immediata):

?Chr(65)&"BCD"&Chr(69)&"FGH"&Chr(73)&"JKLMN"&Chr(79)&"PQRST"&Chr(85)&"VWXYZ"

Rebmu : 15 caratteri

Ctc'`L26[pn++C]

Leggere Rebmu richiede sempre un po 'di non mushing per iniziare con:

c: tc '` l 26 [pn ++ c]

Quindi aiuta ad espandere le abbreviazioni:

c: to-char-mu '`
loop 26 [
    prin ++ c
]

Sarebbe più ovvio usare un carattere letterale per il predecessore di una minuscola a:

c: #"`"
loop 26 [
    prin ++ c
]

Ma questo non "poltiglia", quindi convertire una parola letterale in un personaggio passa per lo stesso scopo. Quello che mi piace al riguardo, come nella maggior parte dei Rebmu, è che ha lo spirito di un programma sensato nonostante la compressione. (La risposta di Golfscript è più breve ma non corrisponde al modo in cui un programmatore di solito pensa durante la codifica.)

<> <(Pesce) - 22 caratteri

Poiché <> <usa la 'o' per stampare un personaggio, questa sfida sembra impossibile da fare. Fortunatamente, i pesci possono cambiare il proprio codice in fase di esecuzione. Questo mi ha permesso di aggiungere le istruzioni di stampa al codice.

Questo codice non utilizza nessuna delle vocali:

'`78'+11pv
:X:'z'=?;>1+

Puoi eseguire il codice qui