获胜者：Chilemagic，巨大的21个字节！

您可以继续提交答案，但是您将无法再获胜。原帖保留：

您的目标是查找字符串中的所有数字，并将每个数字分别乘以用户输入的值

• 您无需担心小数
• 用户将输入数字和字符串
• 用户必须在某个时候键入数字和字符串，但是程序读取它的方法并不重要。它可以与stdin一起使用，读取文本文件等，但是用户必须在某个时候按键盘上的9按钮（例如）
• 任何可以编译和运行的东西都是可以接受的

例：

句子输入：这是22a 3352句子50

数字输入：3

输出：这3是66a 10056句子150

• 该竞赛将于2014年9月6日（发布后7天）结束。
• 这是一个代码高尔夫球，因此最短的代码获胜

更新-Perl-17

s/\d+/$&*$^I/ge

15个字符+ 2个for -i和-pflags。

我们可以使用该-i标志来输入文件扩展名，但是由于我们不读取任何文件，因此可以使用它来获取数字，并且该变量$^I将被分配给它。

运行：

perl -e'print"This 1 is22a 3352sentence 50"' | perl -i3 -pe's/\d+/$&*$^I/ge'

Perl-21

根据@Dennis的评论进行了更新。

$n=<>;s/\d+/$&*$n/ge

带-p标志运行。

示例运行：

perl -e'print"This 1 is22a 3352sentence 50\n3"' | perl -pe'$n=<>;s/\d+/$&*$n/ge'

说明：

$n=<>; 读入号码

-p 打印输出

s/\d+/$&*$n/ge用<>读取输入，然后搜索一个或多个数字，并用数字乘以数字来替换它们。g是全局的，e是evals ///的替换药水。$&包含匹配的内容，然后乘以数字$n。

你可以阅读更多有关s///在perlop得到更多有关Perl的正则表达式中perlre。

另一个解决方案：

@ F.Hauri指出，您还可以使用s 开关将$n变量分配给4。我不确定这算作多少个字符，但我将其保留在此处：

perl -spe 's/\d+/$&*$n/ge' -- -n=4 <<<'This 1 is22a 3352sentence 50'

JavaScript（ES6）-48 44个字符

感谢@bebe保存一个字符。更新：16年3月8日，删除了另外四个字符

b=(p=prompt)();p(p().replace(/\d+/g,y=>y*b))

Ungolfed：

var sentence = prompt(),
    num = parseInt(prompt(), 10); // base 10

sentence = sentence.replace(/\d+/g, digit => digit * num);

alert(sentence);

43个字符：

(p=prompt)(p(b=p()).replace(/\d+/g,y=>y*b))

b=(p=prompt)();p(p().replace(/\d+/g,y=>y*b))

需要先输入数字，然后输入句子。在这里再剪一个字符，再次感谢@bebe！

的Python 2（79）

import re
n=input()
s=input()
print re.sub('\d+',lambda x:`int(x.group())*n`,s)

样品运行

$ python mult.py
3
"This 1 is22a 3352sentence 50"

This 3 is66a 10056sentence 150

在线演示：http：//ideone.com/V6jpyQ

Python 2-126

import re
n=input()
s=input()
for i in list(re.finditer('\d+',s))[::-1]:s=s[:i.start()]+`int(i.group())*n`+s[i.end():]
print s

第一个输入：integer n。

第二个输入：字符串s（带引号，例如"abc42"）。

CJam，47 33 30字节

q_A,sNerN%\[_A,s-Ner~](f*]zs1>

从STDIN读取数字和字符串（以该顺序并以单个空格分隔）。

在线尝试。

运行示例

$ cjam multiply.cjam <<< '7 N0 R3GUL4R 3XPR35510N5 1N CJ4M M4K3 M3 4 54D P4ND4'
N0 R21GUL28R 21XPR248570N35 7N CJ28M M28K21 M21 28 378D P28ND28

怎么运行的

q                                 " Read from STDIN (“Q”) and push a second copy.         ";
  A,s                             " Push “0123456789” (thanks, @aditsu).                  ";
 _   NerN%                        " Replace digits with linefeeds and split at linefeeds. ";
          \ _A,s-Ner              " Replace non-digits with linefeeds.                    ";
                    ~             " Evaluate the resulting string.                        ";
           [         ]            " Collect the results in an array.                      ";
                      (f*         " Multiply all other integers by the first.             ";
                         ]z       " Interleave the elements of both arrays.               ";
                           s1>    " Flatten the result and discard the leading space.     ";

Bash + coreutils，38个字节

eval echo `sed "s/[0-9]\+/$\[$1*&]/g"`

从STDIN和乘数中读取输入字符串作为命令行参数。

输出：

$ ./multstr.sh 3 <<< "This 1 is22a 3352sentence 50"
This 3 is66a 10056sentence 150
$ 

LINQPad中的C＃，124

直截了当。请在LINQPad中使用CTRL + 2（语言：C＃语句）。

var s=Console.ReadLine();var k=int.Parse(Console.ReadLine());new Regex("\\d+").Replace(s,t=>""+int.Parse(t.Value)*k).Dump();

如果乘数是第一个输入参数，则可以用116个字符完成：

var k=int.Parse(Console.ReadLine());new Regex("\\d+").Replace(Console.ReadLine(),t=>""+int.Parse(t.Value)*k).Dump();

编辑：

感谢下面的阿巴斯的评论，这甚至可以通过使用Regex静态方法进行更多研究，而不是实例化它：

var k=int.Parse(Console.ReadLine());Regex.Replace(Console.ReadLine(),"\\d+",t=>""+int‌​.Parse(t.Value)*k).Dump();

眼镜蛇-171

use System.Text.RegularExpressions
class P
    def main
        a=int.parse(Console.readLine?'')
        print Regex.replace(Console.readLine,'\d+',do(m as Match)="[int.parse('[m]')*a]")

Python 3-141

我认为我不能再打高尔夫球了...

import re
n=input()
f=input()
o=''
p=0
for i in re.finditer('\d+',f):o+=f[p:i.start()]+str(int(i.group())*int(n));p=i.end()
o+=f[p:]
print(o)

例：

3     # This is input
h3110 # This is input
h9330 # This is output

10
hello100 hello100
hello1000 hello1000

Mathematica 71 61

感谢Martin Buttner，节省了10个字符。

代码中的空格用于可读性。

f是一个函数，其中s是输入字符串，并且n是将发现的字符串数字乘以的数字。

 StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &

例子

 s="This 1 is22a 3352sentence 50"

整数

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, 3}

“这3是66a 10056句150”

有理数

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, -7.13}

“此-7.13是-156.86a -23899.8句子-356.5”

复数

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, -5 + 3 I}

“此-5 + 3 I是-110 + 66 Ia -16760 + 10056 Isentence -250 + 150 I”

红宝石40

a,b=$*
p a.gsub(/\d+/){|s|s.to_i*b.to_i}

来自stdin的输入。

示例运行：

$ ruby mult.rb "This 1 is22a 3352sentence 50" 3 
"This 3 is66a 10056sentence 150"

在线演示：http : //ideone.com/4BiHC8

Lua：73 69个字符

r=io.read
s=r()n=r()s=s:gsub("%d+",function(m)return m*n end)print(s)

样品运行：

bash-4.3$ lua -e 'r=io.read;s=r()n=r()s=s:gsub("%d+",function(m)return m*n end)print(s)' <<< $'This 1 is22a 3352sentence 50\n3'
This 3 is66a 10056sentence 150

JavaScript，ES6、43个字符

这是我第一次打高尔夫球！

(p=prompt)(p(n=p()).replace(/\d+/g,y=>y*n))

在最新的Firefox控制台中运行此程序。第一个输入是数字，第二个输入是将数字与第一个输入数字相乘的字符串。

最后的提示列出了输出。

Perl-48个字符

$n=<>;print/\d/?$_*$n:$_ for(<>=~/(\d+)|(\D+)/g)

阅读第一行中的数字，然后阅读一个句子并将其分解为数字或非数字的大块。按原样打印非数字，然后数字相乘。

J-63字符

程序先读数字，然后读句子。

;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1

爆炸解释：

;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
                                                         1!:1]1  NB. read sentence
                                         e.&'0123456789'         NB. is digit? bool vector
                                      i=.                        NB. save to i
                                 2  /\                           NB. between adjacent chars:
                                  ~:                             NB.  true if not equal
                               1,                                NB. pad to sentence length
 (                         ;.1~                         )        NB. cut the sentence
                ^:(0{i)                                          NB. if cut is digits:
  *&.".                                                          NB.  multiply as number
       &(1!:1]1)                                                 NB.  with user input
;                                                                NB. rejoin sentence

如果我们使用J的PCRE库并使句子排在最前面，我们可以将其缩减为54个字符：

;_2(,*&.".&(1!:1]1)&.>)/\'\d+'(rxmatches rxcut])1!:1]1

爆炸解释：

                                                1!:1]1  NB. read in sentence
                         '\d+'(rxmatches       )        NB. all /\d+/ matches
                              (          rxcut])        NB. cut by those matches
 _2                     \                               NB. on each nonmatch-match pair:
   (               &.>)/                                NB.  take the match
     *&.".                                              NB.  multiply as number
          &(1!:1]1)                                     NB.  by user input
   (,                 )                                 NB.  prepend nonmatch
;                                                       NB. rejoin sentence

J很不好意思，我能说什么。这很不方便，因为J是如此不可或缺。

一些例子：

   ;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
3
This 1 is22a 3352sentence 50
This 3 is66a 10056sentence 150
   ;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
100
N0 R3GUL4R 3XPR35510N5 1N J M4K35 M3 54D ALS0
N0 R300GUL400R 300XPR3551000N500 100N J M400K3500 M300 5400D ALS0
   0!:0 <'system\main\regex.ijs'  NB. this is usually preloaded by J on startup anyway
   ;_2(,*&.".&(1!:1]1)&.>)/\'\d+'(rxmatches rxcut])1!:1]1
TH4T'5 M4RG1N411Y B3TT3R
0
TH0T'0 M0RG0N0Y B0TT0R

果酱-35

li:X;lN+{_sA,s-,{])\_!!{iX*}*oo}*}/

在http://cjam.aditsu.net/上尝试

输入样例：

7
CJ4M W1LL H4V3 R3GUL4R 3XPR35510N5 L4T3R

样本输出：

CJ28M W7LL H28V21 R21GUL28R 21XPR248570N35 L28T21R

说明：

程序遍历每个字符，收集堆栈中的数字，对于每个非数字，它首先打印所收集的数字（如果有）乘以数字输入，然后打印该字符。

li:X;读取数字输入并将其存储在X中，
lN+读取字符串并为字符串
{…}/中的每个字符添加换行符（有助于尾随数字）
- _s复制字符并转换为字符串
- A,s-,删除所有数字并计算剩余字符；其结果将是0，如果该字符是一个数字或如果不是1
- {…}*执行，如果计数为1（即，非数字）的块; 对于数字，它什么也不做，因此它们保留在堆栈上
- ]从堆栈中收集字符到数组（即字符串）中；字符是先前迭代中的任何数字，再加上当前字符
- )\分隔最后一项（当前字符）并将其移至（剩余）字符串之前
- _!!复制字符串并将其转换为一个布尔值- 0如果为空，1如果不是
- {…}*执行如果字符串不为空块，即我们已经在当前的非数字字符之前的一些数字
--- iX*将字符串转换通过X整数乘法和
- o打印堆栈的顶部-或者，如果我们没有一个数量的倍增号或空字符串
- o（注：第二个）打印堆栈顶新-当前非数字字符

哈斯克尔（161）

打高尔夫球

main=do{n<-getLine;l<-getContents;let{g c(t,s)|c>'/'&&c<':'=(c:t,s)|t/=""=([],c:(show.(*(read n)).read$t)++s)|True=(t,c:s)};putStr.tail.snd.foldr g("","")$' ':l}

不打高尔夫球

modify :: (Show a, Read a) => (a -> a) -> String -> String
modify f = show . f . read

main=do
  number <- fmap read $ getLine    -- get number  
  l <- getContents                 -- get input

  -- if the current character is a digit, add it to the digits
  -- if the current character isn't a digit, and we have collected
  --    some digits, modify them and add them to the string
  -- otherwise add the current characters to the string

  let go current (digits , string) 
        | current `elem` ['0'..'9'] = (current : digits, string)
        | not (null digits)         = ([], current:(modify (*number) digits) ++ string)
        | otherwise                 = (digits, current:string)

  -- since the result of `go` is a pair, take the second value,
  -- remove the head (it's a space, in order to convert digits at the start)
  -- and print it
  putStr . tail . snd . foldr go ("","")$' ':l

不幸的是，Haskell的Prelude中没有Regex库。

flex（-lexer）（94 89个字符）

 int m;main(c,v)char**v;{m=atoi(*++v);yylex();}
%%
[0-9]+ {printf("%d",m*atoi(yytext));}

取消命令行版本，如果您忘记了命令行参数，该版本就不会出错（不再长）：

%{
#define YY_DECL int y(int m)
%}
%option noyywrap noinput nounput
%%
[0-9]+ {printf("%d",m*atoi(yytext));}
%%
int main(int argc, char** argv) {
  return (argc > 1) ? y(atoi(argv[1])) : 1;
}

编译：

flex -o m.c m.l
cc -o m m.c -lfl

要么：

flex --noyywrap -o m.c m.l
cc -o m m.c

例如：

$ ./m 163
This 1 is22a 3352sentence 50
This 163 is3586a 546376sentence 8150

Groovy -124

Scanner s=new Scanner(System.in)
def x=s.nextLine()
def n=s.nextInt()
x=x.replaceAll(/\d+/,{it->it.toInteger()*n})
println x

单击标题以查看可运行的示例

示例已尝试：

这1是22a 3352句子50
3
这3是66a 10056句子150

这1是22a 3352句子50
42
这42是924a 140784句子2100

GNU Awk：86个字符

s{n=split(s RS,a,/[^0-9]+/,d);while(++i<n)printf"%s%s",a[i]==""?"":a[i]*$1,d[i]}{s=$0}

样品运行：

bash-4.3$ awk 's{n=split(s RS,a,/[^0-9]+/,d);while(++i<n)printf"%s%s",a[i]==""?"":a[i]*$1,d[i]}{s=$0}' <<< $'This 1 is22a 3352sentence 50\n3'
This 3 is66a 10056sentence 150

PHP- 75/ 115 68/109

有两个版本，较新的php版本可以做到这一点：

echo preg_replace_callback("/\d+/",function($m){return$m[0]*$f;},$s);

较旧的php版本：我没有计算换行符，而是增加了可读性。

function a($s){echo preg_replace_callback("/\d+/",b,$s);}
function b($i){global$f;return$i[0]*$f;}
a($s,$f);

输入+输出示例

$s = "ab11cd22"; // string
$f =  3; // -> output: ab36cd69
$f = -2; // -> output: ab-24cd-46

有点困难，单词“ function”和“ preg_replace_callback”占用很多字符。如果后跟$ ar（-2个字符），则需要
空格global和returnarent

C（142134个字符）

main(a,b)char**b;{char*c=b++[2],*d="0123456789";for(;*c;c+=strspn(c
,d))write(1,c,a=strcspn(c,d)),dprintf(1,"%d",atoi(*b)*atoi(c+=a));}

插入换行符以提高可读性。将因子作为第一个传递，将字符串作为第二个命令行选项。此实现需要dprintfPOSIX.1 2008的一部分功能，而该功能可能在Windows上不可用。这是未缩小的来源：

/*
 * Multiply all numbers in a string by a number.
 * http://codegolf.stackexchange.com/q/37110/134
 * Solution by user FUZxxl
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

extern int
main(int count, char **argv)
{
    char *str = argv++[2], *digits = "0123456789";

    while (*str) {          /* as long as we have not reached the end */
        count = strcspn(str, digits);
        write(1, str, count);

        dprintf(1, "%d", atoi(*argv) * atoi(str += count));
        str += strspn(str, digits);
    }
}

改进之处

• 142→134：使用strspn和strcspn而不是遍历字符串。

Python 89

import re,sys
j,n,s=sys.argv
print re.sub('(\d+)',lambda m:str(int(m.group())*int(n)),s)

例如：

# python numberstring.py 3 '1shoop da2 w007p!'
3shoop da6 w21p!

Rebol-117

n: do input d: charset"0123456789"parse s: input[any[b: some d e:(e: insert b n * do take/part b e):e | skip]]print s

取消高尔夫：

n: do input 
d: charset "0123456789"

parse s: input [
    any [
        b: some d e: (e: insert b n * do take/part b e) :e
        | skip
    ]
]

print s

Clojure- 141140128 个字符

我是Clojure的新手，但FWIW：

(let[[a b]*command-line-args*](println ((fn[s n](clojure.string/replace s #"\d+"#(str(*(read-string %)(read-string n)))))a b)))

样品运行：

bash$ java -jar clojure-1.6.0.jar multstr.clj "This 1 is22a 3352sentence 50" 3  
This 3 is66a 10056sentence 150

松散（丑陋，但希望更容易阅读）：

(let [[a b] *command-line-args*]
    (println ( (fn [s n] 
                    (clojure.string/replace 
                        s 
                        #"\d+" 
                        #(str (* (read-string %) (read-string n)))))
                    a b)))

蟒蛇-142

import re
s=raw_input()
i=int(raw_input())
print ''.join([x[0]+str(int(x[1])*i) for x in filter(None,re.findall('(\D*)(\d*)',s)) if x[0]!=''])

Java 218

有人不得不做java。输入的字符串是命令行上的2个标记。

java M'This 1 is22a 3352sentence 50'3

public class M{
    public static void main(String[]a) {
        int m=new Integer(a[1]),n=0,b=0;
        String s="";
        for(char c:a[0].toCharArray()){
            if(c<48|c>57)s=b>(b=0)?s+m*n+c:s+c;
            else n=b*n+c-38-(b=10);
        }
        System.out.println(b>0?s+m*n:s);
    }
}

答案二：perl + bash

纯重击（〜262）

首先，有一个不太短的 纯 bash版本（没有fork，没有外部二进制文件）！

mn () { 
    if [[ $1 =~ ^(.*[^0-9]|)([0-9]+)([^0-9].*|)$ ]]; then
        local num=${BASH_REMATCH[2]} rhs="${BASH_REMATCH[3]}";
        mn "${BASH_REMATCH[1]}" ${2:-3} l;
        echo -n "$[num*${2:-3}]$rhs";
    else
        echo -n "$1";
    fi;
    [ "$3" ] || echo
}

让我们展示一下：

mn "This 1 is22a 3352sentence 50" 42
This 42 is924a 140784sentence 2100

（这是一个完全不可能的句子）

Perl有点模糊（仅用于娱乐）

这个版本（基于@Chilemagic的答案）并不短，但被设计为图腾脚本：

cat <<eof >mn.pl

#!/usr/bin/perl          -sp
                      eval eval'"'
                      .('['^'(')
           .'/\\'.'\\'.('`'|'$').'+'.'/\\$\&'
                        .'*\\$'
                      .('`'|'.').'/'
                      .('`'|"'")
                      .('`'|'%').'"'

eof chmod +x mn.pl

样品运行：

./mn.pl -n=2 <<<$'This 1 is22a 3352sentence 50\n21.'
This 2 is44a 6704sentence 100
42.

哈斯克尔，70岁

太糟糕了，我太迟了恕我直言，这对于这个特定的问题和语言来说是相当不错的。Haskell的另一个解决方案是161个字符。

[]%n=""
s%n=f s(reads s)n
f _((a,b):_)n=show(a*n)++b%n
f(x:s)_ n=x:s%n

这通过使用reads部分解析字符串的函数来实现。例如，reads "34abc" = [(34, "abc")]。这显然使其非常适合此挑战。

用法：

*Main> " This 1 is22a 3352sentence 50"%3
" This3 is66a10056sentence150"