“相乘”两个字符串

29

这是受到我最近添加到我的语言Add ++中的功能的启发。因此，我将在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.

这是一个代码高尔夫球，所以最短的代码胜出！ok！

code-golf  string 
— 开斋节
source
35
这是字符串的元素最大值，对吗？这似乎不像乘法。
— xnor
5
Nitpick：PPCG已经毕业，我们只是还没有一个新的设计。
— 丹尼斯，
1
— nmjcman101

Answers:

53

Haskell，11个字节

zipWith max

在线尝试！

没什么可解释的。

— 妮米
source
7
而且我认为数学有奇怪的内置插件
— Xcoder先生
@ Mr.Xcoder Mathematica具有zipWith，它称为MapThread
— michi7x7
2
实际上，@ Mr.Xcoder zipWith并不奇怪。这是一个相当普通的功能原语。将两个列表“压缩”在一起的想法出现了很多问题，一旦这样做，您通常希望将某些功能应用于所得的2元素项，因此使用了“ with”部分。
— 约拿（Jonah）
6

Perl 6，22个字节

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

作为奖励，它接受任意数量的被乘数，而不仅仅是两个。

— 肖恩
source
6

Japt，16字节

ñl g îUy ®¬ñ oÃq

在线测试！将输入作为两个字符串的数组。

缺少最小和最大内置函数伤害了Japt，但仍然设法取得了不错的成绩...

说明

 ñ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
— ETH生产
source
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.

例

令s =混合，t =粗体。

ż产量["bb", "lo", "el", "nd", 'd', 'e', 'd']。最后三个元素是字符。

«是矢量化，二进位最小值，因此产生['b', 'l', 'e', 'd', 'd', 'e', 'd']。

œ-"除去恰好一个发生的Ñ 个第二阵列中的字符从Ñ 个串/字符的第一阵列中，产生["b", "o", "l", "n", "", "", ""]。œ-是多集减法原子，而快速"则使其向量化。

当打印时，它只是读为boln。

— 丹尼斯
source
所以，这是压缩，然后采用某物的多集差异，然后有一些含糊不清的含义的双引号，最后是最小值。很好...请解释一下？：D
— Leo
1
我添加了一个有效的示例。
— 丹尼斯，
6

爱丽丝，8字节

/oI\
@m+

在线尝试！

说明

爱丽丝也有此运算符（我称之为superimpose），但它并不将输出限制为较短字符串的长度（而是附加了较长字符串的其余字符）。但是，它也有一个运算符，可以将两个字符串中的较长者截断为较短者。

/   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.
— 马丁·恩德
source
6

视网膜，28字节

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

在线尝试！

说明

{O^`

该{告诉视网膜在循环中运行整个程序，直到它不能改变工作字符串。O使它成为一个排序阶段，默认情况下对非空行进行排序。该^选项反转结果。因此，实际上，如果两行不是空的，我们将得到相反的排序，将具有较大前导字符的行置于顶部。

G`.

如果有空行，则将其丢弃。

^.*$

如果仅剩一行，则其中一行为空，我们也将另一行删除以停止该过程。

M!\*`^.

这里有很多配置。这会匹配（M）工作字符串（）中的第一个字符^.，返回它（!），不使用尾随换行符（\）进行打印，然后将工作字符串还原为其先前的值（*）。换句话说，我们仅打印工作字符串的第一个字符（这是最大的前导字符），而无需实际更改字符串。

Rm`^.

最后，我们从每一行中删除第一个字符，以便下一次迭代处理下一个字符。

— 马丁·恩德
source
当您评论我的整体答案有多高时，我发现我对这个问题的答案太长了，也许我的翻译效率很低。在查看了您的换位建议的工作原理后，我认为这根本不适合该问题。然后，我想出了一种新方法，该方法为我节省了19个字节...然后向下滚动以发现您已经想出了一个更好的版本……
— Neil
您可以节省3个字节，因为这G`.是不必要的，尽管这确实会输出一条额外的换行符，您可以通过使用^.+¶$或\在答案的开头加上a 来删除该换行符。
— 尼尔
@尼尔哦好点。我还可以使用最新的提交（尚未在TIO上使用，并且可能不会再使用了一段时间），在该位置我进行了打印，而默认的换行没有尾随换行符（然后我也可以删除另一个\）。
— Martin Ender
6

JavaScript（ES6），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]在末尾返回false b。编辑：由于@ETHproductions，节省了2个字节。

— 尼尔
source
在我的手机中，上面的代码无法执行。在PC桌面上，我说的上述示例可以正常运行，但不允许更改功能的输入...为什么不改用Tio？
— RosLuP
@RosLuP当输入很简单时（在这种情况下为2个刺），我更喜欢使用Stack Snippet，它通常使更改输入和输出动态更新变得更加容易。
— 尼尔
5

Mathematica，78个字节

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

Mathematica中已经有另一个答案。此答案将输入作为字符串列表，因此/@可以#代替使用{##}。而且，我们只能Map在对象上使用长函数名，而不是将其分配给变量。（实际上，每个Mathematica内置符号名称在函数中最多使用一次）

— 用户名
source
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个字节，感谢@Jakob。

输入是两个字符数组，并且以结束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
— 凯文·克鲁伊森
source
4

C＃，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
source
1
击败我吧！但是，a=>b=>通过编译为可以节省一个字节Func<string, Func<string, string>>。您可以删除for循环周围的花括号以节省2个字节。
— TheLethalCoder
旁注：C# has implicit char to int conversion是正确的，因为a char在int下面。
— TheLethalCoder
@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'
— 路易斯·门多
source
4

R，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.
— 德朱里奥
source
?？麦克斯是这样吗？TIL
— JAD
1
— 朱塞佩
4

V，28，24，21字节

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

在线尝试！

十六进制转储：

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
source
有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
— 路易斯·门多
source
3

Clojure，31个字节

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

是的，对于函数组合:)返回一个字符序列，而不是字符串，但是它们在Clojure中的工作方式大致相同，除了打印或正则表达式匹配时。

可悲的max是不能与字符一起使用。

— 尼古妮
source
max不起作用，但是起作用max-key。#(map(partial max-key int)% %2)不过，它是完全相同的字节数。
— madstap
哦，很酷，我已经忘记了这一点。比例如简单得多(ffirst (sort-by second ...)。
— NikoNyrh
3

Javascript（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
— 安德烈·沃基
source
欢迎来到PPCG！不错的第一篇文章！
— Rɪᴋᴇʀ
3

视网膜，55 36字节

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

在线尝试！说明：一行前缀以保存结果。当两个字符串都还剩下字符时，将对输入进行排序，并将具有最高代码点的前导字符移到结果中，同时删除另一个前导字符。最后打印结果。

— 尼尔
source
3

外壳，2个字节

z▲

在线尝试！

“非高尔夫” /解释

利用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"
— ბიმო
source
3

Kotlin，50 41 37字节

-9字节，带函数引用语法-4字节，带扩展功能

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

如果s和x在范围内，而不在函数中，则此方法只有16个字节

s.zip(x,::maxOf)

演示版

— 重新产生
source
这是一个try.kotlinlang.org链接：try.kotlinlang.org
— Kirill Rakhman
2

PowerShell，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
source
2

J，25个字节

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

说明

一半字节用于解决以确保两个输入都具有较短的输入长度（如果有人有一个，则希望看到这一部分的改进）：

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

<.&#是两个长度中的最小值，并且{."1,:从2行表的两行中提取了许多字符，这些字符由堆叠在右字符串顶部的左字符串组成。

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

使用Under动词&.将每个字符转换为其ascii索引，取两个数字中的最大值，然后转换回字符。

在线尝试！

— 约拿
source
1
21个字节[:>./&.(3&u:)<.&#$&>;
— 英里
@miles，火车和联结的完美结合-我需要更多地使用该技巧来避免parens。u:对我来说也是TIL。
— 约拿（Jonah）
2

加+，8字节

D,f,@@,^

在线尝试！

在版本0.4到1.11中，^根据参数的类型，指数为两个数字或“相乘”为两个字符串。

— 开斋节
source
这不符合代码高尔夫的精神，在知道您自己的语言（没有其他人使用）具有内置功能的情况下发布一个问题，使其具有垄断性。谢天谢地，果冻的简洁再次赢得了胜利。
— FlipTack
12
@FlipTack您阅读问题的第一行吗？即使这是0个字节，也不会赢。
— caird coinheringaahing
1
@StephenS似乎该功能激发了挑战，而不是反过来。非竞争标签保留用于使用仅在挑战后实施的语言或功能的答案。
— Martin Ender
1

Mathematica，102个字节

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


输入

[“混合”，“粗体”]

— J42161217
source
L@a~Min~L@b保存一个字节
— Greg Martin
1

APL（Dyalog），22字节

将两个（或更多！）字符串作为正确的参数。

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

在线尝试！

{ 一个匿名函数，其中正确的参数由represented表示

 ⎕UCS 从所述符号û nicode Ç haracter 小号等，其对应于

 ⌈⌿ 每列的最大值

 ⎕UCS 从码点ü nicode Ç haracter 小号等为

 ↑ matrified（字符串列表中的矩阵）

 ⍵ 论点

 ↑¨⍨ 每个上限

 ⌊/ 最少的

 ≢¨ 长度

 ⍵ 论据

}

— 亚当
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.