Ваша задача проста . Определить , если одна строка равна другой (не адрес, то значение) без использования операторов равенства (например ==, ===или .equal()) или неравенство ( !=, !==) ничего подобного на других языках. Это значит где угодно! Вы не можете использовать эти операторы где-либо в коде. Однако вы можете использовать такие переключатели, как !expесли бы вы не сравнивали напрямую exp != with something else.

Кроме того, вы не можете использовать любые функции, такие как strcmp , strcasecmp и т. Д.

Что касается операторов сравнения ( >=, <=, >, <), они также запрещены . Я понимаю, что некоторые ответы включают это, но я действительно хотел бы видеть больше ответов, которые не ограничивают оператор равенства.

Пример использования PHP показан:

<?php

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

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

return -count($tmp) + 2;

Просто верните true или false (или что-то, что оценивается в языке как true или false, например 0 или 1), чтобы указать, совпадают ли строки. Строки должны быть жестко закодированы, как видно из приведенного выше примера. Строки не должны учитываться в гольфе, поэтому, если вы объявите переменную заранее, не считайте объявление.

Python 49 45 18 22 15 14

(+ 3, если рассматриваются строковые переменные)

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

Строка должна быть жестко запрограммирована в двух aи в одном экземплярах в bкавычках.

aи bдолжен быть предварительно инициализирован для строк.

Оболочка Python, 9

(+ 3, если рассматриваются строковые переменные)

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

Вывод в оболочку

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

объяснение

Создает dict (хэш-таблицу) с ключом первой и второй строки. Если вторая строка совпадает, значение first заменяется значением second. Наконец, мы печатаем значение первого ключа.

РЕДАКТИРОВАТЬ: OP допускает 0/1 вместо False / True, а также с использованием предварительно инициализированных переменных.

Python ( 17 11):

b in a in b

(Проверяет, содержится ли b в a, а a содержится в b, если это не было ясно из кода.)

Альтернативный питон: ( 8 7)

получено из решения Go из Tom Verelst:

b in[a]

Бонус: это работает для любого типа.

РЕДАКТИРОВАТЬ:

Подождите секунду, просто прочитайте, что вы также можете напрямую программировать в строках, и вам не нужно считать кавычки ... (или, по крайней мере, это то, что делает golfscript). Итак ... Python наравне с гольф-скриптом? Боже мой!

Альтернативная альтернатива Python ( 5 4):

(спасибо Клавдиу)

"string"in["string"]

оригинал:

"string" in["string"]

Альтернатива Альтернатива Альтернатива Бенди-рули Питон (2):

"string"is"string"

Ничего не было сказано о сравнительных ключевых словах (это не серьезное представление, просто то, что пришло мне в голову ...)

JavaScript, 11 10

Строки должны храниться в a и b.

!(a>b|a<b)

Редактировать: спасибо Дэнни за указание, |достаточно вместо||

Руби, 11

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

Проверяет, содержится ли каждая строка в другой.

Python - 11 (без строк)

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

GolfScript (5 символов)

'string1''string1'].&,(

Довольно простой порт реализации PHP-ссылок. Оставляет 0(= false) в стеке, если строки одинаковые, или 1(= true), если они разные.

Javascript (45 байт):

Вот еще одно решение в Javascript.

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

Пространство важно.

cдолжно быть 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

Просто введите две строки в качестве стандартного ввода канала и uniq -d | grep -q .ничего не напечатает, но будет иметь возвращаемое значение успеха или ошибки. Если вы хотите напечатать логическое значение, просто замените наuniq -d | grep -c .

Сколько персонажей? Я позволю тебе считать; uniq -d|grep -q .без лишних пробелов содержит 17 символов, но так как вся работа выполняется uniq, я бы сказал, что это 0-символьное решение на ... uniqсвоем языке!

На самом деле, uniq -dнапечатает одну строку, если две строки идентичны, и ничего, если они разные.

Строки должны храниться в a и b. Не будет работать, если есть null.

C #, 53

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

C #, 28

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

PHP - 49 символов

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

APL ( 8 9)

Обновление: старый не работает для строк разной длины.

{∧/∊⌿↑⍺⍵}

• ↑⍺⍵: сделать матрицу с ⍺первой и ⍵второй строкой, заполняя пробелы.
• ∊⌿: Для каждого столбца посмотрите, содержит ли верхний ряд нижний ряд (как в старой версии).
• ∧/: Взять логическое andиз всех значений.

Старый:

{∧/⍺∊¨⍵}

• ⍺∊¨⍵: для каждой комбинации элементов в ⍺и ⍵, посмотрите, ⍺содержит ли элемент из элемента из ⍵. Так как в строке все они будут одиночными символами, а строка содержит себя, это в основном сравнивает каждую пару символов.
• ∧/: взять логическое и все значения (если все символы совпадают, строки равны)

Питон - 12

not({a}-{b})

Это решение использует наборы. Вычитание равных наборов приведет к пустому набору, который имеет логическое значение False. Отрицание этого приведет к тому, что значения True для a и b будут равными строками.

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

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

Изменить: Спасибо Питер Тейлор за указание на ненужные пробелы.

С - 62

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

Проверено. Позвонить какe(str1, str2)

Если подумать, если не считать char*p,char*q, что кажется справедливым, это всего 49 байтов :)

Haskell - 9

elem a[b]

Обратите внимание, что это, как и многие другие записи здесь, является просто выражением. Это не программа на Haskell.

Ява - 162 147 символов

Идея состоит в том, чтобы сравнить разность каждого байта, одинаковые байты будут иметь разность 0. Программа сгенерирует, java.lang.ArrayIndexOutOfBoundsExceptionкогда байты различаются (попробуйте получить доступ к отрицательному индексу) или когда строки имеют разную длину. Он поймает исключение и вернет 0 (строки не равны) или вернет 1 в противном случае (строки равны).

Сжатый:

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;

Обычный:

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

Этот сценарий может не иметь никакой утилиты, но, по крайней мере, это позволяет сравнивать строки.

PHP

Еще один:

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

Пролог 7

e(A,A).

Это позволяет использовать функцию сопоставления с образцом в Прологе, чтобы объединить 2 аргумента с предикатом, что эффективно проверяет эквивалентность эквивалентности, когда нет несвязанной переменной .

Пример использования:

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

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

Технически говоря, поведение этого решения - поведение оператора объединения =/2, а не оператора ==/2, который проверяет эквивалентность терминов. Разница показывает, когда задействованы несвязанные переменные. В этом решении, когда указана несвязанная переменная, предикат вернется trueпосле успешного объединения. Для сравнения, ==/2сравним порядок сроков без унификации.

PHP, 21

Этот делает работу, используя переменную косвенность.

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

Или, если вам не нужно быть булой

$$a=$b;$$b;

РЕДАКТИРОВАТЬ : я забыл обработать случай, когда вы пытаетесь сравнить две пустые строки, поэтому код сейчас

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

что составляет 21 символ.

CPython: 6

a is b

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

Использование, isочевидно, довольно подозрительно, но поскольку задача специально призывает к тому, чтобы мы определяли равенство значений, а не эталонное равенство, а isсравнивала только идентичность объекта, я чувствую, что она может не попасть в список запрещенных операторов.

Конечно, есть также некоторый вопрос относительно того, действительно ли это даже; это работает на всех моих системах, но это зависит от реализации и, вероятно, не всегда будет работать, если строки не определены вручную в интерактивном интерпретаторе.

Mathematica / Wolfram Language, 15 байтов

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

Довольно понятно, устанавливает каждую строку как набор, а затем проверяет длину объединения двух наборов. Если строки совпадают, возвращает 1, в противном случае возвращает 0. Если мне разрешено возвращать «2» для «другого» и «1» для «одного и того же», вычтите два байта.

C 342 в гольфе

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

Примечание: Visual Studio жалуется, если вы не используете их безопасные методы, например gets_s. CodeBlocks с Mingw компилируется без предупреждений.

C 655 не в гольф

Код создает взвешенную сумму символов для каждой строки. Если разница равна нулю, то они равны, включая 2 пустые строки:

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

питон

Это долго и не красиво, но это моя первая запись!

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 байт

Я предполагаю, что вам запрещено использовать любые операторы сравнения. Так <или >включены.

Идея состоит в том, чтобы использовать побитовый XOR. В разных языках этот оператор имеет разный синтаксис - я покажу пример для PHP. Там это доступно с ^. К сожалению, его поведение со строками не так хорошо, как могло бы быть, поэтому вам нужно проверить длину строки раньше. Это связано с тем, что в PHP xor обрезает более длинную строку до длины более короткой.

Следующим шагом является правильная работа со строками, потому что один xorне даст результата, доступного для дальнейших операций в PHP. Вот почему unpack()был использован. Итак, код будет:

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

Это длиннее, чем опция с </, >но он не будет их использовать. Кроме того, важна жонглирование типов PHP (поэтому будет приведен пустой массив false). Или, может быть, есть более простой способ проверить, содержит ли массив ненулевые члены ( Правка : хотя я уже набирал это, есть хороший улов trim()в другом ответе, поэтому мы можем избавиться от операций с массивами)

Но я верю, что есть языки, на которых мы можем просто a ^ b- буквально, получить результат. Если это 0(обрабатывается из всех приведенных байтов) - тогда наши строки равны . Это очень легко и даже проще, чем <или >вещи.

grep 14 символов

Конечно, я считаю только код grep; эти две строки находятся на двух последовательных строках ввода (либо канал, либо файл, либо даже интерактивный сеанс).

$ 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 символов (после того, как строки в переменных)

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

Код, включающий присвоения, будет:

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

Очень сумасшедший путь

Просто для удовольствия, но есть много способов заставить его потерпеть неудачу, если задуматься. Более того, не забывайте, что строки будут исполняться оболочкой.

$ 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

Хорошим контрпримером является сравнение «string» в качестве первой строки и «rm -Rf /» в качестве второй строки; просто проверьте как root и посмотрите: он скажет "true", хотя обе строки явно не одинаковы.

JavaScript [18 байт]

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

ИЛИ

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

Это вернется, trueесли a == bи falseесли a =/= b. Логика заключается в создании объекта со значением aкак свойство и возвращении 1или undefinedв случае, если свойство bзначения существует или не существует в этом объекте.

JavaScript [15 байт]

![a].indexOf(b)

Это вернется, trueесли a == bи falseесли a =/= b. Скрипт ищет значение bв массиве, который содержит единственный элемент значения a.

С - 86 83

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

Obvioulsy не самый короткий, но это не работает со строковыми переменными и вместо этого принимает строки в качестве ввода из консоли. Кроме того, мне нравится рекурсивный main, даже если это явно не самая короткая версия. Но, безусловно, наименее рекомендуется.