Votre tâche est simple . Déterminer si une chaîne est égale à l'autre (pas d' adresse, la valeur) sans l'utilisation des opérateurs d'égalité ( par exemple ==, ===ou .equal()) ou l' inégalité ( !=, !==) quelque chose de semblable pour d' autres langues. Cela signifie partout! Vous ne pouvez utiliser ces opérateurs nulle part dans le code. Vous pouvez cependant utiliser des bascules telles !expque vous ne comparez pas directement le exp != with something else.

De plus, vous ne pouvez utiliser aucune fonction telle que strcmp , strcasecmp , etc.

En ce qui concerne les opérateurs de comparaison ( >=, <=, >, <), ils sont également refusées . Je me rends compte que certaines réponses incluent cela, mais j'aimerais vraiment voir plus de réponses qui ne limitent pas l'opérateur d'égalité.

Un exemple utilisant PHP est montré:

<?php

$a = 'string';
$b = 'string';

$tmp = array_unique(array($a, $b));

return -count($tmp) + 2;

Renvoyez simplement vrai ou faux (ou quelque chose qui est évalué dans le langage comme vrai ou faux comme 0 ou 1) pour indiquer si les chaînes correspondent. Les chaînes doivent être codées en dur comme dans l'exemple ci-dessus. Les chaînes ne doivent pas être comptées dans le golf, donc si vous déclarez la variable avant la main, ne comptez pas la déclaration.

Python 49 45 18 22 15 14

(+ 3 si les variables de chaîne sont prises en compte)

print{a:0,b:1}[a]

La chaîne doit être codée en dur aux deux occurrences de aet une occurrence de bentouré de guillemets.

aet bdoit être pré-initialisé aux chaînes.

Coque en python, 9

(+ 3 si les variables de chaîne sont prises en compte)

{a:0,b:1}[a]

Sortie en shell

>>> a = 'string'
>>> b = 'string'
>>> {a:0,b:1}[a]
1
>>> a = 'string'
>>> b = 'stringgg'
>>> {a:0,b:1}[a]
0
>>> {'string':0,'string':1}['string']
1
>>> {'stringggg':0,'string':1}['stringggg']
0
>>> 

Explication

Crée un dict (table de hachage) avec la clé de la première et de la deuxième chaîne. Si la deuxième chaîne est la même, la valeur de la première est remplacée par celle de la seconde. Enfin, nous imprimons la valeur de la première clé.

EDIT: OP a permis 0/1 au lieu de False / True ainsi que l'utilisation de variables pré-initialisées.

Python ( 17 11):

b in a in b

(Vérifie si b est contenu dans a et a est contenu dans b, si cela ne ressort pas clairement du code.)

Python alternatif: ( 8 7)

dérivé de la solution Go de Tom Verelst:

b in[a]

Bonus: cela fonctionne pour tout type.

MODIFIER:

Attendez une seconde, lisez simplement que vous pouvez également programmer directement dans les chaînes, et ne pas avoir à compter les guillemets ... (ou du moins, ce que fait golfscript). Alors ... Python à égalité avec golfscript? Oh mon!

Alternative alternative Python ( 5 4):

(merci Claudiu)

"string"in["string"]

original:

"string" in["string"]

Alternative Alternative Alternative Bendy-ruly Python (2):

"string"is"string"

Rien n'a été dit sur les mots clés de comparaison (ce n'est pas une soumission sérieuse, juste quelque chose qui m'est venu à l'esprit ...)

JavaScript, 11 10

Les chaînes doivent être stockées dans a et b.

!(a>b|a<b)

Edit: merci Danny de l'avoir souligné, cela |suffit au lieu de||

Rubis, 11

s = 'string'
t = 'string'
!!s[t]&t[s]

Vérifie si chaque chaîne est contenue dans l'autre.

Python - 11 (sans les chaînes)

>>> a = 'ss'
>>> b = 's'
>>> a in b in a
False

GolfScript (5 caractères)

'string1''string1'].&,(

Port assez simple de l'implémentation de référence PHP. Laisse 0(= false) sur la pile si les chaînes sont identiques, ou 1(= true) si elles sont différentes.

Javascript (45 octets):

Voici une autre solution en Javascript.

var a='string',b='string',c=!a.replace(b,'');

L'espace est important.

cdevrait être true.

C ++, 63 58 56

const char* a = "string";
const char* b = "string";
int main(){while(*a**b*!(*a^*b))++a,++b;return!(*a^*b);}

coreutils: uniq -d

Entrez simplement vos deux chaînes comme entrée standard d'un tuyau et uniq -d | grep -q .n'imprimera rien mais aura une valeur de retour de succès ou d'erreur. Si vous souhaitez imprimer le booléen, remplacez simplement paruniq -d | grep -c .

Combien de personnages? Je vous laisse compter; uniq -d|grep -q .sans espaces supplémentaires contient 17 caractères, mais comme tout le travail est effectué par uniq, je dirais que cette solution est à 0 caractères dans ... sa uniqpropre langue!

En fait, uniq -dimprime une ligne si les deux chaînes sont identiques et rien si les sont différentes.

Les chaînes doivent être stockées dans a et b. Ne fonctionnera pas si l'un ou l'autre l'est null.

C #, 53

string.IsNullOrEmpty(a.Replace(b,"")+b.Replace(a,""))

C #, 28

a.Contains(b)&&b.Contains(a)

PHP - 49 caractères

!(strlen($a)^strlen($b)|strlen(trim($a^$b,"\0")))

APL ( 8 9)

Mise à jour: l'ancienne ne fonctionne pas pour les chaînes de longueurs différentes.

{∧/∊⌿↑⍺⍵}

• ↑⍺⍵: faire une matrice avec ⍺sur la première ligne et ⍵sur la deuxième ligne, en remplissant les espaces vides.
• ∊⌿: Pour chaque colonne, vérifiez si la ligne supérieure contient la ligne inférieure (comme dans l'ancienne version).
• ∧/: Prenez la logique andde toutes les valeurs.

Le vieux:

{∧/⍺∊¨⍵}

• ⍺∊¨⍵: pour chaque combinaison d'éléments dans ⍺et ⍵, voyez si l'élément from ⍺contient l'élément from ⍵. Étant donné que dans une chaîne, ce seront tous des caractères uniques et qu'une chaîne se contient, il s'agit essentiellement de comparer chaque paire de caractères.
• ∧/: prendre la logique et toutes les valeurs (si tous les caractères correspondent, les chaînes sont égales)

Python - 12

not({a}-{b})

Cette solution utilise des ensembles. La soustraction d'ensembles égaux se traduira par un ensemble vide, qui a une valeur booléenne False. La négation qui se traduira par une valeur vraie pour a et b étant des chaînes égales.

>>> a="string1"
>>> b="string2"
>>> not({a}-{b})
False

>>> a="string"
>>> b="string"
>>> not({a}-{b})
True

Edit: Merci à Peter Taylor pour avoir souligné les espaces inutiles.

C - 62

e(char*p,char*q){for(;*p&*q&&!(*p^*q);q++,p++);return!(*p^*q);}

Testé. Appelez en tant quee(str1, str2)

À bien y penser, si vous ne comptez pas le char*p,char*q, ce qui semble juste, ce n'est que 49 octets :)

Haskell - 9

elem a[b]

Notez que, comme beaucoup d'entrées ici, ce n'est qu'une expression. Ce n'est pas un programme Haskell.

Java - 162 147 caractères

L'idée est de comparer la différence de chaque octet, les mêmes octets auront la différence 0. Le programme lancera java.lang.ArrayIndexOutOfBoundsExceptionquand les octets sont différents (essayez d'accéder à un index négatif) ou lorsque les chaînes sont de longueur différente. Il interceptera l'exception et renverra 0 (chaînes non égales), ou renverra 1 sinon (chaînes égales).

Comprimé:

String a = "12345";
String b = "12345";
byte[]x=a.getBytes(),y=b.getBytes();int z,i=a.length()-b.length();try{for(byte d:x){z=d-y[i];z=x[-z*z];i++;}}catch(Exception e){return 0;}return 1;

Ordinaire:

String a = "12345";
String b = "12345";
byte[] byteArrA = a.getBytes();
byte[] byteArrB = b.getBytes();

int byteDifference = 0;
int i = a.length() - b.length();

try {
    for (byte aByte : byteArrA) {
        byteDifference = aByte - byteArrB[i];
        byteDifference = byteArrA[-byteDifference*byteDifference];
        i++;
    }
} catch (Exception e){
    return 0;
}

return 1;

PHP

    $string = 'string';
    isset( ${'string'} );

Ce script peut ne pas avoir d'utilité, mais au moins cela fournit un moyen de comparer les chaînes.

PHP

Un autre:

    $string = 'something';
    $text   = 'something';
    return count( array( $string => 1 , $text => 1 ) ) % 2;

Prolog 7

e(A,A).

Cela utilise la fonction de correspondance de motifs dans Prolog pour unifier les 2 arguments au prédicat, qui teste efficacement l'équivalence égale lorsqu'il n'y a pas de variable non liée .

Exemple d'utilisation:

?- e("abcd", "Abcd").
false.

?- e("abcd", "abcd").
true.

Techniquement parlant, le comportement de cette solution est celui de l'opérateur d'unification =/2, plutôt que celui de ==/2, qui vérifie l'équivalence des termes. La différence montre quand des variables non liées sont impliquées. Dans cette solution, lorsque la variable non liée est fournie, le prédicat est renvoyé truelorsque l'unification est réussie. En comparaison, ==/2comparera l'ordre des termes sans unification.

PHP, 21

Celui-ci fait le travail en utilisant l'indirection variable.

$$a=$b;!!$$b;

Ou, si vous n'en avez pas besoin pour être booléen

$$a=$b;$$b;

EDIT : J'ai oublié de gérer le cas où vous essayez de comparer deux chaînes vides, donc le code est maintenant

$$a=$b;!($a.$b)||$$b;

qui est de 21 caractères.

CPython: 6

a is b

>>> a = 'string'
>>> b = 'string'
>>> c = 'STRING'
>>> a is b
True
>>> a is c
False

L'utilisation de isest évidemment assez suspecte, mais comme la tâche appelle spécifiquement à déterminer l'égalité de valeur plutôt que l'égalité de référence, et isne compare que l'identité d'objet, j'ai l'impression que cela ne peut pas entrer dans la liste des opérateurs interdits.

Bien sûr, il est également question de savoir si cela est même valable; il fonctionne sur tous mes systèmes, mais il est spécifique à l'implémentation et ne fonctionnera probablement pas toujours si les chaînes ne sont pas définies à la main dans l'interpréteur interactif.

Langage Mathematica / Wolfram, 15 octets

2 - Length[{a} ∪ {b}]

Assez explicite, définit chaque chaîne comme un ensemble, puis vérifie la longueur de l'union des deux ensembles. Si les chaînes sont les mêmes, renvoie 1, sinon retourne 0. Si je suis autorisé à retourner «2» pour «différent» et «1» pour «même», soustrayez deux octets.

C 342 golfé

#include <stdio.h>
#define N 100
#define P(x) printf("%s\n",x)
#define G(x) gets(x)
void e(int x){x?P("y"):P("n");}
int main(){
char s[N],t[N];char *p,*q;int r=0; int n=0,m=0;int i=1;p=s,q=t;
if((p=G(s))&&(q=G(t))){while (*p){n+=i*(int)*p;m+=i*(int)*q;i++;p++;q++;if(!(*q)){break;}}
if(!*p&!*q){if(!(m-n)){r=1;}}e(r);}
return 0;
}

Remarque: Visual Studio se plaint si vous n'utilisez pas leurs méthodes sûres, par exemple gets_s. CodeBlocks avec mingw compile sans avertissements.

C 655 non golfé

Le code crée une somme pondérée de caractères pour chaque chaîne. Si la différence est nulle, elles sont égales, y compris 2 chaînes vides:

    #include <stdio.h>
#define N 100
#define P(x) printf(x)
#define G(x) gets_s(x)

void e(int x){ x ? P("equal\n") : P("not equal\n"); }
int main()
{
    char s[N], t[N];//words
    char *p = 0, *q = 0;
    int r = 0; //result 0=false
    int n=0, m=0; //weighted sums
    int i = 1; //char pos start at 1
    if ((p=gets_s(s)) &&
        (q=gets_s(t)))
    {
        while (*p)
        {
            n += i*(int)*p;
            m += i*(int)*q;
            i++;
            p++;
            q++;
            if (!(*q)){
                break;
            }
        }

        if (!*p && !*q){ //both same length strings
            if (!(m - n)){ r = 1; } //weighted sums are equal           
        }//else r=0, false=>not equal

        e(r);
    }
    else{
        P("error\n");
    }
    getchar();
}

Python

C'est long et ce n'est pas beau, mais c'est ma première entrée!

def is_equal(a,b):
    i=0
    a,b=list(a),list(b)
    if len(a)>len(b):
        c=a
        lst=b
    else:
        c=b
        lst=a
    try:
        while i<len(c):
            for j in c:
                if j not in lst[i]:
                    return False
                i+=1
    except IndexError:
        return False
    return True

PHP, 68 octets

Je suppose qu'il vous est interdit d'utiliser des opérateurs de comparaison. Alors <ou >sont inclus.

L'idée est d'utiliser XOR au niveau du bit. Dans différentes langues, cet opérateur a une syntaxe différente - je vais montrer un exemple pour PHP. Là, il est disponible avec ^. Malheureusement, son comportement avec les chaînes n'est pas aussi bon qu'il pourrait l'être, vous devrez donc vérifier la longueur des chaînes avant. En effet, en PHP, xor supprimera la chaîne la plus longue jusqu'à la longueur de la chaîne la plus courte.

La prochaine chose est de travailler correctement avec les chaînes, car un seul xorne produira pas de résultat, disponible pour d'autres opérations en PHP. Voilà pourquoi a unpack()été utilisé. Ainsi, le code serait:

return !(strlen($a)^strlen($b)) & !array_filter(unpack('c*', $a^$b))

C'est plus long que l'option avec </ >mais il ne les utilisera pas. En outre, l'important concerne le jonglage de type PHP (donc le tableau vide sera converti en false). Ou peut-être qu'il existe un moyen plus simple de vérifier si un tableau contient des membres non nuls ( Edit : pendant que je tape ceci, il y a un bon hic avec trim()une autre réponse, afin que nous puissions nous débarrasser des opérations de tableau)

Mais je crois qu'il y a des langues, où nous pouvons faire juste a ^ b- littéralement, obtenir le résultat. Si c'est 0(traité à partir de tous les octets résultants) - alors nos chaînes sont égales . C'est très facile et encore plus simple que <ou autre >.

grep 14 caractères

Bien sûr, je ne compte que le code grep; les deux chaînes sont sur deux lignes consécutives en entrée (soit un pipe soit un fichier ou même une session interactive).

$ echo -e 'string\nstring' | grep -cPzo "(?s)^(\N*).\1$"
1
$ echo -e 'string\nstring1' | grep -cPzo "(?s)^(\N*).\1$"
0
$ echo -e 'string1\nstring' | grep -cPzo "(?s)^(\N*).\1$"
0

Matlab: 12 caractères (après que les chaînes soient dans des variables)

~(x*x'-y*y')

Le code incluant les affectations serait:

x='string1'
y='string2'
~(x*x'-y*y')

La manière très folle

Juste pour le plaisir, mais de nombreuses façons de le faire échouer si on y pense. De plus, n'oubliez pas que les cordes seront EXÉCUTÉES par le shell.

$ echo -e 'string\nstring1' | sed -e '1s/^/#define /' | cpp | sh 2>/dev/null && echo true
$ echo -e 'string\nstring' | sed -e '1s/^/#define /' | cpp | sh 2>/dev/null && echo true
true
$ echo -e 'string1\nstring' | sed -e '1s/^/#define /' | cpp | sh 2>/dev/null && echo true

Un bon contre-exemple compare la "chaîne" comme première chaîne et "rm -Rf /" comme deuxième chaîne; vérifiez simplement en tant que root et voyez: il dira "vrai" bien que les deux chaînes ne soient évidemment pas identiques.

JavaScript [18 octets]

(_={})[a]=1,!!_[b]

OU

!!((_={})[a]=_)[b]

Cela reviendra truesi a == bet falsesi a =/= b. La logique derrière est de créer un objet avec une valeur de acomme propriété et de retourner 1ou undefinedau cas où une propriété de bvaleur existe ou n'existe pas dans cet objet.

JavaScript [15 octets]

![a].indexOf(b)

Cela reviendra truesi a == bet falsesi a =/= b. Le script recherche la valeur de bdans le tableau qui contient un seul élément de valeur de a.

C - 86 83

main(int i,char**v){return*v[1]&!(*v[1]++^*v[2]++)?main(3,v):!(*--v[1]^*--v[2]);}

Évidemment, ce n'est pas le plus court, mais cela ne fonctionne pas avec les variables de chaîne et prend à la place les chaînes en entrée de la console. De plus, j'aime un peu le principal récursif, même si ce n'est évidemment pas la version la plus courte. Mais certainement le moins conseillé.