서로의 아나그램 인 고유 한 문자열 목록이 제공되면 목록의 각 단어와 다른 단어의 아나그램을 출력합니다.
문자열은 영숫자이며 유효한 아나그램이 보장됩니다.
프로그램이나 함수는 비 결정적 일 필요는 없지만 동일한 입력이 주어지면 코드를 여러 번 실행하면 가능한 모든 출력이 유효한 한 다른 출력을 생성 할 수 있습니다.
[Input] -> Possible output
-----------------
[ab] -> ba
[aba, aab] -> baa
[123, 132, 231, 312, 321] -> 213
[hq999, 9h9q9, 9qh99] -> 999hq
[abcde123, ab3e1cd2, 321edbac, bcda1e23] -> ba213ecd
답변:
f=\온라인 TiO 바이트 카운터에 영향을주지 않으면 서 온라인으로 사용해보기 헤더에 함수를 익명으로 남겨 둘 수 있습니다
нœ¹мà
нœ¹мà
н // 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)
h-.ph
h-.ph
h First string in [the input]
.p All permutations
- Remove those in [the input]
h First element.
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그것이 내가 목록을 변경하지 않고 목록에서 모든 요소를 선택하기 위해 알고있는 가장 짧은 방법입니다 (때문에 Ḣ과 Ṫ일을하지 않는, ḷ/그리고 ṛ/이상), 그리고 약간의 임의성의 원인이 발생합니다.
(가) µ여기 꽤 중복,하지만하지 않고는 Ḣ와 결합 될 것이다 ḟ, 그리고 그것은 내가 여기에 필요하지 않다 "입력의 머리에서 필터"로 해석됩니다 (내가 필요한 입력에서 "필터입니다, 머리를 잡아 ").
function f(a){s=a[0];while(a.indexOf(s)!=-1)s=s.split("").sort(function(){return .5-Math.random()).join("")};return s}
나쁜 난수를 사용하여 각 "임의"순열을 반복합니다.
아마도 잘못된 것일 수도 있지만 나쁜 무작위 추출기는 실제 무작위성을 얻지 못하지만 여전히 모든 순열을 얻을 것임을 의미합니다.
크롬에서 모든 경우에 작동하는 것 같지만 이러한 악용에서 정의되지 않은 동작으로 인해 일부 브라우저에서는 작동하지 않습니다.
(아마도 매우 골치 아픈 사람들은 자신의 솔루션으로 자유롭게 향상시킬 수 있습니다)
pirateBay의 의견 덕분에-많은 바이트
Rick 덕분에 -4 바이트
f=a=>eval('s=[...a[0]].sort(()=>.5-Math.random()).join``;a.indexOf(s)<0?s:f(a)')
s.split("")일 수 있습니다 [...s]. 또한 join("")`join``` 수 있습니다
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)
비 결정적
(While[!FreeQ[#,s=""<>RandomSample@Characters@#&@@#]];s)&
결정 론적
#&@@Complement[""<>#&/@Permutations@Characters@#&@@#,#]&
@Shaggy 덕분에 -1 바이트
á 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
á kN ö.
1X)Y@Z{GX-1)
Sanchises 덕분에 2 바이트를 절약했습니다. setdiff(...,'rows')부정보다 짧으며 ismember(...,'rows')중복을 피합니다. Luis Mendo 덕분에 배열 대신 셀로 전환하여 다른 바이트를 절약했습니다.
MATLAB / 옥타브 등가물도 포함됩니다.
% 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'}.
lambda a:[x for x in permutations(a[0])if~-(x in a)][0]
from itertools import*Mr. Xcoder 덕분에 -1 바이트
@:_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
나는 이것이 순열 내장이나 무작위 셔플 / 정렬을 사용하지 않는 유일한 제출물 이라고 생각합니다 . 더 길지만 알고리즘이 깔끔하다고 생각합니다.
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}.이제 아나그램의 목록을 고려
L, 같은L(문제 설명에 따라) 가능한 모든 철자 바꾸기를 포함하지 않습니다. 우리는 문자열이 존재 함을 보여하고자S에서L같은front(S)적어도 하나 개의 철자 바꾸기 포함S'하지 않을 것입니다L.모든 문자열 것으로, 모순의 방법으로, 가정
S에서L, 모든 문자열front(S)도있다L. 일련의 "프론 팅"동작을 통해 임의의 문자열 순열을 생성 할 수 있습니다. 예를 들어ABCDE -> BAEDC우리는 할 수있다
ABCDE -> CABDE -> DCABE -> EDCAB -> AEDCB -> BAEDC우리는 각 가정 한
S에서L, 모든S'의는front(S)또한입니다L. 이것은 또한 모든S''infront(S')이 등에 있음을 의미L합니다. 따라서, 만약S에L, 모든 순열S도있다L. 그런 다음L완전한 아나그램 세트, 모순이어야합니다.우리가 보장되기 때문에 그래서, 적어도 하나의 순열이 하지 에이
L문자열이 존재해야합니다S의L일부에 대한S'인이front(S)아닌가L. QED.
코드 반복 처리 front(S)마다 S에 L및 ENTER 사용 S'하지이다 L. 위의 결과에 따라 S'자격을 갖춘 사람 이 최소한 하나 이상있게됩니다 .
s=>{for(var g="";;)if(s.All(z=>z!=(g=string.Concat(s[0].OrderBy(t=>Guid.NewGuid())))))return g;}내가 처음으로 게시 한 이후 내 골프 기술이 확실히 좋아졌습니다!
{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")))
}#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;}
(l:Seq[String])=>(l(0).permutations.toSet--l).headl(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$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;do{...}while($j);대신 2 바이트를 저장하십시오 $j=1;while($j){...}. $g중괄호를 제거하고 4 바이트를 절약하려면 내부 정의를 사용하십시오 .
while(in_array($s=str_shuffle($argv[1]),$argv));echo$s;비 결정적; 명령 행 인수에서 입력을받습니다.
php -r <code>공백으로 구분 된 단어로 다음을 실행 하거나 온라인으로 시도하십시오 .
&\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]}
((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
{.@(-.~i.@!@#@{.A.{.). 온라인으로 사용해보십시오!
нœ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가 찾은 것과 거의 같은 대답입니다.
a=>eval('for(s=[...a[0]];(a+[]).includes(k=s.sort(a=>~-(Math.random``*3)).join``););k')이 답변은 Imme의 답변 을 바탕으로 합니다. 그는 의견 에서 이것이 다른 대답이어야한다고 제안했다 .
기존 접근 방식의 문제점은 sort 은 구현에 따라 완전히 달라 입니다. 표준은 정렬 함수 호출 순서를 보장하지 않으므로 이론적으로 첫 번째 또는 두 번째 테스트 사례에서는 끝나지 않을 수 있습니다.
이 방법은 몇 바이트 더 길지만 Math.random결코 반환하지 않더라도 제한된 시간 안에 완료되도록 보장 합니다 .5.
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"
{(.[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
itertools답이 있습니까?