Nella lingua Nim , le regole per differenziare gli identificatori sono leggermente più rilassate rispetto alla maggior parte delle altre lingue. Due identificatori sono equivalenti o indirizzano la stessa variabile se seguono queste regole :

• il primo carattere di entrambi è lo stesso (case sensitive)
• entrambe le stringhe sono le stesse (caso in minuscole) dopo aver rimosso tutte le istanze dei personaggi -e_

Sfida

Scrivi un programma / funzione che accetta due stringhe che rappresentano identificatori Nim e producono un valore di verità o falsità in base al fatto che siano o meno equivalenti alle regole sopra.

specificazioni

• Si applicano le regole I / O standard .
• Sono vietate le scappatoie standard .
• Le stringhe conterranno solo stampabili ASCII . Non è necessario verificare se si tratta di un identificatore valido.
• Le stringhe possono essere prese come due input separati, un elenco di stringhe, ecc. (Conosci il drill)
• Le stringhe vuote non devono essere gestite.
• L'output deve essere coerente per entrambi i valori di verità e falsità.
• Questa sfida non riguarda la ricerca dell'approccio più breve in tutte le lingue, ma piuttosto la ricerca dell'approccio più breve in ciascuna lingua .
• Il tuo codice verrà assegnato un punteggio in byte , di solito nella codifica UTF-8, se non diversamente specificato.
• Le funzioni integrate che eseguono questa attività sono consentite ma è incoraggiata l'inclusione di una soluzione che non si basa su un built-in.
• Le spiegazioni, anche per le lingue "pratiche", sono incoraggiate .

Casi test

Input                                    Output

count, Count                             falsey
lookMaNoSeparator, answer                falsey
_test, test                              falsey
test, tset                               falsey
aVariableName, a_variable_name           truthy
numbers_are_cool123, numbersAreCool123   truthy
symbolsAre_too>_>, symbols_areTOO>>      truthy

Implementazione di riferimento non golfata

Questo è scritto in Nim, stesso.

import strutils, re

proc sameIdentifier(a, b: string): bool =
  a[0] == b[0] and
    a.replace(re"_|–", "").toLower == b.replace(re"_|–", "").toLower

JavaScript (ES6), 62 61 byte

Salvato 1 byte grazie a @JohanKarlsson

Accetta input nella sintassi del curry (a)(b). Restituisce un valore booleano.

a=>b=>(r=s=>s[0]+s.replace(/-|_/g,'').toUpperCase())(b)==r(a)

Casi test

let f =

a=>b=>(r=s=>s[0]+s.replace(/-|_/g,'').toUpperCase())(b)==r(a)

console.log(f("count")("Count"))                           // falsey
console.log(f("lookMaNoSeparator")("answer"))              // falsey
console.log(f("_test")("test"))                            // falsey
console.log(f("aVariableName")("a_variable_name"))         // truthy
console.log(f("numbers_are_cool123")("numbersAreCool123")) // truthy

Python 3 , 76 byte

lambda a,b:f(*a)==f(*b)
f=lambda f,*r:[f+k.lower()for k in r if~-(k in'-_')]

Provalo online!

-1 byte grazie a notjagan
-3 byte grazie a Wheat Wizard

In realtà , 15 byte

⌠p"-_"(-Σùo⌡M═Y

Provalo online!

Curiosità: funziona con qualsiasi numero di input (restituisce sempre la verità per meno di 2 input).

Spiegazione:

⌠p"-_"(-Σùo⌡M═Y
⌠p"-_"(-Σùo⌡M    for each input:
 p                 separate the first character
  "-_"(-           remove all dashes and underscores from the rest of the string
        Σù         concatenate the list from the last operation and lowercase the string
          o        append it to the first character
             ═Y  are none of the elements unique?

Pyth , 13 byte

qFm[hd-r0d"-_

Provalo online!

Spiegazione

qFm[hd-r0d"-_
  m              For each value in the input (which is a list of two strings):
   [             Create a list consisting of
    hd               the first character of each value
      -r0d"-_        and the lowercase version of the value without "-" or "_"
qF               Fold over equivalence; checks to see if both lists are the same

05AB1E , 12 byte

εćs„-_SKl«}Ë

Provalo online!

-1 grazie ad Adnan .

Teoricamente, εćs„-_-«}Ëavrebbe dovuto funzionare per 10 byte, ma sfortunatamente questo comportamento è deprecato per ora.

Gelatina , 11 byte

ḟ⁾-_Œl,Ḣµ€E

Provalo online!

-2 byte grazie a Erik the Outgolfer
-1 byte grazie a Jonathan Allan

Rubino , 86 64 63 61 51 byte

f=->x{x[0]+x.upcase.delete("-_")}
->x,y{f[x]==f[y]}

Provalo online!

Questo si sente veramente a lungo ancora si sente un po 'lungo. Gradirei l'aiuto di tutti i guru di Ruby là fuori nel rendere questo almeno un po 'più breve.

C ++, 288 248 byte

-5 byte grazie a Zacharý

#include<string>
#include<algorithm>
#define E(a,v)a.erase(std::remove(a.begin(),a.end(),v),a.end());
#define F(a)for(auto&c:a)c=toupper(c);
int e(std::string&a,std::string&b){if(a[0]!=b[0])return 0;E(a,45)E(b,45)E(a,95)E(b,95)F(a)F(b)return a==b;}

Grazie, preprocessore. Inoltre, questo codice sfrutta il fatto che in C ++ è la regola da trasmettere a boolint_var!=0

CJam, 20 byte

{_"-_"f-:el:=\:c:=*}

Accetta l'input sotto forma di ["string1", "string2"].

Provalo online (versione di prova)

{
_      e# make copy of input
"-_"f- e# remove all "-" and "_" from both words in copy
:el    e# convert words in copy to lowercase
:=     e# 1 if both words in copy are equal, 0 if not
\      e# move original version of input to top of stack
:c     e# convert each word in original input to only 1st character
:=     e# 1 if both characters from original input are equal, 0 if not
*      e# multply the two numbers we obtained. If and only if both are 1 (true) we return 1 (true)
}

Haskell , 85 78 76 71 68 byte

2 byte salvati grazie a Ørjan Johansen

import Data.Char
s(a:x)=a:[toLower a|a<-x,all(/=a)"-_"]
x!y=s x==s y

Provalo online!

Errori sulla stringa vuota.

Python 2 , 72 byte

lambda x,y:r(x)==r(y)
r=lambda x:x[0]+x[1:].lower().translate(None,"-_")

Provalo online!

Non funzionerà con Python 3 a causa della nuova translatesintassi.

Excel, 105 byte

=AND(CODE(A1)=CODE(B1),SUBSTITUTE(SUBSTITUTE(A1,"_",""),"-","")=SUBSTITUTE(SUBSTITUTE(B1,"_",""),"-",""))

CODICE () restituisce il codice numerico del primo carattere.

Il confronto delle stringhe in Excel non fa distinzione tra maiuscole e minuscole.

Buccia , 13 byte

¤=§,←(m_ω-"-_

Provalo online!

Costruisce per ogni stringa una coppia costituita dal primo carattere della stringa e l'intera stringa in minuscolo e con tutte le occorrenze di - / _ rimosse. Quindi controlla se le due coppie sono uguali.

Una particolarità è che -in Husk viene impostata la differenza (ovvero rimuove solo la prima occorrenza trovata): per rimuovere tutte le occorrenze, -"-_viene trovato il punto fisso di ω-"-_.

Japt , 14 25 byte

g ¥Vg ©Uu k"_-" ¥Vu k"_-"

Verifica l'uguaglianza della stringa senza distinzione tra maiuscole e minuscole rimuovendo tutti i caratteri nella parola 2 dalla parola 1 e rimuovendo i -_caratteri; che risulta in una stringa vuota ( "") se le parole sono uguali.
Grazie Ørjan Johansen per averci segnalato il problema.

Verifica l'uguaglianza del primo carattere e se gli input in maiuscolo sono uguali dopo la rimozione _-.

Provalo online!

Spiegazione

Input implicito: Ue Vsono stringhe di input

g ¥Vg

Controlla se la prima lettera di U(implicito) è uguale a ( ¥) il primo carattere di V.

©Uu k"_-" ¥Vu k"_-"

E ( ©) controlla se U, maiuscolo ( u) e con _-rimosso ( k), uguale a ( ¥) lo stesso per V. Restituisce implicitamente il risultato booleano.

Python 2 , 79 73 byte

-6 byte grazie a @notjagan: verifica che la lunghezza dell'insieme di tutti i nomi ridotti sia 1 o meno.

lambda*l:len({x[0]+re.sub('-|_','',x[1:].lower())for x in l})<2
import re

Provalo online!

Perl 5 , 67 byte

s/.//,push@a,$&,y/_-//dr for<>;say($a[0]eq$a[2]&&lc$a[3]eq lc$a[1])

Provalo online!

Prende gli identificatori come input su righe separate.

Spiegazione:

s/.//,             # remove the first character
push@a,            # storage space, even positions are first character
                   # odd positions are remainder
$&,                # implicit variable holding last matched pattern (first char)
y/_-//dr           # Remove _ and - from remainder of input
for<>;             # iterate over all input lines
say                # output
($a[0]eq$a[2]&&    # check that first character is identical and
lc$a[3]eq lc$a[1]) # so is the lowercase version of the rest

Retina , 28 byte

T`L\_-`l_`(?<=.).+
^(.*)¶\1$

Provalo online!

Carbone , 29 byte

∧⁼§θ⁰§η⁰⁼↧⪫⪪⪫⪪θ_ω-ω↧⪫⪪⪫⪪η_ω-ω

Provalo online!

Questo stampa un -per la verità e niente per la falsità.

Link alla versione dettagliata . Prima confronta il primo carattere di entrambe le stringhe di input ( ⁼§θ⁰§η⁰) e quindi confronta il resto di entrambe le stringhe dopo aver rimosso i caratteri di sottolineatura e i trattini ( ⪫⪪⪫⪪θ_ω-ω) e convertito in lettere minuscole ( ↧).

C #, 101 89 byte

string g(string s)=>string.Concat(s.ToUpper().Split('-','_'));f=>s=>f[0]==s[0]&g(f)==g(s)

Salvato 12 byte grazie a @ kusi581.

Java (OpenJDK 8) , 95 byte

a->b->a.charAt(0)==b.charAt(0)&&a.replaceAll("_|-","").equalsIgnoreCase(b.replaceAll("_|-",""))

Provalo online! Abbastanza diretto.

Pyke , 13 byte

F'hl1"-_"-)Xq

Provalo online!

F         )   -  for i in input():
 'hl1         -   i[0], i.lower()
     "-_"-    -         ^.remove("-_")
           Xq - equal(^)

C (gcc) , 126 114 byte

#define p(s)do++s;while(*s==45||*s==95);*s>95?*s-=32:0;
f(char*a,char*b){while(*a&&*a==*b){p(a)p(b)}return*a==*b;}

Provalo online!

Con spazi bianchi e commenti:

#define p(s)                   // Define helper macro p           \
    do ++s;                    // Increment pointer at least once \
    while (*s==45 | *s==95);   // and past any '-' or '_'         \
    *s>95 ? *s -= 32 : 0;      // If lowercase letter, convert to upper

f(char* a, char* b) {          // Define main function f
    while (*a && *a == *b) {   // Loop until end of either string
                               // or a difference found
        p(a)                   // Transform pointer and one char
        p(b)                   // via helper p above
    }
    return *a==*b;             // Test chars equal (on success, both '\0')
}

Dyalog APL, 47 32 28 27 26 22 byte

-4 byte grazie a Lithos Kritixi

{(=/⊃¨⍵)∧≡/819⌶⍵~'-_'}   

Accetta l'input come un elenco delle stringhe.

Provalo online!

Come?

{(=/⊃¨⍵)∧≡/819⌶⍵~'-_'}
               ⍵~'-_'   Remove '-' and '_'
           819⌶         Lowercase
         ≡/             Equality between elements
        ∧               And
 (=/⊃¨⍵)                The first element of each element is equal

Lisp comune, 98 byte

(lambda(x y)(and(eql(elt x 0)(elt y 0))(string-equal(#1=remove #\-(#1##\_ y))(#1##\-(#1##\_ x)))))

Provalo online!

Versione Ungolfed (super semplice!):

(defun f(x y)
  (and (eql (elt x 0) (elt y 0))         ; check if initial characters are identical
       (string-equal                     ; string comparison (case insensitive)
         (remove #\- (remove #\_ y))     ; remove from both strings the unwanted chars
         (remove #\- (remove #\_ x)))))

R , 76 byte

function(l)(g=substr(l,1,1))[1]==g[2]&(h=tolower(gsub('-|_','',l)))[1]==h[2]

Funzione anonima che accetta input come un elenco di due stringhe. Sfrutta il fatto che le operazioni di stringa di R, sebbene abbastanza lunghe in # di caratteri, sono vettorizzate. Inoltre, il wrapping di un'assegnazione tra parentesi vincolerà la variabile, quindi (g=substr(l,1,1))conserva una variabile da riutilizzare più avanti nella riga e in modo simile perh .

R restituisce l'ultima espressione valutata come output della funzione.

Ungolfed:

function(l){
  g <- substr(l,1,1)
  h <- tolower(gsub("_|-","",l))
  (g[1]==g[2])&(h[1]==h[2])
}

Provalo online! (tutti i casi di test)

Brachylog , 17 byte

hᵛ&{{¬∈"_-"&ụ}ˢ}ᵛ

Provalo online!

Output attraverso successo / fallimento predicato.

h                    The first element
 ᵛ                   is the same for each element of the input,
  &                  and
   {           }ᵛ    for each element of the input the following are the same:
    {      &ụ}ˢ      every element uppercased which satisfies the condition that
     ¬∈              it is not an element of
       "_-"          the string "_-".

Erlang 113 byte

A=fun(L)->string:to_lower(lists:flatten(string:tokens(L,"-_")))end,fun([C|D],[C|E])->A(D)==A(E);(_,_)->a==b end.

una coppia di funzioni anonime che confrontano le due liste. doveva essere incollato nella conchiglia erlang.

più leggibile:

A=fun(L) ->
    string:to_lower( % case insensitive
        lists:flatten( % squash all characters back into one list
            string:tokens(L,"-_") % return a list of list of characters
        )
    )
end.
fun([C|D],[C|E]) -> % are the first characters exactly the same?
    A(D)==A(E); % does the rest compare correctly?
   (_,_) -> % first chars not the same
    a==b % shorter than 'false'
end.

Clip , 25 byte

&=(x(y=AxAy[Aa--m.L`a'-'_

Spiegazione :

x, yE zpuò essere fatto riferimento in un programma di clip a prendere implicitamente fino a tre ingressi. Dal momento che questo programma fa riferimento solo xe y, prende due input che sono assegnati a xe y.

 =(x(y                    First characters of x and y are equal
&                         And
      =AxAy               A(x) == A(y)
           [Aa            Function A, takes parameter a
                m.L`a     Map all elements of a to lower case
              --     '-'_ Remove all occurrences of '-' and '_'

Prende due stringhe da input standard, output 1e rispettivamente 0per true e false.