Étant donné une chaîne en entrée, sortez une ou plusieurs variantes de la chaîne de sorte que:

• Aucun personnage n'est dans sa position d'origine
• Aucun personnage n'est adjacent à un personnage auquel il était à l'origine adjacent

Vous pouvez supposer que cela sera toujours possible pour la chaîne donnée et ne contiendra que des caractères alphabétiques à casse unique ( [a-z]ou [A-Z]si vous préférez)

Notez que les doublons du même caractère ne sont pas considérés comme uniques.

Par exemple, étant donné l'entrée programming, la sortie ne peut pas contenir un mau 7ème ou 8ème caractère, et ne peut pas contenir un gau 4ème ou 11ème caractère (1 indexé)

Exemple:

Prends la ficelle abcdef

Ce qui suit serait une sortie valide: daecfb

Cependant, les éléments suivants ne seraient pas valides: fdbcaecomme dans cet exemple cet bsont toujours adjacents.

L'adjacence s'enroule également, ce qui signifie que vous ne pouvez pas faire fdbecacomme fet que vous aêtes toujours adjacent.

Testcases:

Notez que ce ne sont pas les seules sorties valides pour les entrées données

Écrit comme input -> output:

helowi -> ioewhl
mayube -> euabmy
stephens -> nhseespt
aabcdeffghij -> dbfhjfigaeca

Notation:

Il s'agit de code-golf, donc le moins d'octets dans chaque langue gagne!

Gelée , 24 23 octets

ẋ2ṡ2Ṣ€
dzǤœ&¬ɓ³=Sȯ
ẊÇ¿

Essayez-le en ligne!

Extrêmement longue en raison de mon horreur à Jelly, mais ça marche enfin, au moins ... toujours en train de jouer au golf.

link that generates a list of sorted adjacent pairs:
ẋ2            duplicate argument ("abc" -> "abcabc")
  ṡ2          slices of 2 (-> "ab","bc","ca","ab","bc")
    Ṣ€        sort each

link that tests for invalid permutations:
Ç             get sorted adjacent pairs of argument
 ³Ç¤          do the same for the original input
    œ&        set intersection, then...
      ¬       ...inverse; i.e. do they have no elements in common
       ɓ   ȯ  logical OR the result of that with...
        ³=    elementwise equality with original input, and...
          S   ...sum; i.e. are some characters in the same position

main link:
Ẋ             shuffle the input list
  ¿           while
 Ç            the result of the previous link is truthy

Python 2 , 185 octets

from itertools import*
x=input()
g=lambda m:set(zip(m*2,(m*2)[1:]))
for l in permutations(x):
 if not((g(l)|g(l[::-1]))&(g(x)|g(x[::-1]))or any(a==b for a,b in zip(x,l))):print`l`[2::5]

Essayez-le en ligne!
Imprime toutes les chaînes valides

PHP> = 7.1, 147 octets

for($a=$argn,$r="^$a[-1].*$a[0]$",$k=0;$v=$a[$k];)$r.="|^.{{$k}}$v|$v".($l=$a[$k++-1])."|$l$v";for(;preg_match("#$r#",$s=str_shuffle($a)););echo$s;

PHP Sandbox Online

PHP> = 7.1, 184 octets

Utilisez la distance levenshtein au lieu d'une méthode Regex

for($a=$argn;$v=$a[$k];$r[]=$l.$v)$r[]=$v.($l=$a[$k++-1]);for(;!$t&&$s=str_shuffle($a);)for($t=1,$i=0;$v=$s[$i];$t*=$v!=$a[$i++])foreach($r as$x)$t*=levenshtein($x,$s[$i-1].$v);echo$s;

PHP Sandbox Online

PHP , 217 octets

Version sous 7.1

for($l=strlen($a=$argn),$r=$a[$k=0].$a[$l-1]."|".$a[$l-1]."$a[0]|^{$a[$l-1]}.*$a[0]$";$v=$a[$k];!$k?:$r.="|$v".$a[$k-1],++$k<$l?$r.="|$v".$a[$k]:0)$r.="|^.{{$k}}$v";for(;preg_match("#$r#",$s=str_shuffle($a)););echo$s;

Essayez-le en ligne!

Brachylog , 21 octets

p.jP;?z≠ᵐ&j¬{s₂p~s}P∧

Essayez-le en ligne!

Explication

J'aurais vraiment voulu p.;?z≠ᵐ&j¬{s₂p~s~j}travailler pour 2 octets de moins, mais il semble que ce ne ~jsoit pas assez intelligent ...

p.jP;?z≠ᵐ&j¬{s₂p~s}P∧  Input is a string, say ? = "asdfgha"
p                      Take a permutation of ?, say "sfagadh".
 .                     It is the output.
  j                    Concatenate it to itself: "sfagadhsfagadh"
   P                   Call that string P.
    ;?                 Pair P with the input: ["sfagadhsfagadh","asdfgha"]
      z                Zip, repeating elements of the longer string:
                        [["s","a"],["f","s"],["a","d"],...,["a","g"],["d","h"],["h","a"]]
       ≠ᵐ              Each pair must have different elements.
         &             Start new predicate
          j            Concatenate ? to itself: "asdfghaasdfgha"
           ¬{     }    The following cannot be satisfied:
             s₂        Take a substring of length 2
               p       and permute it.
                ~s     It is a substring of
                   P   P.
                    ∧  Do not unify P with the output.

PHP 7.1, 136 131 octets

inspiré par la solution de Jörg :

for($a=$argn;$c=$a[$k];)$r.="|$c".($d=$a[$k-1])."|$d$c|^.{".+$k++."}$c";while(preg_match("#$a$r#",($s=str_shuffle($a)).$s));echo$s;

Exécuter en tant que pipe avec -rou tester en ligne . (Assurez-vous que PHP version 7.1 ou supérieure est sélectionné)

Nécessite PHP 7.1; ajouter 14 octets pour les anciens PHP: remplacer $k-1par ($k?:strlen($a))-1;
(deux octets pour PHP <5.3: $k?$k-1:strlen($a)-1)

panne

# A: loop through input to collect sub-expressions
for($a=$argn;$c=$a[$k];)
    $r.="|$c".($d=$a[$k-1])     # 1. pair of characters
        ."|$d$c"                # 2. reversed pair
        ."|^.{".+$k++."}$c";    # 3. $c is at k-th position
# B: shuffle input until regex does not match the result
while(preg_match("#$a$r#",($s=str_shuffle($a)).$s));    # (input as dummy sub-expression)
# C: print result
echo$s;

PHP 7.1, 187 185 172 172 178 143 octets

do for($r=str_shuffle($s=$argn),$p=$i=0;$c=$s[$i];$p+=($c==$z)+preg_match("#$a|$b#",$s.$s))$b=strrev($a=$r[$i-1].$z=$r[$i++]);while($p);echo$r;

Exécuter en tant que pipe avec -rou tester en ligne . (Assurez-vous que PHP version 7.1.0 ou supérieure est sélectionné!)

panne

do
    for($r=str_shuffle($s=$argn),   # 2. shuffle input
        $p=$i=0;$c=$s[$i];          # 3. loop through input
        $p+=($c==$z)                        # 2. set $p if char is at old position
            +preg_match("#$a|$b#",$s.$s)    #    or if adjacency occurs in input
    )
        $b=strrev($a=$r[$i-1].$z=$r[$i++]); # 1. concat current with previous character
while($p);                          # 1. loop until $p is falsy
echo$r;                             # 4. print

Ruby, 110 97 102 octets

->s{x=s.chars
t=s*2
x.shuffle!while s.size.times.any?{|i|a,b=(x*2)[i,2];a==s[i]||t[a+b]||t[b+a]}
x*''}

Essayez-le en ligne!

JavaScript 6, 116 octets

f=x=>(h=[...x].sort(_=>Math.random(z=0)-.5)).some(y=>y==x[z]||(x+x).match(y+(q=h[++z]||h[0])+'|'+q+y))?f(x):h.join``

f=x=>(h=[...x].sort(_=>Math.random(z=0)-.5)).some(y=>y==x[z]||(x+x).match(y+(q=h[++z]||h[0])+'|'+q+y))?f(x):h.join``

console.log (f('abcdef'));

Stax , 23 21 octets

å╘┤‼¬½P¥ë└w↕⌐î◘E{╟u!Ö

Exécutez et déboguez en ligne!

Merci pour @recursive d'avoir sauvé 2 octets.

Prend très longtemps à courir. Une version plus raisonnable / réalisable est (seulement 2 octets de plus)

Ç≡╨áiS║çdèû.#-Gî☺└╨◙σφ+

Exécutez et déboguez en ligne!

Explication

Utilise la version décompressée pour expliquer.

w|Nc_:=nGyG|*{E-!f+}ch+2B
w                            Loop anything before `}` while
 |N                          Next permutation (starting from the input)
   c_:=                      Index where the current array has the same element as the input (*)
                   }ch+2B    Define a block that finds all contiguous pairs in current string, including the pair `[last element, first element]`
       nG                    Apply the defined block to current string                         
         yG                  Do the same for the input
           |*                Outer product, contains pairs (which themselves are pairs) constructed from the last two array.
             {   f           Only keep pairs
              E-!            whose two elements have the same set of characters
                  +          Prepend the array at step (*).
                             This is used as the condition for the while loop