输出一个字谜！不，不是那个！

28

给定一个彼此为字谜的唯一字符串的列表，请输出与列表中每个单词都不同的那些单词的字谜。

字符串将为字母数字，并且保证有一个有效的字谜。

程序或函数可以但不一定是不确定的，这意味着在给定相同输入的情况下，只要每个可能的输出都是有效的，多次运行该代码即可产生不同的输出。

测试用例

[Input] -> Possible output
-----------------
[ab] -> ba
[aba, aab] -> baa
[123, 132, 231, 312, 321] -> 213
[hq999, 9h9q9, 9qh99] -> 999hq
[abcde123, ab3e1cd2, 321edbac, bcda1e23] -> ba213ecd
code-golf  string  permutations 
— 轻度吐司
source

Answers:

20

Python 3，64字节

lambda a:[*{*permutations(a[0])}-{*a}][0]
from itertools import*

在线尝试！

— Xcoder先生
source
4
但是itertools答案是吗？
— MildlyMilquetoast
@MistahFiggins 提名
— Xcoder先生，2017年
@ Mr.Xcoder在2015
— Stan Strum，
我刚才提到@StanStrum，我知道该限制。正如Stewie所说...
— Xcoder先生17年
1
@ jpmc26是的，通过这种方式，您可以放入f=\“在线试用”标头并将函数保留为匿名，同时不影响自动TiO字节计数器
— Xcoder先生，2017年
9

05AB1E，5个字节

нœ¹мà

在线尝试！

说明

нœ¹мà

н     // Get the first element of the input list
 œ    // Generate all permutations
  ¹   // Push the input again
   м  // In the permutations list, replace all strings that
      //   are in the input list with empty strings
    à // Pick the string with the greatest lexicographic
      //   index (in this case a non-empty string)
4

果冻，6个字节

XŒ!ḟµḢ

在线尝试！

比05AB1E和Pyth答案多1个字节。

说明：

XŒ!ḟµḢ   Main program.
 Œ!      All permutation of...
X        any element from the word list.
   ḟ     Filter out (remove) all the elements in the original word list.
    µ    With the filtered-out list,
     Ḣ   pick the first element.

我X之所以选择它，是因为这是我知道从列表中选择任何元素而不更改列表的最短方法（Ḣ并且Ṫ不起作用，ḷ/而且ṛ/更长），并且碰巧会导致某些随机性。

在µ这里是非常多余的，但没有它，Ḣ将与配对ḟ，并且它被解释为“过滤掉输入的头”，这是不是我在这里需要（我需要的是“过滤掉输入，并得到头”）。

— 用户名
source
4

Javascript，118个字节

function f(a){s=a[0];while(a.indexOf(s)!=-1)s=s.split("").sort(function(){return .5-Math.random()).join("")};return s}

使用错误的随机化器迭代每个“随机”排列。

可能证明是错误的，但是不好的随机化器只是意味着我们不会获得真正的随机性，但是仍然会得到所有排列。

对于我来说，似乎可以在chrome上的所有情况下使用，但显然由于这种滥用中的不确定行为，它在某些浏览器中无法使用。

（可能非常随意，可以通过自己的解决方案进行改进）

80字节

感谢pirateBay的评论-很多字节

-4个字节，感谢Rick

f=a=>eval('s=[...a[0]].sort(()=>.5-Math.random()).join``;a.indexOf(s)<0?s:f(a)')
— Imme
source
允许FYI箭头功能（例如a=>b代替function(a){return b}）。它节省了很多字节。
哇...这会节省很多字节。
— Imme
s.split("")可以[...s]。还join("")可以`join```
— 里克·希区柯克
@ThePirateBay我担心情况会如此，但是为什么呢？（我知道排序不是完全随机的，但是所有序列都应该是可能的）
— Imme
@Imme。这是87字节的工作版本。请注意，您的sort函数永不返回0（或至少极为罕见），这就是为什么它不起作用的原因。
4

Haskell，58个字节

-1个字节和一个修复程序，感谢Laikoni。

import Data.List
f l=[i|i<-permutations$l!!0,all(/=i)l]!!0

在线尝试！

Data.List对于排列可能不值得导入，但是。

— 全人类
source
1
您可以使用保存一个字节notElem。如果有人发现一个优于导入的置换函数，我会感到惊讶，我最短的方法是60字节而不是29字节的导入。
— Laikoni '17
1
这是一个43字节的置换函数，但仅适用于重复的空闲列表。
— Laikoni '17
1
另外，您的解决方案目前无法正常运行，因为$之前缺少l!!0。
— Laikoni '17
3

Brachylog，7个字节

hp.¬∈?∧

在线尝试！

说明

hp.        The Output is a permutation of the first element of the Input
  .¬∈?     The Output is not a member of the Input
      ∧    (Disable implicit Input = Output)
— 致命
source
3

Mathematica，57个字节

不确定的

(While[!FreeQ[#,s=""<>RandomSample@Characters@#&@@#]];s)&

在线尝试！

Mathematica，56个字节

确定性的

#&@@Complement[""<>#&/@Permutations@Characters@#&@@#,#]&

在线尝试！

— J42161217
source
3

Japt，7 6字节

-1字节感谢@Shaggy

á kN ö

在线尝试！

将输入字符串作为多个输入而不是数组。输出随机排列；切换ö为g获取第一个。

说明

á kN ö  Implicit input: N = array of input strings
á       Get all permutations of the first input string
  kN    Remove all input strings from those
     ö  Get a random element from the array. Implicit output
— 贾斯汀·马里纳（Justin Mariner）
source
坚果，你击败了我。您可以将输入作为单个字符串，并使用保存一个字节á kN ö。
— 毛茸茸的
@Shaggy这是获取第一个输入项的好方法，我必须记住这一点。谢谢！
— 贾斯汀·马里纳
2

MATL，15，13，12个字节

1X)Y@Z{GX-1)

在线尝试！

感谢Sanchises，节省了2个字节。setdiff(...,'rows')比否定更短ismember(...,'rows')，并且避免了一次重复。多亏了Luis Mendo，通过切换到单元而不是数组，节省了另一个字节。

说明：

还包括MATLAB / Octave等效项。

                 % Implicitly grab input x containing cells of strings
1X)              % Get first cell. Equivalent to x{1}
   Y@            % All permutations of first row input. Equivalent to p=perms(y)
      Z{         % Convert the list of permutations to a cell array
        G        % Grab input again      
         X-      % setdiff, comparing the input cells with the permutations
           1)    % The first of the results

输入必须是格式之一{'abc', 'acb'}。

— 斯蒂夫·格里芬
source
2

点，11字节

@:_NIgFIPMa

将输入作为命令行参数。在线尝试！

说明

          a  1st cmdline arg
        PM   List of all permutations
      FI     Filter on this function:
  _NIg         Permutation not in cmdline args
@:           First element of resulting list (with : meta-operator to lower precedence)
             Autoprint
— DLosc
source
2

Python 3，87字节

我相信这是唯一提交到目前为止，使用既不置换内置也不随机洗牌/排序。即使更长，我认为该算法也很简洁。

lambda L:[p for s in L for i,c in enumerate(s)for p in[c+s[:i]+s[i+1:]]if~-(p in L)][0]

在线尝试！

说明

我们要做的基本上是这样的：

def unique_anagram(string_list):
    for string in string_list:
        for i, char in enumerate(string):
            # Move the character to the beginning of the string
            permutation = char + string[:i] + string[i+1:]
            if permutation not in string_list:
                return permutation

这是一个有效的证明：

对于字符串S，定义front(S)为通过从中选择一个字符S并将其移动到字符串的前面而获得的字符串集S。例如，front(ABCDE)是{ABCDE, BACDE, CABDE, DABCE, EABCD}。

现在考虑一个anagram 列表L，这样L不包含所有可能的anagram（根据问题描述）。我们希望证明其中存在一个字符串S，L其中front(S)包含至少一个S'不在中的anagram L。

矛盾地，假设对于Sin L中的每个字符串，in 中的每个字符串front(S)也位于in中L。观察到我们可以通过一系列“前移”动作生成任意字符串的任意排列。例如，获得

ABCDE -> BAEDC

我们能做的

ABCDE -> CABDE -> DCABE -> EDCAB -> AEDCB -> BAEDC

我们假设对于每个Sin L，每个S'in front(S)也是in L。这也意味着每个S''in front(S')都在中L，依此类推。因此，如果S处于中L，则的每个置换S也处于中L。然后L必须是一整套完整的字谜，一个矛盾。

所以，既然我们都保证至少有一个置换不中L，必须存在一个字符串S中L的一些S'在front(S)不在L。QED。

代码front(S)针对每个Sin进行迭代，L并选择一个S'不在in中的L。通过以上结果，将至少有一个S'合格。

— DLosc
source
1

JavaScript（ES7），172个字节

f=(a,s=a[0],b=[...s],k=b.findIndex((e,i)=>s[i-1]>e))=>a.includes(s)?f(a,(~k?(t=b[k],b[k]=b[l=a.findIndex(e=>e>t)],b[l]=t,b.map((e,i)=>i<k?b[k+~i]:e)):b.reverse()).join``):s

查找数组中未包含的数组第一个元素的第一个字典排列。

— 尼尔
source
1

Kotlin，104字节

{var r=""
do{r=it[0].map{it to Math.random()}.sortedBy{(_,b)->b}.fold("",{a,(f)->a+f})}while(r in it)
r}

美化

{
    var r = ""
    do {
        r = it[0].map { it to Math.random() }
            .sortedBy { (_, b) -> b }
            .fold("", { a, (f) -> a + f })
    } while (r in it)
    r
}

测试

var ana: (List<String>) -> String =
{var r=""
do{r=it[0].map{it to Math.random()}.sortedBy{(_,b)->b}.fold("",{a,(f)->a+f})}while(r in it)
r}

fun main(args: Array<String>) {
    println(ana(listOf("ab")))
}
— Jrtapsell
source
1

C ++，169字节

#import<set>
#import<string>
#import<algorithm>
using S=std::string;S f(std::set<S>l){S s=*l.begin();for(;l.count(s);)std::next_permutation(s.begin(),s.end());return s;}

在线尝试！

— 稳定箱
source
1

Scala，50个字节

(l:Seq[String])=>(l(0).permutations.toSet--l).head

在线尝试！

说明

l(0)         // Take the first anagram
permutations // Built-in to get all permutations
toSet        // Convert to set, required for -- function
-- l         // Remove the original anagrams
head         // Take a random element from the set
— 卡尔·比勒费尔特
source
1

R，89个字节

x=scan(,'');repeat{a=paste(sample(el(strsplit(x[1],''))),collapse='');if(!a%in%x)break};a

重复采样第一个条目中的字母（因为它们应该是彼此的字谜），并在其中一个采样不在原始列表中时停止。

— 安德鲁·海恩斯
source
— 朱塞佩（Giuseppe）
1

PHP，70字节

$j=1;while($j){$g=str_shuffle($_GET[0]);$j=in_array($g,$_GET);}echo$g;

在网络服务器上运行，输入0索引的get值，或者在线尝试！

不打高尔夫球

$j=1; //set truty value
while($j){ 
    $g=str_shuffle($_GET[0]); //shuffle the first anagram of the set
    $j=in_array($g,$_GET); //see if in the set, if false, the loop ends
}
echo $g;
— SmartCoder
source
使用do{...}while($j);而不是保存两个字节$j=1;while($j){...}。使用就地定义$g删除括号（并保存四个字节）。
— 泰特斯（Titus）
1

PHP，58 55字节

while(in_array($s=str_shuffle($argv[1]),$argv));echo$s;

非确定性 从命令行参数获取输入

php -r <code>以空格分隔的单词跟随运行，或在线尝试。

— 泰特斯
source
1

附件，16字节

&\S@{!S@_[0]Ø_}

在线尝试！

说明

&\S@{!S@_[0]Ø_}
    {         }    lambda (input: `_`)
        _[0]       first element of the given array
       @           pass to:
     !                 on each permutation:
      S                cast to string
            Ø      without any member of
             _     the input
                   this gives all anagrams not in the input
   @               then
&\S                "first string element"
&                  spread input array over each individual arguments
 \                 tale first argument
  S                as a string

备择方案

17个字节：{&\S! !S@_[0]Ø_}

18个字节：{&\S! !Id@_[0]Ø_}

19个字节：{&\S!(!Id)@_[0]Ø_}

26个字节：{&\S!Permutations@_[0]Ø_}

26个字节：{&\S!Permutations[_@0]Ø_}

26个字节：{(Permutations[_@0]Ø_)@0}

26个字节：&\S##~`Ø#Permutations@&\S

27个字节：Last@{Permutations[_@0]Ø_}

27个字节：`@&0@{Permutations[_@0]Ø_}

28个字节：Last##~`Ø#Permutations@&{_}

28个字节：Last##~`Ø#Permutations@Last

28个字节：First@{Permutations[_@0]Ø_}

30个字节：{NestWhile[Shuffle,`in&_,_@0]}

33个字节：{If[(q.=Shuffle[_@0])in _,$@_,q]}

33个字节：{q.=Shuffle[_@0]If[q in _,$@_,q]}

34个字节：{If[Has[_,q.=Shuffle[_@0]],$@_,q]}

— 科纳·奥布莱恩
source
0

J，25个字节

((A.~i.@!@#)@{.@:>){.@-.>

输入的是装箱的字符串列表-我觉得这样很公平，并且不将字符串列表明确声明为4 8 $'abcde123'，'ab3e1cd2'，'321edbac'，'bcda1e23'。

我不喜欢代码中的@混乱，但是这次有很多序列化的动词。

怎么运行的：

                         >  - unboxes the strings
 (                 )        - left verb of the fork as follows:
             @{.@:>         - unbox and take the first string
  (         )               - finds all permutations of the first string
      i.@!@#                - a list 0 .. the factorial of the length of the 1st string
   A.~                      - anagram index, all permutations
                    {.@-.   - remove the inital strings and take the first of the remaining

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source
1
以输入为表格，共21个字节：{.@(-.~i.@!@#@{.A.{.)。 在线尝试！
— 约拿（Jonah）
0

05AB1E，5个字节

нœIмà

在线尝试！

说明

нœIмà full program with implicit input i
н     push first element of i
 œ    push all permutations
  I   push input i
   м  remove all elements of i from the permutations
    à extract greatest element and print implicitly

@ThePirateBay发现的答案几乎相同。

— 辛纳里
source
0

JavaScript，87个字节

a=>eval('for(s=[...a[0]];(a+[]).includes(k=s.sort(a=>~-(Math.random``*3)).join``););k')

在线尝试！

该答案基于（尽管经过了很大的修改）基于Imme的答案。他建议评论中中这应该是一个不同的答案。

旧方法的问题是因为 sort它完全依赖于实现。该标准不能保证调用sort函数的顺序，因此从理论上讲，它可能永远不会在第一个或第二个测试用例中终止。

这种方法要长几个字节，但是即使Math.random没有返回，它也可以保证在有限的时间内完成.5。

0

CJam，11个字节

q~_0=m!\m0=

在线尝试！

说明

q~  e# Read input and evaluate: ["123" "132" "231" "312" "321"]
_   e# Duplicate:               ["123" "132" "231" "312" "321"] ["123" "132" "231" "312" "321"]
0=  e# First:                   ["123" "132" "231" "312" "321"] "123"
m!  e# Permutations:            ["123" "132" "231" "312" "321"] ["123" "132" "213" "231" "312" "321"]
\   e# Swap:                    ["123" "132" "213" "231" "312" "321"] ["123" "132" "231" "312" "321"]
m0  e# Subtract, push 0:        ["213"] 0
    e# (m is used instead of - when in front of a digit)
=   e# Get item:                "213"
— 硕果累累
source
我认为您的解释可能有错字-您的代码给出的答案与您的解释不同
— MildlyMilquetoast
0

Perl 6，42个字节

{(.[0],*.comb.pick(*).join...*∉$_)[*-1]}

在线尝试！

随机混洗输入的第一个字符串，直到它不是输入的元素。

说明：

{(.[0],*.comb.pick(*).join...*∉$_)[*-1]}
{                                      }   # Anonymous code block
 (                        ...    )   # Create a sequence
  .[0],   # The first element is the first element of the input
       *.comb.pick(*).join   # Each element is the previous one shuffled
                             *∉$_   # Until it is not in the input
                                  [*-1]   # Return the last element
— 乔·金
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.