Vincitore: Chilemagic , un enorme 21 byte!

Puoi continuare a inviare la tua risposta, tuttavia non puoi più vincere. Posta originale conservata:

Il tuo obiettivo è trovare tutti i numeri in una stringa e moltiplicarli singolarmente per un valore immesso dall'utente

• Non dovrai preoccuparti dei decimali
• L'utente inserirà un numero e una stringa
• L'utente deve digitare il numero e la stringa ad un certo punto, tuttavia il metodo che il programma legge non ha importanza. Può essere con stdin, leggere un file di testo, ecc. Tuttavia l'utente deve premere il pulsante 9 sulla tastiera (ad esempio) ad un certo punto
• Tutto ciò che può essere compilato ed eseguito è accettabile

Esempio:

Inserimento frase: 1 is22a 3352sentence 50

Numero immesso: 3

Uscita: 3 is66a 10056sentence 150

• Questo concorso termina il 6 settembre 2014 (7 giorni dalla pubblicazione).
• Questo è un codice-golf , quindi vince il codice più corto

Aggiornamento - Perl - 17

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

15 caratteri + 2 per -ie -pbandiere.

Possiamo usare il -iflag per inserire un'estensione di file, ma poiché non stiamo leggendo alcun file, possiamo usarlo per ottenere il numero e la variabile gli $^Iverrà assegnata.

Corri con:

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

Perl - 21

Aggiornato secondo il commento di @ Dennis.

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

Corri con la -pbandiera.

Esempio di esecuzione:

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

Spiegazione:

$n=<>; leggi il numero

-p stampa l'output

s/\d+/$&*$n/geLeggere l'input con <> e cercare una o più cifre e sostituirle con le cifre per il numero. gè globale, eè evalla pozione sostitutiva della s ///. $&contiene ciò che è stato abbinato e moltiplicato per il numero $n,.

Puoi leggere di più su s///in perlop e di più sulle regex di Perl in perlre .

Un'altra soluzione:

@ F.Hauri ha sottolineato che puoi anche utilizzare l' s interruttore per assegnare la $nvariabile a 4. Non sono sicuro di quanti caratteri contino, ma lo lascerò qui:

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

JavaScript (ES6) - 48 44 caratteri

Grazie a @bebe per aver salvato un personaggio. Aggiornamento: 8 / Mar / 16, rimosso altri quattro caratteri

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

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

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

Richiede prima l'immissione del numero e poi la frase. Taglia un altro carattere qui grazie @bebe di nuovo!

Python 2 (79)

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

Esecuzione del campione

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

This 3 is66a 10056sentence 150

Demo online: 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

Primo input: intero n.

Secondo input: stringa s(con virgolette, ad es "abc42".).

CJam, 47 33 30 byte

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

Legge il numero e la stringa (in quell'ordine e separati da un singolo spazio) da STDIN.

Provalo online.

Esempio di esecuzione

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

Come funziona

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 byte

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

Legge la stringa di input da STDIN e dal moltiplicatore come parametro della riga di comando.

Produzione:

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

C # in LINQPad, 124

Semplice. Utilizzare CTRL + 2 in LINQPad (lingua: istruzioni C #).

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

Se il moltiplicatore viene fornito come primo parametro di input, può essere eseguito in 116 caratteri:

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

MODIFICARE:

Grazie al commento di Abbas di seguito, questo può anche essere golfato di più utilizzando il metodo statico Regex , anziché istanziarlo:

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

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

Non credo di poter più giocare a golf ...

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)

Esempio:

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

10
hello100 hello100
hello1000 hello1000

Mathematica 71 61

Con 10 caratteri salvati grazie a Martin Buttner.

Gli spazi nel codice sono per leggibilità.

fè una funzione in cui sè la stringa di input ed nè il numero per cui moltiplicare i numeri di stringa rilevati.

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

Esempi

 s="This 1 is22a 3352sentence 50"

Numero intero

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

"Questo 3 is66a 10056sentence 150"

Numero razionale

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

"Questo -7,13 è-156,86a -23899,8sentence -356,5"

Numero complesso

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

"Questo -5 + 3 I is-110 + 66 Ia -16760 + 10056 Isentence -250 + 150 I"

Ruby 40

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

Input da stdin.

Esempio di esecuzione:

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

Demo online: http://ideone.com/4BiHC8

Lua: 73 69 caratteri

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

Esecuzione di esempio:

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 caratteri

Questo è il mio primo tentativo di giocare a golf!

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

Eseguilo nell'ultima console di Firefox. Il primo input è il numero e il secondo input è la stringa da cui moltiplicare i numeri con il primo numero di input.

Il prompt finale elenca l'output.

Perl - 48 caratteri

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

Leggi un numero sulla prima riga, quindi leggi una frase e suddividila in blocchi di cifre o non cifre. Stampa le non cifre così come sono e i numeri vengono moltiplicati.

J - 63 caratteri

Il programma legge il numero, quindi la frase.

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

Spiegato dall'esplosione:

;(*&.".&(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

Se riusciamo a utilizzare la libreria PCRE di J e facciamo in modo che la frase venga prima, possiamo abbattere questo a 54 caratteri :

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

Spiegato dall'esplosione:

                                                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 è cattivo in questo, cosa posso dire. È un inconveniente perché J è così poco efficace.

Qualche esempio:

   ;(*&.".&(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

CJam - 35

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

Provalo su http://cjam.aditsu.net/

Input di esempio:

7
CJ4M W1LL H4V3 R3GUL4R 3XPR35510N5 L4T3R

Uscita campione:

CJ28M W7LL H28V21 R21GUL28R 21XPR248570N35 L28T21R

Spiegazione:

Il programma passa attraverso ogni carattere, raccogliendo le cifre in pila e per ogni non cifra prima stampa il numero raccolto (se presente) moltiplicato per l'input numerico, quindi stampa il carattere.

li:X;legge l'input numerico e lo memorizza in X
lN+legge la stringa e aggiunge una nuova riga (aiuta con i numeri finali)
{…}/per ogni carattere nella stringa
- _scopia il carattere e converte in stringa
- A,s-,rimuove tutte le cifre e conta i caratteri rimanenti; il risultato sarà 0 se il carattere era una cifra o 1 in caso contrario
- {…}*esegue il blocco se il conteggio era 1 (cioè non cifra); per le cifre non fa nulla, quindi rimangono in pila
- ]raccoglie i caratteri dalla pila in un array (cioè una stringa); i caratteri sono qualsiasi cifra delle iterazioni precedenti, più il carattere corrente
: )\separa l'ultimo elemento (il carattere corrente) e lo sposta prima della stringa (rimanente)
- _!!copia la stringa e la converte in un valore booleano - 0 se vuoto, 1 in caso contrario
- {…}*esegue il blocco se la stringa non era vuota, ovvero avevamo alcune cifre prima dell'attuale carattere non numerico
--- iX*converte la stringa in numero intero e moltiplica per X
- ostampa la parte superiore dello stack - il numero moltiplicato o la stringa vuota se non avessimo un numero
- o(il secondo) stampa il nuovo inizio dello stack - l'attuale carattere non cifra

Haskell (161)

golfed

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}

Ungolfed

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

Sfortunatamente, Haskell non ha una libreria Regex nel suo Preludio .

flex (-lexer) ( 94 89 caratteri)

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

Versione non golfata che non segfault se si dimentica l'argomento della riga di comando (non molto più a lungo):

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

Compilare con:

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

o:

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

Per esempio:

$ ./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

Fai clic sul titolo per vedere l'esempio eseguibile

Esempi provati:

Questo 1 is22a 3352sentence 50
3
Questo 3 is66a 10056sentence 150

Questo 1 is22a 3352sentence 50
42
Questo 42 is924a 140784sentence 2100

GNU Awk: 86 caratteri

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

Esecuzione di esempio:

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

Due versioni, le nuove versioni di php possono fare questo:

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

Versioni php precedenti: non ho contato la nuova riga, ho aggiunto quelli per la leggibilità.

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

Esempio di input + output

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

Un po 'difficile, le parole' funzione 'e' preg_replace_callback 'occupano molti caratteri.
Lo spazio dopo globale returnnon è necessario se seguito da $ var (-2 caratteri)

C ( 142 134 caratteri)

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

Newline inserita per una migliore leggibilità. Passa il fattore come primo, la stringa come seconda opzione della riga di comando. Questa implementazione richiede la dprintffunzione che fa parte di POSIX.1 2008 e potrebbe non essere disponibile su Windows. Ecco la fonte non minificata:

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

miglioramenti

• 142 → 134: utilizzare strspne strcspninvece di eseguire il ciclo sulla stringa.

Python 89

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

per esempio:

# 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

Ungolfed:

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 - 141 140 128 caratteri

Sono un principiante Clojure, ma FWIW:

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

Esecuzione di esempio:

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

Ungolfed (brutto ma si spera un po 'più facile da leggere):

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

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

Qualcuno doveva fare java. Le stringhe di input sono 2 token sulla riga di comando.

java M 'Questo 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);
    }
}

Due risposte: perl + bash

Bash puro (~ 262)

Innanzitutto, esiste una versione bash pura non così corta (niente fork, niente binari esterni)!

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
}

Mostriamo:

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

(Che è una frase totalmente improbabile)

Perl poco offuscato (solo per divertimento)

Questa versione (basata sulla risposta di @ Chilemagic ) non è più breve, ma progettata come uno script totem :

cat <<eof >mn.pl

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

eof chmod +x mn.pl

Esecuzione di esempio:

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

Haskell, 70

peccato che sia troppo tardi IMHO questo è abbastanza buono per questa specifica domanda e lingua. l'altra soluzione di Haskell qui è di 161 caratteri ..

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

funziona usando la readsfunzione che analizza parzialmente una stringa. per esempio reads "34abc" = [(34, "abc")],. questo ovviamente lo rende perfetto per questa sfida.

utilizzo:

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