Mentre scrivevo numeri, dopo un po 'ho notato che la mia tastiera aveva il Shifttasto premuto e bloccato e tutto ciò che scrivevo era $%&simile a un personaggio. E ancora peggio, sono passato dal layout di tastiera inglese a quello spagnolo, quindi non so quale ho usato per ciascun numero.

Sfida

Data una stringa contenente caratteri simbolo, prova a indovinare quale numero ho scritto. La mia tastiera produce i seguenti caratteri per i numeri quando Shiftviene premuto:

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

• L'input sarà una stringa non nulla, non vuota composta dai simboli sopra.
• L'output sarà un singolo numero se il layout della tastiera può essere dedotto dalla stringa (cioè se la stringa contiene un @layout inglese è stata utilizzata e se la stringa contiene un "layout spagnolo è stata utilizzata) o se il numero è lo stesso per entrambi i layout (ovvero l'input è !$che si traduce come 14per entrambi i layout); altrimenti l'output sarà i due possibili numeri per entrambi i layout se non può essere dedotto e i numeri risultanti sono diversi.
• La stringa di input verrà sempre scritta in un unico layout. Quindi non devi aspettarti "@come input.

Esempi

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

Questo è code-golf , quindi può vincere il codice più breve per ogni lingua!

Gelatina , 32 31 byte

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

Provalo online!

• -1 byte grazie 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 byte

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

Provalo online!

Perl 6 , 62 byte

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

Provalo online!

Restituisce un set. (Potrebbe essere ridotto di due o tre byte se non ci fosse un bug nella gestione di # negli elenchi di ricerca di Rakudo.)

Java (JDK) , 173 byte

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

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

Dopo aver sperimentato alcuni valori, mi sono reso conto che ciascuno dei valori ASCII dei caratteri !"·$%&/()=@#^*modulo 16 restituisce un numero univoco. La "matrice di ricerca di hashing magica" memorizza i numeri inglesi associati a ciascun personaggio in questo indice univoco e ciascuno dei numeri spagnoli in questo indice è scostato di 16, rendendo il recupero del numero richiesto dall'array banale per ogni lingua. Un hash viene archiviato per valori non validi per entrambe le lingue.

Japt, 38 byte

Emette prima una matrice di stringhe con il layout spagnolo.

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

Provalo

Gelatina , 38 byte

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

Provalo online!

Retina 0.8.2 , 60 byte

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

Provalo online! Il link include casi di test. Spiegazione:

.+
$&¶$&

Duplica l'input.

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

Prova a tradurre ogni riga in base a un diverso layout di tastiera.

D`

Deduplica il risultato.

Gm`^\d+$

Mantieni solo le righe che contengono solo cifre.

JavaScript (ES6), 99 byte

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

Provalo online!

Come?

$g$

$-1$x >= 0

05AB1E , 42 41 byte

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

La risposta di Jelly al porto di @dylnan .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come liste di interi comprimere? ) Per capire il motivo per cui •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]). Questo (insieme al 2ä) è 1 byte più corta prendendo i valori unicode della stringa: '""!ÿ·$%&/()=""!@#$%^&*()"‚Ç.

Rubino , 68 byte

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

Provalo online!

Pulito , 116 byte

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

Provalo online!

Accetta input ed è codificato in CP437. TIO supporta solo UTF-8, quindi nel codice demo viene utilizzata una escape per ottenere il valore letterale di byte 250 corrispondente al punto centrale (conteggiato come un byte).

APL (Dyalog) , 40 byte

Funzione prefisso tacito anonimo. Sebbene inutilizzato, si · trova nel set di caratteri a byte singolo Dyalog . Presuppone l'indicizzazione in base a 0 ( ⎕IO←0) che è predefinita su molti sistemi.

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

Provalo online!

⊂ l'intero argomento

'=!"·$%&/()' ')!@#$%^&*('⍳¨ indici dei caratteri in ciascuna di queste stringhe

{∪⍵/⍨~10∊¨⍵} applica il seguente lambda ( ⍵è l'argomento):

10∊¨⍵ per ogni elenco di cifre, se 10 (che indica "non trovato") è un membro di esso

 ~ negazione locale (ovvero solo quelle in cui sono state trovate tutte le cifre)

 ⍵/⍨ filtra l'argomento da quello

 ∪ trova gli elementi unici di quello

Dardo , 125 byte

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

• Crea un array con i due valori chiave specificati, da 0 a 9
• Per ognuno di essi, converti la stringa di input nel numero corrispondente usando gli indici dei caratteri
• Unisciti alla matrice risultante per creare un numero
• Rimuovi qualsiasi numero con un '-' (Dart restituisce -1 quando indexOf non riesce a trovare un carattere)
• Ritorna come set per rimuovere i duplicati

Provalo su Dartpad!

T-SQL, 143 byte

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

L'input viene preso tramite la tabella i preesistente con varchar field v , secondo i nostri standard IO .

Unisce la tabella di input con le due diverse stringhe di caratteri, quindi utilizza la nuova funzione SQL 2017TRANSLATE per scambiare singoli caratteri e TRY_CASTvedere se finiamo con un numero. In caso contrario, TRY_CASTritornaNULL .

L'esterno finale SELECT DISTINCTcombina risultati identici e filtra il NULLS.