Fragen Sie mich nicht wie oder warum, aber während ich ein Projekt programmierte, stellte ich fest, dass die Zeichen einiger Wörter ein bestimmtes Muster hatten, das sich auf das Alphabet bezog. Ich verband jedes Zeichen der Wörter mit dem Bleistift auf dem Alphabet und erhielt zwei Spiralen, dann bemerkte ich, dass die erste Spirale im Uhrzeigersinn und die andere gegen den Uhrzeigersinn war, und andere Eigenschaften ... also nannte ich sie Wirbelnde Wörter !

Ein wirbelndes Wort kann sein:

1. im oder gegen den uhrzeigersinn
2. zentripetal oder zentrifugal

Hier einige Beispiele für wirbelnde Wörter :

Aufgabe 1:

Schreiben Sie ein vollständiges Programm oder eine Funktion, die ein Wort von der Standardeingabe übernimmt und ausgibt, wenn es sich um ein wirbelndes Wort handelt und seine Eigenschaften in einem lesbaren Format, erweitertem Text, 3 Zeichen, Flags usw.

Testfälle und Beispielausgaben für verschiedene Wörter (Sie können jedoch entscheiden, wie die Ergebnisse dargestellt werden sollen):

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

Regeln:

1. Die Verbindung zwischen den ersten beiden Zeichen sein muss , bis (wie in der Grafik), die alle die noch Verbindung sein muss , nach unten , alle ungeraden Verbindungen sein muss , bis .
2. Sie können Groß- / Kleinschreibung ignorieren oder alle in Groß- oder Kleinschreibung umwandeln.
3. Die eingegebenen Wörter sind nur Buchstaben im alphabetischen Bereich von AZ, keine Leerzeichen, keine Interpunktion usw.
4. Wenn ein Wort doppelte Zeichen wie "GROOVE" enthält, müssen Sie die doppelten Zeichen zu einem Zeichen zusammenfassen: "GROOVE"> "GROVE".
5. Die Eingabewörter enthalten mindestens 3 verschiedene Zeichen. Wörter wie "MOM", "DAD", "LOL" sind keine gültigen Wörter.
6. Es ist möglich, mehrere Male in demselben Zeichen wie "IRIS" zu spielen.
7. Kürzester Code gewinnt.

Schritt 2:

Um mehr Ansehen zu erlangen, suchen Sie nach den längsten wirbelnden Wörtern und ihren Merkmalen, die Sie im englischen Wörterbuch nach den oben genannten Regeln finden können. Sie können zum Beispiel die vollständige Liste der englischen Wörter hier als Referenz nehmen .

Viel Spaß beim Codieren!

MATL , 33 31 30 Bytes

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

Die Eingabe erfolgt in Großbuchstaben (oder in Kleinbuchstaben, jedoch nicht gemischt).

Ausgabe ist:

• Wenn das Wort nicht wirbelt: Es wird keine Ausgabe erzeugt
• Wenn es wirbelt: Zwei Zahlen werden in verschiedenen Zeilen erzeugt:
  • Erste Ziffer 1/ -1 gibt Zentrifugal / Zentripetal an.
  • Die zweite Zahl 1/ "-1" zeigt im / gegen den Uhrzeigersinn an.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle (Code geändert, um alle Eingaben zu übernehmen und die beiden Ausgabenummern in derselben Zeile zu erzeugen).

Erläuterung

Nehmen wir 'OPERAA'als Beispiel die Eingabe .

Der erste Teil des Codes entfernt Doppelbuchstaben:

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'

Wir prüfen nun, ob die Abstände zwischen den Buchstaben nicht abnehmen (notwendige Bedingung für das Wirbeln des Wortes):

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]

Wir prüfen dann, ob die Buchstaben hin und her gehen (dies ist die andere Bedingung für das wirbelnde Wort):

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]

Zuletzt prüfen wir, ob die beiden Bedingungen erfüllt sind und erzeugen in diesem Fall die Ausgabe:

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

Mathematica, 117 111 Bytes

Vielen Dank an JHM für das Speichern von 6 Bytes und die Berücksichtigung der Groß- und Kleinschreibung beim Booten!

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

Unbenannte Funktion, die eine Zeichenfolge verwendet und eine verschachtelte Liste von Booleschen Werten im Formular zurückgibt {{B1,B2},B3,B4}. B4 zeichnet auf, ob das Wort wirbelt (und wenn nicht, ist der Rest der Ausgabe Müll). Wenn das Wort wirbelt, zeichnet B1 auf, ob das Wort zentrifugal ist, B2 zeichnet auf, ob das Wort zentripetal ist, und B3 zeichnet auf, ob das Wort im Uhrzeigersinn (True) oder gegen den Uhrzeigersinn (False) ist.

Hier ist eine längere Version , dass Post-Prozesse (erste Zeile) die obige Funktion ( im Abstand über die zweiten bis fünften Linien) , um es den OP identisch zu machen: NOwenn das Wort nicht ist , wirbelt, und die geeignete Wahl von {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}oder {SW,CP,CC}wenn das Wort wirbelt:

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} &

Die Erklärung ist die gleiche wie in Martin Enders CJam-Antwort, mit einer zusätzlichen Anmerkung: Die Liste der aufeinanderfolgenden Unterschiede muss sich im Vorzeichen abwechseln, damit das Wort wirbelt. Dies kann festgestellt werden, indem sichergestellt wird, dass alle Produkte von Paaren aufeinanderfolgender Unterschiede negativ sind (das ist was Max[Most[d]Rest@d]<0tut).

Wenn Sie die Funktion für alle mehr als 40.000 Wörter von Mathematica ausführen WordList[], finden Sie die folgenden 8-Buchstaben-Wirbelwörter, die die längsten ihrer jeweiligen Wirbeltypen sind:

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}

(Brownie deutet darauf hin, positivedass es keine Doppelbuchstaben und weniger wiederholte Buchstaben als stowaway.)

Aber der absolute Champion ist das 9-Buchstaben-Gegenuhrzeigersinn wirbelnde zentripetale Wort vassalage!

Scala, 110 Bytes

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

Gibt ein Tupel (a,b)mit zurück

• a == 1 wenn s zentripetal ist
• a == 0 wenn s zentrifugal ist
• a == -1 wenn s nicht wirbelt

und

• b == true wenn s im uhrzeigersinn ist
• b == false wenn s gegen den Uhrzeigersinn ist
• b kann wahr oder falsch sein, wenn s nicht wirbelt

Erläuterung:

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.
  )
}

Gelee , 30 Bytes

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

TryItOnline
Oder sehen Sie sich die Testfälle an (mit einer kleinen Änderung, da die allerletzteÑauf den neuen Hauptlink verweist).

(Mein Mangel an Verkettungsfähigkeiten kostet hier wahrscheinlich ein paar Bytes.)
Alle oberen oder alle unteren.
Gibt eine Merkerliste [D, F, S] zurück:
S: Schleudern = 1 / Nichtschleudern = 0
F: Schleudern = 1 (kreisförmig = 0) zentripetal = -1
D: im Uhrzeigersinn = 1 / gegen den Uhrzeigersinn = -1
- wenn S = 0 Die anderen Flags werden weiterhin ausgewertet, obwohl sie keine nützlichen Informationen enthalten.

Wie?

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

CJam , 39 Bytes

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

Probieren Sie es online!

Die Eingabe kann in Groß- oder Kleinbuchstaben erfolgen, jedoch nicht gemischt.

Das Programm weist versehentlich auf Wörter hin, die nicht unbedingt zentrifugal oder zentripetal sind, aber ansonsten die Anforderungen der Spiralität erfüllen. Diese werden in der folgenden Tabelle als "Rundschreiben" bezeichnet.

Verwenden Sie diese Tabelle, um die Ausgabe zu interpretieren:

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)

Erläuterung:

Das Programm wertet tatsächlich aus, ob die Folge von Unterschieden ungleich Null zwischen Zeichen positiv oder negativ beginnt, ob sie im Vorzeichen wechselt, ob die Beträge anfangen zuzunehmen oder abzunehmen, und ob dies weiterhin der Fall ist. Wenn sich die Werte nicht erhöhen oder verringern, bricht das Programm ab, indem ein leeres Array bearbeitet wird. Die wichtigsten Schritte sind nachstehend aufgeführt (dieser Code zeigt auch den Fortschritt des Stapels an):

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

PHP, 322 Bytes

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;

für eine schönere Ausgabe echo["n","+P","-P","+F","-F"][$s];

Erweiterte Version

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

Aufgabe 2 zweiter Wert ohne kurze Doppelregel

4-F Killness 11 Bytes positivisieren 10 Bytes

3 + F oppositive 10 Bytes logogue 9 Bytes

2-P Vasallage 9 Bytes Sarcocol, Sasarara 8 Bytes

1 + P Bewertung 9 Bytes apanage, aramäisch, argonon, auktion, avision, vergeben, crenele, exesion, exition, eyewink 7 Bytes

Visualisiere ein Wort

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>';  

Im Snippet ist das Ergebnis der SVG, die ich erstellt habe

<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>

Haskell, 148 Bytes

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%(>)]

Probieren Sie es auf Ideone.

Die Eingabe muss entweder in Klein- oder in Großbuchstaben erfolgen.
Die Ausgabe ist eine Liste von fünf booleans: [SW?, CF?, CP?, CW?, CC?].

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

Dies stellte sich als länger als erwartet heraus, insbesondere das Ausblenden von wiederholten Zeichen dauert ungefähr 40 Bytes.

Anfangs habe ich im Vergleich nur die ersten beiden Zeichen zu erhalten CWoder CCvor , dass Testfälle wie zu bemerken , bbaoder bbcsind auch gültig und diesen Ansatz zu besiegen.

Python, 152 Bytes:

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))))])

Eine anonyme Lambda-Funktion. Anrufen als print(<Function Name>('<String>')).

Nimmt die Eingabe als Klein- oder Großbuchstaben, jedoch nicht als gemischte Groß- / Kleinschreibung.

Gibt ein Array mit nothing ( []) aus, wenn das Wort nicht swirly ist, oder ein Array im folgenden Format:

• 1. Element ist True/Falsefür Centrifugal/Centripetal.
• 2. Element ist True/Falsefür Clockwise/Counterclockwise.

Probieren Sie es online! (Ideone)