Inspiré par ce défi (merci @cairdcoinheringaahing pour le titre!), Votre tâche consiste à prendre deux chaînes ASCII imprimables et à les multiplier élément par élément avec les règles suivantes.

Comment ça marche?

Étant donné deux chaînes (par exemple splitet isbn), vous allez d'abord tronquer la plus longue de sorte qu'elles aient une longueur égale, puis déterminer leurs codes ASCII :

split -> spli -> [115, 112, 108, 105]
isbn  -> isbn -> [105, 115,  98, 110]

La prochaine étape consistera à les mapper à la plage [0..94]en soustrayant 32chaque code:

[115, 112, 108, 105] -> [83, 80, 76, 73]
[105, 115,  98, 110] -> [73, 83, 66, 78]

Vous allez maintenant les multiplier par élément modulo 95(pour rester dans la plage imprimable):

[83, 80, 76, 73] ⊗ [73, 83, 66, 78] -> [74, 85, 76, 89]

Ajoutez 32pour revenir à la gamme [32..126]:

[74, 85, 76, 89] -> [106, 117, 108, 121]

Et la dernière étape consiste à les mapper en caractères ASCII:

[106, 117, 108, 121] -> "july"

Règles

• Vous allez écrire un programme / fonction qui implémente les étapes décrites sur deux chaînes et imprime ou renvoie la chaîne résultante
• Le format d'entrée est flexible: vous pouvez prendre deux chaînes, un tuple de chaînes, une liste de chaînes, etc.
• L'entrée peut consister en une ou deux chaînes vides
• L'entrée sera constituée de caractères dans la plage imprimable ( [32..126])
• La sortie est imprimée sur la console ou vous retournez une chaîne
• La sortie peut avoir des espaces de fin

Cas de test

"isbn", "split"                  -> "july"
"", ""                           -> ""
"", "I don't matter"             -> ""
"             ", "Me neither :(" -> "             "
"but I do!", "!!!!!!!!!"         -> "but I do!"
'quotes', '""""""'               -> 'ck_iKg'
"wood", "hungry"                 -> "yarn"
"tray", "gzip"                   -> "jazz"
"industry", "bond"               -> "drop"
"public", "toll"                 -> "fall"
"roll", "dublin"                 -> "ball"
"GX!", "GX!"                     -> "!!!"
"4 lll 4", "4 lll 4"             -> "4 lll 4"
"M>>M", "M>>M"                   -> ">MM>"

Remarque : Les citations sont juste pour la lisibilité, dans le 6ème cas de test que j'ai utilisé à la 'place de ".

MATL , 12 octets

c32-p95\32+c

Essayez-le en ligne!

Explication

c      % Implicitly input cell array of 2 strings. Convert to 2-row char matrix.
       % This pads the shorter string with spaces
32-    % Subtract 32, element-wise. Each char is interpreted as its ASCII code.
       % Note that padding spaces will give 0.
p      % Product of each column. Since (padding) spaces have been mapped to 0, the
       % product effectively eliminates those colums. So the effect is the same as
       % if string length had been limited by the shorter one
95\    % Modulo 95, element-wise
32+    % Add 32, element-wise
c      % Convert to char. Implicitly display

Gelée , 15 12 octets

z⁶O_32P€‘ịØṖ

Essayez-le en ligne!

-3 merci à Jonathan Allan .

Python 3 , 80 74 71 octets

lambda*t:''.join(map(lambda x,y:chr((ord(x)-32)*(ord(y)-32)%95+32),*t))

Merci à @shooqie d'avoir joué au golf sur 3 octets!

Essayez-le en ligne!

Python 2 , 75 70 octets

-3 octets grâce à la suggestion de Dennis de la suggestion de shooqie. -2 octets grâce à la suggestion de Zacharý.

lambda*l:''.join(chr((ord(i)-32)*(ord(j)-32)%95+32)for i,j in zip(*l))

Essayez-le en ligne!

Haskell , 60 57 octets

zipWith(\a b->toEnum$f a*f b`mod`95+32)
f=(-32+).fromEnum

Essayez-le en ligne!

La première ligne est une fonction anonyme prenant deux arguments.

Il s'agit d'une implémentation simple de l'algorithme: zipWithprend les deux chaînes et applique une fonction donnée aux paires de caractères. Il gère la troncature et fonctionne également pour les chaînes vides. fromEnumet toEnumsont des alternatives à ordet chrpour basculer entre les caractères et leurs valeurs ASCII qui n'ont pas besoin d'une importation longue.

Edit: -3 octets grâce à Bruce Forte.

C ++, 331 291 282 270 268 octets, version 2 = 178 176 150 150 148 octets

Version originale :

#include<string>
#include<algorithm>
#define L length()
#define S std::string
S m(S a,S b){S c;int m=a.L<b.L?a.L:b.L;auto l=[m](S&s){s=s.substr(0,m);std::for_each(s.begin(),s.end(),[](char&c){c-=32;});};l(a);l(b);for(int i=0;i<m;++i){c+=a[i]*b[i]%95+32;}return c;}

-40 octets grâce à Bruce Forte
-39 octets grâce à Zacharý

Version 2, inspirée des réponses des autres

#include<string>
#define L length()
using S=std::string;S m(S a,S b){S c;for(int i=0;i<(a.L<b.L?a.L:b.L);++i)c+=(a[i]-32)*(b[i]-32)%95+32;return c;}

Si la première version utilise un lambda, c'est parce que je voulais tester la fonction std :: async C ++ 11 que je viens d'apprendre, donc je l'ai gardée sans raison ...

Version plus lisible:

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;

#define L length()
#define S string

//Function code for the original version
S m(S a,S b) {
    S c;
    int m = a.L < b.L ? a.L : b.L;

    auto l=[m](S&s){
        s = s.substr(0, m);
        for_each(s.begin(),s.end(),[](char&c){
            c -= 32;
        });
    };
    l(a);
    l(b);
    for(int i=0;i<m;++i) {
        c += a[i] * b[i] % 95 + 32;
    }
    return c;
}

//Code for the version 2
S m2(S a,S b) {
    S c;
    for(int i = 0; i < (a.L < b.L ? a.L : b.L); ++i) {
        c += (a[i] - 32) * (b[i] - 32) % 95 + 32;
    }
    return c;
}

int main() {
    string a, b, c;
    getline(cin, a);
    getline(cin, b);
    c = m(a, b);
    cout << c;
}

Dyalog APL, 36 34 33 25 24 octets

{⎕UCS 32+95|×⌿32-⎕UCS↑⍵}

Essayez-le en ligne (TryAPL)!

Essayez-le en ligne (TIO)!

L'entrée est une liste de chaînes et possède un espace de fin.

Voici comment cela fonctionne:

{⎕UCS 32+95|×⌿32-⎕UCS↑⍵}
                     ↑⍵ - the input as a 2d array
                 ⎕UCS   - codepoints
              32-       - subtract 32
            ×⌿          - element wise product reduction ([a,b]=>a×b)
         95|            - Modulo 95
      32+               - Add 32
 ⎕UCS                   - Unicode characters

FSharp 275 octets

let f (p : string, q : string) =     
let l = if p.Length < q.Length then p.Length else q.Length
p.Substring(0,l).ToCharArray() |> Array.mapi (fun i x -> (((int(x) - 32) * (int(q.[i]) - 32)) % 95) + 32) |> Array.map (fun x -> char(x).ToString()) |> Array.fold(+) ""

CJam , 23 octets

{z{2' e]' f-:*95%' +}%}

Essayez-le en ligne!

C # (.NET Core) , 100 96 95 octets

(l,n)=>{for(int i=0;i<l.Length&i<n.Length;)Console.Write((char)((l[i]-32)*(n[i++]-32)%95+32));}

Essayez-le en ligne!

-4 octets grâce à @ Zacharý

-1 octet en déplaçant l'incrément

Utilise un lambda et abuse du fait que les personnages sont essentiellement des ints.

Mathematica, 114 octets

(a=Min@StringLength[x={##}];FromCharacterCode[Mod[Times@@(#-32&/@ToCharacterCode/@(StringTake[#,a]&/@x)),95]+32])&

contribution

["public", "péage"]

Empilé , 52 octets

[,:$#'"!MIN$take"![CS#.toarr]"!32-prod 95%32+#:''#`]

Essayez-le en ligne!

Fonction qui prend deux arguments de la pile.

Explication

[,:$#'"!MIN$take"![CS#.toarr]"!32-prod 95%32+#:''#`]

Regardons la première partie, en supposant que les deux premiers éléments sont 'split'et 'isbn':

,:$#'"!MIN$take"!      stack:                      ('split' 'isbn')
,                      pair top two:               (('split' 'isbn'))
 :                     duplicate:                  (('split' 'isbn') ('split' 'isbn'))
  $#'                  length function literal:    (('split' 'isbn') ('split' 'isbn') $#')
    "!                 execute on each:            (('split' 'isbn') (5 4))
      MIN              obtain the minimum:         (('split' 'isbn') 4)
         $take         "take" function literal:    (('split' 'isbn') 4 $take)
                       (e.g. `'asdf' 2 take` is `'as'`)
              "!       vectorized binary each:     (('spli' 'isbn'))

Cette partie effectue le recadrage.

Ensuite:

[CS#.toarr]"!     stack: (('spli' 'isbn'))
[         ]"!     perform the inside on each string
                  string `'spli'`:
 CS               convert to a character string:    $'spli'
   #.             vectorized "ord":                 (115 112 108 105)
     toarr        convert to array:                 (115 112 108 105)
                  (needed for empty string, since `$'' #.` == `$''` not `()`

Ensuite, la dernière partie:

32-prod 95%32+#:''#`  stack: (((115 112 108 105) (105 115  98 110)))
32-                   subtract 32 from each character code:   (((83 80 76 73) (73 83 66 78)))
   prod               reduce multiplication over the array:   ((6059 6640 5016 5694))
        95%           modulus 95:                             ((74 85 76 89))
           32+        add 32:                                 ((106 117 108 121))
              #:      convert to characters:                  (('j' 'u' 'l' 'y'))
                ''#`  join:                                   ('july')

R , 88 octets

function(r,s,u=utf8ToInt)intToUtf8((((u(r)-32)*(u(s)-32))%%95+32)[0:min(nchar(c(r,s)))])

fonction anonyme; prend l'entrée comme deux chaînes; le troisième argument est juste de s'assurer qu'il s'agit d'une fonction d'une ligne et d'économiser quelques octets.

Le lien TIO ci-dessous renvoie un tableau avec des entrées nommées avec la première entrée.

Essayez tous les cas de test!

Perl 5 , 65 octets

64 octets de code + -pindicateur.

$n=reverse<>;s/./($_=chop$n)&&chr 32+(-32+ord$&)*(-32+ord)%95/ge

Essayez-le en ligne!

D, 113 octets

T m(T)(T a,T b){T c;for(int i;i<(a.length<b.length?a.length:b.length);++i)c~=(a[i]-32)*(b[i]-32)%95+32;return c;}

Ceci est un portage de la solution C ++ de HatsuPointerKun , n'oubliez pas de les voter!

Essayez-le en ligne!

05AB1E , 16 15 octets

.BÇ32-`*₃%32+çJ

Essayez-le en ligne!

-1 pour Emigna soulignant les ₃poussées 95.

                 # ['hi', 'you']
.B               # [['hi ', 'you']]
  Ç              # [[[104, 105, 32], [121, 111, 117]]]
   32-           # [[[72, 73, 0], [89, 79, 85]]]
      `          # [[72, 73, 0], [89, 79, 85]]
       *         # [[6408, 5767, 0]]
        ₃%       # [[43, 67, 0]]
          32+    # [[75, 99, 32]]
             ç   # [['K', 'c', ' ']]
              J  # ['Kc ']

.BÇ32-`*95%žQsèJ

en est un autre.

Java 8, 127 115 97 95 octets

a->b->{for(int i=0;i<a.length&i<b.length;System.out.printf("%c",(a[i]-32)*(b[i++]-32)%95+32));}

Explication:

Essayez-le ici.

a->b->{                       // Method with 2 char-array parameters and no return-type
  for(int i=0;                //  Index-integer, starting at 0
      i<a.length&i<b.length;  //  Loop over both arrays up to the smallest of the two
    System.out.printf("%c",   //   Print, as character:
      (a[i]-32)               //    Current char of `a` minus 32
      *(b[i++]-32)            //    multiplied with current char of `b` minus 32
      %95                     //    Take modulo-95 of that multiplied result
      +32));}                 //    And add 32 again

C #, 166 octets

using System.Linq;s=>t=>{int e=s.Length,n=t.Length,l=e>n?n:e;return string.Concat(s.Substring(0,l).Select((c,i)=>(char)((((c-32)*(t.Substring(0,l)[i]-32))%95)+32)));}

Je suis sûr qu'il y a beaucoup de golf à faire mais je n'ai pas le temps pour l'instant.

Essayez-le en ligne!

Version complète / formatée:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, Func<string, string>> f = s => t =>
        {
            int e = s.Length, n = t.Length, l = e > n ? n : e;

            return string.Concat(s.Substring(0, l).Select((c, i) => (char)((((c - 32) * (t.Substring(0, l)[i] - 32)) % 95) + 32)));
        };

        Console.WriteLine(string.Concat(f("split")("isbn")));

        Console.ReadLine();
    }
}

Lisp commun, 99 octets

(lambda(a b)(map'string(lambda(x y)(code-char(+(mod(*(-(#1=char-code x)32)(-(#1#y)32))95)32)))a b))

Essayez-le en ligne!

Japt , 24 octets

¬íVq)®®©c -HÃ×u95 +H dÃq

Renvoie une chaîne avec des caractères nuls de fin (\u0000 ) lorsque la première entrée est plus longue que la seconde.

Essayez-le en ligne! avec le-Q indicateur pour afficher la sortie formatée, y compris les caractères nuls.

Exécutez tous les cas de test à l' aide de mon WIP CodePen.

Python 2 , 95 73 octets

• Merci @ Zacharý pour 4 octets: les crochets indésirables supprimés

lambda x,y:''.join(chr((ord(i)-32)*(ord(j)-32)%95+32)for i,j in zip(x,y))

Essayez-le en ligne!

Fusain , 30 octets

Ｆ⌊⟦ＬθＬη⟧℅⁺³²﹪×⁻³²℅§θι⁻³²℅§ηι⁹⁵

Essayez-le en ligne! Le lien est vers la version détaillée du code. J'ai en fait écrit le calcul (32 - ord(q)) * (32 - ord(h))car il évite les littéraux numériques consécutifs mais je suppose que j'aurais pu simplement écrire à la (ord(q) - ord(" ")) * (ord(h) - ord(" "))place.

Perl 5 , 95 octets

@a=<>=~/(.)/g;@b=<>=~/(.)/g;$#a=$#b if@a>@b;print chr 32+(-32+ord$_)*(-32+ord$b[$i++])%95 for@a

Essayez-le en ligne!

Explication:

@a=<>=~/(.)/g;@b=<>=~/(.)/g;  # Split the strings into 2 arrays
$#a=$#b if@a>@b;              # Truncate the first if longer than the second
print chr 32+(-32+ord$_)*(-32+ord$b[$i++])%95 for@a  # Multiply each character

Pip , 19 octets

(PA$* *(PA@?Zg)%95)

Prend les chaînes comme arguments de ligne de commande. Essayez-le en ligne!

Explication

(PA$* *(PA@?Zg)%95)
                     g is list of args; PA is string of all printable ASCII characters
            Zg       Zip items of g together: result is list of pairs of characters
        PA@?         Find index of each character in PA
       (      )      (Parentheses to get correct operator precedence)
   $* *              Map (fold on *) to the list: multiplies each pair of numbers
               %95   Take list items mod 95
(PA               )  Use those numbers to index into PA again
                     Print the resulting list of chars, concatenated together (implicit)

Facteur , 45

[ [ [ 32 - ] bi@ * 95 mod 32 + ] "" 2map-as ]

C'est une citation (lambda), callelle avec deux chaînes sur la pile, laisse la nouvelle chaîne sur la pile.

En un mot:

: s* ( s1 s2 -- ps ) [ [ 32 - ] bi@ * 95 mod 32 + ] "" 2map-as ;

"M>>M" "M>>M" s*      ! => ">MM>"
dup s*                ! => "M>>M"
dup s*                ! => ">MM>"
...

K (oK) , 26 octets

Solution:

`c$32+95!*/-32+(&/#:'x)$x:

Essayez-le en ligne!

Exemple:

`c$32+95!*/-32+(&/#:'x)$x:("split";"isbn")
"july"

Explication:

L'évaluation s'effectue de droite à gauche:

`c$32+95!*/-32+(&/#:'x)$x: / the solution
                        x: / assign input to variable x
                       $   / pad right to length on left
               (  #:'x)    / count each x (return length of each char list in list)
                &/         / min-over, get the minimum of these counts
           -32+            / subtract 32, this automagically converts chars -> ints
         */                / multiply-over, product of the two lists
      95!                  / modulo 95
   32+                     / add 32 back again
`c$                        / convert to character array

PHP, 112 octets

for($i=0;$i<min(strlen($a=$argv[1]),strlen($b=$argv[2]));$i++)echo chr((ord($a[$i])-32)*(ord($b[$i])-32)%95+32);

JavaScript (ES6), 89 octets

Javascript et la malédiction des longs noms de fonctions ...

Utiliser le curry et le fait qu'il charCodeAtrevient NaNlorsqu'il est appelé avec une position invalide. Il peut y avoir des valeurs nulles de fin dans la sortie.

a=>b=>a.replace(/./g,(c,i)=>String.fromCharCode((z=x=>x.charCodeAt(i)-32)(a)*z(b)%95+32))

Tester

var f=
a=>b=>a.replace(/./g,(c,i)=>String.fromCharCode((z=x=>x.charCodeAt(i)-32)(a)*z(b)%95+32))

q=x=>'['+x+']'

;[["isbn", "split"],["", ""],["", "I don't matter"],["             ", "Me neither :("],
["but I do!", "!!!!!!!!!"],['quotes', '""""""'],["wood", "hungry"],["tray", "gzip"],
["industry", "bond"],["public", "toll"],["roll", "dublin"],["GX!", "GX!"],
["4 lll 4", "4 lll 4"],["M>>M", "M>>M"]]
.forEach(([a,b])=>console.log(q(a)+' x '+q(b)+' --> '+q(f(a)(b))))