Bu zorluktan esinlenerek (teşekkürler @cairdcoinheringaahing!), Göreviniz yazdırılabilir iki ASCII dizisi alıp bunları aşağıdaki kurallara göre elemanlar ile çarpmak.

O nasıl çalışır?

İki dize verildiğinde (örneğin splitve isbn) ilk önce, uzun olanı, eşit uzunlukta olacak şekilde kısaltın ve daha sonra ASCII kodlarını belirleyin :

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

Bir sonraki adım , her bir kodun [0..94]çıkarılmasıyla onları aralıkla eşleştirmek olacaktır 32:

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

Şimdi element-wise modulo ile çarpacaksınız 95(yazdırılabilir aralıkta kalmak için):

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

32Aralığa geri dönmek için ekle [32..126]:

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

Ve son adım, onları tekrar ASCII karakterleriyle eşlemektir:

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

kurallar

• Tanımlanan adımları iki dizede uygulayan ve elde edilen dizgeyi basan ya da döndüren bir program / işlev yazacaksınız
• Giriş formatı esnektir: iki dizge, bir dizge dizisi, dizelerin listesi vb.
• Giriş bir veya iki boş dizeden oluşabilir
• Giriş, yazdırılabilir aralıktaki karakterler olacaktır ([32..126] )
• Çıktı konsola yazdırılır veya bir dize döndürürsünüz
• Çıktı izleyen beyaz boşluklara sahip olabilir

Test durumları

"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>"

Not : tırnak kullandım 6 deney durumunda, sadece okunabilirlik içindir 'yerine ".

MATL , 12 bayt

c32-p95\32+c

Çevrimiçi deneyin!

açıklama

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

Jöle , 15 12 bayt

z⁶O_32P€‘ịØṖ

Çevrimiçi deneyin!

-3 Jonathan Allan'a teşekkürler .

Python 3 , 80 74 71 bayt

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

3 baytlık golf oynamak için @shooqie'ye teşekkürler!

Çevrimiçi deneyin!

Python 2 , 75 70 bayt

Dennis'in shooqie'nin önerisi ile önerisi sayesinde -3 bayt. Zacharı'nın önerisi sayesinde -2 bayt.

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

Çevrimiçi deneyin!

Haskell , 60 57 bayt

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

Çevrimiçi deneyin!

İlk satır iki argüman alan adsız bir fonksiyondur.

Bu, algoritmanın yalındır bir uygulamasıdır: zipWithher iki dizeyi de alır ve verilen bir işlevi karakter çiftlerine uygular. Kesme işlemini gerçekleştirir ve ayrıca boş dizgiler için de çalışır. fromEnumve toEnumalternatifler vardır ordve chruzun ithalat gerekmez karakterler ve onların ASCII değerleri arasındaki anahtara.

Düzenleme: Bruce Forte sayesinde -3 bayt.

C ++, 331 291 282 270 268 bayt, Sürüm 2 = 178 176 150 148 bayt

Orijinal versiyon :

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

Bruce Forte sayesinde -40 bayt
Zacharý sayesinde -39 bayt

Sürüm 2, başkalarının yanıtlarından ilham aldı

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

İlk sürüm bir lambda kullanıyorsa, bunun nedeni daha önce öğrendiğim C ++ 11 std :: async işlevini sınamak istediğimden, bu yüzden sebepsiz kaldım ...

Daha okunabilir sürüm:

#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 bayt

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

Çevrimiçi deneyin (TryAPL)!

Çevrimiçi deneyin (TIO)!

Giriş, dizelerin bir listesidir ve arkada boşluk var.

İşte nasıl çalışıyor:

{⎕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 bayt

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 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

@ Zacharý sayesinde -4 bayt

Artışı hareket ettirerek -1 bayt

Bir lambda kullanır ve karakterlerin temelde ints olması gerçeğini kötüye kullanır.

Mathematica, 114 bayt

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

giriş

[ "Halka", "otoyol"]

Yığılmış , 52 bayt

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

Çevrimiçi deneyin!

Yığından iki argüman alan işlev.

açıklama

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

İki öğelerdir top varsayarak birinci kısmında atalım, 'split've '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'))

Bu bölüm kırpma işlemini gerçekleştirir.

Sonra:

[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 `()`

Sonra, son kısım:

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 bayt

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

adsız işlev; girişi iki dize olarak alır; üçüncü argüman sadece bunun tek satırlık bir fonksiyon olmasını sağlamak ve bazı baytları kaydetmek.

Aşağıdaki TIO bağlantısı, ilk girişle birlikte adlandırılmış girişleri içeren bir dizi döndürür.

Tüm test durumlarını deneyin!

Perl 5 , 65 bayt

64 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

D, 113 bayt

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

Bu HatsuPointerKun'un C ++ çözümünün limanı, onları yenmeyi unutma!

Çevrimiçi deneyin!

05AB1E , 16 15 bayt

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

Çevrimiçi deneyin!

Emigna işaret için ₃iter 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

başka bir şey.

Java 8, 127 115 97 95 bayt

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

Açıklama:

Burada dene.

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 bayt

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

Eminim yapılacak çok golf var ama şu an vaktim yok.

Çevrimiçi deneyin!

Tam / Biçimli Sürüm:

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

Ortak Lisp, 99 bayt

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

Çevrimiçi deneyin!

Japt , 24 bayt

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

\u0000İlk giriş ikinci değerden daha uzun olduğunda, null karakterlerini ( ) izleyen bir dize döndürür .

Çevrimiçi deneyin! -Qboş karakterleri de içeren formatlanmış çıktıyı göstermek için bayrakla işaretleyin.

WIP CodePen'imi kullanarak tüm test durumlarını çalıştırın .

Python 2 , 95 73 bayt

• 4 bayt için @ Zacharý @ Thanks: istenmeyen parantezler kaldırıldı

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

Çevrimiçi deneyin!

Kömür , 30 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Aslında hesaplamayı (32 - ord(q)) * (32 - ord(h))birbirini takip eden sayısal değişmezlerden kaçındığı için yazdım, ancak sanırım (ord(q) - ord(" ")) * (ord(h) - ord(" "))bunun yerine sadece yazabilirdim .

Perl 5 , 95 bayt

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

Çevrimiçi deneyin!

Açıklama:

@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 bayt

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

Dizeleri komut satırı argümanları olarak alır. Çevrimiçi deneyin!

açıklama

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

Faktör , 45

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

Bu bir teklif (lambda), callyığında iki dize var, yeni ipi yığında bırakıyor.

Bir kelime olarak:

: 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 bayt

Çözüm:

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

Çevrimiçi deneyin!

Örnek:

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

Açıklama:

Değerlendirme sağdan sola yapılır:

`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 bayt

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 bayt

Javascript ve uzun fonksiyon isimlerinin laneti ...

Currying kullanmak ve geçersiz bir pozisyonda çağrıldığında charCodeAtdönen gerçeği kullanmak NaNÇıktıda sondalar boş olabilir.

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

Ölçek

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