Enquanto escrevia números, notei depois de um tempo que meu teclado tinha a Shifttecla pressionada e bloqueada e tudo o que escrevi foram $%&caracteres parecidos. E ainda pior, eu estava alternando entre os layouts de teclado em inglês e espanhol, para não saber qual deles usei para cada número.

Desafio

Dada uma sequência contendo caracteres de símbolo, tente adivinhar qual número eu escrevi. Meu teclado produz os seguintes caracteres para os números quando o Shiftbotão é pressionado:

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

• A entrada será uma sequência não nula e não vazia composta pelos símbolos acima.
• A saída será um número único se o layout do teclado puder ser deduzido da string (ou seja, se a string contiver um @layout em inglês e se a string contiver um "layout em espanhol) ou se o número for o mesmo para ambos os layouts (ou seja, a entrada é a !$que se traduz como 14para os dois layouts); caso contrário, a saída será os dois números possíveis para os dois layouts, se não puderem ser inferidos e os números resultantes forem diferentes.
• A string de entrada sempre será gravada em um único layout. Portanto, você não precisa esperar "@como entrada.

Exemplos

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 é o código-golfe , portanto, pode ganhar o código mais curto para cada idioma!

Geléia , 32 31 bytes

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

Experimente online!

• -1 bytes graças 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}}

Experimente online!

Perl 6 , 62 bytes

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

Experimente online!

Retorna um conjunto. (Pode ser reduzido em dois ou três bytes se não houver um erro no tratamento de Rakudo de # nas listas de pesquisa.)

Java (JDK) , 173 bytes

Golfe

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

Experimente online!

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
}

Depois de experimentar alguns valores, percebi que cada um dos valores ASCII dos caracteres !"·$%&/()=@#^*módulo 16 retorna um número único. A 'matriz de pesquisa de hash mágico' armazena os números em inglês associados a cada caractere nesse índice exclusivo, e cada um dos números em espanhol nesse índice é compensado por 16, tornando a busca do número necessário da matriz trivial para cada idioma. Um hash é armazenado para valores inválidos para qualquer idioma.

Japt, 38 bytes

Produz uma matriz de seqüências de caracteres com o layout em espanhol primeiro.

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

Tente

Gelatina , 38 bytes

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

Experimente online!

Retina 0.8.2 , 60 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

.+
$&¶$&

Duplique a entrada.

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

Tente traduzir cada linha de acordo com um layout de teclado diferente.

D`

Desduplicar o resultado.

Gm`^\d+$

Mantenha apenas linhas que contêm apenas 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

Experimente online!

Quão?

$g$

$-1$x >= 0

05AB1E , 42 41 bytes

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

Porto de @dylnan resposta Jelly 's .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Veja esta minha dica do 05AB1E (seção Como compactar listas inteiras? ) Para entender por que •Hhç₁d©u÷^Σ(“ðΣèõĆ\n-•184вé [33,34,183,36,37,38,47,40,41,61,33,64,35,36,37,94,38,42,40,41]). Isto (em conjunto com a 2ä) é um byte mais curto do que tomar os valores Unicode da cadeia: '""!ÿ·$%&/()=""!@#$%^&*()"‚Ç.

Ruby , 68 bytes

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

Experimente online!

Limpo , 116 bytes

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

Experimente online!

Recebe entrada e é codificado no CP437. O TIO suporta apenas UTF-8, portanto, um escape é usado no código de demonstração para obter o valor literal de byte 250 correspondente ao ponto central (contado como um byte).

APL (Dyalog) , 40 bytes

Função de prefixo tácito anônimo. Embora não seja usado, · está no conjunto de caracteres de byte único Dyalog . Assume a indexação baseada em 0 ( ⎕IO←0), que é padrão em muitos sistemas.

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

Experimente online!

⊂ todo o argumento

'=!"·$%&/()' ')!@#$%^&*('⍳¨ índices dos caracteres em cada uma dessas cadeias

{∪⍵/⍨~10∊¨⍵} aplique o seguinte lambda ( ⍵é o argumento):

10∊¨⍵ para cada lista de dígitos, se 10 (indicando "não encontrado") é um membro

 ~ negação local (ou seja, somente aquelas onde todos os dígitos são encontrados)

 ⍵/⍨ filtrar o argumento por esse

 ∪ encontre os elementos únicos disso

Dardo , 125 bytes

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

Ungolfed:

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

• Cria uma matriz com os dois valores de chave especificados, de 0 a 9
• Para cada um deles, converta a sequência de entrada no número correspondente usando os índices dos caracteres
• Junte-se à matriz resultante para criar um número
• Remova qualquer número que tenha um '-' (o Dart retorna -1 quando o indexOf não consegue encontrar um caractere)
• Retornar como um conjunto para remover duplicatas

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

A entrada é obtida através da tabela preexistente i com o campo varchar v , de acordo com nossos padrões de IO .

Une a tabela de entrada com as duas cadeias de caracteres diferentes e usa a nova função SQL 2017TRANSLATE para trocar caracteres individuais e TRY_CASTver se terminamos com um número. Caso contrário, TRY_CASTretorna NULL.

O exterior final SELECT DISTINCTcombina resultados idênticos e filtra o NULLS.