इस चुनौती से प्रेरित होकर (शीर्षक के लिए @cairdcoinheringaahing धन्यवाद!), आपका काम दो मुद्रण योग्य ASCII तार लेना है और उन्हें निम्नलिखित नियमों के साथ तत्व-वार गुणा करना है।

यह कैसे काम करता है?

दो तार (उदाहरण के लिए यह देखते हुए splitऔर isbn) जब आपने पहली बार काटना होगा लंबे समय तक ऐसे ही एक समान लंबाई है कि वे और फिर अपने निर्धारित ASCII कोड :

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

अगला चरण उन्हें प्रत्येक कोड [0..94]को घटाकर सीमा तक ले जाने 32का होगा:

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

अब आप उन्हें तत्व-वार मोडुलो 95(प्रिंट करने योग्य सीमा में रहने के लिए) गुणा करेंगे :

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

32श्रेणी में वापस लाने के लिए जोड़ें [32..126]:

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

और अंतिम चरण उन्हें ASCII वर्णों में वापस मैप करना है:

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

नियम

आप एक प्रोग्राम / फ़ंक्शन लिखेंगे जो दो स्टिंग्स पर वर्णित चरणों को लागू करता है और या तो प्रिंट करता है या परिणामस्वरूप स्ट्रिंग लौटाता है
इनपुट प्रारूप लचीला है: आप दो तार ले सकते हैं, तार का एक टुकड़ा, तार की सूची आदि।
इनपुट में एक या दो खाली तार हो सकते हैं
इनपुट मुद्रण योग्य श्रेणी में वर्ण होंगे ( [32..126])
आउटपुट या तो कंसोल पर मुद्रित होता है या आप एक स्ट्रिंग लौटाते हैं
आउटपुट को अनुगामी व्हॉट्सएप की अनुमति है

परीक्षण के मामलों

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

नोट : उद्धरण केवल पठनीयता के लिए हैं, 6 वें परीक्षण मामले में जिसके 'बजाय मैंने उपयोग किया था "।

code-golf string printable-ascii

— ბიმო
स्रोत

क्या आपको अपने आउटपुट में अनुगामी स्थान रखने की अनुमति है?

— सितंबर को आउटगोल्फ जूल

@EriktheOutgolfer हां। क्षमा करें, मैंने इसे पोस्ट करने के बाद जोड़ा।

— ।

क्या हम तार के सरणियों की एक सरणी ले सकते हैं? abc, def -> [['a', 'b', 'c'], ['d', 'e', 'f']]

— बिलकुल अमानवीय

@totallyhuman मैं ऐसा नहीं कहूंगा। हालाँकि, यदि आपकी भाषा में तार वर्णों के सरणियाँ हैं और वर्णों के तार समान हैं, तो यह मेरे हिसाब से मान्य होगा।

— ბიმო

क्या हमें स्ट्रिंग्स की सूची के रूप में इनपुट लेने की अनुमति है?

— जकार्इ

9

MATL , 12 बाइट्स

c32-p95\32+c

इसे ऑनलाइन आज़माएं!

व्याख्या

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

— लुइस मेंडो
स्रोत

1

स्ट्रिंग लंबाई के अंतर को प्रबंधित करने का चतुर तरीका।

— Sanchises

6

जेली , 15 12 बाइट्स

z⁶O_32P€‘ịØṖ

इसे ऑनलाइन आज़माएं!

-3 जोनाथन एलन को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

व्हिसपेस को पीछे छोड़ते हुए डरपोक। ;)

— डेनिस

@ डेनिस यह नियमों में है, इसका दुरुपयोग क्यों नहीं करते?

— निकोलस

मेरा मानना है कि आप मुद्रण योग्य पात्रों के लिए निलादिक परमाणु का उपयोग करके 3 बाइट्स बचा सकते हैं ØṖ, के साथ z⁶O_32P€‘ịØṖ- आप सबसे अच्छा दोहरा जांच करेंगे कि अंकगणित हालांकि काम करता है।

— जोनाथन एलन

@JonathanAllan बेशक।

— एलिक आउटफोलर

5

पायथन 3 , 80 74 71 बाइट्स

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

3 बाइट बंद करने के लिए @shooqie को धन्यवाद!

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

1

71 अगर आप (s, t)lambda t:''.join(map(lambda x,y:chr((ord(x)-32)*(ord(y)-32)%95+32),*t))

— टुल्ल के

5

पायथन 2 , 75 70 बाइट्स

शूकी के सुझाव के डेनिस के सुझाव के लिए -3 बाइट्स धन्यवाद। -2 बाइट्स ने ज़ाचार्जी के सुझाव के लिए धन्यवाद दिया।

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

2

एक ही चाल जो मेरे उत्तर पर सुझाई गई थी:lambda*t:''.join(chr(((ord(i)-32)*(ord(j)-32))%95+32)for i,j in zip(*t))

— डेनिस

2

और एक ही है कि मैं एक बहुत सुझाव दिया: ((ord(i)-32)*(ord(j)-32))%95+32=> (ord(i)-32)*(ord(j)-32)%95+32...

— Zacharý

डे_ डेनिस की पिटाई करते हैं। +1

— ज़ाचरी

1

एह, वास्तव में नहीं, मैं सिर्फ उपयोग करने के बजाय एक सूची समझ में बदल गया map। मुझे बस थोड़ी देर हो गई थी।

— बिलकुल अमानवीय

5

हास्केल , 60 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पहली पंक्ति दो तर्कों को लेने वाला एक अनाम कार्य है।

यह एल्गोरिथ्म का एक सीधा आगे कार्यान्वयन है: zipWithदोनों तार लेता है और पात्रों के जोड़े को दिए गए फ़ंक्शन को लागू करता है। यह ट्रंकेशन को संभालता है और खाली तारों के लिए भी काम करता है। fromEnumऔर के toEnumविकल्प हैं ordऔरchr पात्रों और उनके ASCII मूल्यों जो एक लंबा आयात की जरूरत नहीं है के बीच स्विच करने के लिए।

संपादित करें: ब्रूस फोर्ट के लिए -3 बाइट्स धन्यवाद।

— Laikoni
स्रोत

आप 3बाइट्स को खींचकर -32और उन कोष्ठकों को बचाकर बचा सकते हैं, यहां देखें ।

— ბიმო

5

सी ++, 331 291 282 270 268 बाइट्स, संस्करण 2 = 178 176 150 148 बाइट्स

मूल संस्करण :

#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 बाइट्स के लिए धन्यवाद ब्रूस
फोर्टे -39 बाइट्स के लिए धन्यवाद जचार्जी

संस्करण 2, अन्य लोगों के उत्तरों से प्रेरित है

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

यदि पहला संस्करण एक लंबो का उपयोग करता है, तो यह इसलिए है क्योंकि मैं C ++ 11 std :: async फ़ंक्शन का परीक्षण करना चाहता था, जिसे मैंने पहले सीखा था, इसलिए मैंने इसे बिना किसी कारण के रखा ...

अधिक पठनीय संस्करण:

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

— HatsuPointerKun
स्रोत

1

PPCG में आपका स्वागत है!

— मार्टिन एंडर

साइट पर आपका स्वागत है! आपके उत्तर के लिए धन्यवाद, मैं इसकी सराहना करता हूं। मुझे सी ++ के साथ गोल्फ खेलने का कोई अनुभव नहीं है, लेकिन यहां आपको कुछ सुझाव मिलेंगे। यहाँ अपने समय का आनंद लें!

— ।

इसके अलावा, मुझे पूरा यकीन है कि आप इस तरह से एक फ़ंक्शन सबमिट कर सकते हैं ।

— ბიმო

क्या आप यहां रिक्त स्थान नहीं निकाल सकते: #include <string>=> #include<string>और #include <algorithm>=> #include<algorithm>?

— ज़ाचरी

इसके अलावा आप एक मैक्रो के बराबर बनाने में सक्षम होना चाहिए stringऔर तदनुसार उपयोग करें।

— 22

3

Dyalog APL, 36 34 33 25 24 बाइट्स

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

इसे ऑनलाइन आज़माएं (TryAPL)!

इसे ऑनलाइन (TIO) आज़माएं!

इनपुट स्ट्रिंग्स की एक सूची है, और इसमें व्हॉट्सएप को पीछे छोड़ दिया गया है।

यहां देखिए यह कैसे काम करता है:

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

— जाकारी
स्रोत

मुझे इसका इंटरफ़ेस नहीं मिला tryapl.org, इसलिए यहां उन लोगों के लिए एक TIO है जो इसे आज़माना चाहते हैं।

— ბიმო

वहां, मैंने दोनों को वहां रखा।

— जकार्इ

3

एफएसएचआरपी 275 बाइट्स

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

— laco
स्रोत

PPCG में आपका स्वागत है!

— मार्टिन एंडर

169 बाइट्स

— केवल

127 बाइट्स

— ASCII-only

126 बाइट्स

— केवल

124 बाइट्स

— केवल

2

सीजेएम , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

2

सी # (.NET कोर) , 100 96 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-4 बाइट्स @ ज़ाचरी को धन्यवाद

-1 बाइट को बढ़ाकर

एक लैम्ब्डा का उपयोग करता है और इस तथ्य का दुरुपयोग करता है कि अक्षर मूल रूप से स्याही हैं।

— jkelm
स्रोत

क्या आप उपयोग कर सकते हैं (l[i]-32)*(n[i]-32)%95+32?

— जकार्इ

क्यों हाँ, मैं कर सकता हूँ। धन्यवाद!

— jkelm

1

आपको पूरी तरह से अर्हता प्राप्त करने की आवश्यकता है Consoleऔर आप बाइट को बचाने के लिए करी का उपयोग कर सकते हैं। एक करने के लिए संकलित Action<string, Action<string>>की तरह l=>n=>है और कॉल की तरह("word")("string")

— TheLethalCoder

2

मैथेमेटिका, 114 बाइट्स

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

इनपुट

[ "सार्वजनिक", "टोल"]

— J42161217
स्रोत

क्या इसे ऑनलाइन आज़माने का कोई तरीका है?

— ბიმო

बेशक, sandbox.open.wolframcloud.com/app/objects पर जाएं, कोड पेस्ट करें, अंत में इनपुट पेस्ट करें, शिफ्ट + दर्ज करें

— J42161217

क्या "8 वर्ण"?

— J42161217

गलतफहमी के लिए खेद है! संदेश "धन्यवाद!" इस तरह से पोस्ट करने के लिए बहुत कम होगा, इसे 8 वर्णों की अधिक आवश्यकता थी।

— ბიმო

3

ok ....................................

— J42161217

2

स्टैक किया गया , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

फ़ंक्शन जो स्टैक से दो तर्क लेता है।

व्याख्या

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

पहले भाग में आइए नज़र, शीर्ष दो आइटम हैं यह सोचते हैं 'split'और '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'))

यह भाग फसल की कटाई करता है।

फिर:

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

फिर, अंतिम भाग:

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

— कोनोर ओ ब्रायन
स्रोत

2

आर , 88 बाइट्स

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

अनाम फ़ंक्शन; दो तार के रूप में इनपुट लेता है; तीसरा तर्क यह सुनिश्चित करने के लिए है कि यह एक पंक्ति कार्य है और कुछ बाइट्स को बचाने के लिए है।

नीचे दिया गया TIO लिंक पहले इनपुट के साथ नामित प्रविष्टियों के साथ एक सरणी देता है।

सभी परीक्षण मामलों की कोशिश करो!

— ग्यूसेप
स्रोत

2

पर्ल 5 , 65 बाइट्स

कोड + -pध्वज के 64 बाइट्स ।

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

इसे ऑनलाइन आज़माएं!

— बापू
स्रोत

2

डी, 113 बाइट्स

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

यह HatsuPointerKun के C ++ सॉल्यूशन का एक पोर्ट है, इन्हें अपग्रेड करना न भूलें!

इसे ऑनलाइन आज़माएं!

— जाकारी
स्रोत

2

05AB1E , 16 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 के लिए एमिग्ना ने ₃धक्का दिया 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

दूसरा है।

— जादू ऑक्टोपस Urn
स्रोत

₃एक बाइट बचाता है। खाली स्ट्रिंग इनपुट के बारे में बहुत बुरा। अन्यथा øकुछ और बचत होती।

— एमिग्ना

2

जावा 8, 127 115 97 95 बाइट्स

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

— केविन क्रूज़सेन
स्रोत

1

सी #, 166 बाइट्स

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

मुझे यकीन है कि बहुत सारी गोल्फिंग की जानी है, लेकिन मेरे पास अभी समय नहीं है।

इसे ऑनलाइन आज़माएं!

पूर्ण / स्वरूपित संस्करण:

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

— TheLethalCoder
स्रोत

मुझे लगता है कि (((c-32)*(t.Substring(0,l)[i]-32))%95)+32)हो सकता है ((c-32)*(t.Substring(0,l)[i]-32)%95+32)(वहाँ parens खराब हो सकता है ... यह लिस्प की तरह लग रहा है!)

— Zacharý

1

आम लिस्प, 99 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— रेंज़ो
स्रोत

1

जाप , 24 बाइट्स

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

पीछे चल रहे नल-वर्ण ( \u0000) के साथ एक स्ट्रिंग देता है जब पहला इनपुट दूसरे से अधिक लंबा होता है।

इसे ऑनलाइन आज़माएं! उसके साथ-Qझंडे के स्वरूपित आउटपुट दिखाने के झंडे के , अशक्त-वर्ण सहित।

मेरे WIP CodePen का उपयोग करके सभी परीक्षण मामलों को चलाएं।

— जस्टिन मेरिनर
स्रोत

1

पायथन 2 , 95 73 बाइट्स

धन्यवाद @ 4 बाइट्स के लिए Zacharý: अवांछित कोष्ठक हटा दिए गए

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

इसे ऑनलाइन आज़माएं!

— officialaimm
स्रोत

3

अच्छाई अनुग्रह ... संचालन के आदेश का उपयोग करना सीखें! (((ord(x[i])-32)*(ord(y[i])-32))%95)+32=>(ord(x[i])-32)*(ord(y[i])-32)%95+32

— जकार्ही

1

चारकोल , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मैंने वास्तव में कैल्सीलेशन को (32 - ord(q)) * (32 - ord(h))इसलिए लिखा क्योंकि यह लगातार संख्यात्मक शाब्दिकों से बचता है लेकिन मुझे लगता है कि मैं (ord(q) - ord(" ")) * (ord(h) - ord(" "))इसके बजाय बस लिख सकता था।

— नील
स्रोत

1

पर्ल 5 , 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

@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

— Xcali
स्रोत

1

मुझे लगता है कि आप छोटी स्ट्रिंग की लंबाई ( यहां देखें ) के परिणाम को सही ढंग से छोटा नहीं कर रहे हैं ।

— दादा

आप सही हे। कई बाइट्स की कीमत पर इसे तय किया

— Xcali

1

पिप , 19 बाइट्स

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

कमांड-लाइन तर्कों के रूप में तार लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

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

— DLosc
स्रोत

1

कारक , ४५

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

यह एक उद्धरण (लंबोदर) है, callयह स्टैक पर दो तारों के साथ है, स्टैक पर नया स्ट्रिंग छोड़ता है।

एक शब्द के रूप में:

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

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

— फ़ेडर एस।
स्रोत

1

K (oK) , 26 बाइट्स

समाधान:

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

इसे ऑनलाइन आज़माएं!

उदाहरण:

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

स्पष्टीकरण:

मूल्यांकन दाएँ-से-बाएँ किया जाता है:

`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

— streetster
स्रोत

0

PHP, 112 बाइट्स

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

— jstnthms
स्रोत

109 बाइट्स: for($i=0;$i<strlen($a=$argv[1])&&$i<strlen($b=$argv[2]);)echo chr((ord($a[$i])-32)*(ord($b[$i++])-32)%95+32); इसके अलावा, मुझे पूरी तरह से यकीन नहीं है कि पीएचपी के &&साथ &रिप्लेसमेंट भी संभव हो सकता है, इसे एक और बाइट से घटाकर 108 कर दिया जाए ।

— केविन क्रूज़सेन

0

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स

जावास्क्रिप्ट और लंबा कार्य नामों के अभिशाप ...

करी और तथ्य का उपयोग करते हुए charCodeAt रिटर्न NaNजब गलत स्थिति के साथ कहा जाता है। आउटपुट में ट्रेलिंग नल हो सकते हैं।

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

परीक्षा

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

स्निपेट का विस्तार करें

— edc65
स्रोत

तत्व-वार स्ट्रिंग गुणन

यह कैसे काम करता है?

नियम

परीक्षण के मामलों

MATL , 12 बाइट्स

व्याख्या

जेली , 15 12 बाइट्स

पायथन 3 , 80 74 71 बाइट्स

पायथन 2 , 75 70 बाइट्स

हास्केल , 60 57 बाइट्स

सी ++, 331 291 282 270 268 बाइट्स, संस्करण 2 = 178 176 150 148 बाइट्स

Dyalog APL, 36 34 33 25 24 बाइट्स

एफएसएचआरपी 275 बाइट्स

सीजेएम , 23 बाइट्स

सी # (.NET कोर) , 100 96 95 बाइट्स

मैथेमेटिका, 114 बाइट्स

स्टैक किया गया , 52 बाइट्स

व्याख्या

आर , 88 बाइट्स

पर्ल 5 , 65 बाइट्स

डी, 113 बाइट्स

05AB1E , 16 15 बाइट्स

जावा 8, 127 115 97 95 बाइट्स

सी #, 166 बाइट्स

आम लिस्प, 99 बाइट्स

जाप , 24 बाइट्स

पायथन 2 , 95 73 बाइट्स

चारकोल , 30 बाइट्स

पर्ल 5 , 95 बाइट्स

पिप , 19 बाइट्स

व्याख्या

कारक , ४५

K (oK) , 26 बाइट्स

PHP, 112 बाइट्स

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स