找到旋转的单词！

41

不要问我如何或为什么，但是在编码一个项目时，我注意到几个单词的字符有一个特定的模式，称为字母，我用铅笔上的铅笔将单词的每个字符连接起来，我得到了两个螺旋形，然后我注意到第一个螺旋形是顺时针方向，另一个是逆时针方向，还有其他特征...因此我将它们命名为Swirling Words！

一个旋流字可以是：

  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. 前两个字符之间的连接必须为up（如图中所示），所有偶数连接必须为down，所有奇数连接必须为up。
  2. 您可以忽略大写/小写或全部考虑/转换为大写或全部转换为小写。
  3. 输入的单词只能是AZ字母范围内的字符，不能有空格，标点符号等。
  4. 如果单词具有双字符，例如“ GROOVE”，则必须将双精度折叠为一个字符：“ GROOVE”>“ GROVE”。
  5. 输入的单词将至少包含3个不同的字符。诸如“ MOM”，“ DAD”，“ LOL”之类的单词无效。
  6. 可以在同一个字符中多次传递，例如“ IRIS”。
  7. 最短的代码胜出。

任务2：

要获得更高的声誉，请遵循上述规则，在英语词典中找到最长的旋流词及其特征。例如，您可以在此处参考英语单词的完整列表。

编码愉快！

code-golf  string 
— 马里奥
source
15
漂亮的图表！：）（也是很好的挑战；））
— 马丁·恩德
省略“旋转”是一种有效的输出格式，因为当输入不是“不旋转”时就隐含了它吗？
— 马丁·恩德
@MartinEnder是的，因为它在旋转或不旋转时都是可以理解的，所以对于“ not”可以为空，对于“ yes”可以为“ 1”，等等。（很高兴您喜欢这些图和挑战！：））
— Mario
1
@TimmyD但并非所有坎bump的单词都在打转。:)
— Martin Ender
2
@Lynn感谢您的赞赏和建议，我将努力为将来做些改进。我添加了“删除双打”规则，以期望人们问我诸如“双打时我们会做什么？”之类的事情。>您可以将双打视为1个单个字符，因为从“ L”到“ L”的距离为零:)并不是我自己想添加棘手的困难。
— 马里奥

Answers:

11

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
— 路易斯·门多
source
6

Mathematica，117 111字节

感谢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}。B4记录单词是否在旋转（如果不是，则其余输出为垃圾）。如果单词在旋转，则B1记录单词是否是离心的，B2记录单词是向心的，B3记录单词是顺时针（True）还是逆时针（False）。

这里的一个较长的版本，后处理（第一行）上述函数（间隔分布在第二-第五行），使之等同于OP：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} &

解释与Martin Ender的CJam答案相同，但有一个附加说明：连续差异的列表必须在符号上交替出现，以使单词打乱，并且可以通过确保所有连续差异对的所有乘积为负来检测出该差异。 （就是Max[Most[d]Rest@d]<0这样）。

在Mathematica的所有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}

（Brownie指出positive没有双字母，重复字母比少stowaway。）

但是绝对的冠军是9个字母的逆时针旋转向心字vassalage！

— 格雷格·马丁
source
1
您可以保存通过使用3个字节LetterNumber，而不是ToCharacterCode通过和其他3个字节Most[d]，而不是Drop[d,-1]。
— JungHwan Min
5

Scala，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 如果s是离心的
  • a == -1 如果s不旋转

和

  • b == true 如果s是顺时针
  • b == false 如果s是逆时针
  • 如果s不旋转，b可以为真或假

说明：

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.
  )
}
— corvus_192
source
5

果冻，30 个字节

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

TryItOnline
或查看测试用例（稍作更改，因为最后一个Ñ将指向新的主链接）

（我缺乏链接技能，这里可能要花几个字节）
全部上位或全部下位。
返回标志列表[D，F，S]：
S：旋转= 1 /不旋转= 0
F：离心= 1（圆形= 0）向心= -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
— 乔纳森·艾伦
source
1
我认为您在这里遇到了所谓的“新手综合症”。我和你完全一样。也许丹尼斯可以在这里有所帮助。但是，我+1只是因为我看到Jelly有可能。另外，您可以卸下圆形盒；它不再存在。
— 暴民埃里克（Erik the Outgolfer）'16年
感谢有关循环词的戳记-事实证明，实际上不需要6个字节来满足它们，因为最小的空列表是0这样，所以对于那些也是如此！
— 乔纳森·艾伦
那么，它必须为他们工作吗？我认为您circular(0)的解释仍在里面，也许是时候删除它了。
— Erik the Outgolfer '16
它不是必需的，不是-但是，由于min([])=0 jelly.tryitonline.net/#code=W13huYI&input=的事实，在删除了我以前明确执行的代码后，此代码仍然会执行-请注意，由于现在从没有循环词预期的投入，满足他们的需求没有问题。
— 乔纳森·艾伦
我只是要求您仔细检查。而且，我知道您的意思是min([])==0，但我认为这仍然是可行的。
— Erik the Outgolfer '16
3

CJam，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
— 莱纳斯
source
3

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 killingness 11字节确定为10字节

3 + F对立10字节徽标9字节

2 -P vassalage 9字节sarcocol，sasarara 8字节

1 + P assession 9字节字节数，aramic，氩，拍卖，avision，已授予，crenele，exesion，exition，eyewink 7 Bytes

可视化一个词

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的结果

<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>
展开摘要

— 约格·赫尔瑟曼
source
伟大的旋转单词查看器！:)也许您可以尝试用半椭圆而不是半圆连接字符。它会更紧凑，看起来更“动感”。但是无论如何看起来很棒！
— 马里奥（Mario）
@Mario只需要一个因素'.(.8*$radius).'，而不是'.($radius).'，如果你更换($radius).' 0 0 0与($radius).' 0 0 '.(($w[$i-1]<$w[$i]?1:0)^(($i-1)%2)).'该程序还没有一个固定的方向
— 约尔格Hülsermann
2

Haskell，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同样有效时，便比较了这种方法。

— 莱科尼
source
2

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

匿名lambda函数。呼叫为print(<Function Name>('<String>'))。

将输入作为所有小写或大写字母，但不区分大小写。

[]如果单词不是涡旋的，则输出不包含任何内容的数组（），否则输出以下格式的数组：

  • 第一元件是True/False用于Centrifugal/Centripetal。
  • 第二元件是True/False为Clockwise/Counterclockwise。

在线尝试！（爱迪生）

— 卡普
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.