Il tuo compito è semplice . Determinare se una stringa è uguale all'altro (non l'indirizzo, il valore) senza l'uso di operatori di uguaglianza (come ad esempio ==, ===o .equal()) o disuguaglianza ( !=, !==qualsiasi cosa) simile per le altre lingue. Questo significa ovunque! Non è possibile utilizzare questi operatori in nessuna parte del codice. Tuttavia, è possibile utilizzare le levette come se !expnon si sta confrontando direttamente exp != with something else.

Inoltre, non è possibile utilizzare alcuna funzione come strcmp , strcasecmp , ecc.

Per quanto riguarda gli operatori di confronto ( >=, <=, >, <), sono anche consentiti . Mi rendo conto che alcune risposte includono questo, ma mi piacerebbe davvero vedere più risposte che non limitano l'operatore di uguaglianza.

Viene mostrato un esempio usando PHP:

<?php

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

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

return -count($tmp) + 2;

Restituisci semplicemente vero o falso (o qualcosa che valuta nella lingua vero o falso come 0 o 1) per indicare se le stringhe corrispondono. Le stringhe dovrebbero essere hardcoded viste nell'esempio sopra. Le stringhe non devono essere conteggiate nel golf, quindi se dichiari prima la variabile, non contare la dichiarazione.

Python 49 45 18 22 15 14

(+ 3 se si considerano le variabili stringa)

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

La stringa deve essere hardcoded alle due occorrenze di ae una occorrenza bracchiusa tra virgolette.

ae bdovrebbe essere pre-inizializzato alle stringhe.

Shell Python, 9

(+ 3 se si considerano le variabili stringa)

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

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

Spiegazione

Crea un dict (tabella hash) con la chiave della prima e della seconda stringa. Se la seconda stringa è la stessa, il valore di first viene sostituito da quello di second. Infine, stampiamo il valore della prima chiave.

EDIT: OP ha consentito 0/1 invece di False / True, nonché l'utilizzo di variabili pre-inizializzate.

Python ( 17 11):

b in a in b

(Verifica se b è contenuto in a e a è contenuto in b, se non era chiaro dal codice.)

Pitone alternativo: ( 8 7)

derivato dalla soluzione Go di Tom Verelst:

b in[a]

Bonus: funziona per qualsiasi tipo.

MODIFICARE:

Aspetta un secondo, leggi solo che puoi anche programmare direttamente nelle stringhe e non devi contare le virgolette ... (o almeno, ciò che fa golfscript). Quindi ... Python alla pari con golfscript? Oh mio!

Alternativa alternativa a Python ( 5 4):

(grazie Claudiu)

"string"in["string"]

originale:

"string" in["string"]

Alternativa Alternativa alternativa Bendy-ruly Python (2):

"string"is"string"

Non è stato detto nulla sulle parole chiave di confronto (Questa non è una presentazione seria, solo qualcosa che mi è venuto in mente ...)

JavaScript, 11 10

Le stringhe devono essere memorizzate in a e b.

!(a>b|a<b)

Modifica: grazie Danny per aver sottolineato, |è sufficiente invece di||

Ruby, 11

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

Verifica se ciascuna stringa è contenuta nell'altra.

Python - 11 (senza le stringhe)

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

GolfScript (5 caratteri)

'string1''string1'].&,(

Porta abbastanza semplice dell'implementazione di riferimento di PHP. Lascia 0(= false) nello stack se le stringhe sono uguali o 1(= true) se sono diverse.

Javascript (45 byte):

Ecco un'altra soluzione in Javascript.

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

Lo spazio è importante

cdovrebbe essere 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 inserire le tue due stringhe come input standard di una pipe e uniq -d | grep -q .non stampa nulla, ma avrà un valore di ritorno di successo o errore. Se vuoi stampare il booleano, basta sostituirlo conuniq -d | grep -c .

Quanti personaggi? Ti lascio contare; uniq -d|grep -q .senza spazi extra contiene 17 caratteri, ma poiché l'intero lavoro viene eseguito da uniq, direi che questa soluzione è di 0 caratteri nella ... uniqlingua!

In realtà, uniq -dstamperà una riga se le due stringhe sono identiche e nulla se sono diverse.

Le stringhe devono essere memorizzate in a e b. Non funzionerà se nessuno dei due lo è null.

C #, 53

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

C #, 28

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

PHP - 49 caratteri

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

APL ( 8 9)

Aggiornamento: quello vecchio non funziona per stringhe di diverse lunghezze.

{∧/∊⌿↑⍺⍵}

• ↑⍺⍵: crea una matrice con ⍺sulla prima riga e ⍵sulla seconda riga, riempiendo gli spazi con gli spazi.
• ∊⌿: Per ogni colonna, controlla se la riga superiore contiene la riga inferiore (come nella versione precedente).
• ∧/: Prende la logica anddi tutti i valori.

Vecchio:

{∧/⍺∊¨⍵}

• ⍺∊¨⍵: per ogni combinazione di elementi in ⍺e ⍵, vedere se l'elemento da ⍺contiene l'elemento da⍵ . Dato che in una stringa saranno tutti caratteri singoli e una stringa contiene se stessa, si tratta sostanzialmente di confrontare ogni coppia di caratteri.
• ∧/: accetta il logico e di tutti i valori (se tutti i caratteri corrispondono, le stringhe sono uguali)

Python - 12

not({a}-{b})

Questa soluzione utilizza set. Sottraendo set uguali si otterrà un set vuoto, che ha un valore booleano di False. La negazione comporterà un valore True per aeb che sono stringhe uguali.

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

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

Modifica: Grazie a Peter Taylor per aver sottolineato lo spazio bianco non necessario.

C - 62

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

Provato. Chiama comee(str1, str2)

Vieni a pensarci bene, se non conti il char*p,char*q, il che sembra giusto, è solo 49 byte :)

Haskell - 9

elem a[b]

Si noti che questo, proprio come molte voci qui, è solo un'espressione. Questo non è un programma Haskell.

Java - 162 147 caratteri

L'idea è di confrontare la differenza di ogni byte, gli stessi byte avranno la differenza 0. Il programma verrà lanciato java.lang.ArrayIndexOutOfBoundsExceptionquando i byte sono diversi (provare ad accedere a un indice negativo) o quando le stringhe sono di diversa lunghezza. Catturerà l'eccezione e restituirà 0 (stringhe non uguali) o restituirà 1 altrimenti (stringhe uguali).

compressa:

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;

Normale:

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

Questo script potrebbe non avere alcuna utilità, ma almeno questo fornisce un modo per confrontare le stringhe.

PHP

Altro:

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

Prolog 7

e(A,A).

Questo utilizza la funzione di corrispondenza dei modelli in Prolog per unificare i 2 argomenti al predicato, che verifica efficacemente l'equivalenza uguale quando non c'è alcuna variabile non associata .

Esempio di utilizzo:

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

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

Tecnicamente parlando, il comportamento di questa soluzione è quello dell'operatore di unificazione =/2, piuttosto che quello di ==/2, che controlla l'equivalenza dei termini. La differenza mostra quando sono coinvolte le variabili non associate. In questa soluzione, quando viene fornita una variabile non associata, il predicato restituirà truequando l'unificazione ha esito positivo. In confronto, ==/2confronterà l'ordine dei termini senza unificazione.

PHP, 21

Questo sta facendo il lavoro usando l'indirizzamento variabile.

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

Oppure, se non ne hai bisogno per essere bool

$$a=$b;$$b;

EDIT : ho dimenticato di gestire il caso in cui si tenta di confrontare due stringhe vuote, quindi il codice ora è

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

che è di 21 caratteri.

CPython: 6

a is b

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

L'uso di isè ovviamente piuttosto sospetto, ma dal momento che il compito specifica che dobbiamo determinare l'uguaglianza di valore piuttosto che l'uguaglianza di riferimento e isconfrontare solo l'identità dell'oggetto, mi sembra che possa non rientrare nell'elenco degli operatori vietati.

Naturalmente c'è anche qualche domanda sul fatto che questo sia anche valido; funziona su tutti i miei sistemi, ma è specifico dell'implementazione e probabilmente non funzionerà sempre se le stringhe non sono definite manualmente nell'interprete interattivo.

Mathematica / Wolfram Language, 15 byte

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

Abbastanza autoesplicativo, imposta ogni stringa come un set, quindi controlla la lunghezza dell'unione dei due set. Se le stringhe sono uguali, restituisce 1, altrimenti restituisce 0. Se sono autorizzato a restituire "2" per "diverso" e "1" per "stesso", sottrarre due byte.

C 342 ha giocato a 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;
}

Nota: Visual Studio si lamenta se non usi i loro metodi sicuri, ad es. Gets_s. CodeBlocks con mingw viene compilato senza avvisi.

C 655 non golfato

Il codice crea la somma ponderata dei caratteri per ogni stringa. Se la differenza è zero, allora sono uguali, incluse 2 stringhe vuote:

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

Pitone

È lungo e non è bello, ma questa è la mia prima entrata!

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 byte

Presumo che ti sia proibito usare qualsiasi operatore di confronto. Così <o> sono inclusi.

L'idea è di usare XOR bit a bit. In diverse lingue questo operatore ha una sintassi diversa - mostrerò un esempio per PHP. Lì è disponibile con^ . Sfortunatamente, il suo comportamento con le stringhe non è buono come potrebbe essere, quindi dovrai controllare la lunghezza della stringa prima. Questo perché in PHP, xor rimuoverà la stringa più lunga fino alla lunghezza della stringa più corta.

La prossima cosa è lavorare correttamente con le stringhe, perché un singolo xornon produrrà un risultato, disponibile per ulteriori operazioni in PHP. Ecco perché è unpack()stato usato. Quindi, il codice sarebbe:

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

È più lungo dell'opzione con </ >ma non li utilizzerà. Inoltre, la cosa importante è la giocoleria di tipo PHP (quindi verrà eseguito il cast dell'array vuoto false). O forse c'è un modo più semplice per verificare se un array contiene membri diversi da zero ( Modifica : mentre sto scrivendo questo, c'è una buona cattura contrim() risposta in un'altra risposta, quindi possiamo sbarazzarci delle operazioni dell'array)

Ma credo che ci siano lingue, dove possiamo fare solo a ^ b- letteralmente, ottenere il risultato. Se è 0(trattato da tutti i byte risultanti), allora le nostre stringhe sono uguali . È molto facile e persino più semplice <o >roba del genere.

grep 14 caratteri

Certo, conto solo il codice grep; le due stringhe si trovano su due righe consecutive nell'input (una pipe o un file o anche una sessione interattiva).

$ 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 caratteri (dopo che le stringhe sono in variabili)

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

Il codice, inclusi i compiti, sarebbe:

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

Il modo molto pazzo

Solo per divertimento, ma molti modi per farlo fallire se ci si pensa. Inoltre, non dimenticare che le stringhe saranno ESEGUITE dalla 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 buon esempio di esempio è il confronto tra "stringa" come prima stringa e "rm -Rf /" come seconda stringa; basta controllare come root e vedere: dirà "vero" anche se entrambe le stringhe ovviamente non sono uguali.

JavaScript [18 byte]

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

O

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

Questo restituirà truese a == be falsese a =/= b. La logica alla base è la creazione di un oggetto con un valore di acome proprietà e la restituzione 1o undefinednel caso in cui una proprietà di bvalore esiste o non esiste in quell'oggetto.

JavaScript [15 byte]

![a].indexOf(b)

Questo restituirà truese a == be falsese a =/= b. Lo script sta cercando il valore di bnell'array che contiene un singolo elemento di valore di a.

C - 86 83

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

Obvioulsy non è il più breve, ma questo non funziona con le variabili stringa e prende invece le stringhe come input dalla console. Inoltre, mi piace il main ricorsivo, anche se ovviamente non è la versione più breve. Ma sicuramente il meno consigliabile.