Motivazione

In questa sfida il tuo compito era quello di moltiplicare due stringhe, questo introduce naturalmente un modo per prendere la radice quadrata di una stringa.

Come funziona?

Data una stringa (ad esempio pub) la prima cosa che devi fare è determinare il codice ASCII per ogni carattere:

"pub" -> [112, 117, 98]

Successivamente si mappano questi codici all'intervallo [0..94]sottraendo 32ogni valore:

[112, 117, 98] -> [80, 85, 66]

Ora devi trovare per ogni valore il suo modulo radice 95(es. 40*40 % 95 = 80, Puoi anche scegliere 55):

[80, 85, 66] -> [40, 35, 16]

E infine lo ricollegherai all'intervallo [32..126]e lo convertirai nuovamente in una stringa:

[40, 35, 16] -> [72, 67, 48] -> "HC0"

In effetti, "HC0" ⊗ "HC0" = "pub"come puoi verificare con una soluzione dell'altra sfida qui .

Quelli che hanno familiarità con l'aritmetica modulare probabilmente hanno notato che il modulo radice quadrata 95non esiste sempre, per esempio non esiste una radice per 2. In tal caso, la radice quadrata di una stringa non è definita e il programma / funzione potrebbe bloccarsi, eseguire un ciclo indefinitamente ecc.

Per comodità, ecco l'elenco dei caratteri che hanno una radice quadrata (il primo è uno spazio):

 !$%&)+03489:>CDGLMQVW]`bjlpqu

Regole

• Scriverai un programma / funzione che accetta una stringa (o un elenco di caratteri) come argomento e restituisce qualsiasi radice quadrata se esiste
• Si può presumere che l'input abbia sempre una radice quadrata
• L'input può essere costituito da una stringa vuota
• L'input sarà compreso nell'intervallo stampabile ( [32..126])
• L'output viene stampato sulla console o si restituisce una stringa se esiste la radice quadrata
• Nel caso in cui la radice quadrata non esista, il comportamento del programma / funzione rimane indefinito
• Se si sceglie di stampare il root sulla console, le nuove righe o gli spazi bianchi vanno bene

Casi test

Nota che queste non sono necessariamente le uniche soluzioni:

''              -> ''
'pub'           -> 'HC0'
'pull!'         -> 'HC33!'
'M>>M'          -> '>MM>'
'49'            -> '4%'
'64'            -> undefined
'Hello, World!' -> undefined

sh + coreutils, 58 byte

tr '$%&)+0389:>CDGLMQVW]`bjpqu' 1u.#:BFO%+M/L2Aa,795d0@H=C

Provalo online!

La radice quadrata modulare non è in genere unica; abbiamo 2 o 4 scelte per ogni personaggio tranne . Non abbiamo bisogno di tradurre , !, 4, ldal momento che ciascuno è già una radice quadrata di se stesso. Per i restanti personaggi, scegliamo immagini che non devono essere salvate per la shell o tr.

Python 3, 57 56 byte

lambda s:s.translate({k*k%95+32:k+32for k in range(95)})

translateutilizza una mappatura da "ordinali Unicode a ordinali Unicode". Pertanto, non abbiamo bisogno chr/ ordconversioni. Nota: non si arresta in modo anomalo quando il carattere non ha root.

Salvato 1 byte grazie a @ jonathan-allan

Il valore della mappatura è la radice maggiore nell'intervallo 0..94 della chiave. Per avere il minor numero di root (come negli esempi), utilizzare:

lambda s:s.translate({k*k%95+32:k+32for k in range(95,0,-1)})

(61 byte)

>>> [s.translate({k*k%95+32:k+32for k in range(95,0,-1)}) for s in ['','pub','pull!','M>>M','49','64','Hello, World!']]
['', 'HC0', 'HC33!', '>MM>', '4%', '64', 'He33o,\x7f9or3d!']

Python 2 , 80 byte

lambda s:''.join([chr(i+32)for i in range(95)if i*i%95==ord(c)-32][0]for c in s)

Provalo online!

Genera IndexError se non esiste alcuna radice.

Japt , 16 15 byte

c@H+LDz%95+HÃbX

Provalo online!

Salvato un byte guardando la risposta 05AB1E (usando L= 100 invece di 95). Ora Japt è il più breve, un evento abbastanza raro MrGreen

Spiegazione

 c@ H+LÇ   ²  %95+HÃ bX
UcX{H+LoZ{Zp2 %95+H} bX}   Ungolfed
                           Implicit: U = input string, H = 32, L = 100
UcX{                   }   Map each charcode X in the input to the following:
      Lo                     Create the array [0, 1, ..., 98, 99]
        Z{         }         and map each item Z to
          Zp2                  Z ** 2
              %95              mod 95
                 +H            plus 32.
                     bX      Find the first index of X in this array. This gives the
                             smallest square root (mod 95) of (X - 32).
    H+                       Add 32 to map this back into the printable range.
                           Implicit: output result of last expression

Mathematica, 94 byte

(R[x_]:=Min@Select[Range@45,Mod[#^2,95]==x&];FromCharacterCode[R/@(ToCharacterCode@#-32)+32])&

Provalo online!

Gelatina , 18 17 16 byte

95Ḷ²%95+32żØṖFyO

Provalo online!(viene fornito con il piè di pagina della suite di test)

Salvato 2 byte eseguendo una riscrittura completa. Anche la prima volta che ne ho trovato l'uso }.

Spiegazione

Il codice prima calcola tutti i caratteri quadrati, quindi li mappa alle rispettive radici quadrate.

95Ḷ²%95+32żØṖFyO    Main link. Argument: S (string)
95                    Take 95.
  Ḷ                   Get the array [0, 1, ..., 94].
   ²                  Square each to get [0, 1, ..., 8836].
    %95               Get each square modulo 95 to get [0, 1, ..., 1].
       +32            Add 32 to get [32, 33, ..., 33].
           ØṖ         Get the list of printables [" ", "!", ..., "~"].
          ż           Interleave with printables to get [[32, " "], ..., [33, "~"]].
             F        Flatten the mapping to [32, " ", ..., 33, "~"].
               O      Get the code point of each character in input.
              y       Map the code points to the correct output characters using the map.

JavaScript, 82 byte

Collaborato con @ETHproductions

s=>s.map(x=>(g=z=>z*z%95==x.charCodeAt(0)-32?String.fromCharCode(z+32):g(z+1))(0))

L'input e l'output hanno la forma di un array di caratteri.

Test snippet

var f=s=>s.map(x=>(g=z=>z*z%95==x.charCodeAt(0)-32?String.fromCharCode(z+32):g(z+1))(0))

console.log(f([...""]));
console.log(f([..."pub"]));
console.log(f([..."pull!"]));
console.log(f([..."M>>M"]));
console.log(f([..."49"]));

05AB1E , 17 byte

vтLn95%žQykk33+ç?

L'algoritmo è molto simile alla risposta Jelly e Japt (aveva già qualcos'altro prima, ma questo mi ha portato solo a 19 byte)

Spiegazione

vтLn95%žQykk33+ç?
v                 # For each character of the input...
 тL                # Push [1..100]
   n               # Square every element of the list
    95%            # And take it modulo 95
       žQyk        # Push the index of the current character in the printable ascii range
           k       # Push the index of that in the list created earlier
            33+    # Add 33 to the result
               ç   # And convert it back to a character
                ?  # Print the character

Provalo online!

Mathematica, 60 byte

FromCharacterCode[PowerMod[ToCharacterCode@#-32,1/2,95]+32]&

Funzione anonima. Accetta una stringa come input e restituisce una stringa come output. Errori nell'input non valido.

Perl 6 , 53 byte

{[~] .comb.map({32+first *²%95==.ord-32,^95})».chr}

Provalo online!

Mathematica 82 byte

FromCharacterCode[Solve[x^2==#,Modulus->95][[1,1,2]]+32&/@(ToCharacterCode@#-32)]&

Sfruttando la capacità di Solve di eseguire l'aritmetica modulare.