Найти слова, содержащие каждый гласный


28

Ваша программа должна найти все слова в этом списке слов, которые содержат все гласные ( a e i o u y). Есть простые способы сделать это, но я ищу кратчайший ответ. Я возьму любой язык, но я бы хотел увидеть Баш.

Вот пример (может быть значительно улучшен):

cat wordlist.txt | grep "a" | grep "e" | grep "i" | grep "o" | grep "u" | grep "y"

Ваша оценка - это длина кода.

-5 баллов за подсчет всех вхождений слова.

Самый низкий балл побеждает.


11
такой профиль. много фото. очень дож. Вау.
Дверная ручка

2
17 ответов и подсчет! Я хотел бы видеть больше вопросов, как ваш на cg, doc. Часто я вижу здесь кое-что интересное, но у меня нет нескольких часов времени, необходимых для нахождения достойного решения ...
Кэри Свовеланд,

2
Да, но это не может быть язык, посвященный поиску гласных.
TheDoctor

1
@TheDoctor встряхивает кулак
Джейсон C

2
если у него есть бонус, то это не код-гольф. Вместо этого используйте код-вызов.
Тим Сегин

Ответы:


7

GolfScript, 20 символов - 5 = 15 баллов

n%{'aeiouy'\-!},.,+`

Основано на решении Говарда , но с использованием более короткого теста ( \-!экономит один символ &,6=), более короткого добавления длины ( .,+= 3 символа) и более короткого форматирования вывода (никто не говорил, что вывод должен быть разделен символом новой строки, поэтому `сохраняется один символ n*).

Вот вывод, учитывая список слов в нижнем регистре в качестве ввода (разрывы строк вставлены для удобства чтения):

["abstemiously" "authoritatively" "behaviourally" "consequentially" "counterrevolutionary"
"disadvantageously" "educationally" "encouragingly" "eukaryotic" "evolutionarily"
"evolutionary" "exclusionary" "facetiously" "gregariously" "heterosexuality" "homosexuality"
"importunately" "inconsequentially" "instantaneously" "insurrectionary" "intravenously"
"manoeuvrability" "neurologically" "neurotically" "ostentatiously" "pertinaciously"
"precariously" "precautionary" "questionably" "revolutionary" "simultaneously"
"supersonically" "tenaciously" "uncomplimentary" "uncontroversially" "unconventionally"
"undemocratically" "unemotionally" "unequivocally" "uninformatively" "unintentionally"
"unquestionably" "unrecognisably" 43]

(Ps. Технически, учитывая, что задача только говорит, что код должен работать для этого конкретного ввода, n%{'aeiouy'\-!},`43было бы еще на один символ короче. Хотя я считаю, что измена.)


Объяснение:

  • n% разбивает ввод на новых строках в массив.
  • { }, является оператором "grep", выполняющим код в фигурных скобках для каждого элемента массива и выбирающим те, для которых он возвращает истинное значение.
    • Внутри цикла 'aeiouy'\-принимает буквальную строку aeiouyи удаляет из нее все символы, найденные в слове-кандидате. !Затем логически нивелирует полученную строку, получая 1(истина) , если строка пуста , и 0(ложь) , если это не так .
  • .,+ создает копию отфильтрованного массива, считает количество слов в нем и добавляет результат к исходному массиву.
  • Наконец, `снимает массив, преобразуя его в строковое представление его содержимого. (Без этого слова в массиве просто будут объединены в выводе, что приведет к нечитаемому беспорядку.)

Congrats !! самый маленький ответ !!!!
TheDoctor

единственно слово со всеми 6 гласными в порядке. Просто подумал, что поделюсь этим с тобой. Я нашел это круто.
dberm22

15

GolfScript, 19 символов

n%{'aeiouy'&,6=},n*

Использование:

golfscript vowels.gs < wordlist.txt

Выход:

abstemiously
authoritatively
behaviourally
[...]
uninformatively
unintentionally
unquestionably
unrecognisably

Если вы также хотите вывести счет в конце, вы можете использовать

n%{'aeiouy'&,6=},.n*n@,

который на четыре символа длиннее.


1
Мне это нравится! Это может быть на 4 символа больше, но это дает вам бонус -5
пунктов

11

Python - 46 символов

filter(lambda x:set(x)>=set("AEIOUY"),open(f))

Читаемая версия: это уже довольно читабельно :-)


8

APL, 21 - 5 = 16

(,≢)w/⍨∧⌿'aeiouy'∘.∊w

Ожидает найти список слов как w. Возвращает список слов, которые содержат все гласные, плюс их количество. Протестировано с ngn apl . Вот пример .

объяснение

         'aeiouy'∘.∊w   # generate a truth table for every vowel ∊ every word
       ∧⌿               # reduce with ∧ along the rows (vowels)
    w/⍨                 # select the words that contain all the vowels
(,≢)                    # hook: append to the list its own tally

8

Руби 38

Изменить 34: Лучший на данный момент (из @OI):

a.split.select{|w|'aeiouy'.count(w)>5} 

Редактировать 1: Я только что заметил вопрос о том, чтобы 'y' был включен в гласные, поэтому я соответственно отредактировал свой вопрос. Как отметил @Nik в комментарии к своему ответу, "aeiouy".charsэто на один символ меньше %w[a e i o u y], но я оставлю последнего ради разнообразия, хотя я рискую испытать кошмары из-за упущенной возможности.

Изменить 2: Спасибо @OI за предложение улучшения:

s.split.select{|w|'aeiouy'.delete(w)==''}

который спасает 11 символов от того, что у меня было раньше.

Изменить 3 и 3a: @OI сбил еще несколько:

s.split.select{|w|'aeiouy'.tr(w,'')==''}

тогда

s.split.reject{|w|'aeiouy'.tr(w,'')[1]}

и снова (3б):

a.split.select{|w|'aeiouy'.count(w)>5} 

Я простой писец!

Вот еще два неконкурентных решения:

s.split.group_by{|w|'aeiouy'.delete(w)}['']       (43)
s.gsub(/(.+)\n/){|w|'aeiouy'.delete(w)==''?w:''} (48)

Изначально у меня было:

s.split.select{|w|(w.chars&%w[a e i o u y]).size==6}

sэто строка, содержащая слова, разделенные символом новой строки sВозвращается массив слов , содержащий все пять гласных. Для читателей , не знакомых с Ruby, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]и &является массивом пересечений.

предполагать

s = "abbreviations\nabduction\n"
s.split #=> ["abbreviations", "abduction"] 

В блоке {...}изначально

w             #=> "abbreviations"
w.chars       #=> ["a", "b", "b", "r", "e", "v", "i", "a", "t", "i", "o", "n", "s"]
w.chars & %w[a e i o u y] #=> ["a", "e", "i", "o"]
(w.chars & %w[a e i o u y]).size == 6 #=> (4 == 6) => false,

поэтому "аббревиатуры" не выбраны.

Если строка sможет содержать дубликаты, s.split.select...ее можно заменить, s.split.uniq.select...чтобы удалить дубликаты.

Просто заметил, что я могу сохранить 1 символ, заменив size==6на size>5.


1
...size=5это ошибка - должно быть...size==5
Ури Агасси

Спасибо, @Uri, за указание на опечатку в первой строке, которую я исправил (не ошибка - см. Строку выше «, чтобы« сокращения »не были выбраны»).
Кэри Свовеланд,

@CarySwoveland Вы можете спасти себя 11 символов, выполнив это:s.split.select{|w|'aeiouy'.delete(w)==''}
OI

Отлично, @OI. Я сделал правку и нашел место, которое в серых клетках.
Кэри Свовеланд,

@CarySwoveland Это позволит сэкономить более 1 символ: s.split.select{|w|'aeiouy'.tr(w,'')==''}. Я почти уверен, что вы можете получить это до 40 символов, если используете ноль логику и правильный метод String. Все еще смотрю ...
OI

6

Haskell - 67

main=interact$unlines.filter(and.flip map "aeiouy".flip elem).lines

2
Это код-гольф , вы должны попытаться сделать код короче, например, удалив пробелы ...
mniip

6

Рубин - 28 символов (или 27, если yисключен из гласных)

("ieaouy".chars-s.chars)==[]

Полная команда для запуска (48 символов):

ruby -nle 'p $_ if ("ieaouy".chars-$_.chars)==[]'

РЕДАКТИРОВАТЬ: заменено putsна, pкак предложено @CarySwoveland


Хороший, @Nik. %w[a e i o u]сэкономит 1 символ, pибо еще puts3.
Кэри Свовеланд,

Спасибо, @CarySwoveland! Я забыл p, я редко использую это. Что касается% w [], если y включен в набор гласных, версия с символами еще короче.
Ник О'Лай

@ NikO'Lai "aeiouy".delete(s)==''может спасти тебе несколько персонажей.
OI

Очень хорошо! Опубликуйте это как собственное решение, @OI. Я буду голосовать за это
Ник О'Лай

4

AWK - 29

/ А / && / е / && / я / && / о / && / и / && / у /

Для запуска: сохраните список слов в нижнем регистре в wordlist.txt. Затем выполните:

mawk "/ a / && / e / && / i / && / o / && / u / && / y /" wordlist.txt

Если вашей системы нет mawk, awkможно также использовать.

Вы также можете запустить его из файла, сохранив программу program.awkи выполнив mawkили awk -f program.awk.


Выбор правильного порядка ускорит работу: '/y/&&/u/&&/i/&&/o/&&/a/&&/e/'!!
Ф. Хаури


3

к [22-5 = 17 символов]

Я переименовал файл «corncob_lowercase.txt» в «w»

Подсчитайте слова [22 символа]

+/min'"aeiouy"in/:0:`w

Выход

43

Найти все слова [25 символов]

x@&min'"aeiouy"in/:x:0:`w

Всего 43 слова, содержащие все гласные (a e i o u y)

Выход

"abstemiously"
"authoritatively"
"behaviourally"
..
..
"unintentionally"
"unquestionably"
"unrecognisably"

3

Javascript / JScript 147 (152-5), 158 (163-5) или 184 (189-5) байтов:

Вот мой Javascript и JScript чудовищно "негольфированная" версия (164 152 152-5 = 147 байт):

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;}

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=6;for(z in c)i-=!!s[k].search(c[z]);i&&(r[r.length]=s[k]);}return r;}

Спасибо @GaurangTandon за search()функцию, которая спасла мне байт!

RegExp основан на производительности HORRIBLE , но поддерживает прописные и строчные буквы (163-5 = 158 байт):

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=RegExp(c[z],'i').test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

RegExp, основанный на ЛУЧШЕЙ производительности, НО занимает намного больше байтов (189-5 = 184 байта):

function(s,k,z,x,i,c,r,l){l=[];r=[];for(z in c='aeiouy'.split(''))l[z]=RegExp(c[z],'i');for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=l[z].test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}


Этот, если только для забавы (175-5 байт) и не считается ответом:

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;}

Он основан на 1-м ответе, но имеет «поворот»: вы можете знать, сколько раз было найдено слово.

Вы просто делаете это так:

var b=(function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;})('youaie youaie youaie youaie a word');

b.youaie //should be 4

Поскольку в нем lengthнет всех гласных, оно не будет удалено и все равно будет ответом за бонус.


Как вы это называете?

«Простой»: вы оборачиваете функцию внутри, ()а затем добавляете ('string goes here');в конец.

Так: (function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;})('a sentence youyoy iyiuyoui yoiuae oiue oiuea');

Этот пример вернет массив только с 1 строкой: yoiuae

Я знаю, что это худшее решение, но работает!


Почему я считаю -5?

Ну, у массивов Javascript / JScript есть свойство ( length) в массивах, которое сообщает количество элементов, которые у него есть.

После подтверждения в вопросе бонус -5 предназначен для определения количества слов.

Поскольку количество слов находится в этом свойстве, я автоматически получаю оценку -5.


Может быть интересует search()вместо indexOf()сохранения 1 символ.
Гауранг Тандон

Кроме того, насколько я вижу, в вашей самой короткой версии вам не нужно .split()вкл "aeiouy". JS перебирает массив и строку одинаково. (Удаление этого экономит вам ~ 10 символов)
Гауранг Тандон

2

Ruby 39 38

В настоящее время самая короткая запись Ruby при подсчете всей программы, включая ввод и вывод.

Сохраненный символ, используя mapвместо each:

$<.map{|w|w*5=~/a.*e.*i.*o.*u/m&&p(w)}

Другая версия, 39 символов с более красивым выводом:

puts$<.select{|w|w*5=~/a.*e.*i.*o.*u/m}

Обе программы получают ввод из стандартного ввода или в виде имени файла, передаваемого в качестве аргумента командной строки:
$ ruby wovels.rb wordlist.txt

Стоит добавить 3 дополнительных символа yв качестве ткацкого ореха.


В любом случае, чтобы Enumerable#grepсократить это? например, s.split.grep /a*e*i*o*u*y/предположим , что sэто строка слов, разделенных символами новой строки.
OI

@OI Интересная идея, но для этого нужно немного поиграть, потому что регулярное выражение имеет фиксированные последовательности. Вот почему я повторяю эту строку 5 раз, прежде чем сопоставлять ее .*между волнами.
daniero

Не могли бы вы уточнить? Пусть s = "aeiouy\neiouay\nyuaioe\n". Затем s.split.grep /a*e*i*o*u*y/возвращается ["aeiouy", "eiouay", "yuaioe"]за мной. Тестирование в pryRuby 2.0.0. Отличное решение, кстати.
OI

@ Ой Ого, я предположил, что grepиспользовал =~оператор, но, видимо, он использует ===. Я подозревал, что он также будет соответствовать строкам, не содержащим всех wovels, потому что, например, /e*a*i*o*u*y/=~"eioy"работает. Я действительно не понимаю, что на ===самом деле делает регулярное выражение и оператор. Отличная находка; Я бы посоветовал вам опубликовать это как ответ самостоятельно. править я был прав: попытка с, например "heya".
Даниеро

Я думаю, что вы правы, что регулярное выражение нуждается в настройке, хотя. Я нахожу крайние случаи, которые не содержат все гласные, которые просачиваются через. Может быть, слишком хорошо, чтобы быть правдой.
OI

2

Mathematica (65 или 314)

Два совершенно разных подхода, лучший из которых был предложен Велисарием в комментариях к моему первоначальному ответу. Во-первых, мое грубое усилие, которое алгоритмически генерирует каждое возможное регулярное выражение, которое соответствует комбинации из шести гласных (включая «y»), а затем проверяет каждое слово в целевом списке слов по каждому из этих 720 регулярных выражений. Это работает, но это не очень кратко и медленно.

b = Permutations[{"a", "e", "i", "o", "u","y"}]; Table[
 Select[StringSplit[
  URLFetch["http://www.mieliestronk.com/corncob_lowercase.txt"]], 
  StringMatchQ[#, (___ ~~ b[[i]][[1]] ~~ ___ ~~ 
      b[[i]][[2]] ~~ ___ ~~ b[[i]][[3]] ~~ ___ ~~ 
      b[[i]][[4]] ~~ ___ ~~ b[[i]][[5]]~~ ___ ~~ b[[i]][[6]] ~~ ___)] &], {i, 1, 
  Length[b]}]

~ 320 символов. Некоторые из них могут быть сохранены с использованием альтернативной записи, и дополнительные символы будут потеряны при подготовке файла словаря в виде списка строк (естественный формат словаря в Mathematica. Другие языки могут не нуждаться в этой подготовке, но Mathematica делает это). Если мы пропустим этот шаг, предполагая, что он был обработан для нас, такой же подход может быть использован менее чем в 250 символах, и если мы используем встроенный словарь Mathematica, мы получим еще большую экономию,

Map[DictionaryLookup[(___ ~~ #[[1]] ~~ ___ ~~ #[[2]] ~~ ___ ~~ #[[3]] 
~~ ___ ~~ #[[4]] ~~ ___ ~~ #[[5]]~~ ___ ~~ #[[6]] ~~ ___) .., IgnoreCase -> True] &, 
 Permutations[{"a", "e", "i", "o", "u","y"}]]

До 200 символов. Подсчет количества найденных слов требует только передачи результата Length[Flatten[]], который может быть добавлен вокруг любого блока кода выше или может быть выполнен позже, например, с помощью Length@Flatten@%. Список слов, указанный для этого задания, дает 43 соответствия, а словарь Mathematica - 64 (и намного быстрее). В каждом словаре есть совпадающие слова, которых нет в другом. Mathematica находит, например, «непрофессионально», которого нет в общем списке, а общий список находит «eukaryotic», которого нет в словаре Mathematica.

Велисарий предложил гораздо лучшее решение. Предполагая, что список слов уже подготовлен и назначен переменной l, он определяет один тест на основе StringFreeQ[]функции Mathematica , а затем применяет этот тест к списку слов с помощью Pick[]функции. 65 символов, и это примерно в 400 раз быстрее, чем мой подход.

f@u_ := And @@ (! StringFreeQ[u, #] & /@ Characters@"aeiouy"); Pick[l,f /@ l]

В 65 символах: f@u_:=And@@(!StringFreeQ[u,#]&/@Characters@"aeiouy");Pick[l,f/@l]где lсписок слов
доктор Белизарий

Это потому, что вы забыли считать yгласным (согласно требованиям ОП!)
доктор Белизарий,

@belisarius Да, я заметил это после того, как сделал свой комментарий. Я проверяю свои результаты с этим исправлено.
Майкл Стерн

@belisarius подтвердил - ваше решение гораздо лаконичнее и быстрее моего. Почему вы не публикуете это как собственное решение? Я буду голосовать за это.
Майкл Стерн

Благодарность! Если вам это нравится, отредактируйте свой ответ, включая его. Для меня это все о нахождении коротких решений с языком, а не о накоплении репутации :)
Доктор Белизариус

2

Perl 6 - 35 символов

Вдохновленный решением Ruby @CarySwoveland:

say grep <a e i o u y>⊆*.comb,lines

Это выбирает ( grepы) каждую строку, Trueдля <a e i o u y> ⊆ *.combкоторой возвращается , что является просто причудливым способом спросить: «Является ли Set ('a','e','i','o','u','y')подмножеством ( ) Set, составленным из букв input ( *.comb)?»

На самом деле, оба <a e i o u y>и *.combтолько создают Lists: (или (<=)если вы застряли в ASCII) превращает их в Sets для вас.

Чтобы получить количество напечатанных строк, это скрипт из 42 символов - 5 = 37 пунктов также выведет:

say +lines.grep(<a e i o u y>⊆*.comb)».say

2

C - 96 байт

 char*gets(),*i,j[42];main(p){while(p=0,i=gets(j)){while(*i)p|=1<<*i++-96;~p&35684898||puts(j);}}

Я сохранил несколько байтов скобок благодаря удачному совпадению приоритетов операторов.


2

Javascript - Оценка = 124 - 5 = 119 !!!

Изменить: 17/02/14

function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z}

Большое спасибо @Ismael Miguel за помощь в прекращении ~ 12 символов !

Я удалил форму функции обозначения жирной стрелки, потому что, хотя я видел, как она начала использоваться, она не работает. Понятия не имею, почему ...


Чтобы это работало:

Передайте все слова, разделенные символом новой строки, в качестве аргумента функции, как показано ниже.


Тест:

// string is "facetiously\nabstemiously\nhello\nauthoritatively\nbye"

var answer = (function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z})("facetiously\nabstemiously\nhello\nauthoritatively\nbye")

console.log(answer);
console.log(answer.length);

/* output ->    
    ["facetiously", "abstemiously", "authoritatively"]
    3 // count
*/


Синтаксическая ошибка в строке 1: ожидаемое выражение, получено '>' c = (s, j) => {k = "aeiouy" .split ("
Исмаэль Мигель

1
Вы можете уменьшить, если, перейдя k="aeiouy".split("")в for(i in k)цикл. Использование ;вместо новых строк экономит несколько байтов в Windows. И все же я не вижу, как он будет обрабатывать список слов. И как заставить это работать.
Исмаэль Мигель

@ IsmaelMiguel Я знаю, что это (жирная стрелка) не работает. Но так как я видел, что это используется здесь, таким образом, я использовал это, потому что это экономит символы. Но я убрал это. И я не понимаю ваш совет, спасибо, хотя для изучения кода. Включил ваш байтовый совет. И моя новая программа должна устранить ваши сомнения. Спасибо за чтение. :)
Гауранг Тандон

Вместо того k="aeiouy";o=0;for(i in k), чтобы попробовать o=0;for(i in k='aeiouy'). и с помощью экономит байты, вы можете использовать их , чтобы изменить o+=RegExp(k[i]).test(s)в o+=RegExp(k[i],'i').test(s), занимая один байт больше, но работать как с верхним и нижним.
Исмаэль Мигель

Обновлен с улучшенным алгоритмом. Хотя я теперь понимаю вашу идею, но я не понимаю, почему она работает здесь, а не здесь . Пожалуйста помоги! Спасибо :)
Гауранг Тандон

2

Bash + coreutils, 39

eval cat`printf "|grep %s" a e i o u y`

Принимает ввод от стандартного ввода.


Это выглядит как право на 5-балльный бонус.
Гленн Рандерс-Персон

@ GlennRanders-Pehrson Этот бонус не имеет никакого смысла для меня вообще ;-)
Digital Trauma

Независимо от того, имеет ли это смысл или нет, вы корректно выделяете 86 строк при обработке файла, содержащего две копии списка слов. Решения, которые сортируют и только сообщают 43, не получат бонус, насколько я понимаю.
Гленн Рандерс-Персон

2

Сед 29 символов

/y/{/u/{/o/{/i/{/a/{/e/p}}}}}

Порядок выбран из Частота письма в Википедии для проверки скорости.

На моем хосте:

time sed -ne '/a/{/e/{/i/{/o/{/u/{/y/p}}}}}' </usr/share/dict/american-english >/dev/null 
real    0m0.046s

а также

time sed -ne '/y/{/u/{/i/{/o/{/a/{/e/p}}}}}'</usr/share/dict/american-english >/dev/null 
real    0m0.030s

1
Хорошо (+1), но я думаю, что вам нужно включить в сценарий «sed -n» для подсчета 36 байтов.
Гленн Рандерс-Персон

2

Bash (grep) - 36 байт

g=grep;$g y|$g u|$g o|$g i|$g a|$g e

Обратите внимание на порядок проверки гласных, в первую очередь наименее часто встречающихся. Для тестового примера это выполняется примерно в 3 раза быстрее, чем тестирование в порядке. Таким образом, первый тест удаляет большее количество слов, поэтому последующим тестам меньше работы. Очевидно, что это не влияет на длину кода. Многие другие решения, опубликованные здесь, также выиграют от выполнения тестов в этом порядке.


Почему мы не находим, не считаем? Кроме того, мы считаем код ввода в число символов?
Орион

Я не совсем понимаю бонус "-5 очков за подсчет всех вхождений слова". Если это действительно означает «сообщать обо всех вхождениях слова», это то, что делают мои сценарии без «| wc». Я не использую «входной код», потому что grep читает стандартный ввод, поэтому «grep» является «входным кодом», и я его посчитал. Я удалю "| wc" сейчас.
Гленн Рандерс-Персон

Я отказался от бонуса.
Гленн Рандерс-Персон

1

Д - 196

import std.regex,std.stream;void main(string[]a){auto f=new File(a[1]);while(!f.eof)if(!(a[0]=f.readLine.idup).match("(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*").empty)std.stdio.writeln(a[0]);}

Без гольфа :

import std.regex, std.stream;

void main( string[] a )
{
    auto f = new File( a[1] );

    while( !f.eof )
        if( !( a[0] = f.readLine.idup ).match( "(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*" ).empty )
            std.stdio.writeln( a[0] );
}

использование :C:\>rdmd vowels.d wordlist.txt

wordlist.txt должен содержать строчный список слов.


1

Реболь (104 символа)

remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]

Un-golfed:

remove-each w d: read/lines %wordlist.txt [
    6 != length? collect [foreach n "aeiouy" [if find w n [keep n]]]
]

dтеперь содержит список найденных слов. Вот пример из консоли Rebol:

>> ; paste in golf line.  This (REMOVE-EACH) returns the numbers of words removed from list

>> remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]
== 58067

>> length? d
== 43

1

Smalltalk (36/57 символов)

'corncob_lowercase.txt' asFilename contents select:[:w | w includesAll:'aeiouy']

чтобы получить количество, отправьте #size в результирующую коллекцию. Коллекция результат содержит 43 слова ( «воздержанно» «авторитетно» ... «несомненно,» «неузнаваемо»)

Приведенный выше код содержит 77 символов, но я мог бы переименовать файл списка слов в «w», поэтому я считаю, что имя файла равно 1, что дает оценку 57.

Является ли чтение файла частью проблемы или нет? Если нет (см. Другие примеры), и список слов уже находится в коллекции c, то код сокращается до:

c select:[:w | w includesAll:'aeiouy']

что составляет 36 символов (с пропуском пропущенного пробела).


1

обновлено: ненужные пробелы удалены

Очень медленно, но в bash (81 символ):

while read l;do [ `fold -w1<<<$l|sort -u|tr -dc ieaouy|wc -m` = 6 ]&&echo $l;done

РЕДАКТИРОВАТЬ: echo $l|fold -w1заменено на, fold -w1<<<$lкак предложено @ nyuszika7h


Это кодовый гольф, возможно, вы захотите немного сократить код. Начните с удаления ненужных пробелов. ;)
nyuszika7h

Вы можете дополнительно минимизировать код, используя fold -w1<<<$lвместо echo $l|fold -w1. Примечание: текущий код состоит из 84 символов, вы не должны считать завершающий перевод строки.
nyuszika7h

До сегодняшнего дня я ничего не знал о <<<. Еще раз спасибо, @ nyuszika7h. Можете ли вы сказать мне, где это объясняется.
Ник О'Лай


1

JavaScript - 95 байт

Вот мой гольф.

function f(s){return[var a=s.match(/^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/),a.length];}

И я также хотел бы отметить, что ваш гольф, кажется, не встречает все случаи появления гласных.

Ungolfed:

function countVowels(string) {
  var regex   = /^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/;
  var matches = string.match(regex);
  var length  = matches.length;
  return [matches, length];

1
Читайте спецификацию более внимательно. Он ищет слова, которые - как и злобно - содержат все гласные в одном слове. Хотя он не настаивает на том, чтобы они содержались в порядке, как в шутку.
dmckee

1
Ваше регулярное выражение неверно. Все упреждающие проверки эффективно проверяют, является ли первый символ гласным. Вы должны (?=.*a)проверить, aнаходится ли где-нибудь в строке.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@dmckee Вот почему я использовал взгляды . Они не требуют какого-либо конкретного заказа.
Исия Медоуз

@nhahtdh Спасибо за подвох
Isiah Meadows

1

сортировать + uniq + sed

Этот не соответствует повторным вхождениям слова. Оно также не соответствует букве «у», если оно встречается в начале слова.

sort wordlist.txt | uniq | sed -n '/a/p' | sed -n '/e/p' | sed -n '/i/p' | sed -n '/o/p' | sed -n '/u/p' | sed -nr '/^[^y]+y/p' 

Как и в другом ответе, замените «sort wordlist.txt | uniq» на «sort -u wordlist.txt», чтобы сохранить 4 байта.
Гленн Рандерс-Персон

1

удар

Не такой короткий, как ОП, но одна строка в Bash:

while read p; do if [ $(sed 's/[^aeiouy]//g' <<< $p | fold -w1 | sort | uniq | wc -l) -eq 6 ] ; then echo $p; fi; done < wordlist.txt

Вы можете сэкономить четыре байта, заменив «sort | uniq» на «sort -u»
Гленн Рандерс-Персон

Также вы можете убрать пробелы из "|" и ";", чтобы сохранить еще несколько байтов
Гленн Рандерс-Персон

1

C # - 170

using System.Linq;class P{static void Main(string[]a){System.Console.Write(string.Join(",",System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)))));}}

отформатирован:

using System.Linq;
class P
{
    static void Main(string[] a) { 
        System.Console.Write(
            string.Join(",", System.IO.File.ReadAllLines(a[0])
                .Where(w => "aeiouy".All(c => w.Contains(c))))); 
    }
}

Сейчас не в настроении для подсчета, PUHно это должно быть легко. Путь к списку слов (в нижнем регистре) должен быть передан программе в качестве первого аргумента:

program.exe D:\foo\bar\corncob_lowercase.txt

Выход:

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably

Я взял на себя смелость выводить и разделять запятыми слова; ни то, ни другое не указано в правилах (какое состояние «должно найти все слова», а не то, как (и ЕСЛИ) выводить).

Включая счет (+ вывод): 192 - 5 = 187

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));System.Console.Write(string.Join(",",r)+" "+r.Count());}}

Выход:

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably 4
3

(Обратите внимание на количество в конце: 43)

Нет вывода («должен найти все слова»): 137 - 5 = 132

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));}}

(Снова немного изменив правила: не совсем). Это находит все слова, и счет доступен после выполнения r.Count().


1

C-Sharp

Я никогда не делал этого раньше, и я не совсем уверен, каковы процедуры размещения. Но вот что я придумал:

185 байт

Action<string>x=(s=>s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v)))Console.Write(w);}));using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

wordList = а List<string> из всех слов.

если вы хотите отобразить итог:

219 - 5 = 214 байтов

Action<string>x=(s=>{var t=0;s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v))){Console.Write(w);t++;}});Console.Write(t);});using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());


расширенный

// init
var words = "";
var vowels = "aeiouy";
var total = 0;

using (var stream = new StreamReader(@"C:\corncob_lowercase.txt"))
{
    // read file
    words = stream.ReadToEnd();

    // convert word to List<string>
    var wordList = words.Split('\n').ToList();

    // loop through each word in the list
    foreach (var word in wordList)

        // check if the current word contains all the vowels
        if(vowels.All (w => word.ToCharArray().Contains(w)))
        {
            // Count total
            total += 1;
            // Output word
            Console.Write(word);
        }

    // Display total
    Console.WriteLine(total);
}

Как правило, если вопрос требует «программы», вы должны опубликовать свою полную программу, включая загрузку / инициализацию и т. Д. Отличная работа в противном случае!
ProgrammerDan

О хорошо Таким образом, в минимизированной версии я должен включить все, а не только строку, которая выполняет требование? Я думал, что это последний, судя по другим ответам, так как им не хватало кода для загрузки / чтения текстового файла.
jzm

Вы увидите различные подходы, и, учитывая, что срок действия ответа, скорее всего, не будет таким сильным для новых ответов, но в целом, если вопрос требует «программы», он должен быть компилируемым и запускаемым, как опубликовано. Возьмите пример из самого вопроса - это полное, выполнимое решение, которое стоит отдельно.
ProgrammerDan

аааа ну, в этом случае я обновил 2 сокращенные версии, чтобы они были автономными.
июня

Большой! Обязательно обновите текст вашего ответа (вы упомянули «без загрузки / чтения») и вычислите ваш счет.
ProgrammerDan

1

vb.net (оценка 91 = 96с - 5) * 0

* 0 + 49с мин

Это создает перечисление, содержащее все слова, которые содержат все гласные.

Dim r=IO.File.ReadLines(a(0)).Where(Function(w)"aeiou".Intersect(w).Count=5)
Dim c=r.Count

Your program must find all the words in this wordlist, Это а) не программа, а фрагмент программы и б) не читает / не использует список слов.
RobIII

@RobIII vb.net имеет минимум 49c для базовой консольной программы. Аргументами программы (в данном случае это список слов) является массив a . Плюс, как отметили некоторые другие, это действительная программа в LinqPad.
Адам Спейт

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.