È diventato in qualche modo una tradizione in PPCG che alcuni utenti cambino temporaneamente i loro nomi con un anagramma (un nuovo nome formato riordinando le lettere del vecchio).

A volte diventa difficile scoprire chi è chi. Potrei usare un programma o una funzione per dire se due frasi sono anagrammi l'una dell'altra.

La sfida

Il programma o la funzione dovrebbero prendere due stringhe e produrre un risultato veritiero se sono anagrammi l'uno dell'altro, e falsare altrimenti.

Regole

• L'input conterrà solo lettere (ASCII da 65 a 90 e da 97 a 122), cifre (ASCII da 48 a 57) o spazio (ASCII 32).
• La relazione anagramma è indipendente dal caso. Quindi "Arm" e "RAM" sono anagrammi.
• Neanche gli spazi contano. Quindi "tastiera" e "Barked Yo" sono anagrammi
• Sono ammessi tutti i builtin
• Il formato di input è flessibile (due stringhe, una matrice di due stringhe, una stringa contenente entrambe le frasi con un separatore adatto ...)

Codice golf. Vince il minor numero di byte.

Casi test

Truthy:

Lynn, Nyl N
Digital Trauma, Tau Digital Arm
Sp3000, P S 3000
Manage Trash So, Those anagrams

Falsy

Calvins Hobbies, Helka Homba
Android, rains odd
In between days, bayed entwine
Code golf, cod elf got

05AB1E , 9 8 byte

Codice:

lvyð-{}Q

Spiegazione:

l         # Lowercase the strings
 vy   }   # Map over the list, for each...
   ð-     #   remove spaces
     {    #   and sort
       Q  # Check equality

Provalo online!

Retina, 25

i+`(\w)(.*,.*)\1
$2
^\W*$

Provalo online! Inoltre, è possibile eseguire una versione multilinea modificata .

Elimina le lettere prima della virgola insieme alle loro corrispondenze dopo la virgola. Se non ci sono più lettere, allora era un anagramma.

Pyth, 11 10 byte

Grazie a @FryAmTheEggman per avermi insegnato il potere di ;!

qFmSr-d;0Q

Provalo qui!

Prende un elenco di due stringhe come input.

Spiegazione

qFmSr-d; 0Q # Q = input

  m Q # mappa Q con d come variabile lambda
     -d; # filtra gli spazi fuori dalla stringa
    r 0 # converti in minuscolo
   S # ordina tutti i caratteri nella stringa
qF # Spiega l'elenco risultante e verifica l'uguaglianza

Python 2, 63 61 byte

lambda*l:len({`sorted(s.lower())`[2::5].strip()for s in l})<2

Una funzione anonima che, di fatto, accetta n argomenti e determina se tutti e n sono palindromi reciproci! f("Lynn", "Nyl N")ritorna True.

Questo trucco di comprensione set è di xnor. Ha salvato due byte, ma il vecchio approccio sembrava molto pulito:

exec"a=`sorted(input().lower())`[2::5].strip();a"*2;print a==aa

Gelatina, 12 byte

ḟ€⁶O&95Ṣ€QLḂ

Provalo online!

Come funziona

ḟ€⁶O&95Ṣ€QLḂ  Main link. Input: A (list of strings)

  ⁶           Yield ' '.
ḟ€            Filter it from each string.
   O          Apply ordinal to all characters.
    &95       Take bitwise AND with 95 to make the ordinals case-insensitive.
       Ṣ€     Sort each list of ordinals.
         Q    Deduplicate the list.
          L   Get the length.
           Ḃ  Compute the length's parity (1 -> 1, 2 -> 0).

Versione alternativa, non competitiva (9 byte)

L'atomo maiuscolo di Jelly aveva un bug, e Jelly non aveva ancora incorporato per testare le liste per l'uguaglianza ...

ḟ⁶ŒuṢµ€⁼/

Provalo online!

Come funziona

ḟ⁶ŒuṢµ€⁼/     Main link. Input: A (list of strings)

     µ€       Map the chain to the left over A.
 ⁶            Yield ' '.
ḟ             Filter it from the string.
  Œu          Cast to uppercase.
    Ṣ         Sort.
       ⁼/     Reduce by equality.

CJam, 11 12 14 byte

3 2 byte rimossi grazie a @FryAmTheEggman

{lelS-$}2*=

Provalo online!

{      }2*       e# do this twice
 l               e# read line as a string
  el             e# make lowercase
    S-           e# remove spaces from string
      $          e# sort
          =      e# compare strings

Javascript, 69 61 60 59 byte

1 byte spento grazie @ ӍѲꝆΛҐӍΛПҒЦꝆ . 1 byte spento con curry ( indicato da @apsillers )

n=>m=>(G=s=>[]+s.toLowerCase().split(/ */).sort())(n)==G(m)

f=n=>m=>
    (G=s=>[]+s.toLowerCase()
        .split(/ */)
        .sort()
    )(n)==G(m)

F=(n,m)=>document.body.innerHTML+=`<pre>f('${n}')('${m}') -> ${f(n)(m)}</pre>`

F('Luis Mendo','Don Muesli')
F('Calvins Hobbies','Helka Homba')
F('Android','rains odd')
F('In between days','bayed entwine')
F('Code golf','cod elf got')
F('Lynn','Nyl N')
F('Digital Trauma','Tau Digital Arm')
F('Sp3000','P S 3000')
F('Manage Trash So','Those anagrams')

MATL , 11 byte

2:"jkXvS]X=

EDIT (20 maggio 2016) Il codice nel link utilizza Xzinvece di Xv, a causa di recenti cambiamenti nella lingua.

Provalo online!

2:"     ]       % do this twice
   j            % read input line as a string
    k           % convert to lowercase
     Xv         % remove spaces
       S        % sort
         X=     % are they equal?

Scherzi a parte, 11 9 byte

2`,ùSô`n=

Provalo online!

Tutti sembrano usare lo stesso algoritmo. Eccolo di nuovo.

2`    `n          Do it twice
  ,               Read a string
   ù              Make it lowercase
    S             Sort
     ô            Strip spaces.
        =         Check equality.

Modifica: l'ordinamento realizzato funziona correttamente sulle stringhe e ordina gli spazi in primo piano, quindi strip () funzionerà.

C, 165 byte

#define d(x) int x(char*a,char*b){
d(q)return*a&224-*b&224;}
#define n(x) for(qsort(x,strlen(x),1,(__compar_fn_t)q);*x<33;x++);
d(s)n(a)n(b)return strcasecmp(a,b);}

Leggibile e in contesto lavorativo,

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// start of comparison
int q(char *a, char *b){
     return ((*a)&0xdf)-((*b)&0xdf); // case-insensitive
}
int s(char *a, char *b){
    for(qsort(a,strlen(a),1,(__compar_fn_t)q); *a<33; a++) /**/;
    for(qsort(b,strlen(b),1,(__compar_fn_t)q); *b<33; b++) /**/;
    return strcasecmp(a,b);
}
// end of comparison

int main(int i, char **v){
    printf("'%s' '%s'", v[1], v[2]);
    printf("=> %d\n", s(v[1], v[2])); // 0 if equalish
    return 0;
}

zsh, 85 byte

[ $(for x in $@;{tr -d \ <<<$x|tr A-Z a-z|fold -1|sort|paste -sd x}|uniq|wc -l) = 1 ]

Input come argomenti della riga di comando, output come codice di ritorno.

La forsintassi rende questo Bash incompatibile.

[               # test...
$(for x in $@;  # map over arguments
{tr -d \ <<<$x  # remove spaces
|tr A-Z a-z     # lowercase
|fold -1        # put each character on its own line
|sort           # sort lines
|paste -sd x    # remove all newlines except last
}|uniq          # take only unique lines
|wc -l          # how many lines remain?
) = 1 ]         # if only 1 line left, it must have been an anagram

Japt, 12 byte

N®v ¬n ¬xÃä¥

Provalo online!

Come funziona

        // Implicit: N = array of input strings
N®    Ã // Take N, and map each item Z to:
v ¬n    //  Take Z.toLowerCase(), split into chars, and sort.
¬x      //  Join and trim off whitespace.
ä¥      // Reduce each pair of items (that's exactly one pair) X and Y to X == Y.

GNU Sed, 33

Il punteggio include +2 per le -rnopzioni da sed.

Questo è quasi un porto diretto della risposta Retina di @ FryAmTheEggman :

:
s/(\w)(.*,.*)\1/\2/i
t
/\w/Q1

Ideone.

Perl, 34 33 + 1 = 34 byte

s/(.)(.*,.*)\1/$2/i?redo:say!/\w/

Richiede la -nbandiera e il libero -M5.010| -E:

$ perl -M5.010 -ne's/(.)(.*,.*)\1/$2/i?redo:say!/\w/' <<< 'hello, lloeh'
1

Come funziona:

                                   # '-n' make a implicit while loop around the code
 s/(.)(.*,.*)\1/$2/i               # Remove a letter that occurs on both sides of the comma.
                    ?
                     redo:         # Redo is a glorified goto statement that goes to the top of the while loop
                          say!/\w/ # Check to see if any letter is left

Grazie a msh210 per aver suggerito di usare operatori ternari per salvare un byte

Baloch Gyr , 9 byte

{ṇ₁cḷ}ᵐpᵈ

Provalo online!

L'output di verità / falsità si ottiene attraverso successo / fallimento predicato, essendo questo Brachylog.

Precedentemente ho salvato un byte usando cṇ₁cḷḍinvece {ṇ₁cḷ}ᵐche nell'ipotesi che le due stringhe di input fossero della stessa lunghezza meno gli spazi bianchi, ma mi sono reso conto che avrebbe avuto successo dove avrebbe dovuto fallire Ah Hass, haha.

{    }ᵐ      For both strings in the input,
 ṇ₁          split on spaces,
   c         concatenate,
    ḷ        and lowercase.
       pᵈ    The strings are permutations of each other.

PHP, 109 94 byte

function f($x){return str_split((trim($x));}function g($x,$y){return array_diff(f($x),f($y));}

Blech, i due function/returnmi stanno uccidendo qui.

Restituisce la differenza tra due stringinput come arraydi caratteri. PHP considera la []falsità, soddisfacendo i returnrequisiti.

Utilità Bash + GNU, 51

f()(fold -1<<<${@^^}|sort)
f $1|diff -qBw - <(f $2)

• Definire una funzione f()che:
  • ${@^^} converte tutti i parametri in maiuscolo
  • fold -1 divide i caratteri - uno per riga
  • sortlinee s
• chiamare diffcon -qper eliminare l'output diff completo e -Bwignorare le modifiche agli spazi bianchi

Pyke (commit 30, non competitivo), 9 byte

Fl1dk:S)q

Spiegazione:

F      )  -  for _ in eval_or_not(input())
 l1       -     ^.lower()
   dk:    -    ^.replace(" ", "")
      S   -   sorted(^)
        q - ^==^

Mathematica, 77 76 byte

StringMatchQ[##,IgnoreCase->1>0]&@@(""<>Sort[Characters@#/." "->""]&/@{##})&

La prima parte è in realtà una delle mie risposte a un'altra domanda!

Pike, 54 112 109 109 96 byte

#define a(x) sort((array)replace(lower_case(x)," ",""))
int s(mixed i){return a(i[0])==a(i[1]);}

mixedsembra essere più corto di array(string).

sritorna 1se i suoi argomenti sono anagrammi.

Q, 25 byte

f:{~/{x@<x:x@&~^x:_x}'x}

NOTA.- il conteggio include il nome della funzione f: per facilitare i test (come lambda possiamo diminuire di 2 byte)

Versione leggibile

corrisponde sopra {crescente non null inferiore x} ogni x

{.. x ..} is an anonymous function with arg x
_x        lowers string x
&~^x      where not null x (space is considered null)
x@..      selects elements of x according to indexes .. 
<x        ascending indexes of x (not values). Ex <"cab" is 1 2 0
x@<x      ascending values of x (x at ascending indexes of x)
~         match (diad function). Ex "one"~"one" is true
f'..      applies function f for each argument ..
f/..      applies function f over elements of sequence (fold)

Test

f("Lynn";"Nyl N")                       
f("Digital Trauma";"Tau Digital Arm")   
f("Sp3000";"P S 3000")                  
f("Manage Trash So";"Those anagrams")   
f("Calvins Hobbies";"Helka Homba")      
f("Android";"rains odd")                
f("In between days";"bayed entwine")    
f("Code golf";"cod elf got")    

genera (1b = vero, 0b = falso)

1b
1b
1b
1b
0b
0b
0b
0b

A proposito di Q

Linguaggio di uso generale (derivato APL, specializzato nell'elaborazione dei dati) sviluppato da kx.com. Versione di valutazione funzionale completa gratuita per Windows / Linux / MacOS.

APL, 31 caratteri

{≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}

Da usare così:

    {≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}'Sp3000' 'P S 3000' 
1

In inglese:

• { ... }¨⍵: per ciascuno dei due elementi dell'argomento
• x←('.'⎕R'\u0')⍵~' ': trasforma in maiuscolo (usando un regex ...) la stringa senza spazi e assegna il risultato temporaneo a x
• x[⍋x]: ordina x
• ≡/: confronta i due risultati dell'ordinamento: se corrispondono, restituiscono 1.

Java, 218 byte

Prima volta che ho mai scritto Java ...

golfed:

import java.util.Arrays;boolean M(String a,String b){char[]A=a.toUpperCase().replace(" ","").toCharArray();char[]B=b.toUpperCase().replace(" ","").toCharArray();Arrays.sort(A);Arrays.sort(B);return Arrays.equals(A,B);}

Ungolfed:

import java.util.Arrays;
public class ManageTrashSo {
    public boolean M(String a, String b) {
    char[] A = a.toUpperCase().replace(" ", "").toCharArray();
    char[] B = b.toUpperCase().replace(" ", "").toCharArray();
    Arrays.sort(A);
    Arrays.sort(B);
    return Arrays.equals(A, B);
   }
}

test:

    ManageTrashSo manageTrashSo = new ManageTrashSo();

    //True
    System.out.println(manageTrashSo.M("Lynn", "Nyl N"));
    System.out.println(manageTrashSo.M("Digital Trauma", "Tau Digital Arm"));

    //False
    System.out.println(manageTrashSo.M("Android", "rains odd"));
    System.out.println(manageTrashSo.M("In between days", "bayed entwine"));

Japt , 10 byte

v á øVrS v

Provalo

Rubino, 50 byte

def f;gets.upcase.chars.sort.join.strip;end
p f==f

Scrivere f=->{...}ed f[]==f[]è altrettanto lungo. :(

PowerShell, 81 byte

param([char[]]$a,[char[]]$b)-join($a-replace' '|sort)-eq-join($b-replace' '|sort)

Una leggera riscrittura della mia risposta sulla sfida Anagram collegata.

Prende l'input come array di caratteri, esegue -replaceun'operazione per rimuovere gli spazi, sortli ordina (che ordina in ordine alfabetico, non in base al valore ASCII), quindi -joinli rimette in una stringa. In -eqPowerShell per impostazione predefinita non fa distinzione tra maiuscole e minuscole, ma qui deve essere eseguito su stringhe, poiché [char]'a'non è uguale a [char]'A', quindi il motivo di -join.

Perl, 35 byte

Includi +1 per -p

Un po 'offensivo poiché dipende dal programma dato dalla riga di comando.

perl -pe'<>=~s%\S%*_=s/$&//i?_:0%reg;$_=!//'

Quindi dare le stringhe come 2 righe consecutive su STDIN

Una soluzione molto offensiva è di 30 byte:

perl -ne'<>=~s%\w%1/!s/$&//i%reg;1/!//'

Questo si arresta in modo anomalo se le stringhe non sono anagrammi e quindi fornisce un falso codice di uscita dal punto di vista della shell. Dà anche spazzatura su STDERR per quel caso. Se le stringhe sono anagrammi, il programma è silenzioso e fornisce un codice di uscita "vero"

PHP , 89 byte

for(;$i++<2;)$r[]=count_chars(join(explode(" ",strtolower($argv[$i]))));echo$r[0]==$r[1];

Provalo online!

PHP , 94 byte

for(;$i++<2;sort($x),$r[]=trim(join($x)))$x=str_split(strtolower($argv[$i]));echo$r[0]==$r[1];

Provalo online!

Excel VBA, 122 byte

Finestra immediata VBE anonima Funzione che accetta l'input dall'intervallo [A1:B1]e le uscite alla finestra immediata VBE

a=Replace([A1]," ",""):b=Replace([B1]," ",""):For i=1To Len(a):b=Replace(b,Mid(a,i,1),"|",,1,1):Next:?b=String(len(a),"|")

C #, 378 byte

Ho bisogno di un handicap !!

https://dotnetfiddle.net/FNDt0E

using System;
using System.Linq;
using System.Text;

public class Program
{

    public static void Main()
    {
        var l = "Hello World";

        var r = "Red Who Loll";

        var y = new Func<string,string>(s => new String(s.ToLower().Replace(" ","").OrderBy(v => v).ToArray()));
        var z = new Func<string,string,Func<string,string>,bool>((w,x,f) => f(w) == f(x));
        var o = z(l, r, y);


        Console.WriteLine("{0} & {1} are anagram: {2}",l, r, o);


                Console.WriteLine("C#, {0} bytes", Encoding.Unicode.GetByteCount(@"var y = new Func<string,string>(s => new String(s.ToLower().Replace("" "","""").OrderBy(v => v).ToArray()));
    var z = new Func<string,string,Func<string,string>,bool>((w,x,f) => f(w) == f(x));"));

    }

}