พวกเขาพูดว่าhateเป็นคำที่หนักแน่น ฉันอยากรู้ว่าทำไมฉันจึงดูคำนี้ดี

ฉันสังเกตว่าพยัญชนะทุกตัวมีสระอยู่หลังนั้น นั่นทำให้ฉันดูค่อนข้างแข็งแกร่งดังนั้นฉันจึงตัดสินใจว่านั่นคือสิ่งที่ทำให้คำมีความแข็งแกร่ง

ฉันต้องการคำศัพท์ที่แรงกว่านี้ดังนั้นฉันต้องการโปรแกรมสำหรับมัน!

การค้นหาคำที่แข็งแกร่ง

คำที่แข็งแกร่งคือคำที่ทุก ๆ พยัญชนะ (ตัวอักษรในชุดBCDFGHJKLMNPQRSTVWXZ) ตามด้วยสระ (ตัวอักษรในชุดAEIOUY) แค่นั้นแหละ. ไม่มีอะไรอื่นที่สำคัญ

หากคำเริ่มต้นด้วยเสียงสระคุณไม่ต้องกังวลเกี่ยวกับตัวอักษรใด ๆ ก่อนที่จะมีพยัญชนะตัวแรก หากคำนั้นไม่มีพยัญชนะอยู่เลยมันก็เป็นคำที่แข็งแกร่งโดยอัตโนมัติ!

ตัวอย่างบางส่วนของคำพูดที่แข็งแกร่งagate, และhate ยังคงเป็นคำที่แข็งแกร่งเพราะแม้ว่ามันจะเริ่มต้นด้วยเสียงสระพยัญชนะทุกตัวยังคงตามด้วยเสียงสระ เป็นคำที่แข็งแกร่งเพราะไม่มีพยัญชนะyouagateyou

ไม่มีการจำกัดความยาวของคำศัพท์ที่เข้มงวด

ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่รับสตริงที่ไม่ว่างเปล่าเป็นอินพุตและส่งออกค่าจริงถ้าเป็นคำที่แรงหรือค่าเท็จหากไม่ได้

ชี้แจง

• คุณอาจตัดสินใจรับอินพุตเป็นตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่ ระบุว่าในคำตอบของคุณ
• คำพูดจะไม่มีเครื่องหมายวรรคตอนใด ๆ ABCDEFGHIJKLMNOPQRSTUVWXYZพวกเขาจะประกอบด้วยตัวอักษรธรรมดาในชุด
• แทนที่จะเป็นค่าจริงและเท็จคุณอาจเลือกค่าที่แตกต่างและสอดคล้องกันสองค่าเพื่อส่งกลับค่าจริงและเท็จ หากคุณทำเช่นนี้ระบุค่าที่คุณเลือกในคำตอบของคุณ
  • คุณอาจส่งออกค่าเท็จสำหรับคำที่แข็งแกร่งและเป็นความจริงสำหรับคำที่ไม่แข็งแกร่ง

กรณีทดสอบ

Input      -> Output
hate       -> true
love       -> true
popularize -> true
academy    -> true
you        -> true
mouse      -> true
acorn      -> false
nut        -> false
ah         -> false
strong     -> false
false      -> false
parakeet   -> false

เกณฑ์การให้คะแนน

เนื่องจากนี่คือโค้ดกอล์ฟคำตอบที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ!

JavaScript (ES6), 36 28 27 ไบต์

^{บันทึก 1 ไบต์โดยย้อนกลับผลลัพธ์ตามที่ LarsW แนะนำ}

ใช้อินพุตเป็นตัวพิมพ์เล็ก ส่งคืนfalseสำหรับคำที่แรงและtrueสำหรับคำที่ไม่แรง

s=>/[^aeiouy]{2}/.test(s+0)

อย่างไร?

เราต่อท้าย0(ไม่ใช่สระ) ต่อท้ายสตริงป้อนข้อมูลและค้นหาอักขระที่ไม่ใช่สระติดต่อกันสองตัว สิ่งนี้ทำให้เราครอบคลุมทั้งสองกรณีที่ทำให้คำไม่แข็งแรง

• มันประกอบด้วยพยัญชนะสองตัวติดต่อกัน
• หรือลงท้ายด้วยพยัญชนะ

กรณีทดสอบ

let f =

s=>/[^aeiouy]{2}/.test(s+0)

;[
  "hate", "love", "popularize", "academy", "you", "mouse", "a", "euouae",
  "acorn", "nut", "ah", "strong", "false", "parakeet"
]
.forEach(s => console.log(s + ' --> ' + f(s)))

Python 2 , 48 ไบต์

lambda s:'se, F'in`[v in'aeiouy'for v in s+'b']`

ฟังก์ชั่นที่ไม่มีชื่อการใช้สตริง (ตัวพิมพ์เล็ก) sและส่งคืนFalseถ้ามีความแข็งแรงหรือTrueไม่

ลองออนไลน์! (พลิกผลลัพธ์ให้ตรงกับ OP)

อย่างไร?

คำที่ไม่แข็งแรงมีทั้งพยัญชนะตามด้วยพยัญชนะหรือลงท้ายด้วยพยัญชนะ

รหัสเพิ่มพยัญชนะท้าย ( s+'b') เพื่อให้การทดสอบที่จำเป็นเป็นเพียงสำหรับสองพยัญชนะในแถว

มันจะค้นหาว่าตัวอักษรแต่ละตัวในคำที่ถูกดัดแปลงนั้นเป็นสระที่มีความเข้าใจในรายการ[v in'aeiouy'for v in s+'b']หรือไม่

ตอนนี้จะต้องมีการตรวจสอบสองFalseผลในแถว (การส่งสัญญาณเป็นคำที่ไม่แข็งแรง) มันไม่ได้โดยได้รับการแสดงสตริง (ใช้`...`) 'se, F'ของรายการนี้และกำลังมองหาการดำรงอยู่ของ นี่คือสตริงที่สั้นที่สุดที่พบใน'False, False'แต่ไม่มี: 'True, True'; 'False, True'; 'True, False'หรือ

ตัวอย่างเช่นพิจารณา'nut'ความเข้าใจรายการประเมินแต่ละตัวอักษรvของ'nutb'การดำรงอยู่ใน'aeiouy'ผลผลิตรายการ[False, True, False, False]ที่แสดงสตริงของรายการนี้'[False, True, False, False]'ซึ่งมี'e, F'ที่นี่: '[False, True, Fals>>e, F<<alse]'ด้วยเหตุนี้ผลตอบแทนที่ฟังก์ชั่นTrueความหมายถั่วที่เป็นไม่ได้เป็นคำที่แข็งแกร่ง

เยลลี่ ,  10  9 ไบต์

e€ØY;Ạ11ẇ

ลิงก์ monadic ที่รับรายการอักขระและส่งคืน:

• 0 ถ้าแข็งแรง
• 1 ถ้าไม่

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

e€ØY;Ạ11ẇ - Link: list of characters, s      e.g. "hate"  or  "you"  or  "not"
  ØY      - consonant yield                   "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
e€        - exists in? for €ach letter            [1,0,1,0]   [0,0,0]    [1,0,1]
     Ạ    - all truthy? (1 for any valid input)   1           1          1
    ;     - concatenate                           [1,0,1,0,1] [0,0,0,1]  [1,0,1,1]
      11  - literal eleven
        ẇ - sublist exists?                       0           0          1
          -  N.B.: left of ẇ implicitly makes digits so it looks for the sublist [1,1]

หมายเหตุ: เหตุผลในการใช้Ạเป็นเพียงการบันทึกไบต์ไปใช้1(เนื่องจากเราต้องการใช้11ทันที)

05AB1E , 8 ไบต์

รหัส

žPS¡¦õÊP

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

คำอธิบาย

žPS¡         # Split the string on consonants (bcdfghjklmnpqrstvwxz)
    ¦        # Remove the first element of the array to handle cases when the
               string starts with a consonant
     õÊP     # Check if the empty string is not in the array

ตัวอย่าง

             # "popularize"
žPS¡         # ['', 'o', 'u', 'a', 'i', 'e']
    ¦        # ['o', 'u', 'a', 'i', 'e']
     õÊ      # [1, 1, 1, 1, 1]
       P     # 1

R , 43 ไบต์

function(s)grep("[^aeiouy]{2}",paste(s,""))

ลองออนไลน์!

คำตอบ JavaScript ของพอร์ตของ Arnauld; ส่งคืน 1 สำหรับคำที่อ่อนแอและinteger(0)สำหรับผู้ที่แข็งแรง; มันผนวก(ช่องว่าง) ต่อท้ายของสตริง

นี่คือ vectorized จริง ๆ ; ด้วยเวกเตอร์ของสตริงมันจะส่งกลับดัชนี (1-based) ของคำที่อ่อนแอ

Dyalog APL ขนาด 20 ไบต์

⎕←∧/2∨/0,⍨⍞∊'aeiouy'

ลองออนไลน์!

Haskell , 61 54 ไบต์

f=and.(zipWith(||)=<<tail).(map(`elem`"aeiouy")).(++"z")

ลองออนไลน์!

ฉันต้องเพิ่ม a zท้ายสตริงเพื่อจัดการกับพยัญชนะท้าย

Java (OpenJDK 8) , 93 81 ไบต์

s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}

ลองออนไลน์!

Huskขนาด 12 ไบต์

ΛΣX_2m€¨γaıu

ลองออนไลน์!

ขอบคุณH.PWizสำหรับความช่วยเหลือในการ -4 ส่งคืนค่าที่ไม่สอดคล้องกัน แต่เหมาะสมตามความจริงหรือเป็นเท็จ
ขอบคุณLeoสำหรับ -1 ตอนนี้คืนค่าความจริง / ค่าเท็จที่สอดคล้องกัน

Pyth , 18 ไบต์

:+Q1."2}M>åYà

ตรวจสอบกรณีทดสอบทั้งหมด

"ยืม" regex จากคำตอบที่ JS สิ่งนี้จะส่งกลับFalseสำหรับคำที่แข็งแกร่งTrueมิฉะนั้น

Brachylog , 18 11 10 ไบต์

,Ḷs₂{¬∈Ẉ}ᵐ

ลองออนไลน์!

เรียบร้อยและเรียบง่าย (ยกเว้นอาจเพิ่ม 2 ไบต์แรกเริ่มเพื่อจัดการกรณีตัวอักษรสุดท้ายเช่น "นกแก้ว")

เป็นเท็จสำหรับคำที่แข็งแกร่งและความจริงสำหรับคำที่ไม่แข็งแกร่ง

,Ḷ               % append a newline (non-vowel) at the end of input, 
                 %   to catch final consonants
     s₂          % the result has some substring of length 2
       {¬∈Ẉ}ᵐ    % where neither of its elements belong to  
                 %   the set of alternate vowels (with "y")

Python 2 , 58 ไบต์

-30 ไบต์โดยไม่ทราบว่ามันสามารถจะเป็นง่ายๆเป็นArnauld คำตอบของ

lambda s:re.search('[^aeiouy]([^aeiouy]|$)',s)<1
import re

ลองออนไลน์!

Perl 5, 31 ไบต์ (30 + 1)

$_=''if/[^aeiouy](?![aeiouy])/

+1 ไบต์สำหรับการ-pตั้งค่าสถานะบรรทัดคำสั่ง พิมพ์คำหากมันเป็นคำที่แข็งแกร่งหรือสตริงที่ว่างเปล่าถ้ามันไม่ได้

เยลลี่ 11 ไบต์

e€ØY;1a2\¬Ȧ

ลองออนไลน์!

e€ØY;1a2\¬Ȧ  Main link
 €           For each letter
e            Is it an element of
  ØY         The consonants (excluding Yy)?
    ;1       Append 1 (true) (consonant) to make sure last letter isn't consonant
       2\    For all (overlapping) slices of length 2 (the <link><nilad>\ functionality)
      a      Logical AND of the two values; is it a consonant pair?
         ¬   Logical NOT vectorizing; for each (overlapping) pair, is it not a consonant pair?
          Ȧ  Any and all; make sure all pairs are not consonant pairs

ใช่ฉันรู้ว่าโจนาธานอัลลันถูกทุบตีอย่างหนัก แต่ฉันต้องการแบ่งปันวิธีการของฉันต่อไป: พี

-4 ไบต์โดยการขโมยคำตอบของ Jonathan Allan เล็กน้อย (แทนการเพิ่มตัวอักษรเพื่อตรวจสอบตัวอักษรตัวสุดท้ายของตัวอักษรท้ายเพียงแค่ต่อท้าย 1)
-1 byte ขอบคุณไมล์

อ๊ะ 39 ไบต์

/([^aeiouy]{2}|[^aeiouy]$)/{print "n"}

พิมพ์nสำหรับคำที่ไม่รัดกุมไม่มีอะไร (หรือเพียงแค่ขึ้นบรรทัดใหม่) สำหรับ strongword

ติดตามแพ็คและค้นหาสองสระที่ไม่ต่อเนื่องกันบนอินพุตตัวพิมพ์เล็ก

การทดสอบ

$ awk -f strongwork.awk
hate
love
popularize
academy
you
mouse
acorn
n
nut
n
ah
n
strong
n
false
n
parakeet
n

Kotlin , 49 ไบต์

{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}

จริงและเท็จถูกสับเปลี่ยน

เชิดชู

{
    Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)
}

ทดสอบ

var s:(String)->Boolean =
{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    val items = listOf(
            TestData("hate", true),
            TestData("love", true),
            TestData("popularize", true),
            TestData("academy", true),
            TestData("you", true),
            TestData("mouse", true),
            TestData("acorn", false),
            TestData("nut", false),
            TestData("ah", false),
            TestData("strong", false),
            TestData("false", false),
            TestData("parakeet", false)
    )

    items
            .filter { s(it.input) == it.output }
            .forEach { throw AssertionError(it.toString()) }

    println("Test Passed")
}

TryItOnline

ตามคำตอบของ @ Arnauld

เรติน่า23 23ไบต์

$
$
1`[^aeiouy]{2}

ลองออนไลน์! เอาต์พุต 0 สำหรับค่า strong, 1 หากไม่ใช่ เพิ่ม 1 ไบต์เพื่อรองรับกรณีผสม แก้ไข: บันทึก 5 ไบต์ขอบคุณ @ovs

Java 8, 53 42 ไบต์

s->s.matches(".*[^aeiouy]([^aeiouy].*|$)")

-11 ไบต์โดยใช้ regex เช่นเดียวกับใน@jrtapsell 's คำตอบ Kotlinแทน

ลองที่นี่ ( falseถ้าแข็งแกร่งtrueถ้าไม่)

คำอธิบาย:

s->               // Method with String parameter and boolean return-type
  s.matches(      //  Checks if the String matches the following regex:
    ".*           //   One or more characters
     [^aeiouy]    //   Followed by a consonant
     ([^aeiouy].* //   Followed by another consonant (+ any more characters)
      |$)")       //   Or the end of the String
                  // End of method (implicit / single-line return statement)

โดยพื้นฐานแล้วตรวจสอบว่าเราสามารถหาพยัญชนะสองตัวที่อยู่ติดกันหรือไม่หรือว่า String ลงท้ายด้วยตัวอักษร

คำตอบเก่า ( 53 ไบต์ ):

s->s.matches("[aeiouy]*([a-z&&[^aeiouy]][aeiouy]+)*")

ลองที่นี่ ( trueถ้าแข็งแกร่งfalseถ้าไม่)

ใช้ regex เพื่อดูว่า Input-String ตรงกับ 'strong'-regex โปรดทราบว่าString#matchesใน Java จะเพิ่มโดยอัตโนมัติ^...$เพื่อตรวจสอบว่าสตริงตรงกับ regex ที่กำหนดทั้งหมด

คำอธิบาย ":

 s->                   // Method with String parameter and boolean return-type
  s.matches(           //  Checks if the String matches the following regex:
    "[aeiouy]*         //   0 or more vowels
    ([a-z&&[^aeiouy]]  //     { A consonant,
     [aeiouy]+)        //       plus one or more vowels }
    *")                //    Repeated 0 or more times
                       // End of method (implicit / single-line return statement)

การค้นหาแทนการจับคู่ (เช่นการใช้คำตอบอื่น ๆ ) เป็นจริงใน Java:
70 ไบต์ :

s->java.util.regex.Pattern.compile("[^aeiouy]{2}").matcher(s+0).find()

ลองที่นี่ ( falseถ้าแข็งแกร่งtrueถ้าไม่)

Ruby , 25 ไบต์

->w{w+?t!~/[^aeiouy]{2}/}

ลองออนไลน์!

ทุกคนกำลังทำมันอยู่ทำไมทับทิมถึงทำไม่ได้ล่ะ?

SOGL V0.12 , 19 18 ไบต์

æ"[^ŗy]”ŗ(ŗ|$)”øβ=

ลองที่นี่!

คำอธิบาย:

æ                   push "aeiou"
 "[^ŗy]”            push "[^ŗy]" with ŗ replaced with pop
        ŗ(ŗ|$)”     push `ŗ(ŗ|$)` with ŗ replaced with pop
               øβ   replace in the input that regex with nothing
                 =  check for equality with the original input

05AB1E , 11 ไบต์

žP¹SåJ1«11å

ลองออนไลน์!

ใช้อัลกอริทึมของ Jonathan ส่งกลับค่า0จริงและ1เท็จ

Swift 3.1 , 85 bytes

import Foundation
{($0+"0").range(of:"[^aeiouy]{2}",options:.regularExpression)==nil}

ลองที่นี่!

นี้ยืมregex Arnauld ของ

Lua, 41 ไบต์

return#(io.read()..0):match"[^aeiouy]+"<2

อ่านจากอินพุตมาตรฐาน

Lua (loadstring'ed), 37 ไบต์

return#((...)..0):match"[^aeiouy]+"<2

อ่านจากฟังก์ชั่นพารามิเตอร์

อินพุตเป็นตัวพิมพ์เล็ก

ดูว่ามีสตริงที่มีความยาว 2 หรือมากกว่าประกอบด้วยเสียงสระ (พยัญชนะ) เท่านั้นหรือหากสตริงลงท้ายด้วยเสียงสระ

ส่งคืนจริง / เท็จ

C ++, 195 194 ไบต์

-1 ไบต์ขอบคุณZacharý

ตัวพิมพ์ใหญ่ส่งคืนค่าจริงถ้าอินพุตเป็นคำที่แข็งแกร่งเท็จเป็นอย่างอื่น (C ++ มีกฎการใช้งานแบบง่ายต่อการส่งผลโดยนัย bool, 0 => เท็จเป็นจริงมิฉะนั้น)

#include<string>
#define C(p)(v.find(e[p])==size_t(-1))
std::string v="AEIOUY";int s(std::string e){for(int i=0;i<e.size()-1;++i)if(e[i]>64&&e[i]<91&&C(i)&&C(i+1))return 0;return!C(e.size()-1);}

รหัสที่จะทดสอบ:

auto t = {
    "HATE",
    "LOVE",
    "POPULARIZE",
    "ACADEMY",
    "YOU",
    "MOUSE",
    "ACORN",
    "NUT",
    "AH",
    "STRONG",
    "FALSE",
    "PARAKEET"
};

for (auto&a : t) {
    std::cout << (s(a) ? "true" : "false") << '\n';
}

C, 107 ไบต์

i,v,w,r,t;a(char*s){w=0;for(r=1;*s;s++){v=1;for(i=6;v&&i;)v=*s^" aeiouy"[i--];r=w&&v?0:r;w=v;}return r&~v;}

ส่งคืน 1 สำหรับคำที่แข็งแกร่งและ 0 สำหรับคำที่อ่อนแอ ทดสอบกับคำที่ให้ไว้ในโพสต์หลัก

C (gcc) , 59 ไบต์

f(char*s){return*s?strcspn(s,"aeiouy")+!s[1]<2?f(s+1):0:1;}

ลองออนไลน์!

PHP, 69 ไบต์

preg_match("/([^AEIOUY][^AEIOUY]+|[^AEIOUY]$)/",$_SERVER['argv'][1]);

ส่งคืน1คือคำไม่แข็งแรง

CJam , 57 ไบต์

q{"aeiouy"#W=}%_,:B{_A={_A_)\B(<{=!X&:X;}{0:X;;;}?}&}fA;X

ลองออนไลน์!

อ่านอินพุตแปลงเป็น 1s สำหรับพยัญชนะ 0s สำหรับสระ สำหรับพยัญชนะทุกตัวและตัวแปร X ที่กำหนดไว้ล่วงหน้าแล้ว (ที่กำหนดไว้ล่วงหน้าถึง 1) พร้อมค่าของตัวละครถัดไป เอาท์พุท X