"गुणा" दो तार

29

यह एक समारोह से प्रेरित था जिसे मैंने हाल ही में अपनी भाषा में जोड़ा + ++ । इसलिए मैं Add ++ में एक संक्षिप्त उत्तर प्रस्तुत करूंगा लेकिन अगर यह जीत जाता है तो मैं इसे स्वीकार नहीं करूंगा (यह उचित नहीं होगा)

जब आप संख्याओं को गुणा कर सकते हैं लेकिन तार नहीं, तो क्या आप उससे घृणा नहीं करते हैं? तो आपको उसे सही करना चाहिए, है ना?

आपको एक फ़ंक्शन या पूर्ण प्रोग्राम लिखना है जो इनपुट के रूप में दो गैर-खाली स्ट्रिंग लेता है और उनके गुणक संस्करण को आउटपुट करता है।

आप स्ट्रिंग्स को कैसे गुणा करते हैं? मैं आपको बताउँगा!

दो स्ट्रिंग्स को गुणा करने के लिए, आप दो स्ट्रिंग्स लेते हैं और प्रत्येक वर्ण की तुलना करते हैं। उच्चतम कोड बिंदु वाला वर्ण फिर आउटपुट में जोड़ा जाता है। यदि वे समान हैं, तो बस चरित्र को आउटपुट में जोड़ें।

स्ट्रिंग्स की लंबाई में बराबर होने की गारंटी नहीं है। यदि लंबाई अलग हैं, तो अंतिम स्ट्रिंग की लंबाई सबसे छोटी स्ट्रिंग की लंबाई है। इनपुट हमेशा कम होगा और प्रिंट करने योग्य ASCII रेंज ( 0x20 - 0x7E) में कोई भी अक्षर हो सकता है , अपरकेस अक्षरों को छोड़कर।

आप किसी भी उचित प्रारूप में आउटपुट कर सकते हैं, जैसे कि स्ट्रिंग, सूची आदि समझदार हो, पूर्णांक इस चुनौती में आउटपुट के लिए एक समझदार तरीका नहीं है।

की जानकारी के साथ hello,और world!, इस यह कैसे काम करता है

hello,
world!

w > h so "w" is added ("w")
o > e so "o" is added ("wo")
r > l so "r" is added ("wor")
l = l so "l" is added ("worl")
d < o so "o" is added ("worlo")
! < , so "," is added ("worlo,")

तो के लिए अंतिम उत्पादन hello,और world!होगा worlo,!

अधिक परीक्षण के मामले

(बिना चरणों के)

input1
input2 => output

programming puzzles & code golf!?
not yet graduated, needs a rehaul => prtgyetmirgduuzzlesneedsde rolful

king
object => oing

blended
bold => boln

lab0ur win.
the "super bowl" => the0usuwir.

donald j.
trumfefe! => trumlefj.

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है! Luok!

code-golf  string 
— केर्ड सिक्काहिरिंग
स्रोत
35
यह तत्व के अधिकतम तत्व है, है ना? यह गुणा करने जैसा कुछ भी प्रतीत नहीं होता है।
— xnor
5
नाइटपिक: पीपीसीजी ने स्नातक किया है, हमें अभी नया डिजाइन नहीं मिला है।
— डेनिस
1
संभावित प्रासंगिक: codegolf.stackexchange.com/questions/74809/merging-two-strings/…
— nmjcman101

जवाबों:

53

हास्केल, 11 बाइट्स

zipWith max

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

समझाने के लिए ज्यादा कुछ नहीं।

— nimi
स्रोत
7
और मुझे लगा कि गणितज्ञ ने अजीब निर्माण किया था
— श्री एक्सकोडर
@ Mr.Xcoder Mathematica में zipWith है, इसे MapThread कहा जाता है
— michi7x7
2
@ Mr.Xcoder वास्तव में, zipWithबहुत अजीब नहीं है। यह एक काफी सामान्य कार्यात्मक आदिम है। दो सूचियों को एक साथ "ज़िपिंग" करने का विचार कई समस्याओं में आता है, और एक बार जब आप ऐसा करते हैं, तो आप अक्सर कुछ फ़ंक्शन को परिणामी 2-तत्व आइटम पर लागू करना चाहते हैं, इसलिए "भाग" के साथ।
— जोनाह
8

05AB1E , 4 बाइट्स

øΣà?

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
मुझे लगता है कि ø€àकाम करना चाहिए, लेकिन ऐसा नहीं है।
— मैजिक ऑक्टोपस Urn
एक उत्तर lol की तुलना में अधिक प्रश्न की तरह दिखता है
— स्टेन स्ट्रम
6

पर्ल 6 , 22 बाइट्स

{[~] [Zmax] @_».comb}

एक बोनस के रूप में, यह केवल दो ही नहीं, कई गुणा संख्या को स्वीकार करता है।

— शॉन
स्रोत
6

जाप , 16 बाइट्स

ñl g îUy ®¬ñ oÃq

इसे ऑनलाइन टेस्ट करें! दो तारों के एक सरणी के रूप में इनपुट लेता है।

न्यूनतम और अधिकतम बिल्ट-इन की कमी ने यहाँ जाप को चोट पहुँचाई है, लेकिन यह अभी भी कुछ हद तक सभ्य स्कोर को खींच लेता है ...

व्याख्या

 ñl g îUy ®   ¬ ñ oà q
Uñl g îUy mZ{Zq ñ o} q
                        // Implicit: U = input array     ["object", "king"]
       Uy               // Transpose the strings of U.   ["ok", "bi", "jn", "eg", "c ", "t "]
          mZ{      }    // Map each string Z to
             Zq ñ o     //   the larger of the two chars. (Literally Z.split().sort().pop())
                        //                               ["o", "i", "n", "g", "c", "t"]
                     q  // Join into a single string.    "oingct"
Uñl g                   // Sort the two input strings by length and take the shorter.
      î                 // Trim the previous result to this length.
                        //            "king"î"oingct" -> "oing"
                        // Implicit: output result of last expression
— ETHproductions
स्रोत
6

जेली , 5 बाइट्स

żœ-"«

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

यह काम किस प्रकार करता है

żœ-"«  Main link. Arguemts: s, t (strings)

ż      Zipwith; form all pairs of corresponding characters from s and t.
       If one of the strings is longer than the other, its extra characters are 
       appended to the array of pairs.
    «  Dyadic minimum; get all minima of corresponding characters.
       This yields the characters themselves for unmatched characters.
 œ-"   Zipwith multiset subtraction; remove a single occurrence of the minimum from
       each character pair/singleton.
       This yields the maximum for pairs, but an empty string for singletons.

उदाहरण

चलो = मिश्रित और टी = बोल्ड ।

żपैदावार ["bb", "lo", "el", "nd", 'd', 'e', 'd']। अंतिम तीन तत्व वर्ण हैं।

«वेक्टरिंग, डाइएडिक न्यूनतम है, इसलिए यह पैदावार देता है ['b', 'l', 'e', 'd', 'd', 'e', 'd']।

œ-"पहली सरणी में n वें स्ट्रिंग / वर्ण से दूसरे सरणी में n वें वर्ण की ठीक एक घटना निकालता है , उपज । है मल्टीसेट घटाव परमाणु, और त्वरित बनाता है यह vectorize।["b", "o", "l", "n", "", "", ""]œ-"

मुद्रित होने पर, यह केवल बोलन पढ़ता है ।

— डेनिस
स्रोत
तो, यह ज़िपिंग है, फिर किसी चीज़ का मल्टीसेट अंतर लेना, फिर मिस्टीरियस अर्थ के कुछ अच्छे दोहरे उद्धरण और अंत में न्यूनतम। अच्छा लगा ... स्पष्टीकरण, कृपया? : डी
— सिंह
1
मैंने एक काम किया उदाहरण जोड़ा है।
— डेनिस
6

PHP> = 7.1, 52 बाइट्स

for(;$t=min(~$argv[1][$i],~$argv[2][$i++]);)echo~$t;

PHP सैंडबॉक्स ऑनलाइन

PHP> = 7.1, 69 बाइट्स

for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=max($c,$d);;echo$r;

PHP सैंडबॉक्स ऑनलाइन

PHP> = 7.1, 70 बाइट्स

for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=$c>$d?$c:$d;echo$r;

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत
1
थोड़ा गोल्फ for(;$t=min(~$argv[1][$i],~$argv[2][$i++]);)echo~$t;:।
— user63956
6

ऐलिस , 8 बाइट्स

/oI\
@m+

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

व्याख्या

ऐलिस के पास भी यह ऑपरेटर है (जिसे मैंने सुपरइम्पोज़ कहा था ) लेकिन यह आउटपुट को छोटी स्ट्रिंग की लंबाई तक सीमित नहीं करता है (इसके बजाय, लंबे स्ट्रिंग के शेष वर्णों को जोड़ दिया जाता है)। हालांकि, इसके पास छोटे वाले की लंबाई के लिए दो तारों के लंबे समय तक टुकड़े करने के लिए एक ऑपरेटर भी है।

/   Reflect to SE, switch to Ordinal. The IP bounces diagonally up and down
    through the code.
m   Truncate, doesn't really do anything right now.
I   Read a line of input.
    The IP bounces off the bottom right corner and turns around.
I   Read another line of input.
m   Truncate the longer of the two input lines to the length of the shorter.
+   Superimpose: compute their elementwise maximum. 
o   Output the result.
@   Terminate the program.
— मार्टिन एंडर
स्रोत
6

रेटिना , 28 बाइट्स

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

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

व्याख्या

{O^`

{रेटिना बताता है जब तक यह काम कर रहे स्ट्रिंग को बदलने के लिए विफल रहता है एक पाश में पूरे कार्यक्रम को चलाने के लिए। Oयह एक छँटाई चरण बनाता है जो डिफ़ॉल्ट रूप से गैर-रिक्त लाइनों को सॉर्ट करता है। ^विकल्प परिणाम उलट। इसलिए, यदि हम गैर-रिक्त हैं, तो हम दो पंक्तियों का एक उल्टा प्रकार प्राप्त करते हैं, शीर्ष पर बड़े अग्रणी वर्ण के साथ रेखा डालते हैं।

G`.

यदि कोई हो तो खाली लाइनों को छोड़ दें।

^.*$

यदि केवल एक पंक्ति बची है, तो लाइनों में से एक खाली थी, और हम प्रक्रिया को रोकने के लिए दूसरे को भी हटा देते हैं।

M!\*`^.

यहाँ पर बहुत सारी कॉन्फ़िगरेशन चल रही है। यह मेल ( M) काम करने वाले स्ट्रिंग में पहला चरित्र ( ^.), इसे लौटाता है ( !), इसे एक अनुगामी लाइनफीड के बिना प्रिंट करता है ( \) और फिर काम करने वाले स्ट्रिंग को उसके पिछले मूल्य ( *) में बदल देता है। दूसरे शब्दों में, हम वास्तव में स्ट्रिंग को बदलने के बिना काम करने वाले स्ट्रिंग (जो कि अधिकतम अग्रणी चरित्र है) के पहले चरित्र को प्रिंट करते हैं।

Rm`^.

अंत में, हम प्रत्येक पंक्ति से पहला वर्ण हटाते हैं, ताकि अगला पुनरावृत्ति अगले वर्ण को संसाधित करे।

— मार्टिन एंडर
स्रोत
जब आपने टिप्पणी की कि मोनोलिथ के उत्तर कितने लम्बे हैं, तो मेरे साथ यह हुआ कि इस प्रश्न का मेरा उत्तर बहुत लंबा था, और शायद यह कि मैं अयोग्य रूप से स्थानांतरित कर रहा था। आपका ट्रांसपोज़ेशन सुझाव कैसे काम करता है, यह देखने के बाद मैंने फैसला किया कि यह इस सवाल के लिए उचित नहीं था। मैं फिर एक नया तरीका लेकर आया, जिसने मुझे 19 बाइट्स बचाए ... और फिर नीचे स्क्रॉल करके पाया कि आप पहले से ही एक बेहतर संस्करण के साथ आएंगे ...
— नील
आप G`.अनावश्यक होने के बाद से 3 बाइट्स बचा सकते हैं , हालांकि यह एक अतिरिक्त नईलाइन को आउटपुट करता है जिसे आप उत्तर की शुरुआत में उपयोग करके ^.+¶$या उपसर्ग करके निकाल सकते हैं \।
— नील
@ नील ओह अच्छी बात है। मैं नवीनतम कमिट का भी उपयोग कर सकता था (जो अभी तक TIO पर नहीं है और शायद थोड़ी देर के लिए नहीं होने वाला है) जहां मैंने मुद्रण को बिना लाइन किए हुए डिफ़ॉल्ट रूप से फीडफीड किया है (मैं तब दूसरे को भी छोड़ सकता था \)।
— मार्टिन एंडर
6

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

f=
(a,b)=>a.replace(/./g,(c,i)=>c>b[i]?c:[b[i]])
<div oninput=o.textContent=f(a.value,b.value)><input id=a><input id=b><pre id=o>
स्निपेट का विस्तार करें

आसानी से c>b[i]झूठे अतीत के अंत में लौटता है b। संपादित करें: 2 बाइट्स @ETHproductions की बदौलत सहेजे गए।

— नील
स्रोत
यहाँ मेरे सेलफोन में कि ऊपर कोड निष्पादित नहीं किया जा सकता है। पीसी डेस्कटॉप में उपरोक्त उदाहरण मैं कहता हूं कि ठीक चल सकता है, लेकिन फ़ंक्शन के लिए इनपुट बदलने की अनुमति नहीं है ... इसके बजाय टियो का उपयोग क्यों नहीं किया जाता है?
— रोजलूप
@RosLuP जब इनपुट सरल है (इस मामले में 2 डंक) मैं एक स्टैक स्निपेट का उपयोग करना पसंद करता हूं जो आम तौर पर इनपुट को बदलने में आसान बनाता है और आउटपुट अपडेट गतिशील रूप से भी करता है।
— नील
5

गणितज्ञ, 78 बाइट्स

FromCharacterCode[Max/@Thread[#~Take~Min[Length/@x]&/@(x=ToCharacterCode@#)]]&

पहले से ही गणितज्ञ में एक और जवाब है । यह उत्तर इनपुट को स्ट्रिंग्स की एक सूची के रूप में लेता है, इसलिए /@इसका उपयोग करने के #बजाय किया जा सकता है {##}। और हम केवल Mapचर पर नाम देने के बजाय ऑब्जेक्ट पर लंबे फ़ंक्शन नाम कर सकते हैं । (वास्तव में, प्रत्येक मैथेमेटिका निर्मित प्रतीक नाम का उपयोग फ़ंक्शन में एक बार सबसे अधिक किया जाता है)

— user202729
स्रोत
5

जावा 8, 124 120 117 63 बाइट्स

a->b->{for(int i=0;;i++)System.out.print(a[i]>b[i]?a[i]:b[i]);}

-4 बाइट्स @ Khaled.K को धन्यवाद ।
-3 बाइट्स @ जेकॉब को धन्यवाद ।

इनपुट दो चरित्र-सरणियाँ हैं, और यह एक के साथ बंद हो जाता है ArrayIndexOutOfBoundsException।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->b->{                       // Method with two char-array parameters and no return-type
  for(int i=0;;i++)           //  Loop `i` from 0 up indefinitely (until an error is given)
    System.out.print(         //   Print:
      a[i]>b[i]?a[i]:b[i]);}  //    The character that has the highest unicode value
— केविन क्रूज़सेन
स्रोत
4

सी #, 81 78 बाइट्स

a=>b=>{var s="";try{for(int q=0;;q++)s+=a[q]>b[q]?a[q]:b[q];}catch{}return s;}

C # में रूपांतरण निहित charहै int(क्योंकि charवास्तव में एक कम intहै) जो अच्छा है, और इसके बजाय सबसे छोटी स्ट्रिंग की तलाश में असफलता के लिए प्रयास करें

— LiefdeWen
स्रोत
1
मुझे इससे हराएं! हालांकि, एक a=>b=>को संकलित करके करी के साथ एक बाइट बचाओ Func<string, Func<string, string>>। आप 2 बाइट्स को बचाने के लिए लूप के लिए ब्रेसिज़ को निकाल सकते हैं।
— द लीथलकोडर
साइड नोट: C# has implicit char to int conversionक्योंकि एक सच है charएक है intनीचे।
— TheLethalCoder
@ लॉथलॉकर: बिल्कुल नहीं। sizeof(int) == 4लेकिन sizeof(char) == 2।
— पुनरावर्ती
4

MATL , 8 बाइट्स

otX>cwA)

इनपुट स्ट्रिंग्स का एक सेल ऐरे है, फॉर्मेट में {'abcd' 'efg'}

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

एक तरफ के रूप में, यह दो से अधिक तारों के लिए भी काम करता है ।

व्याख्या

इनपुट पर विचार करें {'blended' 'bold'}। स्टैक को ऊपर की ओर दिखाया गया है, नीचे हाल के तत्वों के साथ।

o    % Implicitly input a cell array of strongs. Convert to numeric
     % vector of code points. This right-pads with zeros if needed
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
tX>  % Duplicate. Maximum of each column
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                [98 111 108 110 100 101 100]
c    % Convert to char
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                'bolnded'
w    % Swap
     %   STACK: 'bolnded'
                [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
A    % All: gives true (shown as 1) for columns containing only nonzeros
     %   STACK: 'bolnded'
                [1 1 1 1 0 0 0]
)    % Use as logical index (mask). Implicitly display
     %   STACK: 'boln'
— लुइस मेंडो
स्रोत
4

आर, 103 बाइट्स

कोड:

n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")

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

> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: programming puzzles & code golf!?
2: not yet graduated, needs a rehaul
3: 
Read 2 items
prtgretmirgduuzzlesneedsde rolful
> x <- scan(,"",sep=NULL)
1: asd asd 
3: 
Read 2 items
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: king
2: object
3: 
Read 2 items
oing
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: lab0ur win.
2: the "super bowl"
3: 
Read 2 items
the0usuwir.
— djhurio
स्रोत
है ना? मैक्स की तरह काम करता है? TIL
— JAD
1
— ग्यूसेप
4

वी , 28, 24 , 21 बाइट्स

Í./&ò
dd{JdêHPÎúúx
Íî

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

Hexdump:

00000000: cd2e 2f26 f20a 6464 7b4a 64ea 4850 cefa  ../&..dd{Jd.HP..
00000010: fa78 0acd ee                             .x...

तीन बाइट्स @ nmjcman101 की बदौलत बच गईं!

स्पष्टीकरण:

Í             " Globally substitute:
 .            "   Any character
  /           " With:
   &          "   That character
    ò         "   And a newline
dd            " Delete this line
  {           " Move to the first empty line
   J          " Delete this line
    dê        " Columnwise delete the second word
      HP      " Move to the first line, and paste the column we just deleted
        Î     " On every line:
         úú   "   Sort the line by ASCII value
           x  "   And delete the first character
Í             " Remove all:
 î            "   Newlines
— DJMcMayhem
स्रोत
है dGआवश्यक? वैसे भी सभी नए रास्ते से नहीं हटते हैं Íî?
— nmjcman101
@ nmjcman101 स्ट्रिंग्स की लंबाई अलग होने की स्थिति में इसकी आवश्यकता है।
— DJMcMayhem
3

CJam , 12 बाइट्स

q~z{1/~e>o}%

इनपुट दो तारों की एक सूची है। यदि दो तारों की लंबाई अलग है, तो प्रोग्राम एक त्रुटि (सही आउटपुट उत्पन्न करने के बाद) से बाहर निकलता है।

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

व्याख्या

q~              e# Read input and evaluate
  z             e# Zip: list of strings of length 2, or 1 if one string is shorter
   {      }%    e# Map this block over list
    1/          e# Split the string into array of (1 or 2) chars
      ~         e# Dump the chars onto the stack
       e>       e# Maximum of two chars. Error if there is only one char
         o      e# Output immediately, in case the program will error
— लुइस मेंडो
स्रोत
3

क्लोजर, 31 बाइट्स

#(map(comp last sort list)% %2)

समारोह रचना के लिए याय :) एक स्ट्रिंग के बजाय वर्णों का क्रम लौटाता है, लेकिन वे मुद्रण या रेगेक्स मिलान के अलावा क्लोजर में ज्यादातर उसी तरह काम करते हैं।

अफसोस की बात maxहै कि पात्रों के साथ काम नहीं करता है।

— NikoNyrh
स्रोत
maxकाम नहीं करता है, लेकिन max-keyकरता है। #(map(partial max-key int)% %2)यह ठीक उसी बाइट की गिनती है, हालांकि।
— madstap
ओह शांत, मैं उस के बारे में भूल गया था। उदाहरण के लिए बहुत सरल (ffirst (sort-by second ...)।
— निकोनिरह
3

जावास्क्रिप्ट (ES2015), 66 63 49 बाइट्स

a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]||'').join``

स्पष्टीकरण:

a=>b=>                       // Function with two string parameters
  [...a]                     // Split a into array of characters
    .map((c, i) =>           // Iterate over array
      c>b[i] ? c : b[i]||'') //   Use the character with the larger unicode value until the end of the larger string
    .join``                  // Join the array into a string

पिछला संस्करण:

//ES2015
a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join``    //63
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join`` //66
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,Math.min(a.length,b.length)).join``   //85
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[i]>b[i]?a[i]:b[i];return c}  //86
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i];return c}   //105
a=>b=>a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]).slice(0,Math.min(a.length,b.length)).join``  //106

//With array comprehensions
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,b.length).join``                             //79
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``          //98
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join``   //105
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join`` //107
a=>b=>[for(i of a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``        //119
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join``   //124
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join`` //127
— andrewarchi
स्रोत
PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!
— R
3

रेटिना , 55 36 बाइट्स

^
¶
{O`¶.*
}`¶.(.*)¶(.)
$2¶$1¶
1!`.*

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: परिणाम धारण करने के लिए एक रेखा उपसर्ग है। हालांकि दोनों तारों में अभी भी अक्षर बाकी हैं, इनपुट्स को छांटा गया है और उच्चतम कोड बिंदु वाले प्रमुख चरित्र को परिणाम में ले जाया गया है जबकि अन्य प्रमुख वर्ण हटा दिए गए हैं। अंत में रिजल्ट छपा।

— नील
स्रोत
3

भूसी , 2 बाइट्स

z▲

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

"Ungolfed" / समझाया

zip fउस सूची का उपयोग छोटी सूची को काटता है जैसे कि हमेशा दो तर्क होते हैं f, जैसे zip f [1,2] [3,4,5] == zip f [1,2] [3,4] == [f 1 3, f 2 4]:

z   -- zip the implicit lists A,B with  - e.g. "ab" "bcd" (lists of characters)
 ▲  -- maximum                          -      [max 'a' 'b', max 'b' 'c']
    -- implicitly print the result      -      "bc"
— ბიმო
स्रोत
3

कोटलिन, 50 41 37 बाइट्स

-9 बाइट्स फ़ंक्शन संदर्भ सिंटैक्स -4 के साथ बाइट्स एक्सटेंशन फ़ंक्शन के साथ

fun String.x(o:String)=zip(o,::maxOf)

यदि s, और x कार्यक्षेत्र में हैं, और फ़ंक्शन में नहीं हैं, तो यह विधि केवल 16 बाइट्स है

s.zip(x,::maxOf)

डेमो

— Redrield
स्रोत
यहाँ एक try.kotlinlang.org लिंक दिया गया है: try.kotlinlang.org/#/UserProjects/ulm4nriigeio44jq1sdqer9sg2/…
— Kirill Rakhman
2

पॉवरशेल, 75 बाइट्स

-join(1..(($a,$b=$args)|sort l*)[0].length|%{(,$a[$_-1],$b[$_-1]|sort)[1]})
#            ^input array unpack
#       ^string index generation offset by 1
#                         ^sort by length property, so output length matches shorter input
#                                           ^loop over indices
#                                       max of the two characters^
# ^output join

.Ps1 फ़ाइल के रूप में सहेजें और चलाएँ

PS C:\> .\Get-MultipliedString.ps1 'hello,' 'world!'
worlo,

इससे पहले, 78 बाइट्स:

$i=0;-join$(while(($a=$args[0][$i])-and($b=$args[1][$i++])){($a,$b)[$b-gt$a]})
— TessellatingHeckler
स्रोत
2

जे, 25 बाइट्स

>./&.(a.&i.)@(<.&#{."1,:)

व्याख्या

आधे बाइट्स यह सुनिश्चित करने के लिए हल करते हैं कि दोनों इनपुट्स की लंबाई कम है (यदि किसी के पास एक है, तो इस हिस्से में सुधार देखना पसंद करेंगे):

(<.&#{."1,:)

<.&#दो लंबाई की न्यूनतम है, और {."1,:दाईं ओर शीर्ष पर खड़ी बाईं स्ट्रिंग से मिलकर 2-पंक्ति तालिका की दोनों पंक्तियों से कई वर्णों को लेता है।

>./&.(a.&i.)

&.प्रत्येक वर्ण को उसकी एससीआई इंडेक्स में बदलने के लिए अंडर वर्ब का उपयोग करें , अधिकतम दो संख्याएं लें, और फिर वापस वर्णों में परिवर्तित करें।

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

— जोनाह
स्रोत
1
21 बाइट्स[:>./&.(3&u:)<.&#$&>;
— मील
@ मीलों, ट्रेन और संयोजन का सुरुचिपूर्ण संयोजन - मुझे परगनों से बचने के लिए उस चाल का अधिक उपयोग करने की आवश्यकता है। u:मेरे लिए एक TIL भी था।
— जोनाह
2

जावा 8 + ग्रहण संग्रह, 70 64 बाइट्स

a->b->a.zip(b).collect(p->(char)Math.max(p.getOne(),p.getTwo()))

aऔर bदोनों MutableList<Character>ग्रहण संग्रह से हैं।

— नाथन मेरिल
स्रोत
2

++ , 8 बाइट्स जोड़ें

D,f,@@,^

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

1.11 के माध्यम से संस्करण 0.4 में, ^दो प्रकारों की व्याख्या करता है या दो प्रकार के "गुणक" को तर्क के प्रकार पर निर्भर करता है।

— केर्ड सिक्काहिरिंग
स्रोत
यह कोड-गोल्फ की भावना के खिलाफ है, यह जानने के लिए कि आपकी अपनी भाषा (जो कोई और उपयोग नहीं करता है) में एक अंतर्निहित पोस्ट है जिसमें एक अंतर्निहित है जो इसे एकाधिकार देता है। शुक्र है कि जेली की सहमति फिर से जीत गई।
— FlipTack
12
@FlipTack क्या आपने प्रश्न की पहली पंक्ति पढ़ी है? यहां तक ​​कि अगर यह 0 बाइट्स था, तो यह जीत नहीं होगी।
— केयर्ड सिक्काहिंगाहिंग
1
@StephenS ऐसा लगता है कि इस सुविधा ने चुनौती को प्रेरित किया, अन्य तरीके से नहीं। गैर-प्रतिस्पर्धी लेबल उन उत्तरों के लिए आरक्षित है जो उन भाषाओं या विशेषताओं का उपयोग करते हैं जिन्हें केवल चुनौती के बाद लागू किया गया था।
— मार्टिन एंडर
1

गणितज्ञ, 102 बाइट्स

T=ToCharacterCode;L=Length;(a=T@#;b=T@#2;FromCharacterCode@Table[Max[a[[i]],b[[i]]],{i,L@a~Min~L@b}])&


इनपुट

["मिश्रित", "बोल्ड"]

— J42161217
स्रोत
L@a~Min~L@bएक बाइट बचाता है
— ग्रेग मार्टिन
1

एपीएल (डायलॉग) , 22 बाइट्स

सही तर्क के रूप में दो (या अधिक!) तार लेता है।

{⎕UCS⌈⌿⎕UCS↑⍵↑¨⍨⌊/≢¨⍵}

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

{ एक अनाम फ़ंक्शन जहां सही तर्क का प्रतिनिधित्व right द्वारा किया जाता है

 ⎕UCSयू निकोड सी हैचर एस एट  के प्रतीक जो इसके अनुरूप हैं

 ⌈⌿ के प्रत्येक कॉलम में अधिकतम मूल्य

 ⎕UCSयू निकोड सी हैचर एस एट  से कोड अंक

 ↑ मैट्रिफ़ाइड (स्ट्रिंग्स की सूची से मैट्रिक्स)

 ⍵ बहस

 ↑¨⍨ प्रत्येक पर छाया हुआ

 ⌊/ न्यूनतम

 ≢¨ लंबाई

 ⍵ तर्कों की

}

— एडम
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.