Mientras escribía números, noté después de un tiempo que mi teclado tenía la Shifttecla presionada y bloqueada y que todo lo que escribía eran $%&caracteres similares. Y aún peor, había estado cambiando entre los diseños de teclado en inglés y español, así que no sé cuál usé para cada número.

Reto

Dada una cadena que contiene caracteres de símbolos, intenta adivinar qué número escribí. Mi teclado produce los siguientes caracteres para los números cuando Shiftse presiona:

1234567890
----------
!"·$%&/()=  Spanish layout
!@#$%^&*()  English layout

• La entrada será una cadena no nula y no vacía compuesta de los símbolos anteriores.
• La salida será un solo número si la distribución del teclado se puede inferir de la cadena (es decir, si la cadena contiene un @diseño en inglés y si la cadena contiene un "diseño en español) o si el número es el mismo para ambos diseños (es decir, la entrada es la !$que se traduce como 14para ambos diseños); de lo contrario, la salida serán los dos números posibles para ambos diseños si no se puede inferir y los números resultantes son diferentes.
• La cadena de entrada siempre se escribirá en un diseño único. Por lo tanto, no necesita esperar "@como entrada.

Ejemplos

Input  -->  Output
------------------
/()         789        (Spanish layout detected by the use of /)
$%&         456,457    (Layout cannot be inferred)
!@#         123        (English layout detected by the use of @ and #)
()&!        8961,9071  (Layout cannot be inferred)
((·))       88399      (Spanish layout detected by the use of ·)
!$          14         (Layout cannot be inferred but the result is the same for both)
!!$$%%      114455     (Layout cannot be inferred but the result is the same for both)
==$"        0042/42    (Spanish layout, if a number starts with 0 you can choose to
                       omit them in the result or not)

Single character translations:
------------------------------
!   1    
"   2
·   3
$   4
%   5
&   6,7
/   7
(   8,9
)   9,0
=   0
@   2
#   3
^   6
*   8

Este es el código de golf , ¡así que puede ganar el código más corto para cada idioma!

Jalea , 32 31 bytes

O“=!"Ṣ$%&/()“)!@#$%^&*(‘iⱮ€PƇ’Q

Pruébalo en línea!

• -1 bytes gracias a Erik the Outgolfer

O“!"Ṣ$%&/()=“!@#$%^&*()‘iⱮ€PƇ%⁵Q
O                                  ord of each character in the input
 “!"Ṣ$%&/()=“!@#$%^&*()‘           Constant that yields the list:
                                      [[33, 34, 183, 36, 37, 38, 47, 40, 41, 61],
                                       [33, 64, 35, 36, 37, 94, 38, 42, 40, 41]
                          €        For each list of numbers:
                         Ɱ           For each ord of the characters in the input:
                        i              Find the index of the ord of the character
                                       in the list of numbers.
                                       If the number is not found, `i` returns zero
                                       which means it's a character from only one
                                       keyboard.
                                   There are now two lists of numbers 1-10.
                            Ƈ      Keep the list(s) that: 
                           P         have nonzero product.
                             %⁵    Modulo 10. This maps 10->0.
                               Q   Unique elements. This removes duplicates if the two numbers are the same.

Python 3 , 76 bytes

lambda s:{(*map(k.find,s),)for k in['=!"·$%&/()',')!@#$%^&*(']if{*s}<={*k}}

Pruébalo en línea!

Perl 6 , 62 bytes

{set grep {!/\D/},TR'=!"·$%&/()'0..9',TR')!@\x23$%^&*('0..9'}

Pruébalo en línea!

Devuelve un conjunto. (Podría reducirse dos o tres bytes si no hubiera un error en el manejo de # de Rakudo en las listas de búsqueda).

Java (JDK) , 173 bytes

Golfed

c->{String s="",e=s;var m="21#3457#908###6##12#456389###0#7".split("");for(int l:c){e+=m[l=l%16];s+=m[l+16];}return s.equals(e)|s.contains("#")?e:e.contains("#")?s:s+","+e;}

Pruébalo en línea!

c->{                                                      // Lamdba taking char array as input
    String s="",e=s;                                      // Initialise Spanish and English strings
    var m="21#3457#908###6##12#456389###0#7".split("");   // Create magic hashing lookup array (see below)
    for(int l:c){                                         // Loops through all chars in input
        e+=m[l=l%16];                                     // Get english number from array and append
        s+=m[l+16];                                       // Get Spanish number from array and append
    }
    return s.equals(e)|s.contains("#")?e:                 // If equal or Spanish is invalid return english
        e.contains("#")?s:                                // If English is invalid return Spanish
        s+","+e;                                          // If both are valid but not equal, return both
}

Después de experimentar un poco con los valores, me di cuenta de que cada uno de los valores ASCII de los caracteres del !"·$%&/()=@#^*módulo 16 devuelve un número único. El 'conjunto de búsqueda de hash mágico' almacena los números en inglés asociados con cada carácter en este índice único, y cada uno de los números en español en este índice se compensa en 16, haciendo que la obtención del número requerido del conjunto sea trivial para cada idioma. Se almacena un hash para valores que no son válidos para ninguno de los idiomas.

Japt, 38 bytes

Emite una serie de cadenas con el diseño español primero.

"=!\"·$%&/())!@#$%^&*("òA £ËXbD
kø'- â

Intentalo

Jalea , 38 bytes

183Ọ“=!"“$%&/()”j,“)!@#$%^&*(”iⱮ€⁸ẠƇ’Q

Pruébalo en línea!

Retina 0.8.2 , 60 bytes

.+
$&¶$&
T`=!"·$%&/()`d`^.+
T`)!@#$%^&*(`d`.+$
D`
Gm`^\d+$

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

.+
$&¶$&

Duplicar la entrada.

T`=!"·$%&/()`d`^.+
T`)!@#$%^&*(`d`.+$

Intente traducir cada línea de acuerdo con un diseño de teclado diferente.

D`

Deduplicar el resultado.

Gm`^\d+$

Solo mantenga líneas que solo contengan dígitos.

JavaScript (ES6), 99 bytes

s=>(g=l=>a=s.replace(/./g,c=>l.indexOf(c)))('=!"·$%&/()',b=g(')!@#$%^&*('))>=0?a-b&&b>=0?[a,b]:a:b

Pruébalo en línea!

¿Cómo?

$g$

$-1$x >= 0

05AB1E , 42 41 bytes

•Hhç₁d©u÷^Σ(“ðΣèõĆ
-•184в2äεIÇk}ʒ®å_}>T%Ù

Port of @dylnan 's Jelly respuesta .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

•Hhç₁d©u÷^Σ(“ðΣèõĆ
-•184в           # Compressed list [33,34,183,36,37,38,47,40,41,61,33,64,35,36,37,94,38,42,40,41]
      2ä         # Split into two parts: [[33,34,183,36,37,38,47,40,41,61],[33,64,35,36,37,94,38,42,40,41]]
ε   }            # Map each inner list to:
 IÇ              #  Get the input, and convert each character to its unicode value
   k             #  Then get the index of each unicode value in the current map-list
                 #  (this results in -1 if the item doesn't exist)
     ʒ   }       # Filter the resulting list of indices by:
      ®å_        #  If the inner list does not contain any -1
          >      # Increase each index by 1 to make it from 0-indexed to 1-indexed
           T%    # Take modulo-10 to convert 10 to 0
             Ù   # Uniquify the result-lists (and output implicitly)

Ver este consejo 05AB1E mío (sección Cómo comprimir listas de números enteros? ) Para entender por qué •Hhç₁d©u÷^Σ(“ðΣèõĆ\n-•184вes [33,34,183,36,37,38,47,40,41,61,33,64,35,36,37,94,38,42,40,41]). Este (junto con el 2ä) es de 1 byte más corto que tomar los valores Unicode de la cadena: '""!ÿ·$%&/()=""!@#$%^&*()"‚Ç.

Ruby , 68 bytes

->s{%w[=!"·$%&/() )!@#$%^&*(].map{|a|s.tr a,'0-9'}.grep_v(/\D/)|[]}

Pruébalo en línea!

Limpio , 116 bytes

import StdEnv,Text
$s=removeDup[foldl(<+)""d\\r<-["=!\"·$%&/()",")!@#$%^&*("],d<-[[indexOf{c}r\\c<-s]]|all((<) -1)d]

Pruébalo en línea!

Toma entrada y está codificado en CP437. TIO solo admite UTF-8, por lo que se utiliza un escape en el código de demostración para obtener el valor de byte literal 250 correspondiente al punto central (contado como un byte).

APL (Dyalog) , 40 bytes

Función de prefijo tácito anónimo. Aunque no · se utiliza, está en el conjunto de caracteres de un solo byte Dyalog . Asume indexación basada en 0 ( ⎕IO←0) que es predeterminada en muchos sistemas.

{∪⍵/⍨~10∊¨⍵}'=!"·$%&/()' ')!@#$%^&*('⍳¨⊂

Pruébalo en línea!

⊂ todo el argumento

'=!"·$%&/()' ')!@#$%^&*('⍳¨ índices de los caracteres en cada una de estas cadenas

{∪⍵/⍨~10∊¨⍵} aplique la siguiente lambda ( ⍵es el argumento):

10∊¨⍵ para cada lista de dígitos, si 10 (que indica "no encontrado") es miembro del mismo

 ~ negación local (es decir, solo aquellos donde se encuentran todos los dígitos)

 ⍵/⍨ filtrar el argumento por eso

 ∪ encontrar los elementos únicos de eso

Dart , 125 bytes

f(s)=>['=!"·\$%&/()',')!@#\$%^&*('].map((b)=>s.split('').map((e)=>b.indexOf(e)).join()).where((e)=>!e.contains('-')).toSet();

Sin golf:

f(s){
  ['=!"·\$%&/()',')!@#\$%^&*(']
    .map(
      (b)=>s.split('').map((e)=>b.indexOf(e))
      .join()
    ).where(
      (e)=>!e.contains('-')
    ).toSet();
}

• Crea una matriz con los dos valores clave especificados, de 0 a 9
• Para cada uno de ellos, convierta la cadena de entrada al número correspondiente utilizando los índices de los caracteres.
• Únete a la matriz resultante para crear un número
• Elimine cualquier número que tenga un '-' (Dart devuelve -1 cuando indexOf no puede encontrar un carácter)
• Regresar como un conjunto para eliminar duplicados

Pruébalo en Dartpad!

T-SQL, 143 bytes

SELECT DISTINCT*FROM(SELECT TRY_CAST(TRANSLATE(v,m,'1234567890')as INT)a
FROM i,(VALUES('!"·$%&/()='),('!@#$%^&*()'))t(m))b
WHERE a IS NOT NULL

La entrada se toma a través de la tabla i existente con el campo varchar v , según nuestros estándares IO .

Une la tabla de entrada con las dos cadenas de caracteres diferentes, luego usa la nueva función SQL 2017TRANSLATE para intercambiar caracteres individuales y TRY_CASTver si terminamos con un número. Si no, TRY_CASTvuelve NULL.

El exterior final SELECT DISTINCTcombina resultados idénticos y filtra el NULLS.