숫자를 사용하지 않고 두 숫자를 곱하십시오.

30

기수 10에서 양수를 나타내는 두 개의 문자열 (예 : "12345"및)이 입력으로 제공됩니다 "42". "518490"이 경우 제품 이 포함 된 문자열을 출력해야합니다 .

트위스트는 코드에 숫자 유형을 사용할 수 없다는 것입니다. 아니 ints, floats,unsigned long s 등은 내장 된 복소수 유형이나 임의의 정밀 정수 또는 해당 행을 따라 아무것도 없습니다. 이러한 유형의 리터럴이나이를 반환하는 함수, 메서드, 연산자 등을 사용하지 않는 경우가 많습니다.

당신은 할 수 문자열, 부울, 배열, 또는 일반적으로 숫자를 표현하기 위해 사용되지 않을 것이다 아무것도를 사용합니다. (하지만 숫자 형을 호출하지 않고는 배열에 색인을 생성하거나 길이를 가져 오는 것이 불가능할 수 있습니다.) chars는 허용되지만 산술 또는 비트 연산을 수행하거나 다른 방법으로 처리 할 수는 없습니다. 문자열의 일부를 나타내는 토큰 (서사 학적 비교char s의 가 허용됩니다.)

제한을 해결하지 못할 수 있습니다. 여기에는 숫자 형식을 사용하는 것이 포함되지만 이에 국한되지 않습니다.eval 유형 함수 암시 적 유형 변환, 지원하는 숫자가 아닌 유형의 숫자 ​​또는 비트 연산자, 컨테이너 유형 내에 저장된 숫자 유형 사용 또는 함수 호출 또는 숫자 형태의 결과를 문자열 형태로 반환하는 외부 프로그램. (다른 해결책이 답변에 나타나면이 목록에 추가 할 권리가 있습니다.) 숫자가 아닌 유형 만 사용하여 곱셈을 직접 구현해야합니다.

입력 및 출력은 데이터가 문자열 형태로 코드에 들어오고 나가는 한 편리한 방법으로 수행 할 수 있습니다. 두 개의 입력 인수 각각에 ASCII 문자 만 포함되어 [0-9]있고로 시작하지 않는다고 가정 할 수 있습니다 0. 출력에는 선행 0이 없어야합니다.

한 가지 더 : 코드가 있어야 올바르게에 입력을 처리 할 길이가 적어도 10 자 하고 있어야 위한 현대 컴퓨터에 1 분에서 실행되는 모든 그 범위에서 입력. 게시하기 전에 입력이 주어 졌을 때 확인하시기 바랍니다 9999999999하고 9999999999, 프로그램이의 출력 제공 99999999980000000001분 미만의를. 이 제한은 크기 배열을 할당 한 a*b다음 반복 하여 작동하는 답변을 방지하기 위해 존재 하므로 해당 양식의 답변이 이길 수 없다는 점을 명심하십시오.

이것은 code-golf 이므로 가장 짧은 유효한 솔루션 (바이트)이 이깁니다.

code-golf  restricted-source  arithmetic 
— 나다니엘
소스
우리 "12345"는 STDIN보다 오히려 받아 들일 수 있습니까 12345? 또는 두 숫자를 모두 사용할 수 "12345", "42"있습니까?
— 저스틴
내 첫번째 생각은 함수의 길이의 문자열 인수를 복용 작성했다 m및 n길이의 인수를 반환 m*n. 그러나 문자열에는 문자 그대로 숫자의 ASCII 표현이 포함되어야하기 때문에 규칙에 위배되는 것 같습니다.
— Level River St
1
@xnor 많은 언어에서 모든 경우를 작성하는 것이 더 짧을 수 있습니다. 그러나 나는 파이썬에서이 방법을 찾았습니다.a,b="0123456789x".split('0');c=iter(b).next() if c=='x': c='0'
— Nathaniel
1
또는 Python 3에서a,b="0123456789x".split(x);c,*d=b if c=='x': c='0'
— Nathaniel
2
@Nathanield='123456789';I=dict(zip('0'+d,d+'0'))
— 저스틴

답변:

6

하스켈 - 180 206 214

r=reverse
f=filter
z=['0'..'9']
a?f|f="1"!a
a?_=a
(a:b)!(c:d)=e:b!d?(e<a)where e=fst$last$zip(f(>=c)z++z)$f(<=a)z
a!c=a++c
a%(b:c)=foldr(!)('0':a%c)$f(<b)z>>[a]
_%b=b
a#b=r$r a%r b

반복 가산을 통해 곱셈을 구현하며, ['0'..'9']목록 을 이동 및 필터링하여 모든 종류의 숫자 마법을 처리 합니다. #유형 의 연산자 를 정의합니다 String -> String -> String.

*> :set +s
*> "9990123456789"#"9999876543210"
"99900001219316321126352690"
(0.02 secs, 9862288 bytes)
— 니프
소스
새로운 승자가있는 것 같습니다! (이전처럼, 나는이 정도의 정교함의 Haskell을 읽을 수 없습니다-누군가가 사양을 충족하는지 독립적으로 확인할 수 있습니까?)
— Nathaniel
([ '0'.. '9']는 문자를 암시 적으로 반복 할 수있는 숫자로 처리하는 것과 같은 느낌이 듭니다. 대신 문자열 "0123456789"에서 해당 목록을 생성하는 짧은 방법이 있습니까?)
— Nathaniel
@Nathaniel 우선 모든 문자열 "0123456789" 이 목록 ['0'..'9']입니다. 둘째, Haskell에서 [a..b]는 열거 형이고, typeclass의 인스턴스를 선언 한 형식은 Enum이와 같이 열거 될 수 있으며, 선언은 열거의 작동 방식을 설명합니다. Bool부울 형식에도 인스턴스가 있으므로을 수행 할 수도 있습니다 [False..True]. 관련된 숫자는 거의 없습니다.
— mniip
14

sed, 339 338 바이트

나는 이것이 오래된 것임을 알고 있지만 탐색하고 있었고 내 관심을 끌었습니다. 실제로 사용자로 등록하기에 충분합니다! " 나는 전체 sed 솔루션을보고 싶습니다 – Nathaniel "... 

s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g
:o
s/\( .*\)0$/0\1/
/x$/{
x
G
s/ .*/\n/
:a
s/\(.*\)0\(x*\)\n\(.*\)0\(x*\)\n/\1\n\3\n0\2\4/
ta
s/\n//g
:c
s/^x/0x/
s/0xxxxxxxxxx/x0/
tc
x
s/x$//
}
/ 0/bo
g
s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g

이 sed 스크립트는 하나의 공백으로 구분 된 두 개의 소수를 입력으로 예상합니다.

테스트 :

time test 518490 = $(./40297.sed <<<)"12345 42" || echo fail
time test 99999999980000000001 = $(./40297.sed <<<"9999999999 9999999999") || echo fail
time test 1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139 = $(./40297.sed <<<"37975227936943673922808872755445627854565536638199 40094690950920881030683735292761468389214899724061") || echo fail
time test 1230186684530117755130494958384962720772853569595334792197322452151726400507263657518745202199786469389956474942774063845925192557326303453731548268507917026122142913461670429214311602221240479274737794080665351419597459856902143413 = $(./40297.sed <<<"33478071698956898786044169848212690817704794983713768568912431388982883793878002287614711652531743087737814467999489 36746043666799590428244633799627952632279158164343087642676032283815739666511279233373417143396810270092798736308917") || echo fail

마지막 두 개는 RSA-100 (50 x 50 자리) 및 RSA-768 (116 x 116 자리)로 인식 될 수 있습니다.

최신이 아닌 최신 (2007 년 인텔 코어 2)에서 GNU sed를 사용하면 마지막 작업이 1 분 이상 걸리지 만 새로운 프로세서에서는 더 빠릅니다.

  • Q6600 :> 1 분
  • i7-3770 : 26 초
  • i7-6700 : 22 초

질문에 지정된 10 자리 숫자의 곱셈은 병리학 적 9로 가득 차 있지만 1 초 미만이면 잘 수행됩니다.

나는 그것이 확장이없는 표준 sed라고 생각합니다. POSIX는 8192 바이트의 공간만을 보장하므로 400x400 숫자의 곱으로 제한하지만 구현은 더 많은 것을 제공 할 수 있습니다. GNU sed는 사용 가능한 메모리에 의해서만 제한되므로 기꺼이 기다리면 훨씬 더 큰 것을 관리 할 수 ​​있습니다.

그리고 나는 규칙을 준수했다고 확신합니다. 거의 숫자가없는 언어로 제공됩니다. :-)

설명

나는 십진수를 단항 시퀀스로 변환하는 단항 / 십진 하이브리드를 사용합니다.

 42 => _xxxx_xx

십진법에서는 덧셈이 쉽다. 우리는 x를 연결하여 가장 작은 자릿수에서 가장 큰 자릿수로 반복합니다.

   X=965                   Y=106                                 SUM
   _xxxxxxxxx_xxxxxx_xxxxx _x__xxxxxx
   _xxxxxxxxx_xxxxxx       _x_                          _xxxxxxxxxxx
   _xxxxxxxxx              _x                    _xxxxxx_xxxxxxxxxxx
                                      _xxxxxxxxxx_xxxxxx_xxxxxxxxxxx

그런 다음 공백을 제거하고 10 개의 연속 x를 다음 단위 중 하나로 변환하여 캐리를 처리합니다.

 _xxxxxxxxxx_xxxxxx_xxxxxxxxxxx       10.6.11
 _xxxxxxxxxx_xxxxxxx_x                10.7.1
 _x__xxxxxxx_x                        1.0.7.1

덧셈을하면 곱셈이 가능합니다. y의 마지막 숫자를 고려하여 x * y를 곱합니다. 어큐뮬레이터에 x를 여러 번 추가 한 다음 다음 숫자로 이동하고 x를 소수점 이하 한 자리 왼쪽으로 이동합니다. y가 0이 될 때까지 반복하십시오.

확장 코드

#!/bin/sed -f

# Convert to unary decimal.  We save two or three bytes of code by
# reusing 0 as the digit separator.
s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g

# until y==0

:one

# y ends in zero => x *= 10 and y /= 10
s/\( .*\)0$/0\1/

# while y%10, acc += x, y -= 1
/x$/{
x
G
s/ .*/\n/
# Add x
:add
s/\(.*\)0\(x*\)\n\(.*\)0\(x*\)\n/\1\n\3\n0\2\4/
tadd
s/\n//g
:carry
s/^x/0x/
s/0xxxxxxxxxx/x0/
tcarry

# repeat for each unit of y
x
s/x$//
}

# y?
/ 0/bone


# convert hold space to decimal
g
s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g
— 토비 스피
소스
1
매우 만족스러운 답변, 감사합니다!
— Nathaniel
9

sed, 379 바이트

이 훌륭한 답변에 대한 크레딧은 Unix & Linux에서 @LuigiTiburzi로갑니다. https://unix.stackexchange.com/a/37213/34061에 있습니다. 방금 며칠 전에이 문제가 발생했습니다.

s/[0-9]/<&/g
s/0//g
s/1/|/g
s/2/||/g
s/3/|||/g
s/4/||||/g
s/5/|||||/g
s/6/||||||/g
s/7/|||||||/g
s/8/||||||||/g
s/9/|||||||||/g
:t
s/|</<||||||||||/g
tt
s/<//g
s/.*\*$/0/
s/^\*.*/0/
s/*|/*/
:m
s/\(|*\)\*|/\1<\1*/
tm
s/*//g
s/<//g
:b
s/||||||||||/</g
s/<\([0-9]*\)$/<0\1/
s/|||||||||/9/
s/||||||||/8/
s/|||||||/7/
s/||||||/6/
s/|||||/5/
s/||||/4/
s/|||/3/
s/||/2/
s/|/1/
s/</|/g
tb

넓은 설명

  • 각 숫자를 구분하십시오. 그러므로12*3 이된다<1<2*<3
  • 각 숫자를 해당 |문자 수로 변환하십시오 . 그러므로<1<2*<3 이된다<|<||*<|||
  • 소수점 이하 자릿수를 모두 단위 위치로 옮기려면 반복해서 |<로 바꾸 <||||||||||십시오. 그러므로<|<||*<||| 이된다<||||||||||||*<|||
  • 를 제거하십시오 <. 그러므로<||||||||||||*<||| 이된다||||||||||||*|||
  • |의 RHS에서 1 을 제거하십시오 *. 그러므로||||||||||||*||| 이된다||||||||||||*||
  • |RHS의 각 항목 을 |LHS의 모든 항목으로 반복해서 교체하십시오 . 이것의 LHS와 RHS 번호 승산 효과 갖는다 |의 제품 번호를 제공하기 | 때문에이||||||||||||*|| 된다를||||||||||||||||||||||||||||||||||||*
  • 를 제거하십시오 *. 그러므로||||||||||||||||||||||||||||||||||||* 이된다||||||||||||||||||||||||||||||||||||
  • |처음 몇 단계를 거꾸로하여 숫자를 다시 소수 로 변환 합니다. 따라서 ||||||||||||||||||||||||||||||||||||이된다36 .

산출:

$ echo "04*3
4*3
40*3
42*32
150*20
1*3
3*1
0*3
3*0" | sed -f mult.sed
12
12
120
1344
3000
3
3
0
0
$

불행히도 시간 요구 사항에 따라 비참하게 실패합니다 200*1000. 내 우분투 VM에서 41 초가 걸리고 런타임은 경험적으로 최종 제품의 제곱과 함께 올라가는 것처럼 보입니다.

— 디지털 외상
소스
1
이것은 숫자 부분으로 다시 변환하는 것을 제외하고는 삭제 된 JS 답변과 거의 알고리즘 적으로 동일합니다.
— Optimizer
@Optimizer가 동의했습니다. 차이점은 귀하가 사용 length()하는 숫자를 반환 한다는 것 입니다. 이것은 숫자 형식이없는 순수한 정규식 대체를 사용합니다. 나는 당신이 대답을 잠재적으로 승자라고 생각합니다.하지만 제거 length()할 수 있다면 비슷한 정규식 대체를 할 수 있습니까?
— Digital Trauma
1
매우 훌륭하지만 1 분 제한은 구체적으로 답을 세어 작동하는 솔루션을 방지하기위한 것입니다. 그래도 전체 sed 솔루션을보고 싶습니다.
— Nathaniel
1
나는이 대답 (시스템의 주소 공간보다 예를 들어 큰) 큰 숫자에서 작동합니다.
— Toby Speight
@TobySpeight 예, 아주 좋습니다. 난 이미 upvoted 당신에게 잠시 뒤로 :)이 있어야합니다 생각
— 디지털 외상
9

파이썬 - 312 286 273

D={}
e=t=""
N=[e]
for c in"0123456789":D[c]=t;D[t]=c;t+="I";N+=N
B=lambda s:[D[c]for c in reversed(s)]
Y=B(input())+N
for a in B(input())+N:
 for c in a:
    s=[];o=e
    for a,b in zip(N,Y):i=a+b+o;o=t<=i and"I"or e;s+=i.replace(t,e),;N=s
 Y=[e]+Y
print e.join(B(N)).lstrip("0")

선행 0을 허용하는 경우 마지막 12자가 필요하지 않습니다.

이것은 본질적으로 표준 곱셈을 수동으로 수행합니다. 숫자는 I기본 로마 숫자처럼 반복되는 s의 문자열로 표시됩니다 . 숫자는 숫자 목록을 역순으로 나타냅니다. 단일 숫자의 추가는 문자열을 연결하고 I필요한 경우 10을 제거하여 수행됩니다 .

ungolfed 버전은 다음과 같습니다.

N = [""] # zero object: list with a lot of empty strings
D = {}   # dictionary for conversion from and to digits
i = ""   # iterates over digits
for c in "0123456789":
    D[c] = i  # map digit to Roman digit
    D[i] = c  # and vice versa
    i += "I"  # increments Roman digit
    N += N    # add leading zeros to zero

ten = "IIIIIIIIII" # Roman digit ten

# Conversion function
B = lambda s: [D[c] for c in reversed(s)]

def Add(x,y):
    Sum = []
    carryover = ""
    for a,b in zip(x,y):
        increment = a+b+carryover
        carryover = "I" if ten in increment else ""
        increment = increment.replace(ten,"") # take increment modulo ten
        Sum += [increment]
    return Sum

def M(x,y):
    Sum = N[:] # Initiate Sum as zero
    X = B(x)+N # Convert and add leading zeros
    Y = B(y)+N
    for a in X:
        for c in a:
            Sum = Add(Sum,p+Y)
        Y = [""] + Y # multiply Y by 10
    return "".join(B(Sum)).lstrip("0") # Convert back and to string, remove leading zeros.

M(input(),input())
— rz 르프
소스
1
이 마법은 무엇입니까! 어떻게 작동합니까! 와우. 또한, 당신이 할 수있는 또 다른 골프가 있습니다 : def A(x,y):\n S=[];o=""-> def A(x,y,S=[],o=""):. 또한 안타깝게도 ["","1"][t in i]허용되지 않습니다. 부울을 사용하여 색인을 생성하고 숫자로 취급합니다. t in i and"1"or""그래도 작동해야 한다고 생각합니다 .
— Justin
@Quincunx : S기본값을 가진 인수로 정의 하는 것은 효과가 없었습니다. 함수의 다른 호출에 대해서도 항상 같은 목록이어서로 재설정되지 않았기 때문 []입니다. 당신이 옳았어요 ["","1"][t in i]. 고 쳤어요. 나는 또한 설명을 추가했다.
— Wrzlprmft
이것은 꽤 놀랍습니다. 지금은 녹색 진드기를 얻습니다. (출력에서 선행 0은 허용되지 않음을 명확히하기 위해 질문을 편집했습니다.)
— Nathaniel
7

루비 : 752 698

이것은 단지 호기심으로 답변을 얻는 것입니다. 편집 : 이제 약간 골프.

$F='0123456789'
$G="#{$F}abcdefghij"
def x(a,b);p(a=~/[13579]$/?b:"",a==""?"":x(Hash[*%w(b0 5 b1 6 b2 7 b3 8 b4 9)].to_a.inject(a.tr($F,'0011223344').chars.zip(a.tr($F,'ababababab').chars).flatten.join("")){|n,q|k,v=q;n.gsub(k,v)}.gsub(/[ab]/,'').sub(/^0*/,''),p(b,b)));end
def p(a,b);j,k=["0#{a}","0#{b}"].map{|c|c.gsub(/./,'0')};c="#{k}#{a}".chars.zip("#{j}#{b}".chars).drop_while{|z|z==%w(0 0)}.map{|m|$G.sub(/#{m.map{|n|"122333444455555666666777777788888888999999999".chars.select{|c|c==n}}.flatten.map{|c|'.'}.join("")}/,"").chars.first}.flatten.join("");d=nil;
while c!=d
 d=c;c="0#{d}".gsub(/[0-9][a-j]/) {|m| m.tr($G,"123456789a#{$F}")}.sub(/^0/,'')
end;c;end
puts x(ARGV.shift,ARGV.shift)

사용법 : 나는 peasant.rb라는 파일에 이것을 가지고 있습니다 :

$ time ruby peasant.rb 9999999999 9999999999
99999999980000000001

real    0m0.129s
user    0m0.096s
sys 0m0.027s

설명 : 농민 곱셈이므로 반복적으로 반으로 두 배로 늘립니다. 반은 숫자를 반으로 나누고 나머지는 다음과 같이 표시함으로써 수행됩니다. 1234-> 0b1a1b2a; 그런 다음 b를 찾아서 교체하십시오. 06a17a; 그런 다음 정리-> 617.

덧셈은 이렇게 수행됩니다 ... 우선, 두 문자열을 같은 길이로 채우고 숫자로 쌍을 만듭니다. 그런 다음 각 숫자의 길이를 가진 문자열을 구성하고 연결하여 숫자를 추가합니다. '0123456789abcdefghij'의 시작 부분에서 해당 길이의 문자열을 제거한 다음 첫 번째 문자를 유지합니다. 따라서, 예를 들어 "9"+ "9"-> "i". NB 나는 숫자 유형을 완전히 피하기 위해 실제로 길이 함수를 사용하지 않습니다. 접두사 제거는 대신 정규 표현식으로 수행됩니다.

이제 숫자와 문자가 혼합 된 문자열이 있습니다. 문자는 캐리 숫자가있는 숫자를 나타냅니다. 숫자 앞에 0을 붙인 다음 추가가 완료 될 때까지 캐리 문자의 결과로 숫자 문자 패턴을 반복해서 바꿉니다.

— 바자르
소스
1
매우 영리한 대답, 내가보고 싶었던 것과 정확히 일치합니다!
— Nathaniel
1
나는 실제로 누군가가 교회 숫자로 하나를 게시하기를 바라고 있습니다!
— bazzargh
효율성 요구 사항에 맞는지 잘 모르겠지만, 문자열과 교회 숫자를 변환하는 데 최대 99999999980000000001을 세는 것이 효과적이라고 생각합니다.
— Nathaniel
7

Brainfuck (1328 바이트)

처음에 고려할 사항 :

  • 셀 값이 '숫자 유형'으로 간주되는지 확실하지 않기 때문에 brainfuck 이이 질문에 대한 올바른 대답인지 확실하지 않습니다. BF는 유형을 알지 못하기 때문에 그렇게 생각하지 않지만 그건 내 자신의 의견입니다. 잘못되면 수정하십시오.
  • (거의) 무제한 값을 지원하는 구현이 필요합니다.
  • 구현에 따라 너무 느릴 수 있습니다.

나는 내 자신의 통역사로만 프로그램을 테스트했습니다. 여기에서 찾을 수 있습니다. . .

입력은 단일 ASCII 공백으로 구분 된 두 숫자 여야합니다.

골프 :

,>++++++[<----->-]<--[>,>++++++[<----->-]<--]>>>+<<<<[>>++++[<<---->>-]<<[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<,[>,]>>>+<<<<[>>+++++++[<<------->>-]<<+[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<<<<<[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]

언 골프 드 :

,
>++++++[<----->-]<--
[                                           # read input until space
    >,
    >++++++[<----->-]<--                    # decrease cell by 32 to check if it's a space
]
>>>+<<<<                                    # set multiplier to 1

[

    >>++++[<<---->>-]<<                     # decrease by 16 to get cell value of number

    [>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]        # multiply value by multiplier
    >>>>>[<<<<<+>>>>>-]                     # copy value back
    <[>++++++++++<-]>[<<+>>-]               # multiply multiplier by 10
    <<<<<                                   # go back to number

    [->+<]>[-<+>]                           # add value to next cell and move sum to previous cell

    <<                                      # go to next number
]

>>>>[-]<                                    # delete old multiplier

,[>,]                                       # read second number until end of input
>>>+<<<<                                    # set new multiplier

[

    >>+++++++[<<------->>-]<<+              # decrease by 48 to get cell value of number

    [>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]        # multiply value by multiplier
    >>>>>[<<<<<+>>>>>-]                     # copy value back
    <[>++++++++++<-]>[<<+>>-]               # multiply multiplier by 10
    <<<<<                                   # go back to number

    [->+<]>[-<+>]                           # add value to next cell and move sum to previous cell

    <<                                      # go to next number
]

>>>>[-]<<<<<                                # delete multiplier

[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>          # multiply both values

# magical algorithm for printing cell value as number taken from Cedric Mamo's code from a previous question
[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]

이 답변 에서 값의 출력을위한 코드를 가져 왔습니다.저자 덕분 !

프로그램 이 유효하지 않을 수도 있지만 어느 쪽이든 나는 당신과 공유하고 싶었습니다 ^^

최신 정보: 이제 SP3000의 @에, 여기 (단지 작은 곱셈에 대한) 감사를 테스트 할 수 대답 에 이 대회 와 SE의 새로운 스택 조각!

var NUM_CELLS = 30000;var ITERS_PER_SEC = 100000;var TIMEOUT_MILLISECS = 5000;function clear_output(){document.getElementById("output").value="";document.getElementById("stderr").innerHTML=""}function stop(){running=false;document.getElementById("run").disabled=false;document.getElementById("stop").disabled=true;document.getElementById("clear").disabled=false;document.getElementById("wrap").disabled=false;document.getElementById("timeout").disabled=false;document.getElementById("eof").disabled=false}function interrupt(){error(ERROR_INTERRUPT)}function error(e){document.getElementById("stderr").innerHTML=e;stop()}function run(){clear_output();document.getElementById("run").disabled=true;document.getElementById("stop").disabled=false;document.getElementById("clear").disabled=true;document.getElementById("wrap").disabled=true;document.getElementById("timeout").disabled=true;document.getElementById("eof").disabled=true;code=document.getElementById("code").value;input=document.getElementById("input").value;wrap=document.getElementById("wrap").value;timeout=document.getElementById("timeout").checked;eof=document.getElementById("eof").value;loop_stack=[];loop_map={};for(var e=0;e<code.length;++e){if(code[e]=="["){loop_stack.push(e)}else if(code[e]=="]"){if(loop_stack.length==0){error(ERROR_BRACKET);return}else{var t=loop_stack.pop();loop_map[t]=e;loop_map[e]=t}}}if(loop_stack.length>0){error(ERROR_BRACKET);return}running=true;start_time=Date.now();code_ptr=0;input_ptr=0;cell_ptr=Math.floor(NUM_CELLS/2);cells={};iterations=0;bf_iter(1)}function bf_iter(e){if(code_ptr>=code.length||!running){stop();return}var t=Date.now();for(var n=0;n<e;++n){if(cells[cell_ptr]==undefined){cells[cell_ptr]=0}switch(code[code_ptr]){case"+":if(wrap=="8"&&cells[cell_ptr]==255||wrap=="16"&&cells[cell_ptr]==65535||wrap=="32"&&cells[cell_ptr]==2147483647){cells[cell_ptr]=0}else{cells[cell_ptr]++}break;case"-":if(cells[cell_ptr]==0){if(wrap=="8"){cells[cell_ptr]=255}if(wrap=="16"){cells[cell_ptr]=65535}if(wrap=="32"){cells[cell_ptr]=2147483647}}else{cells[cell_ptr]--}break;case"<":cell_ptr--;break;case">":cell_ptr++;break;case".":document.getElementById("output").value+=String.fromCharCode(cells[cell_ptr]);break;case",":if(input_ptr>=input.length){if(eof!="nochange"){cells[cell_ptr]=parseInt(eof)}}else{cells[cell_ptr]=input.charCodeAt(input_ptr);input_ptr++}break;case"[":if(cells[cell_ptr]==0){code_ptr=loop_map[code_ptr]}break;case"]":if(cells[cell_ptr]!=0){code_ptr=loop_map[code_ptr]}break}code_ptr++;iterations++;if(timeout&&Date.now()-start_time>TIMEOUT_MILLISECS){error(ERROR_TIMEOUT);return}}setTimeout(function(){bf_iter(ITERS_PER_SEC*(Date.now()-t)/1e3)},0)}var ERROR_BRACKET="Mismatched brackets";var ERROR_TIMEOUT="Timeout";var ERROR_INTERRUPT="Interrupted by user";var code,input,wrap,timeout,eof,loop_stack,loop_map;var running,start_time,code_ptr,input_ptr,cell_ptr,cells,iterations
<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;"> <div style="float:left; width:50%;"> Code: <br> <textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">,>++++++[<----->-]<--[>,>++++++[<----->-]<--]>>>+<<<<[>>++++[<<---->>-]<<[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<,[>,]>>>+<<<<[>>+++++++[<<------->>-]<<+[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<<<<<[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]</textarea> <br>Input: <br> <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">7 6</textarea> <p> Wrap: <select id="wrap"> <option value="8">8-bit</option> <option value="16">16-bit</option> <option value="32" selected="selected">32-bit</option> </select> &nbsp; Timeout: <input id="timeout" type="checkbox"></input>&nbsp; EOF: <select id="eof"> <option value="nochange">Same</option> <option value="0" selected="selected">0</option> <option value="-1">-1</option> </select> </p> </div> <div style="float:left; width:50%;"> Output: <br> <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea> <p> <input id="run" type="button" value="Run" onclick="run()"></input> <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="true"></input> <input id="clear" type="button" value="Clear" onclick="clear_output()"></input> &nbsp; <span id="stderr" style="color:red"></span></p></div></div>
스 니펫 확장

— 암호
소스
나는 그것이 유효한지 모른다! 나는 Brainfuck의 모든 것이 숫자이거나 아무것도 아니라고 생각합니다.
— Nathaniel
나는이 답변을 좋아한다. 나는 최근에 BF와 엉망이었다. 그것은 기계 수준에서 모든 것이 어쨌든 단지 토큰이라는 사실에 빛을 발합니다. 이것이 실제로 규칙을 따르는 지 말하기 어렵다.
— Octopus
6

파이썬, 394 349 자

D='0123456789'
R=reversed
U=lambda x:[R for y in D if y<x]
T=U(':')
def A(a,b,r='',c=[]):
 for x,y in map(None,R(a),R(b)):
    d=U(x)+U(y)+c;t=T;c=[R]
    if d<T:t=c=[]
    r=min(k for k in D if U(k)+t>=d)+r
 if c:r='1'+r
 return r
a,b=input()
m=''
while b:
 if list(b).pop()in'13579':m=A(m,a)
 b=list(A(b,A(b,A(b,A(b,b)))));b.pop();a=A(a,a)
print m

다음과 같이 실행하십시오.

echo '"9999999999","9999999999"' | ./mulstr.py

50 밀리 초가 걸립니다.

러시아어 농민 곱셈을 사용합니다 . 숫자를 추가 할 때 숫자를 단항 ( '5'=> [R, R, R, R, R])으로 변환하고 목록을 연결 한 다음 다시 변환합니다. 단항 숫자로 U사용하여 단항으로 변환합니다 R. 로 계산 b/=2합니다 b=b*5/10.

— 키이스 랜달
소스
커플 골프 : def A(a,b):\n r='';c=[]-> def A(a,b,r='',c=[]):와 비슷합니다 def M. 당신은 변경할 수 있습니다 for z in D:d.pop()\n c=['X']할 수 [d.pop()for z in D];c=['X']있으며,이 경우에 당신도 이전에 그것을 축소 수 있습니다 if. 또한, if list(b).pop()in'13579'그냥있을 수 if b[:].pop()in'13579'있습니까?
— Justin
@Quincunx : 감사합니다. 첫 번째 반복 b에서는 목록이 아닌 문자열 이기 때문에 마지막 것은 작동 하지 않습니다.
— Keith Randall
M완전한 프로그램을 건너 뛰고 작성할 수 있습니다. a,b=input() 허용됩니다.
— Justin
1
b * 5 / 10은 좋은 트릭입니다.
— bazzargh
난 그냥 우연히 발견 reduce, 당신이 좋아할 A(b,A(b,A(b,A(b,b))))수 reduce(A,[b,b,b,b,b])있습니다. 슬프게도 이것은 문자 수에 영향을 미치지 않습니다.
— Wrzlprmft
5

자바 스크립트 (E6) 337595411449

편집 Golfed
편집 버그 수정 : 캐리 플래그를 클리어 누락

거의 0 번에 기호 조작만으로 수행 할 수 있습니다.
이 버전에서는 기호가 오름차순 인 한 숫자 대신 문자를 사용할 수 있습니다.

참고 : 문자열 사용, 문자열 키가있는 해시 맵, 목록으로 사용되는 배열. 인덱싱이 없으면 'map'을 사용하여 배열을 순회하거나 push & shift를 사용하여 회전합니다.
모든 '+'는 문자열 연결입니다. 

M=(x,y,S=a=>a.shift()||z,R=a=>[...a].reverse(),e=R('9876543210'),d=[...e])=>
  R(y)[T='map'](b=>
     R(x)[T](a=>(
       u=R[e[a+=b]+v],
       v=R[S[a]+(u<v?'1':z)],
       p[P](t=R[S(o)+u]),
       t<u?v=R[v+'1']:v
     ),o=p,p=[])
    +(v>z&&p[P](v),x+=v=z),
    d[T](a=>d[T](b=>e[P='push'](R[a+b]=S(e)))+e[P](S(e))),  
    d[T](a=>d[T](b=>e[d[T](c=>v=c<a?(u=R[u+b])<b?R[v+'1']:v:v,v=u=z='0'),S[a+b]=v,a+b]=u)),
    p=[v=z]
  )&&R(p).join(o)

덜 골프 (아마 내일 설명을 추가 할 것입니다)

M=(x,y)=>(
  R=a=>[...a].reverse(),
  // Addition table s 
  s={},
  e=[...'9012345678'],
  [for(a of(d='0123456789'))for(b of(e.push(e.shift()),d))e.push(s[a+b]=c=e.shift())],
  // Multiplication table m,n
  m={},n={},
  [for(a of d)for(b of d)(
     [for(c of(z=u=v='0',d))
     c<a&&(t=s[u+b],t<u?v=s[v+'1']:v,u=t)
     ],m[a+b]=u,n[a+b]=v
  )],
  x=R(x),v=z,o=[],p=[],
  [for(b of R(y))(
     [for(a of x)(
       u=s[m[a+b]+v],v=s[n[a+b]+(u<v?'1':z)],
       p.push(t=s[(o.shift()||z)+u]),
       t<u?v=s[v+'1']:v
     )],
     v>z?p.push(v):o,o=p,p=[],x.unshift(v=z)
  )],
  R(o).join('')
)

FireFox / FireBug 콘솔에서 테스트

t0=-new Date
r=M('9999999999','9999999999')
t1=-new Date
console.log("Result",r, "time ms", t0-t1)

산출

Result 99999999980000000001 time ms 14
— edc65
소스
아마도 약간의 버그 9999999999가있을 수 있습니다 . 사건 의 결과는 그렇지 않아야합니다 99999999980000000001.99999999980000000081
— Nathaniel
:( 체크 예정
— edc65
곱셈표를 사용하는 경우 합산이 허용되지 않는다는 사실을 어떻게 극복하고 있습니까?
— COTO
1
합산은 해시 테이블 (코드의 s)을 사용하여 허용됩니다. 전의. s ['34 ']->'7 '. 숫자가 아닌 기호입니다. s [ 'cd']-> 'g'일 수 있음
— edc65
5

하스켈, 231 바이트

이것은 자연수의 두 문자열 표현을 곱하는 연산자 #를 정의합니다. 문자열에 기본 증분 / 감소 연산을 정의한 다음이를 사용하여 덧셈과 곱셈을 만듭니다. 약간의 추가 마법은 모든 것을 가능하게하는 기하 급수적 인 속도 향상을 제공합니다.

r=reverse
n="9876543210"
t=True
c&(x:y)|c==x=head y|t=c&y
m%[]="1";m%(c:s)|c==last m=head m:m%s|t=c&m:s
[]!y=y;x![]=x;(x:a)!('0':b)=x:a!b;x!y=(r n%x)!(n%y)
"0"?_="0";x?('0':y)|all(=='0')y="0"|t=('0':x)?y;x?y=x?(n%y)!x
x#y=r$r x?r y

이 방법은 최적화되지 않은 ghci REPL의 2008 랩톱에서도 테스트 시간이 1 초에 불과합니다.

λ> :set +s
λ> let test = replicate 10 '9'
(0.00 secs, 0 bytes)
λ> test
"9999999999"
(0.00 secs, 1069784 bytes)
λ> test # test
"99999999980000000001"
(0.06 secs, 13451288 bytes)

두 자리 숫자 제품이 모두 올바른지 확인하십시오.

λ> and [ show (x * y) == (show x # show y) | x <- [0..100], y <- [0..100] ]
True
— 맷 누난
소스
새로운 지도자가있는 것 같습니다! (나는 Haskell을 읽을 수 없지만 누군가 스펙에 맞는지 독립적으로 확인할 수 있습니까?)
— Nathaniel
1
그렇습니다. 완벽하게 cromulent haskell이며 사양에 맞으며 광고 된대로 작동합니다. 잘 했어!
— bazzargh
4

배쉬 + ImageMagick : 52

convert -size ${a}x${b} xc:red txt:-|grep -v g|wc -l

입력이 쉘 변수 a및 에있을 것으로 예상합니다 b. 특히 영리하거나 효율적이지는 않지만 작업이 완료됩니다. 아마 전에 이루어 졌을 것입니다.

이 x표시는 이미지의 크기를 나타냅니다. 이 문맥에서는 산술 연산자가 아닙니다.

나는 이것을 테스트하지 않았지만 극단적 인 입력이 아닌 경우 1 분 안에 완료 될 것이라고 가정합니다. 내일 테스트 할 수 있습니다.

ImageMagick 버전으로 재미있는 사업이있는 경우 이것이 내가 사용하는 것입니다. ImageMagick 6.7.7-10

— 밀리 온
소스
시도해 보았지만 입력 9999999999및 에 대해 1 분 이내에 (또는 실제로 기존 컴퓨터에서 전혀 작동하지 않을 것) 확신합니다 9999999999.
— Nathaniel
4
이것은 또한 작동합니다 : dd if=/dev/zero bs=$a count=$b 2>&-|wc -c.
— jimmy23013
1
9999999999x99999999998 비트 형식 의 이미지는 현재 지구에 존재하는 모든 하드 드라이브 공간을 차지합니다. 물론 원시 이미지를 먼저 만들지 않고 만들 수 있다면 png는 훨씬 작을 것입니다. (나는 당신이 그 크기의 이미지에 정수 오버플로 문제가있을 것이라고 강력하게 생각합니다.) 그러나 여전히 그러한 방법은 호출하는 것, 즉 숫자-결과-문자열의 허점에 거의 파울 수 있습니다.
— Nathaniel
1
$b대신을 사용하여 2 바이트를 절약 할 수 있습니다 ${b}.
— nyuszika7 시간
1
또한 grep -vc g대신을 사용하여 5 바이트를 절약 할 수 있습니다 grep -v g|wc -l.
— nyuszika7 시간
2

Python 2 (개념 증명)

이 솔루션은 문자열과 목록 만 사용하고 약간의 정규식을 사용합니다. 나는 그것이 9999999999x9999999999분 안에 할 수있는 방법이 없다는 것을 제외하고는 사양에 완전히 부합한다고 생각합니다 . 충분한 시간이 주어졌지만 작동합니다. 4 자리 숫자를 매우 빠르게 곱할 수 있습니다.

기술적으로 유효하지 않기 때문에 아직 완전히 골프를 치르지 않았습니다. 규칙이 바뀌면 그렇게 할 것입니다.

import re
D='123456789'
D=dict(zip('0'+D,D+'0'))

def toRlist(s):
    if s:t,h=re.match(r'(\d*)(\d)',s).groups();return[h,toRlist(t)]
    return''

def increment(r):
    if not r:return['1','']
    h,t=r
    return[D[h],increment(t)if h=='9'else t]

def toString(r):
    if not r:return''
    h,t=r
    return h+toString(t)

def listify(r,L):
    if not r:return
    h,t=r
    if h=='1':L.append('')
    if h=='2':L.extend(['',''])
    if h=='3':L.extend(['','',''])
    if h=='4':L.extend(['','','',''])
    if h=='5':L.extend(['','','','',''])
    if h=='6':L.extend(['','','','','',''])
    if h=='7':L.extend(['','','','','','',''])
    if h=='8':L.extend(['','','','','','','',''])
    if h=='9':L.extend(['','','','','','','','',''])
    listify(t,L);listify(t,L);listify(t,L);listify(t,L);listify(t,L)
    listify(t,L);listify(t,L);listify(t,L);listify(t,L);listify(t,L)

def add(r1,r2):
    L=[];listify(r2,L)
    for _ in L:r1=increment(r1)
    return r1

def multiply(a,b):
    total=''
    r=toRlist(a)
    L=[];listify(toRlist(b),L)
    for _ in L:total=r if total=='' else add(total,r)
    return''.join(reversed(toString(total)))

예 :

multiply('12','5') #returns the string 60

multiply('1869','1243') #returns the string 2323167
— 캘빈의 취미
소스
1
내가 말할 수있는 한 사양 (효율 요구 사항 제외)을 충족하기 때문에 +1
— Nathaniel
2

파이썬 2 (555)

나는 보통 내 자신의 도전에 너무 빨리 (또는 전혀) 대답하지 않을 것이지만, 그것이 가능하다는 것을 증명하고 싶었다. (행운이 있기 전에 다른 답변이 있었지만, 끝내기를 원치 않았습니다.) 할 수있는 골프가 더 있지만, 이것이 합리적이라고 생각합니다. 9999999999x9999999999내 컴퓨터의 0.03 미만 에서 사례를 처리합니다 .

d="123456789";I=dict(zip('0'+d,d+'0'))
def r(x):return reversed(x)
def s(x):return''.join(x)
def i(x):
    try:
        h=I[x.next()]
        if h!='0':h+=s(x)
        else:h+=i(x)
        return h
    except:return'1'
def b(x,y):
    for c in'0'+d:
        if c==y:break
        x=iter(i(x))
    return x
def a(x,y):
    z=''
    for c in y:
        x=b(x,c)
        try:z+=x.next()
        except:z+='0'
    return z+s(x)
def n(x,y):
    z='0'
    for c in'0'+d:
        if c==y:break
        z=a(iter(z),x)
    return z
def o(x,y):
    x=s(x)
    l='';z=''
    for c in y:
        z=a(iter(z),l+s(n(x,c)))
        l+='0'
    return z
def m(x,y):
    return s(r(o(r(x),r(y))))

사용 예 : m("12345","42")

문자열 조작을 사용하여 긴 곱셈을 수행하여 작동합니다. 때로는 변수가 문자열이고 때로는 문자열을 반복하는 변수이므로 정수 리터럴을 사용하지 않고 첫 번째 요소를 가져올 수 있습니다. 첫 번째 요소가 최하위 숫자가되도록 모든 숫자가 숫자가 반대로 저장됩니다.

기능별 설명은 다음과 같습니다.

  • r 과 s 기능을 부기한다. ( r에 대한 별칭 reversed일 뿐이 므로 역 반복자를 만들고 s반복자를 문자열로 변환합니다.)

  • i39+1=40and와 같은 경우를 포함하여 문자열의 숫자를 1 씩 증가시킵니다 99+1=100.

  • b추가 x하고 y있지만,y 한 자리 여야합니다. x y시간 을 늘리면 작동합니다 .

  • a 전화하여 여러 자리를 가질 수있는 두 개의 숫자를 더합니다. b 각 자리수를 하여y .

  • nx및을 곱 y하지만 y한 자리 여야합니다. 그것은 추가하여 작동x자체 y시간 하여 .

  • o 곱하기 x 및 y이며 두 인수 모두 여러 자릿수를 가질 수 있습니다. 고전적인 곱셈을 사용합니다.

  • m문자열 입력을 역 반복자 o로 변환하고로 넘긴 다음 결과를 뒤집어 문자열로 변환합니다.

— 나다니엘
소스
커플 골프 : def a(x,y):-> def a(x,y,z=''):다음 줄을 제거; 다른 기능에 대한 유사한 트릭 def o(x,y):, 변경 x=s(x)하기 x=s(x);l='';z='', 점에서 루프, 유사하게 줄 바꿈 + 걸음을 제거; 대신을 사용하십시오 ;. 또한, 나는 if h!='0':h+=s(x)\nelse:h+=i(x)단순히 할 수 있다고 생각 한다 h+=h!='0'and i(x)or s(x); 어쩌면 h+=(h!='0'and i or s)(x); 그렇지 않으면 간단히로 변경하십시오 if'0'!=h. 또한 def r(x):return reversed(x)->r=reversed
— Justin
또한, 나는에 대한 얘기를 깜빡 했네요 s, m: s=lambda x:''.join(x), m=lambda x,y:s(r(o(r(x),r(y))))대신 전체 함수 선언의. 내가 알고있는 것만으로도 바이트 수가 521로 줄어 듭니다.
— Justin
아, 그리고 하나 더 : 당신의 for루프 : for c in'0'+d:\nif c==y:break\nz=a(iter(z),x)-> for c in'0'+d:\nif c!=y:z=a(iter(z),x), 이것은 프로그램의 속도를 크게 바꿀 수 있지만.
— Justin
@Quincunx 감사합니다! 오늘 아침에도 몇 가지 개선 사항이 있습니다. (함수를 정의하는 대신 루프를 중첩하는 경우가 있습니다.) 좀 더 경쟁적인 답변이 표시되면 이러한 변경을 할 것입니다. 현재 가능성이있는 것으로 보입니다. ve는 더 이상 그것에 대해 생각했다.
— Nathaniel
2

자바 스크립트 : 3710 3604 바이트

  • 1 자리 곱셈으로 문자열 조회 테이블을 사용하고 캐리로 추가합니다.
  • 곱셈은 ​​숫자 x 행 대신 숫자 x 숫자로 수행됩니다.

골프:

var M={
'00':'0','01':'0','02':'0','03':'0','04':'0','05':'0','06':'0','07':'0','08':'0','09':'0',
'10':'0','11':'1','12':'2','13':'3','14':'4','15':'5','16':'6','17':'7','18':'8','19':'9',
'20':'0','21':'2','22':'4','23':'6','24':'8','25':'10','26':'12','27':'14','28':'16','29':'18',
'30':'0','31':'3','32':'6','33':'9','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
'40':'0','41':'4','42':'8','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
'50':'0','51':'5','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
'60':'0','61':'6','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
'70':'0','71':'7','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
'80':'0','81':'8','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
'90':'0','91':'9','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81'
};
var A={
'000':'0','001':'1','002':'2','003':'3','004':'4','005':'5','006':'6','007':'7','008':'8','009':'9',
'010':'1','011':'2','012':'3','013':'4','014':'5','015':'6','016':'7','017':'8','018':'9','019':'10',
'020':'2','021':'3','022':'4','023':'5','024':'6','025':'7','026':'8','027':'9','028':'10','029':'11',
'030':'3','031':'4','032':'5','033':'6','034':'7','035':'8','036':'9','037':'10','038':'11','039':'12',
'040':'4','041':'5','042':'6','043':'7','044':'8','045':'9','046':'10','047':'11','048':'12','049':'13',
'050':'5','051':'6','052':'7','053':'8','054':'9','055':'10','056':'11','057':'12','058':'13','059':'14',
'060':'6','061':'7','062':'8','063':'9','064':'10','065':'11','066':'12','067':'13','068':'14','069':'15',
'070':'7','071':'8','072':'9','073':'10','074':'11','075':'12','076':'13','077':'14','078':'15','079':'16',
'080':'8','081':'9','082':'10','083':'11','084':'12','085':'13','086':'14','087':'15','088':'16','089':'17',
'090':'9','091':'10','092':'11','093':'12','094':'13','095':'14','096':'15','097':'16','098':'17','099':'18',
'100':'1','101':'2','102':'3','103':'4','104':'5','105':'6','106':'7','107':'8','108':'9','109':'10',
'110':'2','111':'3','112':'4','113':'5','114':'6','115':'7','116':'8','117':'9','118':'10','119':'11',
'120':'3','121':'4','122':'5','123':'6','124':'7','125':'8','126':'9','127':'10','128':'11','129':'12',
'130':'4','131':'5','132':'6','133':'7','134':'8','135':'9','136':'10','137':'11','138':'12','139':'13',
'140':'5','141':'6','142':'7','143':'8','144':'9','145':'10','146':'11','147':'12','148':'13','149':'14',
'150':'6','151':'7','152':'8','153':'9','154':'10','155':'11','156':'12','157':'13','158':'14','159':'15',
'160':'7','161':'8','162':'9','163':'10','164':'11','165':'12','166':'13','167':'14','168':'15','169':'16',
'170':'8','171':'9','172':'10','173':'11','174':'12','175':'13','176':'14','177':'15','178':'16','179':'17',
'180':'9','181':'10','182':'11','183':'12','184':'13','185':'14','186':'15','187':'16','188':'17','189':'18',
'190':'10','191':'11','192':'12','193':'13','194':'14','195':'15','196':'16','197':'17','198':'18','199':'19'
} 
Array.prototype.e=function(){return(''+this)==='';}
String.prototype.s=function(){return this.split('').reverse();}
function B(a,b,c) {
var r='',s='';
a=a.s();
b=b.s();
while (!a.e()||!b.e()||c!=='0') {
x=a.e()?'0':a.shift();
y=b.e()?'0':b.shift();
s=A[c+x+y];
s=s.s();
r=s.shift()+r;
c=s.e()?'0':'1';
}
return r;
}
function m(a,b) {
var s='0',m='';
b.split('').reverse().forEach(function(e){
var z=m;
a.split('').reverse().forEach(function(f){s=B(s,M[e+f]+z,'0');z+='0';});
m+='0';
});
return s;
}

테스트로 풀리지 않은 :

var mul = {
'00':'0','01':'0','02':'0','03':'0','04':'0','05':'0','06':'0','07':'0','08':'0','09':'0',
'10':'0','11':'1','12':'2','13':'3','14':'4','15':'5','16':'6','17':'7','18':'8','19':'9',
'20':'0','21':'2','22':'4','23':'6','24':'8','25':'10','26':'12','27':'14','28':'16','29':'18',
'30':'0','31':'3','32':'6','33':'9','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
'40':'0','41':'4','42':'8','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
'50':'0','51':'5','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
'60':'0','61':'6','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
'70':'0','71':'7','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
'80':'0','81':'8','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
'90':'0','91':'9','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81'
};

var adc = {
'000':'0','001':'1','002':'2','003':'3','004':'4','005':'5','006':'6','007':'7','008':'8','009':'9',
'010':'1','011':'2','012':'3','013':'4','014':'5','015':'6','016':'7','017':'8','018':'9','019':'10',
'020':'2','021':'3','022':'4','023':'5','024':'6','025':'7','026':'8','027':'9','028':'10','029':'11',
'030':'3','031':'4','032':'5','033':'6','034':'7','035':'8','036':'9','037':'10','038':'11','039':'12',
'040':'4','041':'5','042':'6','043':'7','044':'8','045':'9','046':'10','047':'11','048':'12','049':'13',
'050':'5','051':'6','052':'7','053':'8','054':'9','055':'10','056':'11','057':'12','058':'13','059':'14',
'060':'6','061':'7','062':'8','063':'9','064':'10','065':'11','066':'12','067':'13','068':'14','069':'15',
'070':'7','071':'8','072':'9','073':'10','074':'11','075':'12','076':'13','077':'14','078':'15','079':'16',
'080':'8','081':'9','082':'10','083':'11','084':'12','085':'13','086':'14','087':'15','088':'16','089':'17',
'090':'9','091':'10','092':'11','093':'12','094':'13','095':'14','096':'15','097':'16','098':'17','099':'18',
'100':'1','101':'2','102':'3','103':'4','104':'5','105':'6','106':'7','107':'8','108':'9','109':'10',
'110':'2','111':'3','112':'4','113':'5','114':'6','115':'7','116':'8','117':'9','118':'10','119':'11',
'120':'3','121':'4','122':'5','123':'6','124':'7','125':'8','126':'9','127':'10','128':'11','129':'12',
'130':'4','131':'5','132':'6','133':'7','134':'8','135':'9','136':'10','137':'11','138':'12','139':'13',
'140':'5','141':'6','142':'7','143':'8','144':'9','145':'10','146':'11','147':'12','148':'13','149':'14',
'150':'6','151':'7','152':'8','153':'9','154':'10','155':'11','156':'12','157':'13','158':'14','159':'15',
'160':'7','161':'8','162':'9','163':'10','164':'11','165':'12','166':'13','167':'14','168':'15','169':'16',
'170':'8','171':'9','172':'10','173':'11','174':'12','175':'13','176':'14','177':'15','178':'16','179':'17',
'180':'9','181':'10','182':'11','183':'12','184':'13','185':'14','186':'15','187':'16','188':'17','189':'18',
'190':'10','191':'11','192':'12','193':'13','194':'14','195':'15','196':'16','197':'17','198':'18','199':'19'
} 

Array.prototype.isEmpty = function() {
  return (''+this) === '';
}

function add(a, b, c) {
  var r = '', s = '';
  a = a.split("").reverse();
  b = b.split("").reverse();
  while (!a.isEmpty() || !b.isEmpty() || c !== '0') {
    x = a.isEmpty() ? '0' : a.shift();
    y = b.isEmpty() ? '0' : b.shift();
    s = adc[c + x + y];
    s = s.split("").reverse();
    r = (s.shift()) + r;
    c = (s.isEmpty()) ? '0' : '1';
  }
  return r;
}

function mult(a, b) {
  var s = '0';
  var m = '';
  b.split('').reverse().forEach(function(e) {
    var z = m;
    a.split('').reverse().forEach(function(f) {
      s = add(s, mul[e + f] + z, '0');
      z = z + '0';
    });
    m = m + '0';
  } );
  return s;
}

function test(a, b) {
  var t0 = (new Date()).getTime();
  var r = mult(a,b);
  var t1 = (new Date()).getTime();
  var e = t1 - t0;
  console.log('mult ' + a + ' * ' + b + ' = ' + r + " (" + e + " ms)");
}

test('12345', '42');
test('9999999999', '9999999999');

이 결과는 다음과 같습니다.

mult 12345 * 42 = 518490 (3 ms) 
mult 9999999999 * 9999999999 = 99999999980000000001 (47 ms)
— 스티븐 콴
소스
2

하스켈 (507) 496

이것은 임의로 큰 정수에 적용됩니다. 0에서 18까지의 자연수에 대한 사용자 정의 표현 (두 자릿수의 합과 가장 큰 자연수)을 정의하고 숫자 + 숫자 곱셈으로 정의하는 리틀 엔디안 곱셈을 정의합니다. 숫자 + 숫자 추가로 정의합니다. 10-18 값을 디지털 분해로 확장하는 축소 기능이 있습니다. 그런 다음 두 문자열을 읽고 뒤집어 맞춤 바인딩으로 변환하고 곱한 다음 다시 변환하여 올바른 결과를 얻습니다.

편집 2

공백과 괄호를 제거하고 가능한 경우 (- )쌍을 대체하여 여러 문자 명령에 대해 짧은 로컬 별칭을 만들어 여러 문자를 저장했습니다 $.

data S=Z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R deriving(Enum, Ord, Eq)
p Z=id
p x=succ.p(pred x)
s Z=id
s x=pred.s(pred x)
z=s J
r[]=[]
r(x:y)|x<J=x:r y
r(x:[])=z x:[A]
r(x:y)=z x:(r$p A a:b)where(a:b)=r y
a x y=r$w(r x)(r y)
m Z _=[]
m _[]=[]
m x y=r$a y(m(pred x)y)
t[]_=[Z]
t _[]=[Z]
t(x:z)y=r$a(m x y)(Z:r(t z y))
i '0'=Z
i x=succ.i.pred$x
b Z='0'
b x=succ.b.pred$x
w[]y=y
w x[]=x
w(x:c)(y:d)=p x y:(w c d)
o=map
v=reverse
f=(o i).v
g=v.o b
main=getLine>>=putStrLn.(\[x,y]->g$t(f x)(f y)).words

참고로, S는 정의 정수와 같은 데이터 형식 p(숫자 + 자리 추가)이며, "플러스" s(감소) 감산된다 r(디지털 분해로 확장)를 감소하고, a또한 (번호 + 숫자 첨가)이다 m인 곱하기 (숫자 * 숫자 곱하기) t는 시간 (숫자 * 숫자 곱하기) i이며 '해석'(문자열을 목록으로 변환 S),b '뒤로'(S를 문자열로 목록), f와 g는 골프를위한 단축입니다. 목적. 나는 암시 적으로도 숫자를 사용하지 않았다. 내가 얻은 가장 가까운 것은 후계자와 전임자를 사용하는 것이 었습니다.이 숫자는 자연수의 덧셈과 곱셈보다 훨씬 높은 수준의 수학적 개념입니다.

편집하다

시간 프로필을 포함하지 않았습니다.

> time echo "9999999999 9999999999" | runhaskell multnonum.hs
99999999980000000001

real    0m0.246s
user    0m0.228s
sys     0m0.012s

좋은 측정을 위해 :

> time echo "99999999980000000001 99999999980000000001" | runhaskell multnonum.hs
9999999996000000000599999999960000000001

real    0m0.244s
user    0m0.224s
sys     0m0.016s

미쳐 가자!

> time echo "9999999996000000000599999999960000000001 9999999996000000000599999999960000000001" | runhaskell multnonum.hs
99999999920000000027999999994400000000699999999944000000002799999999920000000001

real    0m0.433s
user    0m0.424s
sys     0m0.004s

확인

— 고고학
소스
1

파이썬 2-1165, 712, 668664

I,T,V,N,X,J=raw_input,dict,reversed,None,zip,''.join
D='0123456789'
z,o='01'
A,B=I(),I()
r=i=""
K=map(J,X('666622222222911111551111555884444447773333333','678945672389954132987698765898967457989837654'))
P=T(X(K,map(J,X('344501110011800000440000332673322124652202211','628480244668154132507698505422648609367491852'))))
S=T(X(K,'cdef678945abi65243ed87a9cbaghcdab89egfcb6a987'))
for d in D:P[z+d]=z;S[z+d]=d
def Z(A,B,R=r):
 for a,b in V(map(N,V(z+A),V(z+B))):c=(a or z)+(b or z);s=S[min(c)+max(c)];R=Z(R,o)+T(X('abcdefghi',D))[s]if s>"?"else R+s
 return R
for a in V(A):
 j=""
 for b in V(B):r=Z(r,P[min(a+b)+max(a+b)]+i+j).lstrip(z);j+=z
 i+=z
print r if r else z

나는 논리적 인덱싱을 사용하고 있지 않습니다 Z = [X, Y][N == "0"]. 이것은 숫자 인덱스로 캐스팅 된 부울로 해석 될 수 있기 때문입니다.

언 골프 드 :

A = raw_input()
B = raw_input()

P = {'00':'00','01':'00','02':'00','03':'00','04':'00','05':'00','06':'00','07':'00','08':'00','09':'00',
     '10':'00','11':'01','12':'02','13':'03','14':'04','15':'05','16':'06','17':'07','18':'08','19':'09',
     '20':'00','21':'02','22':'04','23':'06','24':'08','25':'10','26':'12','27':'14','28':'16','29':'18',
     '30':'00','31':'03','32':'06','33':'09','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
     '40':'00','41':'04','42':'08','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
     '50':'00','51':'05','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
     '60':'00','61':'06','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
     '70':'00','71':'07','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
     '80':'00','81':'08','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
     '90':'00','91':'09','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81',
     }
S = {'00':'0','01':'1','02':'2','03':'3','04':'4','05':'5','06':'6','07':'7','08':'8','09':'9',
     '10':'1','11':'2','12':'3','13':'4','14':'5','15':'6','16':'7','17':'8','18':'9','19':'a',
     '20':'2','21':'3','22':'4','23':'5','24':'6','25':'7','26':'8','27':'9','28':'a','29':'b',
     '30':'3','31':'4','32':'5','33':'6','34':'7','35':'8','36':'9','37':'a','38':'b','39':'c',
     '40':'4','41':'5','42':'6','43':'7','44':'8','45':'9','46':'a','47':'b','48':'c','49':'d',
     '50':'5','51':'6','52':'7','53':'8','54':'9','55':'a','56':'b','57':'c','58':'d','59':'e',
     '60':'6','61':'7','62':'8','63':'9','64':'a','65':'b','66':'c','67':'d','68':'e','69':'f',
     '70':'7','71':'8','72':'9','73':'a','74':'b','75':'c','76':'d','77':'e','78':'f','79':'g',
     '80':'8','81':'9','82':'a','83':'b','84':'c','85':'d','86':'e','87':'f','88':'g','89':'h',
     '90':'9','91':'a','92':'b','93':'c','94':'d','95':'e','96':'f','97':'g','98':'h','99':'i',
     }
L = {'a':'0','b':'1','c':'2','d':'3','e':'4','f':'5','g':'6','h':'7','i':'8'}

def strSum(A, B):
    R = ""
    for a, b in reversed(map(None, reversed("0" + A), reversed("0" + B))):
        if a == None: a = '0'
        if b == None: b = '0'
        s = S[a + b]
        if s.isdigit():
            R += s
        else:
            R = strSum(R, "1") + L[s]
    return R

i = ""
r = "0"
for a in reversed(A):
    j = ""
    for b in reversed(B):
        p = P[a + b] + i + j
        r = strSum(r, p)
        j += "0"
    i += "0"

r = r.lstrip("0")
if r == "":
    r = "0"

print r
— 팔코
소스
나는 실제 정수 값을 비교하고 있기 때문에 min () 및 max () 함수를 사용해서는 안된다고 말하고 싶습니다.
— WorldSEnder
@WorldSEnder : 나는 그들이이 도전에서 허용되는 문자를 비교한다고 말하고 싶습니다. ( "문자의 문자
— Falko
1

스칼라, 470 자

(이것은 ⇒표준 스칼라이지만 =>바이트를 세는 경우 대신 대체 할 수 있습니다 )

def p(a: String,b: String)={type D=List[Char]
val d="0123456789".toList
def v(s: String)=s.toList.map{c⇒d.takeWhile(c.!=)}
def u(l:D, a:D):(Char,D)=l match {
case _::_::_::_::_::_::_::_::_::_::m⇒u(m,'a'::a)
case _⇒(('a'::l).zip(d).last._2,a)}
val o=(("", List[Char]())/:v(a).tails.toList.init.map{l⇒(v(b) map {_.flatMap(_⇒l.head)})++l.tail.map(_⇒Nil) reverse}.reduce(_.zipAll(_, Nil, Nil).map{t⇒t._1++t._2}))({(t,e)⇒val s=u(t._2++e,Nil);(s._1+t._1,s._2)})
u(o._2, Nil)._1+o._1}

여기서 우리는 목록의 길이를 사용하여 숫자를 모방하고 있습니다. 접기,지도, 우편 번호 등의 숫자 연산을 사용하지 않도록주의하십시오. 숫자는이 자릿수의 목록입니다 (계산 도중 반쯤 순서가 역순 임). 우리는 개별 숫자를 곱하고 flatMap행 을와 곱 reduce합니다. u캐리를 계산하고 (> 10 개 요소의 목록과 직접 일치하고 되풀이하여) 숫자를 다시 문자로 변환하여 a /:를 사용 하여 스택을 통해 작업합니다. 필수 예제는 1 초 이내에 완료됩니다.

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