भंवर शब्द खोजें!

Question

मुझसे यह मत पूछो कि कैसे या क्यों लेकिन एक परियोजना पर कोडिंग करते समय मैंने देखा कि कुछ शब्दों के वर्णों में वर्णमाला को संदर्भित एक विशेष पैटर्न था, मैंने वर्णमाला पर पेंसिल के साथ शब्दों के प्रत्येक चरित्र को जोड़ा और मैंने दो प्राप्त किए सर्पिल, तब मैंने देखा कि पहला सर्पिल दक्षिणावर्त था और दूसरा वामावर्त था, और अन्य विशेषताएँ ... इसलिए मैंने उन्हें स्वार्लिंग शब्द का नाम दिया !

एक घूमता शब्द हो सकता है:

1. दक्षिणावर्त या वामावर्त
2. सेंट्रीपीटल या सेंट्रीफ्यूगल

यहाँ घूमने वाले शब्दों के कुछ उदाहरण दिए गए हैं :

कार्य 1:

एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें जो मानक इनपुट से एक शब्द लेगा और आउटपुट होगा यदि एक घूमता हुआ शब्द है और यह एक पठनीय प्रारूप, विस्तारित पाठ, 3 वर्ण, झंडे, आदि में विशेषताओं है।

विभिन्न मामलों के लिए परीक्षण के मामले और उदाहरण के आउटपुट (लेकिन आप यह तय कर सकते हैं कि परिणामों का प्रतिनिधित्व कैसे करें):

EARTH, GROUP            > NO        // NOT A SWIRLING WORD
OPERA, STAY, IRIS       > SW,CF,CW  // SWIRLING WORD, CENTRIFUGAL, CLOCKWISE
MINER, TAX, PLUG, META  > SW,CF,CC  // SWIRLING WORD, CENTRIFUGAL, COUNTERCLOCKWISE
AXIOM, AXIS, COOK       > SW,CP,CW  // SWIRLING WORD, CENTRIPETAL, CLOCKWISE
WATCH, YETI, PILL       > SW,CP,CC  // SWIRLING WORD, CENTRIPETAL, COUNTERCLOCKWISE

MORE EXAMPLES OF FALSE TEST CASES (NOT SWIRLING WORDS): 
EARTH, GROUP, OUTPUT, WORD, CONNECTION, ODD, MOM, DAD, 
CHARACTER, EXAMPLE, QUESTION, NEWSLETTER, OTHER

नियम:

1. पहले दो वर्णों के बीच का कनेक्शन ऊपर होना चाहिए (जैसे ग्राफिक्स), सभी समान कनेक्शन नीचे होने चाहिए , सभी विषम कनेक्शन ऊपर होने चाहिए ।
2. आप ऊपरी / निचले हिस्से को अनदेखा कर सकते हैं या सभी ऊपरी मामले या सभी निचले मामलों में परिवर्तित / विचार कर सकते हैं।
3. इनपुट शब्द केवल AZ की वर्णमाला श्रेणी के अक्षर हैं, कोई स्थान नहीं, कोई विराम चिह्न आदि नहीं।
4. यदि किसी शब्द में दोहरे वर्ण हैं, जैसे "GROOVE", तो आपको युगल को एक वर्ण में ढहाना होगा: "GROOVE"> "GROVE"।
5. इनपुट शब्दों में कम से कम 3 अलग अक्षर होंगे। "MOM", "DAD", "LOL" जैसे शब्द मान्य शब्द नहीं हैं।
6. एक ही चरित्र में कई बार पास करना संभव है, जैसे "आईआरआईएस"।
7. सबसे छोटा कोड जीतता है।

कार्य 2:

अधिक प्रतिष्ठा प्राप्त करने के लिए, सबसे लंबे घूमने वाले शब्द ढूंढें , और इसकी विशेषताएं हैं, कि आप उपरोक्त नियमों का पालन करते हुए अंग्रेजी शब्दकोश में खोज सकते हैं। उदाहरण के लिए आप यहां अंग्रेजी शब्दों की पूरी सूची का संदर्भ ले सकते हैं ।

हैप्पी कोडिंग!

Comments

अच्छा चित्र! :) (और अच्छी चुनौती, भी;))

— मार्टिन एंडर

"घूमता" छोड़ना एक वैध आउटपुट प्रारूप होगा, क्योंकि यह निहित है जब इनपुट "नहीं घूमता है"?

— मार्टिन एंडर

@MartinEnder हाँ, चूंकि यह समझ में आता है कि यह घूमता है या नहीं, "नहीं" और "1" के लिए "हाँ" आदि के लिए खाली हो सकता है, (खुशी है कि आपको आरेख और चुनौती पसंद है! :))

— मारियो

@ टिम्मीड लेकिन सभी ऊबड़-खाबड़ शब्द नहीं घूम रहे हैं। :)

— मार्टिन एंडर

@ लियन सराहना और सुझावों के लिए धन्यवाद, मैं भविष्य के लिए सुधार करने की कोशिश करूंगा। मैंने लोगों से यह पूछने के लिए "डबल हटा दें" नियम जोड़ा कि "युगल होने पर हम क्या करते हैं?" > आप डबल्स को 1 सिंगल कैरेक्टर मान सकते हैं क्योंकि "L" से "L" पर जाना ज़ीरो डिस्टेंस है :) ऐसा नहीं है कि मैं इसके लिए ट्रिकी मुश्किलें जोड़ना चाहता था।

— मारियो

Answer 1

MATL , 33 31 30 बाइट्स

lydhg)dt|dZSXz&=wZSdh?4M1)3M1)

इनपुट अपरकेस अक्षरों में है (या निचले अक्षरों में, लेकिन मिश्रित नहीं है)।

आउटपुट है:

• यदि शब्द गैर-घूमता है: कोई आउटपुट नहीं बनता है
• अगर यह घूमता है: दो नंबर अलग-अलग लाइनों में निर्मित होते हैं:
  • पहला नंबर 1/ -1 सेंट्रीफ्यूगल / सेंट्रिपेटल दर्शाता है।
  • दूसरी संख्या 1/ `-1 'दक्षिणावर्त / वामावर्त इंगित करती है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (सभी इनपुट लेने के लिए संशोधित कोड और एक ही लाइन पर दो आउटपुट नंबर का उत्पादन करने के लिए)

व्याख्या

'OPERAA'एक उदाहरण के रूप में इनपुट लेते हैं ।

कोड का पहला भाग दोहरे अक्षरों को हटा देता है:

l     % Push 1
      %   STACK: 1
y     % Take input implicitly from below, and duplicate
      %   STACK: 'OPERAA', 1, 'OPERAA'
d     % Convert to code points and compute differences
      %   STACK: 'OPERAA', 1, [1 -11  13 -17 0]
h     % Concatenate horizontally
      %   STACK: 'OPERAA', [1 1 -11  13 -17 0]
g     % Convert to logical
      %   STACK: 'OPERAA', [true true true true true false]
)     % Index
      %   STACK: 'OPERA'

अब हम जांचते हैं कि अक्षरों के बीच की दूरी गैर-घटती है (शब्द घूमने के लिए आवश्यक स्थिति):

d     % Convert to code points and compute differences
      %   STACK: [1 -11  13 -17]
t|    % Duplicate and take absolute value
      %   STACK: [1 -11  13 -17], [1 11  13 17]
d     % Differences
      %   STACK: [1 -11  13 -17], [10 2 4]
ZS    % Signum
      %   STACK: [1 -11  13 -17], [1 1 1]
Xz    % Remove zeros (gives a vertical vector). Needed for words like 'IRIS',
      % where some consecutive distances are equal
      %   STACK: [1 -11  13 -17], [1; 1; 1]
&=    % All pairwise equality comparisons. Gives a matrix. If all the signs 
      % were equal the matrix will contain all ones
      %   STACK: [1 -11  13 -17], [1 1 1; 1 1 1; 1 1 1]

हम तब जांचते हैं कि क्या अक्षर आगे और पीछे जाते हैं (यह शब्द घूमने के लिए दूसरी शर्त है):

w     % Swap
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [1 -11  13 -17]
ZS    % Signum
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [1 -1 1 -1]
d     % Differences
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [-2 2 -2]

अंत में, हम जाँचते हैं कि क्या दो स्थितियाँ हैं, और उस स्थिति में आउटपुट का उत्पादन होता है:

h     % Concatenate horizontally
      %   STACK: [1 1 1 1 1 1 1 1 1 -2 2 -2]
?     % If all elements are nonzero
  4M  %   Push first signum array without zeros, from the automatic clipboard
      %     STACK: [1; 1; 1]
  1)  %   Get first element (tells if first difference was positive or negative)
      %     STACK: 1
  3M  %   Push second signum array, from the automatic clipboard
      %     STACK: 1, [1 -1 1 -1]
  1)  %   Get first element (tells if first movement was right or left)
      %     STACK: 1, 1
      %   Implicitly end if
      % Implicitly display

Answer 2

गणितज्ञ, ११hem १११ बाइट्स

JHM को 6 बाइट बचाने और बूट करने के लिए इसे असंवेदनशील बनाने के लिए धन्यवाद!

 {o=OrderedQ/@{a=Abs[d=Differences[#&@@@Split@LetterNumber@#]],Reverse@a},d[[1]]>0,Or@@o&&Max[Most[d]Rest@d]<0}&

फ़ंक्शन जो स्ट्रिंग लेता है और प्रपत्र में बूलियनों की एक नेस्टेड सूची देता है {{B1,B2},B3,B4}। बी 4 रिकॉर्ड करता है कि क्या शब्द घूम रहा है (और यदि यह नहीं है, तो बाकी आउटपुट कचरा है)। यदि शब्द घूम रहा है, तो बी 1 रिकॉर्ड करता है कि क्या शब्द केन्द्रापसारक है, बी 2 रिकॉर्ड करता है कि क्या शब्द सेंट्रिपेटल है, और बी 3 रिकॉर्ड है कि क्या शब्द दक्षिणावर्त (सत्य) या वामावर्त (गलत) है।

यहाँ एक लंबे समय तक संस्करण है कि बाद प्रक्रियाओं (पहली पंक्ति) से ऊपर समारोह (2-5 लाइनों पर स्थान दिया गया है) यह ओपी के समान बनाने के लिए है: NOअगर शब्द घूमता नहीं है और का उचित विकल्प {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}, या {SW,CP,CC}अगर शब्द घूम रहा है:

If[#3, {SW, If[#[[1]], CF, CP], If[#2, CW, CC]}, NO] & @@
  {o = OrderedQ /@
    {a = Abs[d = Differences[# & @@@ Split@LetterNumber@#]], Reverse@a},
  d[[1]] > 0,
  Or @@ o && Max[Most[d] Rest@d] < 0} &

यह स्पष्टीकरण मार्टिन एंडर के सीजाम के उत्तर के समान है, एक अतिरिक्त नोट के साथ: निरंतर अंतर की सूची शब्द घूमने के लिए वैकल्पिक रूप से साइन इन होनी चाहिए, और यह सुनिश्चित करके पता लगाया जा सकता है कि लगातार अंतर के जोड़े के सभी उत्पाद नकारात्मक हैं (ऐसा ही Max[Most[d]Rest@d]<0होता है)।

मैथमेटिका के सभी 40,000+ शब्दों पर फ़ंक्शन चलाने पर WordList[], हमें निम्नलिखित 8-अक्षर घूमने वाले शब्द मिलते हैं, जो उनके संबंधित ज़ुल्फ़ों के प्रकारों में सबसे लंबे होते हैं:

operetta    {SW, CF, CW}
opposite    {SW, CF, CW}
stowaway    {SW, CF, CW}
assassin    {SW, CP, CW}
assessor    {SW, CP, CW}
baccarat    {SW, CF, CC}
keenness    {SW, CF, CC}
positive    {SW, CF, CC}

(ब्राउनी positiveके पास कोई दोहरा अक्षर नहीं होने की तुलना में कम दोहराए जाने वाले पत्र हैं stowaway।)

लेकिन पूर्ण चैंपियन 9-अक्षर वामावर्त-घूमता सेंट्रिपेटल शब्द है vassalage!

Comments

आप 3 बाइट्स के LetterNumberबजाय ToCharacterCodeऔर 3 बाइट्स का उपयोग करके बचा सकते Most[d]हैं Drop[d,-1]।

— जंगवान मिन ऑक्ट

Answer 3

स्काला, 110 बाइट्स

def/(s:String)={val ? =s.sliding(2).map(t=>(t(0)-t(1)).abs).toSeq
(Seq(?,?reverse)indexOf(?sorted),s(0)<s(1))}

के (a,b)साथ एक टपल लौटाता है

• a == 1 अगर s सेन्टिपेटल है
• a == 0 अगर एस सेंट्रीफ्यूगल है
• a == -1 अगर घूमता नहीं है

तथा

• b == true यदि दक्षिणावर्त है
• b == false अगर एस वामावर्त है
• b सही या गलत हो सकता है यदि s घूमता नहीं है

स्पष्टीकरण:

def/(s:String)={      //define a method called / with a String argument
  val ? =s            //define ? as...
    .sliding(2)       //an iterator for each two consecutive elements
    .map(t=>          //foreach 2 chars
      (t(0)-t(1)).abs //get the absolute value of their difference
    ) 
    .toSeq            //and convert the iterator to a Seq, because iterator doesn't have reverse and sorted methods
  (                   //return a tuple of
    Seq(?,?reverse)     //a Seq of ? and reversed ?
    .indexOf(?sorted)   //and check which of them is sorted ?
  ,                   //and
   s(0)< s(1)          //the difference bewteen the first two elements of the string.
  )
}

Answer 4

जेली , 30 बाइट्स

3Ŀḟ0ṠE
ÑṠḟ0Ṃ
ÑAI
OIḟ0
ÇṠḢ;2Ŀ;Ñ

TryItOnline
या परीक्षण के मामलों को देखें(बहुत ही पिछलेÑनए मुख्य लिंक की ओर इशारा करते हुएथोड़े बदलाव के साथ)

(मेरे कौशल का पीछा करने की कमी शायद कुछ बाइट्स की लागत है)
सभी ऊपरी या सभी निचले।
एक ध्वज सूची लौटाता है [D, F, S]:
S: कताई = 1 / कताई नहीं = 0
F: केन्द्रापसारक = 1 (गोलाकार = 0) centripetal = -1
D: दक्षिणावर्त = 1 / प्रतिलोकवार = -1
- यदि S = 0 अन्य झंडों का मूल्यांकन तब भी किया जाता है, जब वे कोई उपयोगी जानकारी नहीं देते हैं।

कैसे?

3Ŀḟ0ṠE      - Link 1, isSpinning: s
3Ŀ          - call link 3 as a monad with s
  ḟ0        - filter out zeros
    Ṡ       - sign
     E      - all equal?

ÑṠḟ0Ṃ       - Link 2, centrifugal(-1), circular(0) or centripetal(1): s
Ñ           - call next link (3) as a monad with s
 Ṡ          - sign (+1 for positive changes, -1 for negative changes, 0 for no change)
  ḟ0        - filter out zeros (ignore these for cases like "IRIS")
    Ṃ       - minimum (will be the only value for spinning words)
            -    (circular words like "DAD", now excluded, yield min([])=0)

ÑAI         - Link 3, absolute change of moves over alphabet: s
Ñ           - call next link (4) as a monad with s
 A          - absolute
  I         - differences

OIḟ0        - Link 4, non-zero moves over alphabet: s
O           - ordinal cast
 I          - differences
  ḟ0        - filter out zeros

ÇṠḢ;2Ŀ;Ñ    - Main link: s
Ç           - call last link (4) as a monad with s
 Ṡ          - sign
  Ḣ         - head (clockwise / anticlockwise: 1 / -1)
   ;  ;     - concatenate
    2Ŀ      - call link (2) as a monad with s
       Ñ    - call next link (1) as a monad with s

Comments

मुझे लगता है कि आप अनुभव कर रहे हैं कि मैं यहां "नौसिखिया सिंड्रोम" क्या कहता हूं। मैं बिलकुल तुम्हारे जैसा ही महसूस करता हूं। शायद डेनिस यहां कुछ मदद कर सकता है। लेकिन, I + 1'd, सिर्फ इसलिए कि मैंने देखा कि यह जेली में संभव है। इसके अलावा, आप परिपत्र मामले को हटा सकते हैं; यह अब मौजूद नहीं है।

— आउटगॉल्फ

परिपत्र शब्दों के बारे में प्रहार के लिए धन्यवाद - जैसा कि यह पता लगाने के लिए 6 बाइट्स निकलता है वास्तव में अनावश्यक थे क्योंकि एक खाली सूची के न्यूनतम 0इसलिए यह अभी भी उन लोगों के लिए भी काम करता है!

— जोनाथन एलन

तो, यह उनके लिए काम करना चाहिए ? मुझे लगता है कि circular(0)आपके पास अभी भी आपके स्पष्टीकरण के अंदर है, शायद इसे हटाने का समय है।

— आउटगॉल्फ

यह आवश्यक नहीं है, नहीं - लेकिन यह कोड अभी भी हटाने के बाद करता है जो मैंने स्पष्ट रूप से उपयोग करने के लिए उपयोग किया था, ऐसा इस तथ्य के कारण है कि min([])=0 jelly.tryitonline.net/#code=W13huYI&input= - ध्यान दें कि अब परिपत्र शब्द कभी नहीं हैं। अपेक्षित इनपुट, उनके लिए खानपान में कोई समस्या नहीं है।

— जोनाथन एलन

मैंने आपसे डबल-चेक करने के लिए कहा था। और, मैं समझ गया कि आपका मतलब है min([])==0, लेकिन मुझे लगा कि यह अभी भी गोल्फ है।

— आउटगॉल्फ

Answer 5

सीजेएम , 39 बाइट्स

r{2ew::-V}:D~-_:g_0=\D#)!@:zD-:g_0=\(-!

इसे ऑनलाइन आज़माएं!

इनपुट अपरकेस या लोअरकेस हो सकता है, लेकिन मिश्रित नहीं।

कार्यक्रम अनजाने में उन शब्दों को इंगित करता है जो जरूरी नहीं कि केन्द्रापसारक या सेंट्रिपेटल हैं, लेकिन अन्यथा सर्पिल होने की आवश्यकताओं को पूरा करते हैं। इन्हें नीचे दिए गए चार्ट में "परिपत्र" के रूप में वर्णित किया गया है।

आउटपुट की व्याख्या करने के लिए इस चार्ट का उपयोग करें:

SPIRAL (output contains four 1s)
-11-11 : Clockwise Centrifugal
-1111  : Clockwise Centripetal
11-11  : Counter-clockwise Centrifugal
1111   : Counter-clockwise Centripetal

CIRCULAR (output contains two 1s)
-11    : Clockwise Circular
11     : Counter-clockwise Circular

NONSPIRAL (output contains a 0)

स्पष्टीकरण:

कार्यक्रम वास्तव में मूल्यांकन करता है कि क्या वर्णों के बीच गैर-शून्य मतभेदों का क्रम सकारात्मक या नकारात्मक शुरू होता है, अगर यह संकेत में वैकल्पिक होता है, अगर परिमाण बढ़ने या घटने लगते हैं, और यदि ऐसा करना जारी रहता है। यदि परिमाण में वृद्धि या कमी नहीं होती है, तो प्रोग्राम खाली सरणी पर संचालित होकर टूट जाता है। प्रमुख चरण नीचे दिखाए गए हैं (यह कोड स्टैक की प्रगति भी दिखाएगा):

r{2ew::-V}:D~-   e# take difference of overlapping pairs, removing 0s handles duplicates
               ede# store difference function plus 0 as D, it's multipurpose
_:g_0=\          e# compute signs differences, keep first to show starting direction
               ede# -1 = CLOCKWISE, 1 = COUNTERCLOCKWISE
D#)!@            e# difference of signs includes 0 if not alternating, keep in stack
               ede# 1 = ALTERNATING, 0 = NOT ALTERNATING
:zD-:g           e# signs of difference of absolute values, ignoring 0s (fixed magnitude)
_0=\             e# keep first sign in stack to indicate how the sequence starts
               ede# -1 = INCREASING, 1 = DECREASING
(-!              e# remove first item from entire list and see if nothing remains
               ede# 1 = EMPTY(MONOTONE), 0 = NONEMPTY

Answer 6

PHP, 322 बाइट्स

for(;++$i<strlen($z=preg_replace("#(.)\\1#","$1",$argv[1]));){$t[]=$z[$i-1]<=>$z[$i]?:0;$o[]=$z[0]<=>$z[$i];$i<2?:$k[]=$z[$i-2]<=>$z[$i];}$s=preg_match("#^1?(-11)*(-1)?$#",join($t))?($t[0]!=1?1:2):0;$s+=2*preg_match($r="#^(-1|0)?([01](-1|0))*[01]?$#",join($o));$s*=preg_match($r,join($k));count_chars($z,3)[2]?:$s=0;echo$s;

अधिक सुंदर आउटपुट के लिए echo["n","+P","-P","+F","-F"][$s];

विस्तारित संस्करण

for(;++$i<strlen($z=preg_replace("#(.)\\1#","$1",$argv[1]));){
    $t[]=$z[$i-1]<=>$z[$i]?:0;
    $o[]=$z[0]<=>$z[$i];
    $i<2?:$k[]=$z[$i-2]<=>$z[$i];
    }
$s=preg_match("#^1?(-11)*(-1)?$#",join($t))?($t[0]!=1?1:2):0; #Clockwise direction or not
$s+=2*preg_match($r="#^(-1|0)?([01](-1|0))*[01]?$#",join($o)); # True centrifugal
$s*=preg_match($r,join($k)); #true or false second test for not
count_chars($z,3)[2]?:$s=0; # word must have >2 different characters
echo$s;# short output
echo["n","+P","-P","+F","-F"][$s]; #long output alternative

लघु युगल नियम के बिना टास्क 2 दूसरा मूल्य

4 -F हत्या 11 बाइट्स 10 बाइट्स को सकारात्मक बनाते हैं

3 + एफ विरोधी 10 बाइट्स लॉगोगॉग 9 बाइट्स

२ -२ वशीकरण ९ बाइट्स सार्कोकोल, ससारारा। बाइट्स

1 + पी का उपयोग करें

एक शब्द कल्पना

header('Content-Type: image/svg+xml; charset=UTF-8');
$w=$_GET["w"]??"OOPERRA";
$w=strtoupper($w);
echo '<?xml version="1.0" encoding="UTF-8"?>'
.'<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'

.'<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 -100 420 400">'
.'<title>Swirl Word</title><desc>Viualize a Word</desc>';
echo '<text x="210" y="-50" text-anchor="middle" font-family="arial">'.$w.'</text>';

foreach(range("A","Z")as $x=>$c){
    echo '<text x="'.(15+$x*15).'" y="110" text-anchor="middle" font-family="arial">'.$c.'</text>';
    $r[$c]=15+$x*15;
}
for($i=0;++$i<strlen($w);){
    echo '<path d="M '.($r[$w[$i-1]]).',105 A '.($radius=abs($r[$w[$i]]-$r[$w[$i-1]])/2).' '.($radius).' 0 0 0 '.($r[$w[$i]]).',105" style="stroke:gold; stroke-width:1px;fill:none;" />';
}
echo '</svg>';  

स्निपेट में मेरे द्वारा बनाए गए एसवीजी का परिणाम है

<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 -100 420 400"><title>Swirl Word</title><desc>Viualize a Word</desc><text x="210" y="-50"  text-anchor="middle" font-family="arial">KILLINGNESS</text><text x="15" y="110" text-anchor="middle" font-family="arial">A</text><text x="30" y="110" text-anchor="middle" font-family="arial">B</text><text x="45" y="110" text-anchor="middle" font-family="arial">C</text><text x="60" y="110" text-anchor="middle" font-family="arial">D</text><text x="75" y="110" text-anchor="middle" font-family="arial">E</text><text x="90" y="110" text-anchor="middle" font-family="arial">F</text><text x="105" y="110" text-anchor="middle" font-family="arial">G</text><text x="120" y="110" text-anchor="middle" font-family="arial">H</text><text x="135" y="110" text-anchor="middle" font-family="arial">I</text><text x="150" y="110" text-anchor="middle" font-family="arial">J</text><text x="165" y="110" text-anchor="middle" font-family="arial">K</text><text x="180" y="110" text-anchor="middle" font-family="arial">L</text><text x="195" y="110" text-anchor="middle" font-family="arial">M</text><text x="210" y="110" text-anchor="middle" font-family="arial">N</text><text x="225" y="110" text-anchor="middle" font-family="arial">O</text><text x="240" y="110" text-anchor="middle" font-family="arial">P</text><text x="255" y="110" text-anchor="middle" font-family="arial">Q</text><text x="270" y="110" text-anchor="middle" font-family="arial">R</text><text x="285" y="110" text-anchor="middle" font-family="arial">S</text><text x="300" y="110" text-anchor="middle" font-family="arial">T</text><text x="315" y="110" text-anchor="middle" font-family="arial">U</text><text x="330" y="110" text-anchor="middle" font-family="arial">V</text><text x="345" y="110" text-anchor="middle" font-family="arial">W</text><text x="360" y="110" text-anchor="middle" font-family="arial">X</text><text x="375" y="110" text-anchor="middle" font-family="arial">Y</text><text x="390" y="110" text-anchor="middle" font-family="arial">Z</text><path d="M 165,105 A 15 15 0 0 0 135,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 135,105 A 22.5 22.5 0 0 0 180,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 180,105 A 0 0 0 0 0 180,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 180,105 A 22.5 22.5 0 0 0 135,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 135,105 A 37.5 37.5 0 0 0 210,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 210,105 A 52.5 52.5 0 0 0 105,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 105,105 A 52.5 52.5 0 0 0 210,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 210,105 A 67.5 67.5 0 0 0 75,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 75,105 A 105 105 0 0 0 285,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 285,105 A 0 0 0 0 0 285,105" style="stroke:gold; stroke-width:1px;fill:none;" /></svg>

Comments

महान घूमता शब्द दर्शक! :) हो सकता है कि आप वर्णों को आधे वृत्त के बजाय आधे दीर्घवृत्त के साथ जोड़ने का प्रयास कर सकें। यह अधिक कॉम्पैक्ट होगा और अधिक "डायनामिक" दिखेगा। लेकिन वैसे भी बहुत अच्छा लग रहा है!

— मारियो

@ मोरियो को इसके '.(.8*$radius).'बजाय केवल एक कारक की आवश्यकता होती है '.($radius).'और यदि आप कार्यक्रम को बदलते हैं ($radius).' 0 0 0, ($radius).' 0 0 '.(($w[$i-1]<$w[$i]?1:0)^(($i-1)%2)).'तो एक निश्चित दिशा नहीं है

— Jörg Hülsermann

Answer 7

हास्केल, 148 बाइट्स

z f=tail>>=zipWith f
g c=and.z c.filter(/=0).map abs.z(-).map fromEnum
(a:b:r)%c|a==b=(b:r)%c|1<3=c a b
f s|a<-[g(>=)s,g(<=)s]=or a:a++[s%(<),s%(>)]

Ideone पर इसे आज़माएं।

इनपुट या तो अल लोअर होना चाहिए या सभी अपर-केस।
आउटपुट पांच बूलियन की एक सूची है [SW?, CF?, CP?, CW?, CC?]:।

f "positive" -> [True,True,False,False,True]

यह उम्मीद से अधिक लंबा हो गया, विशेष रूप से दोहराया पात्रों के ढहने के बारे में 40 बाइट्स लेता है।

पहले तो मैंने पैदावार के लिए पहले दो पात्रों की तुलना की CWया यह देखने के CCपहले कि इस तरह के टेस्टकेस भी मान्य हैं bbaया bbcइस दृष्टिकोण को भी पराजित करते हैं।

Answer 8

पायथन, 152 बाइट्स:

lambda C:[C[-1]in max(C)+min(C),C[1]>C[0]]*all([[i>g,i<g][[h%2>0,h%2<1][C[1]>C[0]]]for i,g,h in filter(lambda i:i[0]!=i[1],zip(C,C[1:],range(len(C))))])

एक अनाम मेमने का कार्य। के रूप में बुलाओ print(<Function Name>('<String>'))।

सभी लोअरकेस या अपरकेस के रूप में इनपुट लेता है, लेकिन मिश्रित मामला नहीं है।

किसी सरणी में कुछ भी नहीं होता है ( []) अगर शब्द स्वायर नहीं है, या निम्न प्रारूप में एक सरणी है अन्यथा:

• 1 तत्व है True/Falseके लिए Centrifugal/Centripetal।
• 2 तत्व के True/Falseलिए है Clockwise/Counterclockwise।

यह ऑनलाइन की कोशिश करो! (Ideone)