Sua tarefa é simples . Determinar se uma cadeia é igual ao outro (não endereço, o valor) sem o uso de operadores de igualdade (como ==, ===ou .equal()) ou desigualdade ( !=, !==) algo semelhante para outros idiomas. Isso significa em qualquer lugar! Você não pode usar esses operadores em qualquer lugar do código. No entanto, você pode usar alternâncias como !expnão comparar diretamente o exp != with something else.

Além disso, você não pode usar funções como strcmp , strcasecmp , etc.

Tal como para os operadores de comparação ( >=, <=, >, <), eles são também anulado . Sei que algumas respostas incluem isso, mas eu realmente gostaria de ver mais respostas que não fazem fronteira com o operador de igualdade.

Um exemplo usando PHP é mostrado:

<?php

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

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

return -count($tmp) + 2;

Simplesmente retorne verdadeiro ou falso (ou algo que avalie no idioma como verdadeiro ou falso como 0 ou 1) para indicar se as cadeias correspondem. As strings devem ser codificadas como no exemplo acima. As seqüências de caracteres não devem ser contadas no golfe; portanto, se você declarar a variável antes da mão, não conte a declaração.

Python 49 45 18 22 15 14

(+ 3 se variáveis ​​de string forem consideradas)

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

A cadeia deve ser codificada nas duas ocorrências de ae uma ocorrência entre baspas.

ae bdeve ser pré-inicializado para as strings.

Shell Python, 9

(+ 3 se variáveis ​​de string forem consideradas)

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

Saída com casca

>>> 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
>>> 

Explicação

Cria um ditado (tabela de hash) com a chave da primeira e da segunda string. Se a segunda sequência for a mesma, o valor da primeira será substituído pelo valor da segunda. Finalmente, imprimimos o valor da primeira chave.

EDIT: OP permitiu 0/1 em vez de False / True, além de usar variáveis ​​pré-inicializadas.

Python ( 17 11):

b in a in b

(Verifica se b está contido em ae a está contido em b, se isso não ficou claro no código.)

Python alternativo: ( 8 7)

derivado da solução Go de Tom Verelst:

b in[a]

Bônus: isso funciona para qualquer tipo.

EDITAR:

Espere um segundo, apenas leia que você também pode programar diretamente nas strings e não precisa contar aspas ... (ou pelo menos o que o golfscript faz). Então ... Python a par com golfscript? Oh meu!

Alternativa alternativa em Python ( 5 4):

(obrigado Claudiu)

"string"in["string"]

original:

"string" in["string"]

Alternativa Alternativa Alternativa Python Bendy-ruly (2):

"string"is"string"

Nada foi dito sobre palavras-chave de comparação (este não é um envio sério, apenas algo que me ocorreu ...)

JavaScript, 11 10

As strings devem ser armazenadas em a e b.

!(a>b|a<b)

Edit: obrigado Danny por apontar, |é suficiente em vez de||

Ruby, 11

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

Verifica se cada sequência está contida na outra.

Python - 11 (sem as cordas)

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

GolfScript (5 caracteres)

'string1''string1'].&,(

Porta bastante direta da implementação de referência do PHP. Deixa 0(= false) na pilha se as strings forem iguais ou 1(= true) se forem diferentes.

Javascript (45 bytes):

Aqui está outra solução em Javascript.

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

O espaço é importante.

cdeveria ser 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

Basta digitar suas duas seqüências como a entrada padrão de um tubo e uniq -d | grep -q .não imprimirá nada, mas terá um valor de retorno de sucesso ou erro. Se você deseja imprimir o booleano, substitua-o poruniq -d | grep -c .

Quantos caracteres? Eu deixo você contar; uniq -d|grep -q .sem espaços extras tem 17 caracteres, mas como todo o trabalho é realizado pela uniq, eu diria que esta solução é de 0 caracteres em ... uniqidioma próprio!

Na verdade, uniq -dimprimirá uma linha se as duas strings forem idênticas e nada se as forem diferentes.

As strings devem ser armazenadas em a e b. Não funcionará se for null.

C #, 53

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

C #, 28

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

PHP - 49 caracteres

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

APL ( 8 9)

Atualização: o antigo não funciona para strings de comprimentos diferentes.

{∧/∊⌿↑⍺⍵}

• ↑⍺⍵: faça uma matriz com ⍺ na primeira linha e ⍵na segunda linha, preenchendo espaços em branco com espaços.
• ∊⌿: Para cada coluna, veja se a linha superior contém a linha inferior (como na versão antiga).
• ∧/: Pegue a lógica and de todos os valores.

Antigo:

{∧/⍺∊¨⍵}

• ⍺∊¨⍵: para cada combinação de elementos em ⍺e ⍵, veja se o elemento de⍺ contém o elemento de⍵ . Como em uma string, todos serão caracteres únicos e uma string contém a si mesma, isso basicamente compara cada par de caracteres.
• ∧/: pegue o lógico e todos os valores (se todos os caracteres corresponderem, as seqüências de caracteres serão iguais)

Python - 12

not({a}-{b})

Esta solução usa conjuntos. Subtrair conjuntos iguais resultará em um conjunto vazio, que possui um valor booleano False. Negar isso resultará em um valor Verdadeiro para a e b sendo cadeias iguais.

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

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

Edit: Obrigado a Peter Taylor por apontar o espaço em branco desnecessário.

C - 62

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

Testado. Ligar comoe(str1, str2)

Venha para pensar sobre isso, se você não conta char*p,char*q, o que parece justo, são apenas 49 bytes :)

Haskell - 9

elem a[b]

Observe que isso, assim como muitas entradas aqui, é apenas uma expressão. Este não é um programa Haskell.

Java - 162 147 caracteres

A idéia é comparar a diferença de cada byte, os mesmos bytes terão diferença 0. O programa lançará java.lang.ArrayIndexOutOfBoundsExceptionpara quando os bytes forem diferentes (tente acessar um índice negativo) ou quando as strings tiverem comprimento diferente. Ele capturará a exceção e retornará 0 (cadeias não iguais) ou retornará 1 caso contrário (cadeias iguais).

Comprimido:

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;

Normal:

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'} );

Esse script pode não ter nenhum utilitário, mas pelo menos isso fornece uma maneira de comparar seqüências de caracteres.

PHP

Outro:

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

Prolog 7

e(A,A).

Isso usa o recurso de correspondência de padrões no Prolog para unificar os 2 argumentos ao predicado, que efetivamente testa a equivalência igual quando não há variável não acoplada .

Uso da amostra:

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

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

Tecnicamente falando, o comportamento dessa solução é o de operador de unificação =/2, e não o de ==/2, que verifica a equivalência de termos. A diferença mostra quando variáveis ​​não acopladas estão envolvidas. Nesta solução, quando a variável não acoplada for fornecida, o predicado retornará truequando a unificação for bem-sucedida. Em comparação, ==/2comparará a ordem do termo sem unificação.

PHP, 21

Este está fazendo o trabalho usando variável indireta.

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

Ou, se você não precisa ser booleano

$$a=$b;$$b;

Edição : Eu esqueci de lidar com o caso em que você tenta comparar duas seqüências de caracteres vazias, então o código agora é

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

que são 21 caracteres.

CPython: 6

a is b

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

O uso de isé obviamente bastante suspeito, mas como a tarefa especifica especificamente que devemos determinar a igualdade de valor em vez de referenciar a igualdade, e isapenas comparar a identidade do objeto, acho que pode não estar na lista de operadores proibidos.

É claro que há também uma dúvida sobre se isso é válido; funciona em todos os meus sistemas, mas é específico da implementação e provavelmente nem sempre funcionará se as seqüências de caracteres não forem definidas manualmente no intérprete interativo.

Linguagem Mathematica / Wolfram, 15 bytes

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

Bastante auto-explicativo, define cada string como um conjunto e depois verifica o comprimento da união dos dois conjuntos. Se as seqüências de caracteres forem iguais, retorna 1, caso contrário, retorna 0. Se for permitido retornar '2' para "diferente" e '1' para "igual", subtraia dois bytes.

C 342 golfed

#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;
}

Nota: O Visual Studio reclama se você não usar seus métodos seguros, por exemplo, gets_s. CodeBlocks com mingw compila sem avisos.

C 655 não jogou golfe

O código cria uma soma ponderada de caracteres para cada sequência. Se a diferença for zero, eles serão iguais, incluindo duas cadeias vazias:

    #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

É longo e não é bonito, mas esta é a minha primeira entrada!

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 bytes

Eu suponho que você está proibido de usar quaisquer operadores de comparação. Então, <ou >estão incluídos.

A idéia é usar o XOR bit a bit. Em linguagens diferentes, este operador possui sintaxe diferente - mostrarei um exemplo para PHP. Lá está disponível com ^. Infelizmente, seu comportamento com as strings não é tão bom quanto poderia ser, portanto, você precisará verificar o comprimento da string antes. Isso ocorre porque, no PHP, o xor reduz a cadeia mais longa até o comprimento da cadeia mais curta.

O próximo passo é trabalhar com as strings corretamente, porque uma única xornão produzirá um resultado, disponível para operações adicionais no PHP. Por isso unpack()foi usado. Então, o código seria:

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

É mais longo que a opção com </ >mas não os usará. Além disso, o importante é o malabarismo do tipo PHP (para que a matriz vazia seja convertida em false). Ou talvez haja uma maneira mais simples de verificar se uma matriz contém membros diferentes de zero ( Edit : enquanto eu estiver digitando isso, há uma boa captura com trim()outra resposta, para que possamos nos livrar das operações da matriz)

Mas acredito que existem idiomas, onde podemos fazer exatamente a ^ b- literalmente, obter o resultado. Se for 0(tratado de todos os bytes resultantes) - então nossas strings são iguais . É muito fácil e ainda mais simples do que <ou >material.

grep 14 caracteres

Claro, eu apenas conto o código grep; as duas strings estão em duas linhas consecutivas na entrada (um pipe ou um arquivo ou mesmo uma sessão interativa).

$ 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 caracteres (após as strings estarem em variáveis)

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

O código, incluindo atribuições, seria:

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

O jeito muito louco

Apenas por diversão, mas muitas maneiras de fazê-lo falhar se alguém pensar sobre isso. Além disso, não esqueça que as cordas serão EXECUTADAS pelo 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

Um bom contra-exemplo é comparar "string" como primeira string e "rm -Rf /" como segunda string; basta verificar como root e ver: ele dirá "true", embora ambas as strings obviamente não sejam iguais.

JavaScript [18 bytes]

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

OU

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

Isso retornará truese a == be falsese a =/= b. A lógica subjacente é criar um objeto com um valor de acomo uma propriedade e retornar 1ou undefined, caso bexista ou não uma propriedade de valor nesse objeto.

JavaScript [15 bytes]

![a].indexOf(b)

Isso retornará truese a == be falsese a =/= b. O script está procurando o valor de bna matriz que contém um único elemento de valor de a.

C - 86 83

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

Obvioulsy não é o menor, mas isso não funciona com variáveis ​​de string e, em vez disso, pega as strings como entrada do console. Além disso, eu meio que gosto do main recursivo, mesmo que obviamente não seja a versão mais curta. Mas certamente o menos aconselhável.