En el lenguaje Nim , las reglas para diferenciar los identificadores son un poco más relajadas que la mayoría de los otros idiomas. Dos identificadores son equivalentes o abordan la misma variable si siguen estas reglas :

• el primer caracter de ambos es el mismo (mayúsculas y minúsculas)
• ambas cadenas son iguales (mayúsculas y minúsculas) después de eliminar todas las instancias de los caracteres -y_

Desafío

Escriba un programa / función que tome dos cadenas que representen identificadores Nim y genere un valor verdadero o falso en función de si son equivalentes o no según las reglas anteriores.

Especificaciones

• Normas estándar de E / S se aplican .
• Las lagunas estándar están prohibidas .
• Las cadenas solo contendrán imprimibles ASCII . Usted no necesita comprobar si es un identificador válido.
• Las cadenas se pueden tomar como dos entradas separadas, una lista de cadenas, etc. (conoce el ejercicio)
• Las cadenas vacías no necesitan ser manejadas.
• El resultado debe ser coherente tanto para los valores de verdad como para los de falsey.
• Este desafío no se trata de encontrar el enfoque más corto en todos los idiomas, sino de encontrar el enfoque más corto en cada idioma .
• Su código se puntuará en bytes , generalmente en la codificación UTF-8, a menos que se especifique lo contrario.
• Se permiten las funciones integradas que realizan esta tarea, pero se recomienda incluir una solución que no se base en una función integrada.
• Se alientan las explicaciones, incluso para los idiomas "prácticos" .

Casos de prueba

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

Implementación de referencia sin golf

Esto está escrito en Nim, en sí mismo.

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 bytes

Guardado 1 byte gracias a @JohanKarlsson

Toma entrada en la sintaxis de curry (a)(b). Devuelve un booleano.

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

Casos de prueba

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 bytes

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

Pruébalo en línea!

-1 byte gracias a notjagan
-3 bytes gracias a Wheat Wizard

En realidad , 15 bytes

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

Pruébalo en línea!

Dato curioso: esto funciona con cualquier cantidad de entradas (siempre devuelve verdad por menos de 2 entradas).

Explicación:

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

qFm[hd-r0d"-_

Pruébalo en línea!

Explicación

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 bytes

εćs„-_SKl«}Ë

Pruébalo en línea!

-1 gracias a Adnan .

Teóricamente, εćs„-_-«}Ëdebería haber funcionado durante 10 bytes, pero desafortunadamente este comportamiento está en desuso por ahora.

Jalea , 11 bytes

ḟ⁾-_Œl,Ḣµ€E

Pruébalo en línea!

-2 bytes gracias a Erik the Outgolfer
-1 byte gracias a Jonathan Allan

Ruby , 86 64 63 61 51 bytes

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

Pruébalo en línea!

Esto se siente realmente largo, todavía se siente un poco largo. Agradecería la ayuda de cualquier gurú de Ruby para hacer esto al menos un poco más corto.

C ++, 288 248 bytes

-5 bytes gracias 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;}

Gracias, preprocesador. Además, este código aprovecha el hecho de que en C ++ la regla para convertir int en bool esint_var!=0

CJam, 20 bytes

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

Toma entrada en forma de ["cadena1", "cadena2"].

Pruébelo en línea (versión de prueba)

{
_      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 bytes

2 bytes guardados gracias a Ørjan Johansen

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

Pruébalo en línea!

Errores en la cadena vacía.

Python 2 , 72 bytes

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

Pruébalo en línea!

No funcionará con Python 3 debido a la nueva translatesintaxis.

Excel, 105 bytes

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

CODE () devuelve el código numérico del primer carácter.

La comparación de cadenas en Excel no distingue entre mayúsculas y minúsculas.

Casco , 13 bytes

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

Pruébalo en línea!

Construye para cada cadena un par que consiste en el primer carácter de la cadena y toda la cadena en minúsculas y con todas las apariciones de - / _ eliminadas. Luego verifica si los dos pares son iguales.

Una particularidad es que -en cáscara es diferencia de conjuntos (es decir, que elimina sólo la primera aparición encontrado): a fin de eliminar todas las apariciones, el punto de fija -"-_se encuentra con ω-"-_.

Japt , 14 25 bytes

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

Comprueba la igualdad de cadenas entre mayúsculas y minúsculas eliminando todos los caracteres de la palabra 2 de la palabra 1 y eliminando -_ caracteres; eso da como resultado una cadena vacía ("" ) si las palabras son iguales.
Gracias Ørjan Johansen por señalar el problema con esto.

Comprueba la igualdad del primer carácter y si las entradas en mayúsculas son iguales después de eliminarlas _-.

Pruébalo en línea!

Explicación

Entrada implícita: Uy Vson cadenas de entrada

g ¥Vg

Compruebe si la primera letra de U(implícito) es igual a ( ¥) el primer carácter de V.

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

Y ( ©) verifica si U, en mayúsculas ( u) y con _-eliminado ( k), es igual a ( ¥) lo mismo para V. Devuelve implícitamente el resultado booleano.

Pitón 2 , 79 73 bytes

-6 bytes gracias a @notjagan: compruebe que la longitud del conjunto de todos los nombres reducidos es 1 o no.

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

Pruébalo en línea!

Perl 5 , 67 bytes

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

Pruébalo en línea!

Toma los identificadores como entrada en líneas separadas.

Explicación:

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 bytes

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

Pruébalo en línea!

Carbón , 29 bytes

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

Pruébalo en línea!

Esto imprime un - verdad y nada para Falsey.

Enlace a la versión detallada . Primero compara el primer carácter de ambas cadenas de entrada ( ⁼§θ⁰§η⁰) y luego compara el resto de ambas cadenas después de eliminar los guiones bajos y los guiones ( ⪫⪪⪫⪪θ_ω-ω) y convertirlos a minúsculas ( ↧).

C #, 101 89 bytes

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

Guardado 12 bytes gracias a @ kusi581.

Java (OpenJDK 8) , 95 bytes

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

Pruébalo en línea! Muy claro.

Pyke , 13 bytes

F'hl1"-_"-)Xq

Pruébalo en línea!

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

C (gcc) , 126114 bytes

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

Pruébalo en línea!

Con espacios en blanco y comentarios:

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

-4 bytes gracias a Kritixi Lithos

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

Toma la entrada como una lista de las cadenas.

Pruébalo en línea!

¿Cómo?

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

Lisp común, 98 bytes

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

Pruébalo en línea!

Versión sin golf (¡súper directa!):

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

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

Función anónima que toma la entrada como una lista de dos cadenas. Aprovecha el hecho de que las operaciones de cadena de R, aunque bastante largas en # de caracteres, están vectorizadas. Además, envolver una asignación entre paréntesis vinculará la variable, por lo que (g=substr(l,1,1))conserva una variable para ser reutilizada más adelante en la línea y de manera similar h.

R devuelve la última expresión evaluada como salida de función.

Sin golf:

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

Pruébalo en línea! (todos los casos de prueba)

Brachylog , 17 bytes

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

Pruébalo en línea!

Salidas a través del predicado éxito / fracaso

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 bytes

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

Un par de funciones anónimas que comparan las dos listas. destinado a ser pegado en el caparazón de erlang.

más legible:

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 bytes

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

Explicacion :

x, yy zpuede ser referenciado en un programa Clip para tomar implícitamente hasta tres entradas. Como este programa solo hace referencia a xy y, toma dos entradas que están asignadas a xy 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 '_'

Toma dos cadenas de entrada estándar, salidas 1y 0para verdadero y falso respectivamente.