보편적 인 유령 밈 번역기


43

소개

외계인은 우리처럼 밈을 좋아합니다. 우리가 지금까지 만난 모든 외계인 종족은 고유 한 버전 2spooky4me( 다음 질문 참조 )이 있지만 그와 동등한 변형이 있습니다. 행성 CUTE1f의 주민들은 많은 유령을 처리 할 수 ​​없으므로 선호하는 유령은 1spooky2me이며, skeletor7 memer는 약간의 유령을 좋아하므로 사용하는 경향이 있습니다 9spooky11me.

도전

밈 번역은 어려운 작업이므로,이 사람들이 밈넷에 올바르게 액세스 할 수 있도록 범용 밈 번역기를 작성해야합니다. 귀하의 프로그램은 다른 행성의 주민들에게 적합하도록 meme 및 그 meme의 숫자 시퀀스에 적용 할 변환을 허용합니다.

입력

프로그램은 두 개의 문자열 입력을받습니다 :

  1. 입력 밈 (예 2spooky4me). 일치 [a-zA-Z0-9]+합니다.
  2. 변환은 (예를 들어 그것을 적용 +1에서 이동, 2spooky4me3spooky5me). 일치 [+\-*/^]\d+(당신이 동의해야합니다 +, -, *, /, 및 ^운영 등에 관계없이 해당 언어의 기본 표현).

산출

프로그램은 입력 meme의 숫자 시퀀스에 지정된 변환이 적용된 문자열 출력 (표준 출력 또는 이와 동등한 출력)을 반환해야합니다. 이상한 사건의 전환에서, 지금까지 만난 모든 종족은 분수보다 정수 적분을 선호하므로 이러한 변환은 정수 산술을 수행해야합니다 (예 : 1spooky1me /2결과 0spooky0me).

표준 산술 연산이 적용됩니다 :

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

숫자 시퀀스는 필수입니다. 다음과 같은 경우 정수 잘림이 발생합니다.

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

입력 한 숫자 시퀀스가 ​​없을 수 있습니다.

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

선택한 언어의 기본 연산이 아닌 경우에도 지수를 지원해야합니다.

Input:  2spooky4me ^3
Output: 8spooky64me

문자열의 숫자 시퀀스 수의 문자열 길이에는 제한이 없습니다.

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

추가

언어에서 임의의 정밀도 정수를 언어 기능으로 지원하는 경우이를 사용해야합니다. 그렇지 않은 경우 임의 정밀도 정수를 지원할 필요가 없습니다. 예를 들어 언어의 일부로 제공되므로 IntegerHaskell 대신 사용해야 Int합니다. 에서 언어 기능이 아닌 라이브러리 기능이므로 Java사용할 필요가 없습니다 BigInteger.

Input:  2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
Output: 1000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky2me

이것은 이므로 표준 허점 은 금지되어 있으며 바이트 단위의 최단 답변이 이깁니다!

리더 보드

이 게시물의 하단에있는 스택 스 니펫은 답변 a) 언어별로 가장 짧은 솔루션 목록으로, b) 전체 리더 보드로 답변에서 리더 보드를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

## Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

## Ruby, <s>104</s> <s>101</s> 96 bytes

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

## Perl, 43 + 2 (-p flag) = 45 bytes

언어 이름을 링크로 만들면 스 니펫에 표시됩니다.

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


3
마지막 테스트 사례가 잘못되었습니다. 출력에 0이 너무 많아서 / 5가되지 않습니다.
Nic Hartley

5
우선 이것은 합리적으로 잘 넣어 함께 첫 번째 게시물은 축하 : 주, 그래서 우리는 가지고있다 샌드 박스 는 라이브되기 전에 당신이 의견을 당신의 도전을 게시 할 수 있습니다.
FryAmTheEggman

3
PPCG에 오신 것을 환영합니다 (2 년 이상 여기에 있었음에도 불구하고). 좋은 첫 번째 도전. 임의 정밀도 정수에 대한 부록은 예를 들어 Java BigInteger 계산에 사용해야 합니까?
AdmBorkBork

18
우리가 지금까지 만난 모든 외계인 종족은 ... 사실입니다! :-)
Luis Mendo

2
그것은 당신의 도전이며 궁극적으로 당신에게 달려 있지만, 다른 구문을 사용하는 언어에 대해서는 실제로 공평하지 않습니다.
Dennis

답변:


10

줄프, 15 14 바이트

ρi«\d+»dC!6+HI

여기 사용해보십시오!

설명

ρi«\d+»dC!6+HI
ρ «\d+»         replace all digits
 i              in the input
       d        (functional replace)
         !6     eval (using jolf's custom infix eval)
           +H   the number as a string plus
             I  the second input
        C       floor the result (integer truncate)

이 도전 후에 Jolf를 업데이트하고 RegExp 내장을 추가했습니다. 이것은 12 11 바이트 일 수 있습니다 .

ρiLRdC!6+HI

24

루비, 50 44 43 바이트

FGITW 답변. 빨리 가야 해!

6 바이트를 절약 해 준 @Neil에게 감사합니다.

아 맞아 44이 아직 44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}

아, 이건 거의 내가 정확히 쫓아 낸 대답 a=gets;$><<gets.gsub(/\d+/){eval$&+a}이다. 내 것은 ^! = ** 일을 놓 쳤고 아마도 조금 더 길 것입니다.
Nic Hartley

3
전체 솔루션이 PowerShell에서 처리하는 것보다 4 바이트 더 짧아 지도록 +1했습니다 ^. : D
AdmBorkBork

15

펄, 36 34 바이트

s/\d+/"0|$&$^I"=~s#\^#**#r/gee

소스 코드의 길이 는 30 바이트 이며 스위치 -pi( +4 바이트 ) 가 필요합니다 . STDIN에서 첫 번째 입력을 받고 두 번째 입력을의 인수로 사용 -i합니다.

2 바이트를 골라 낸 @DenisIbaev에게 감사드립니다!

Ideone에서 테스트하십시오 .


그래도 누군가 루비의 대답을 이길 수 있다면 데니스 나 펄에있을 것이라고 생각했고, 동시에 두 가지 기대를 동시에 충족시킬 수있었습니다
Value Ink

1
-pi4 바이트입니까?
CalculatorFeline

@CatsAreFluffy 현재 컨센서스 는 플래그없이 호출로부터 편집 거리를 계산하는 것입니다. 여기에는 -pi나머지 명령과 분리 할 공간이 포함됩니다 .
Dennis

"0|$&"보다 짧습니다 "0|".$&.
Denis Ibaev

@DenisIbaev 입력이 영숫자이므로 "0|$&$^I"작동합니다. 감사!
Dennis

9

PowerShell v2 +, 139137 바이트

param($a,$b)-join($a-split"(\d+)"|%{if($_-match"\d+"){if($b[0]-ne'^'){[math]::Floor((iex $_$b))}else{"$_*"*$b.Trim('^')+1|iex}}else{$_}})

Ooof ... 47 바이트 ^는 PowerShell의 기본 연산자가 아니기 때문에 설명합니다. @TessellatingHeckler 덕분에 2 바이트를 절약했습니다.

로 입력을 받아 $a=<word>, $b=<operation>.\universal-spooky-meme.ps1 2spooky4me ^3. 우리 -split $a는 구분 기호를 유지하고 결과 배열을 loop 통해 파이프로 묶어 숫자로 묶습니다 |%{...}. 현재 작품이 숫자이면 첫 번째 if입니다. 의 첫 문자가 $b입니다 ^. 그렇지 않은 경우, 우리는 단순히 우리의 현재 조각을 연결하고 $b와로 전송 iex(유사 eval), 다음 파이프 라인에 떠날. 그렇지 않은 경우 지수 문자열을 생성하여 "$_*"*$b.Trim('^')+1파이프 iex하고 파이프 라인에 그대로 두어야합니다. 주어진 2spooky4me ^3예에서, 이것은 각각 2*2*2*14*4*4*1입니다.

그렇지 않으면 파이프 라인에 그대로 문자열을 그대로 둡니다.

이러한 결과는 모두 -join하나의 문자열로 다시 연결 되기 전에 캡슐화 패런이있는 파이프 라인에서 수집됩니다 . 이것이 파이프 라인에서 다시 남은 것이며 프로그램 종료시 출력이 암시 적입니다.

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me ^5
32spooky1024me

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me /3
0spooky1me

나는 대답을보기 전에 내 자신의 글을 썼다. 그리고 나는 당신의 아이디어 중 일부를 고쳤다. 나는 당신이 대체 할 수있는 생각 Floor(("$_$b"|iex))과 함께 Floor((iex $_$b))몇 가지를 저장하거나 어쩌면하는 iex $_+$b.
TessellatingHeckler

@TessellatingHeckler 2 바이트 감사합니다!
AdmBorkBork

8

자바 스크립트 (ES7), 58 57 바이트

(s,t)=>s.replace(/\d+/g,n=>0|eval(n+t.replace('^','**')))

편집 : replace리터럴 문자열에서도 작동 한다는 것을 기억했을 때 1 바이트를 저장했습니다 .


Cool, 저는 ES6 솔루션을 개발 중입니다
Bálint

바이트를 절약하기 위해 카레를 줄 수 있습니까?
gcampbell

1
@gcampbell 네,하지만 너무 게으르다.
Neil

6

피 이스, 29

Jws.i:zK"\d+"3m.vs.iJ]+d;:zK1

이것은 meme에서 각 숫자를 추출한 다음 .i공백 을 인터리빙하고 ( ) 다른 인수로 목록에 래핑하여 작동합니다. 따라서 우리의 숫자가 7있고 우리가 가지고 있다면 우리 ^20는 목록을 얻을 것입니다 : ["^", "7 ", "20"]. 이것에 Pyth eval( .v) 를 평평하게하고 사용 하면 항상 원하는 작업을 수행 할 수 있습니다. 마지막으로 이러한 값은 숫자 발생시 원래 문자열 분할과 인터리브됩니다.

두 입력이 모두 따옴표로 묶인 경우 바이트가 더 짧아 질 수 있고 그 중 하나만 따옴표로 묶을 수 있으면 2 바이트가 더 짧을 수 있습니다.

여기에서 시도 하거나 테스트 스위트를 실행 하십시오.


6

파이썬 2, 156 89 88 87 바이트

언어 처리기에서 언어 대체 함수를 사용하여 long input 문자열 의 숫자 부분을 operator 로 처리하는 다른 답변에서 영감을 얻었 습니다. 파이썬에게는 운이 좋지 않습니다. ^는로 교체해야합니다 **. .group(0)호출은 단지에 액세스 할 수 일치하는 객체 의 문자열 표현이 더 나은 일을하지 않습니다 ...

스퓨리어스 공간을 발견 한 QPaysTaxes와 불필요한 인수에 대한 RootTwo 덕분에 .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)

나는 당신이 공간을 제거 할 수 있다고 생각합니다i,o:
Nic Hartley

(1)을 사용하여 2 바이트를 더 절약 할 수 있습니다 p.group(). (기본값은 0); 그리고 (2) r=re.sub;replace first first re.subcall을 삽입 r한 다음 r('^','**',o)대신 사용o.replace(...)
RootTwo

@RootTwo : 나를 위해, r('^','**',o)다음은 탈출 필요 ^\^문자, 아니 시작을 일치시키기 위해 o, 더 바이트 :-( 저장되지 순 - 불필요한 지적하지만, 감사합니다 0!
ojdo

5

자바 스크립트 (ES6) 99 바이트

또 다른 예, ES7이 호환성을 갖기를 기다리는 것을 싫어하는 이유

(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)|0:_).join``

실행 가능한 예 :

f=(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?Math.ceil(eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)):_).join``

alert(f(prompt("Enter string!"), prompt("Enter operation!")));


일치하는 정규 표현식이 약간 벗어난 것 같습니다. 실행 가능한 예제에서는 대문자를 생략하여 결과에서 제거합니다 ( "2spooky4ME", "+1"=> "3spooky5"). 첫 번째 예제에서는 \d+|\D+에 해당합니다 .+. [a-zA-Z0-9]+당신이 원하는 정규식입니까? 또는 [a-zA-Z]+|[0-9]+분할이 차이를 만드는 경우?
Itai Ferber

Math.pow어쨌든 특수한 경우에 직접 호출하는 것이 더 쉬울 것입니다. 또한 정수 나누기를 사용하고 있습니까?
Neil

@Neil 나는 그것을 잊었다
Bálint

@Neil 천장에 더 좋은 방법이 있습니까?
Bálint

1
@ItaiFerber는 \d+|\D+같은 아주 동일하지 않습니다 .+. kleene 확장이 이전에 발생하기 때문에 동일하지 않습니다 or. 모양이 같으면 동일 (\d|\D)+하지만 2a한 그룹의 모든 항목과 일치하지는 않지만 두 개의 개별 그룹이됩니다.
FryAmTheEggman


4

코 틀린, 416 413 바이트

eval()Kotlin 의 부족으로 인해 바이트 수가 실제로 증가했습니다 ...

fun main(a:Array<String>){var r=Regex("\\d+");var i=a[0];var n=a[1].takeLast(a[1].length-1).toInt();when(a[1][0]){'+'->print(r.replace(i,{m->""+(m.value.toInt()+n)}));'*'->print(r.replace(i,{m->""+(m.value.toInt()*n)}));'/'->print(r.replace(i,{m->""+(m.value.toInt()/n)}));'-'->print(r.replace(i,{m->""+(m.value.toInt()-n)}));'^'->print(r.replace(i,{m->""+(Math.pow(m.value.toDouble(),n.toDouble())).toInt()}));}}

온라인으로 사용해보십시오!

언 골프

fun main(a: Array<String>) {
    var r = Regex("""\d+""")
    var i = a[0]
    var n = a[1].takeLast(a[1].length - 1).toInt()
    when (a[1][0]) {
        '+' -> print(r.replace(i, { m -> "" + (m.value.toInt() + n) }))
        '*' -> print(r.replace(i, { m -> "" + (m.value.toInt() * n) }))
        '/' -> print(r.replace(i, { m -> "" + (m.value.toInt() / n) }))
        '-' -> print(r.replace(i, { m -> "" + (m.value.toInt() - n) }))
        '^' -> print(r.replace(i, { m -> "" + (Math.pow(m.value.toDouble(), n.toDouble())).toInt() }))
    }
}

4

PowerShell (v4), 124120 바이트

# New 120 byte version:
$s,$a=$args;[regex]::Replace($s,'\d+',{($(if($a-ne($a=$a.Trim('^'))){
"$args*"*$a+1}else{"$args$a"})|iex)-replace'\..*'})

# Previous 124 byte version
$s,$a=$args;[regex]::Replace($s,'\d+',{if($a[0]-eq'^'){
[math]::pow("$args",$a.Trim('^'))}else{iex "$args$a-replace'\..*'"}})

줄 바꿈은 가로 스크롤을 피하기 위해 여기에 있으며 한 줄로 저장하면 작동합니다.

댓글 및 ungolfed 버전이 요청되었습니다.

$meme, $instruction = $args

# Scriptblock which processes the numbers
# to be replaced. $args is the input number.
$replacement = {

    # Generates a string of the calculation, by:
    # Removing leading ^ character, if present.
    # ^3 -> 3,      +3 -> +3
    # See if it was present, and switch code paths.
    # (Can be one combined step in the golf)
    # Switch code paths for "raise to the power of",
    # or basic arithmetic.
    $trimmedInstruction = $instruction.Trim('^')
    $tmp = if ( $instruction -ne $trimmedInstruction ) {

        # String multiplication, changes
        # function input "45" and instruction "3" into
        # "45*45*45*+1". The "3" implicitly casts to [int]
        # the +1 is there to make the trailing * not crash.
        "$args*" * $instruction + 1

    } else {
        # Cobble the basic math together as a string
        # "45" and "+10" becomes
        # "45+10"
        "$args$instruction"
    }

    # eval() the generated string (e.g. "45+10" or "45*45*45*+1")
    $tmp = Invoke-Expression $tmp      # iex

    # Use a regex golf to replace trailing .23423
    # decimals in case of division with remainder.
    # Acts as [math]::floor(), harmless on other numbers.
    $tmp -replace'\..*'
}

# A regular expression replacement which picks out all 
# the numbers (\d+) and runs them through the
# replacement function. Returns a string which 
# ends up on stdout
[regex]::Replace($meme, '\d+', $replacement)
  • .Net 정규식 라이브러리는 일치하는 내용에서 실행되는 스크립트 블록으로 대체 할 수 있으며 PowerShell은 형식 문자열을 숫자로 캐스팅 하며 다른 언어 iex와 유사 eval()합니다. 그냥 "2spooky" "+3"->eval("2+3")
  • 예외는 ... ^연산자 나 다른 편리한 지수를 처리 할 수 ​​없습니다 **. [math]::Pow()라이브러리 호출 만 사용할 수 있으므로 해당 분기를 처리 할 큰 블록이 있습니다.
    • 업데이트 된 버전 @TimmyD에서 아이디어를 훔치고 대신 문자열 곱셈을 수행 - "2*" * n이되는 "2*2*2*2*"다음 추가 +1대신 후행에 대해 불평 중 하나에 의해 곱 끝에 *.
  • .Net은 기본적으로 가장 가까운 짝수로 반올림하고 3/2 = 1이 아닌 3/2 = 2로 반올림하는 Banker 's Rounding을 수행합니다 [math]::Truncate(). 대신 -replace소수점을 자르기 위해 문자를 저장 합니다.

테스트 사례 :

PS D:\> .\meme.ps1 2spooky4me +1
3spooky5me

PS D:\> .\meme.ps1 2spooky4me -1
1spooky3me

PS D:\> .\meme.ps1 2spooky4me *15
30spooky60me

PS D:\> .\meme.ps1 10spooky900me /5
2spooky180me

PS D:\> .\meme.ps1 idontunderstandememes3 /2
idontunderstandememes1

PS D:\> .\meme.ps1 "idontunderstandememes3" "/2"
idontunderstandememes1

PS D:\> .\meme.ps1 "notreallyafunnymeme" "*100"
notreallyafunnymeme

PS D:\> .\meme.ps1 "2spooky4me" "^3"
8spooky64me

PS D:\> .\meme.ps1 "some1meme2sequences3can4be5really6long7" "/2"
some0meme1sequences1can2be2really3long3

PS D:\> .\meme.ps1 2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
1E+78‌​0spooky2me

NB. 마지막 테스트에서는 숫자가 [BigInteger]자동 으로 유형이 넘치지 만 과학적 표기법으로 표시됩니다. 운 좋게도, 별들 사이에서 의사 소통을 할 수있는 모든 알려진 종족은 문제없이 과학적 표기법을 처리 할 수있는 충분한 과학적 발달을 가지고 있습니다.


1
다른 답변에서 읽을 수없는 골프 버전을 제공 한 다음 코드 동작을 검사하기 위해 별도의 ungolfed 버전을 제공하는 방법을 볼 수 있습니다. 당신과 함께해야합니다 (즉, 골프 버전에서 줄 바꿈을 제거하십시오).
jpmc26

크레딧에 감사하지만 내 트릭은 아닙니다. PowerShell 팁 스레드에서 가져 왔습니다.
AdmBorkBork 12

분명히, 나는 의견을 남기기에 충분히 관심이 있으며, 다른 사람은 나의 의견을 찬성하기에 충분히 관심이 있습니다. ;)
jpmc26

아니요, 정식 골프 버전과 완전 골프 버전이 있어야한다고 말했습니다. 골프는 스크롤해야합니다. ungolfed 하나는 당신이 가지고있는 것보다 더 읽기 쉽지 않을 것입니다.
jpmc26

1
@ jpmc26 좋아, 나는 주석이 달린 버전으로 편집했습니다.
TessellatingHeckler

3

배쉬 + GNU 코어 유틸리티, 144 바이트

d=
u=$1,
for((i=0;i<${#u};i++)){ l=${u:i:1}
[[ "$l" =~ [0-9] ]]&&d=$d$l||{ [ -z $d ]||echo -n `bc<<<$d$2`&&{ [ $l != , ]&&echo -n $l; };d=; }
}

이것은 숫자와 비 숫자 사이의 변경을 검토하므로 입력 문자열에 임의의 유효하지 않은 입력 문자 (쉼표)가 추가됩니다. 그런 다음이 쉼표는 출력에서 ​​무시됩니다. OP의 규칙은 bc수학을 수행하는 데 사용되는 구문을 정확하게 따릅니다 .


그건 그렇고 @TessellatingHeckler의 PowerShell 솔루션에 대한 토론으로 인해 내 솔루션에서는 줄 바꿈을 세미콜론으로 바꾸어 프로그램을 단일 줄로 변환 할 수 있으며 길이는 변경되지 않습니다.
rexkogitans

3

루아, 145 93 바이트

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)

왜 함수를 게시하지 않습니까?
Bálint

2

R, 163 바이트

R에서 정규 표현식과 문자열 대체를 배우는 사람으로서 이것은 매우 어려운 과제였습니다. 특히 숫자를 일치시키는 것은 쉽지만으로 여러 대체를 사용하는 방법을 찾을 수 없기 때문입니다 gsub. 또한 eval(parse(paste0(...작업 간을 전환하는 가장 효율적인 방법 인지 모르겠습니다 . 아마도이 기능 switch이 더 적합 할 것입니다.

function(s,o){p=strsplit;y=p(gsub("\\d+","?",s),"?")[[1]];x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]));y[y=="?"]=floor(eval(parse(,,paste0("x",o))));cat(y,sep="")}

설명

f=function(s,o){
    p=strsplit                                    # alias for stringsplit    
    y=p(gsub("\\d+","?",s),"?")[[1]]              # substitute numbers with "?" and split into vector on "?"
    x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]))  # split at alphabetical char, return vector with numbers to be operated on
    y[y=="?"]=floor(eval(parse(,,paste0("x",o)))) # replace inserted "?" with vector of numbers operated on
    cat(y,sep="")                                 # print concatenated vector
}

매치에서 클로저와 함께 gsub를 사용하면 주석에서 암시 한 바와 같이 바이트를 절약 할 수 있다고 생각합니다. 그래도 R에서 어떻게 해야할지 모르겠습니다. Groovy에서 어떻게해야하는지 알 때까지 나는 그것으로 고투했다. 거의 게임 체인저였습니다.
매직 문어 Urn

2

자바 스크립트 (ES6), 85 바이트

x=(s)=>{var a=s.split(" ");return[...a[0]].map(x=>(!isNaN(x))?eval(x+a[1]):x).join``}

console.log(x("2spookie5me +1"));

언 골프 드 :

x = (s) => {
  var a = s.split(" ");
  return [...a[0]].map(x => (!isNaN(x)) ? eval(x + a[1]) : x).join ``
}
console.log(x("2spookie5me +1"));

스프레드 연산자를 사용하여 공백을 나눌 수 있는지 아는 사람이 있습니까? 이로부터 s.split ( ""); [ ""... s]; 적어도 그 아이디어입니다.
Bladimir Ruiz

당신은 ()람다 인수를 필요로하지 않으며, 필요하지 않으며 var, 중괄호 대신 parens와 쉼표 연산자를 사용해야합니다.return
Cyoce

또한 ^JavaScript의 특별한 경우입니다. 대신 비트 XOR입니다.Math.pow
Sunny Pun

2

그루비, 64 60 바이트

{a,b->a.replaceAll(/\d+/,{Eval.me(it+b.replace("^","**"))})}

전달 된 단어의 숫자 부분에 대한 연산을 평가하는 클로저로 모든 숫자 인스턴스를 바꿉니다. 지수 함수를 전달하면 적절한 표기법으로 대체합니다. Eval.me()구문 분석 된 문자열이 2^32-1범위를 벗어날 수 있으므로 Groovy는 사용할 때 BigInteger / BigDecimal 변환을 암시 적으로 처리 합니다.

설명

{a,b->...} -두 개의 인수로 마감합니다.

a.replaceAll(/\d+/,{...}) -문자열의 모든 숫자 시퀀스를 검색하고 클로저로 바꿉니다.

{Eval.me(it+b.replace("^","**"))} -보다 구체적으로, 각 일치 항목에 작업이 추가 된 클로저는 그루비 코드로 평가됩니다.

.replace("^","**")- 제공된 작업에서 첫 번째 인스턴스를 ^그루비 지수 연산자 **로 교체하십시오 . 지수를 사용하는 전체 방정식 문자열에서이 작업을 수행하려면 replaceAll()+3 바이트 페널티를 대신 사용하십시오 .

그의 재미있는 참고 사항은 유효한 테스트 시나리오입니다.
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)


1

RProgN , 39 바이트

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R

설명

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R
►                                       # Spaceless segment.
 x=                                     # Assign the top value of the stack '[+*/-]\d+' 
   '$d+'§                         }R     # Replace everything in the pattern %d+ (all numbers) based on an anonymous function 
         x'%D+'''R                      # Replace all Non-digits in the modifer with nothing, leaving just the second argument for the operator.
                  x'%d+'''R             # Snip all digits, separating our operator from our digits such that digit operator exists in the stack.
                           g'y'=        # Grab the function that is represented by the top of the stack (the operator in this case)
                                y       # Run it
                                 _      # Floor the result. 

이 언어는 존재하지 않기 때문에 기술적으로 잘못된 답변입니다. 그러나 특별히 설계된 것은 아니며 특정 추가 사항도 없습니다. 그래서 나는 그것을 실행하고 있습니다. 고소

온라인으로 사용해보십시오!


0

펄 6, 111 바이트

{/(\w+)\s(<[+\-*/^]>)(\d+)/&&my \b=+$2;my \o=(*+b,*-b,* *b,*div b,* **b)[index "+-*/^",$1];$0.subst(/\d+/,o):g}

불행히도 EVAL기본적으로 비활성화되어 있습니다. 또한 div정수 나누기에도 사용해야 합니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.