Lấy cảm hứng từ CMC này

Cho một số nguyên dương lớn hơn 0, thực hiện thao tác sau trên nó:

• Nếu tất cả mười chữ số đơn ( 1234567890) đều ở số ít nhất một lần, hãy xuất số đếm và thoát khỏi chương trình
• Nếu không, nhân đôi số và lặp lại, tăng số đếm.

Số đếm bắt đầu từ 0 và là số lần đầu vào được nhân đôi. Ví dụ: nếu đầu vào là 617283945, nó sẽ cần được nhân đôi một lần vì 1234567890 có tất cả 10 chữ số trong đó.

Đây là một môn đánh gôn nên mã ngắn nhất sẽ thắng. Đầu vào có thể được lấy dưới dạng một chuỗi, nếu bạn muốn.

Các trường hợp thử nghiệm

input => output

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

Python 3 , 39 byte

f=lambda n:len({*str(n)})<10and-~f(n*2)

Hãy thử trực tuyến!

Đầu ra Falsecho 0.

J , 24 23 byte

(]1&(+$:)2**)10>#@~.@":

Hãy thử trực tuyến!

Giải trình

(]1&(+$:)2**)10>#@~.@":  Input: integer n
                     ":  Format as string
                  ~.@    Unique
                #@       Length
             10>         Less than 10
           *             Multiply, gives n if previous was true, else 0
         2*              Multiply by 2
 ]                       Get the previous condition
  1&(   )                Execute this if true on 2n, else return 0
      $:                   Recurse
  1  +                     Add 1

05AB1E , 11 10 byte

-1 byte nhờ scottinet

[D9ÝåË#·]N

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

[          // Start infinity loop
 D         // Duplicate current value (or input)
  9Ý       // Push [0,1,2,3,4,5,6,7,8,9]
    å      // Does each exist in the current value
     Ë#    // Break if all equal (if every digit exists)
       ·   // Else double the current value
        ]N // End loop and print the number of times through the loop

Perl 6 ,31 28 byte (27 ký tự)

-3 byte nhờ @Joshua

{($_,2×*...*.comb.Set>9)-1}

Hãy thử trực tuyến!

Giải thích: Vẫn cùng cấu trúc để tạo danh sách đệ quy. Phần tử đầu tiên là số đã cho ( $_), mỗi phần tử tiếp theo gấp 2 lần số trước ( 2×*- chúng tôi sử dụng ×, bởi vì, mặc dù ký tự 2 byte, nó vẫn rẻ hơn 1 byte 2 * *) và chúng tôi làm điều này cho đến khi điều kiện cuối *.comb.unique>9được thỏa mãn , tức là khi có nhiều hơn 9 ký tự duy nhất trong số. (Về mặt kỹ thuật, chúng tôi chia chuỗi thành một danh sách các ký tự .comb, buộc nó thành một tập hợp với .Set(tất nhiên, Bộ chỉ chứa mỗi phần tử một lần) và so sánh với 9, điều này buộc tập hợp vào bối cảnh số, lần lượt đưa ra bối cảnh số. số lượng phần tử của nó.)

Cuối cùng, chúng tôi trừ 1 từ danh sách này. Một lần nữa, danh sách bị buộc vào bối cảnh số, vì vậy những gì chúng tôi trả về ít hơn 1 so với độ dài của danh sách đó.

JavaScript (ES6) + big.js , 84 74 73 70 byte

Cảm ơn @ ConorO'Brien vì đã tiết kiệm 10 byte bằng cách đề xuất big.js thay vì bignumber.js
Cảm ơn @Rick Hitchcock cho -1 byte
Cảm ơn @Shaggy cho -3 byte

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

Lấy đầu vào dưới dạng chuỗi; hỗ trợ lên đến khoảng 2 ⁶⁹ do chuyển đổi ký hiệu khoa học tự động xảy ra ngoài thời điểm đó.

Kiểm tra đoạn trích

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

;[617283945, 2, 66833, 1234567890, 100, 42].forEach(t=>console.log(`f(${t}) = `+f(t)))

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>

Phạm vi vô hạn, 106 88 87 84 byte

Bằng cách sử dụng tùy chọn cấu hình để vô hiệu hóa ký hiệu khoa học khi chuyển đổi số thành chuỗi, chúng ta có thể có phạm vi gần như vô hạn.

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)),Big.E_POS=1e9)?0:1+f(c.mul(2))

let num = `${Math.random()*1e6|0}`.repeat(100)
O.innerText=`f(\n${num}\n) = ${f(num)}`

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>
<pre id=O style="width:100%;white-space:normal;overflow-wrap:break-word"></pre>

Thạch , 12 , 11 byte

QLn⁵
ḤÇпL’

Hãy thử trực tuyến!

Phải đi thật nhanh!

Giải trình:

        # Helper link, takes one argument 'z'
Q       # The unique digits of 'z'
 L      # Length
  n     # Does not equal
   ⁵    # 10
        #
        # Main link
  п    # While <condition> is true, run <body> and return all intermediate results
        # Condition:
 Ç      #   The helper link
        # Body:
Ḥ       #   Double the input
        # Now we have a list of all the 'z's that we passed to the helper link
    L   # Return it's length
     ’  # minus one

Haskell , 46 byte

f n|all(`elem`show n)['0'..'9']=0|1<3=1+f(2*n)

Hãy thử trực tuyến!

J , 43 byte

f=:(,$:@+:@{.)`[@.(9<[:#@~.10&#.inv)
<:@#@f

Hãy thử trực tuyến!

Xác định một hàm ẩn danh. Thu thập kết quả khá tuyệt vời. Kiểm tra câu trả lời vượt trội dặm ở đây!

Haskell, 44 byte

until(\c->all(`elem`show(n*2^c))['0'..'9'])(+1)0

Clojure, 115 89 82 byte

-26 byte chỉ bằng cách sử dụng một chuỗi để biểu thị danh sách các ký tự (duh, khi nhìn lại) và thay đổi từ sử dụng đệ quy sang loop, cho phép tôi thực hiện một vài tối ưu hóa.

-7 byte bằng cách loại bỏ cuộc gọi đến bigint. Rõ ràng chúng ta chỉ cần xử lý đầu vào sẽ không gây ra tràn.

#(loop[n % c 0](if(empty?(remove(set(str n))"1234567890"))c(recur(* 2 n)(inc c))))

Đã sẵn sàng:

(defn pan [num]
  (loop [n num
         cnt 0]

    ; Remove all the characters from the stringified input
    ;  that are numeric. If the result is an empty list, all
    ;  the numbers were present.
    (if (empty? (remove (set (str n)) "1234567890"))
      cnt
      (recur (* 2 n) (inc cnt)))))

Võng mạc , 85 byte

^\d*
$&¶$&
D`.(?=.*¶)
\d{10}¶\d+|\d*¶

[5-9]
#$&
T`d`EE
T`_d#`d_`\d#
#
1
}`\d\b
$&@
@

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Hơi tối ưu hóa cho thời gian chạy. Giải trình:

^\d*
$&¶$&

Nhân đôi số đầu vào.

D`.(?=.*¶)

Lặp lại các chữ số trong bản sao đầu tiên.

\d{10}¶\d+|\d*¶

Nếu vẫn còn 10 chữ số, hãy xóa cả hai số, nếu không thì chỉ cần xóa bản sao đầu tiên. Lưu ý rằng việc xóa cả hai số làm cho phần còn lại của vòng lặp không có op.

[5-9]
#$&

Đặt một #chữ số lớn trước.

T`d`EE

Nhân đôi mỗi chữ số.

T`_d#`d_`\d#

Thêm vào mang.

#
1

Đối phó với một thực hiện hàng đầu.

}`\d\b
$&@

Nối một @ và lặp cho đến khi tìm thấy tất cả 10 chữ số.

@

In số @s được thêm vào.

APL (Dyalog Unicode) , 19 + 2 = 21 byte

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵}

Hãy thử trực tuyến!

Đây là một dyadic Dfn( d irect f unstio n ), lấy 0 làm đối số bên trái của nó và số nguyên là bên phải. Vì đầu vào được cho là chỉ là số nguyên, tôi đã thêm 2 byte cho đối số 0∘vào số byte.

f←không được bao gồm trong số byte, vì nó không cần thiết . Nó chỉ làm cho nó dễ dàng hơn để xây dựng các trường hợp thử nghiệm.

Làm thế nào nó hoạt động:

Các tiêu đề: Tôi đã xóa chúng khỏi số byte sau khi trò chuyện trong phòng APL, vì chức năng thực hiện những gì nó phải làm và kết quả chỉ không chính xác do cài đặt mặc định của REPL của APL.

⎕FR←1287Thiết lập F loat R epresentation đến 128-bit thập phân (7 là mã cho số thập phân trong REPL APL). ⎕PP←34Đặt P rint P recision thành 34 chữ số. Cả hai điều này đều cần thiết, vì đại diện mặc định của APL cho các số lớn biến chúng thành ký hiệu khoa học (ví dụ: 3.14159265359E15) làm rối mã thời gian lớn.

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵} ⍝ Dyadic Dfn
0∘                     ⍝ Fixes 0 as the left argument  
          :            ⍝ If
     ⎕D                ⍝ String representation of all digits [0, 9]
       ∊               ⍝ "is in"
        ⍕⍵             ⍝ String representation of the input
   ∧/                  ⍝ AND-reduction. Yields 1 (true) iff all digits are in the right argument.
           ⍺           ⍝ return the left argument
            ⋄          ⍝ Else
                 2×⍵   ⍝ Double the right arg
             ⍺+1       ⍝ increment the left arg
                ∇      ⍝ Recursively call this function with the new arguments.

Java 8, 132 110 87 74 byte

n->{int c=0;for(;(n+"").chars().distinct().count()!=10;n*=2)c++;return c;}

-57 byte nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử nó ở đây. (Lưu ý: trường hợp kiểm tra 2bị vô hiệu hóa vì nó sẽ dừng ở 2 ⁶⁸ , nhưng kích thước của longđược giới hạn ở 2 ⁶³ -1.)

n->          // Method with long parameter and integer return-type
  int c=0;   //  Count-integer, starting at 0
  for(;(n+"").chars().distinct().count()!=10;
             //  Loop (1) as long as the unique amount of digits in the number are not 10
    n*=2)    //    After every iteration: multiply the input by 2
   c++;      //   Increase the count by 1
             //  End of loop (1) (implicit / single-line body)
  return c;  //  Return the counter
}            // End of method

Cũ 132 byte trả lời bằng cách sử dụng Stringđầu vào và regex:

n->f(n,0)int f(String n,int c){String t="";for(int i=0;i<10;t+="(?=.*"+i+++")");return n.matches(t+".*")?c:f(new Long(n)*2+"",c+1);}

Hãy thử nó ở đây. (Lưu ý: trường hợp kiểm tra 2bị vô hiệu hóa vì nó gây ra StackOverflowException do đệ quy quá nhiều.)

Tổng regex để kiểm tra xem Chuỗi có chứa tất cả 9 chữ số hay không ^(?=.*0)(?=.*1)(?=.*2)(?=.*3)(?=.*4)(?=.*5)(?=.*6)(?=.*7)(?=.*8)(?=.*9).*$, sử dụng giao diện tích cực cho toàn bộ Chuỗi.

Husk , 10 byte

←Vö>9Lud¡D

Hãy thử trực tuyến!

Giải trình

        ¡D    Repeatedly double the input, collecting results in a list
 V            Return the first index where the following is true
     L          The length of
       d        the digits
      u         with duplicates removed
  ö>9           is greater than 9
←             Decrement (as Husk uses 1-indexing)

Toán học, 59 48 47 46 38 byte

-9 byte nhờ Jenny_mathy.

If[!FreeQ[DigitCount@#,0],#0[2#]+1,0]&

Hãy thử trực tuyến bằng Mathics!

R , 74 byte

function(x){while(!all(0:9%in%el(strsplit(c(x,""),"")))){F=F+1;x=2*x};F*1}

Hãy thử trực tuyến! Lưu ý rằng R sẽ đưa ra câu trả lời sai f(2)do những hạn chế về cách ngôn ngữ lưu trữ các số nguyên lớn.

Giải thích: Đối với bài kiểm tra về tính kỹ thuật số, đầu vào được ép thành một vectơ ký tự bằng cách nối với một chuỗi rỗng và sau đó chia thành các chữ số riêng lẻ. Sau đó chúng tôi kiểm tra xem tất cả 0: 9 có trong vectơ kết quả hay không; nếu không, chúng ta tăng bộ đếm, tăng gấp đôi đầu vào và lặp lại.

Bộ đếm sử dụng F khởi tạo là FALSE. Để đảm bảo nó được ép thành số, chúng tôi nhân một số trước khi quay trở lại.

PowerShell , 70 69 byte

for($n=[bigint]$args[0];([char[]]"$n"|group).count-le9;$n*=2){$i++}$i

Hãy thử trực tuyến!

(Gần gấp đôi câu trả lời của Python: - \)

Đưa đầu vào $args[0], biến nó thành một [bigint], lưu nó vào $n. Nhập một forvòng lặp. Mỗi lần lặp, chúng tôi kiểm tra xem liệu $number có chuyển đổi thành chuỗi sau đó thành char-array hay không, khi Group-Object'cùng nhau, có một.count -l ess hơn hoặc equal tới 9. Có nghĩa là, cách duy nhất mà nó bằng 10 là nếu có ít nhất một chữ số của mỗi số 1234567890. Nếu có, chúng tôi thoát khỏi vòng lặp. Nếu không, chúng tôi $n*=2và tiếp tục. Mỗi lần lặp bên trong vòng lặp, chúng ta chỉ đơn giản là tăng lên $i. Khi chúng ta thoát khỏi vòng lặp, chúng ta chỉ cần xuất ra $i.

Lưu ý rằng đối với đầu vào như 1234567890nơi mà mọi chữ số đã được tính, điều này sẽ không tạo ra gì, đó là giá trị falsey trong PowerShell và tương đương với 0khi được chọn là một [int]. Nếu điều đó không ổn, chúng ta chỉ cần đặt một +đầu ra trước đầu ra $iđể đúc nó thành một số nguyên.

Lưu một byte nhờ Roland Heath.

Pyth , 11 byte

f>l{`.<QT9Z

Bộ kiểm tra .

Số tự nhiên đầu tiên Tnơi input << Tđáp ứng yêu cầu.

Perl 5 , 52 + 1 (-p) = 53 byte

$/=10;for$i(0..9){$/-=/$i/}$_*=2;++$\;$/&&redo}{$\--

Hãy thử trực tuyến!

Perl, 43 + 1 byte

for$x(0..9){$_*=2,++$\,redo LINE if!/$x/}}{

Sử dụng -pcờ. Điều này được xây dựng dựa trên giải pháp được cung cấp bởi Xcali ở trên.

Swift 4 , 111 byte

func p(_ x:Int,_ c:Int=0)->Int{if !(String(Set(String(x)).sorted())=="0123456789"){return p(x*2,c+1)};return c}

Lưu ý: Không hoạt động cho x = 2, vì tràn.

Giải thích - Đầu vào x là kiểu chữ đầu tiên được xâu chuỗi. Sau đó Set () xóa các ký tự lặp lại. Sau đó, nó được sắp xếp để phù hợp với kết quả. Nếu nó không khớp, x sẽ tăng gấp đôi và bộ đếm được tăng lên.

Hồng ngọc 46 45 39 38 byte

def f n;n.digits.uniq[9]?0:1+f(n*2)end

Hãy thử trực tuyến!

Cập nhật:

1. -1 bằng cách sử dụng def f n;thay vì def f(n);.
2. -6 bằng cách sử dụng …[9]thay vì….size==10
3. -1 bằng cách xóa dấu chấm phẩy

Japt , 15 byte

LÆ*2pXÃbì_â Ê¥A

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U.

LÆ    Ã

Tạo một mảng các số nguyên từ 0đến 99và chuyển từng thông qua một hàm trong đó Xlà phần tử hiện tại.

*2pX

Unhân với 2 nâng lên sức mạnh của X.

b

Lấy chỉ mục của phần tử đầu tiên thay thế trả về true khi được chuyển qua hàm sau.

ì_â

Chia thành một mảng các chữ số và loại bỏ các bản sao.

Ê¥A

Lấy độ dài của mảng và kiểm tra sự bằng nhau với 10 .

Thay thế, 15 byte

@*2pX)ìâ sÊ¥A}a

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U.

@            }a

Bắt đầu với 0, trả về số đầu tiên trả về true khi chuyển qua hàm sau, với Xsố hiện tại.

*2pX)

Như trên, nhân Uvới 2 với sức mạnh của X.

ìâ

Tách thành một mảng các chữ số, loại bỏ trùng lặp và nối lại với một số nguyên.

sÊ

Chuyển đổi thành một chuỗi, lấy độ dài và chuyển đổi lại thành một số nguyên.

¥A

Kiểm tra sự bình đẳng với 10.

QBIC , 48 byte, nc

{q=1[z|q=q*instr(!:$,!a-1$)]~q>0|_Xp\p=p+1┘b=b*2

Điều này nên làm việc, trên lý thuyết. Tuy nhiên, trong thực tế, điều này không thành công vì QBasic đưa ra các số có mười chữ số (ít nhất là cần thiết để có được tất cả các chữ số) theo ký hiệu khoa học ... Tôi đã đánh dấu nó là không cạnh tranh vì điều đó.

Giải trình

{             DO ad infinitum
q=1           set q to 1
[z|           FOR a = 1 to 10
q=q*instr     multiply q by the position
(!:$             - in 'b' (read from cmd line at start) cast to string (! ... $)
,!a-1$)          - of the number a-1 [0-9] cast to string
]             NEXT
~q>0          IF any character was not found, instr gave a 0. If q != 0 all digits were present
|_Xp          THEN quit, printing  p (is 0 at start)
\p=p+1        ELSE increase step counter p
┘b=b*2        and double 'b'

GNU dc, 61 byte

Đầu vào được sao chép từ đầu ngăn xếp (phải khác trống); đầu ra được đẩy lên đầu ngăn xếp.

[I~1r:ad0<s]ss[d1+r;a1=p]sp[d2*lfx]sh[0Sadlsxlpx11!=h]dsfxz1-

Giải trình

Chúng tôi sử dụng biến mảng a, lưu trữ 1 in a[d]nếu có chữ số d, nếu không sẽ rơi về 0 ở đó. Chúng tôi sử dụng phần mở rộng GNU ~để lấy thương số và phần còn lại trong một lệnh.

# populate a[0-9] from the digits
[I~1r:ad0<s]ss

# check pandigit
# return 1 more than lowest unset element of a[]
# start with stack=0
[d1+r;a1=p]sp

# Test for pandigit; double and repeat if needed
[dd+lfx]sh
[0Sadlsxlpx11!=h]dsfx

# We left one value on the stack for each doubling, plus the original
z1-

Là một phần thưởng, điều này sẽ hoạt động trong các cơ sở số tùy ý (không chỉ thập phân): chỉ cần đặt cơ số đầu vào theo yêu cầu (hằng số 11trong định nghĩa fsẽ được đọc bằng cơ sở số đó, do đó sẽ tự động chính xác).

Kiểm tra

for i in 617283945 2 66833 1234567890 100 42
do
    printf '%s => ' $i
    dc -e $i \
       -e '[I~1r:ad0<s]ss[d1+r;a1=p]sp[dd+lfx]sh[0Sadlsxlpx11!=h]dsfxz1-' \
       -e p
done

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

REXX, 57 byte

arg n
do b=0 while verify(0123456789,n)>0
  n=n*2
  end
say b

q / kdb + , 33 byte

Giải pháp:

(#)1_{x*2 1 min!:[10]in 10 vs x}\

Ví dụ:

q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[100]
51
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[1234567890]
0
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[42]
55

Giải trình:

Tất cả các byte là trong đẳng thức, có thể có thể đánh gôn này xuống một chút nữa. Sử dụng scantrạng từ của q :

count 1_{x*2 1 min til[10] in 10 vs x}\ / ungolfed solution
        {                            }\ / scan over this lambda until it yields same result
                              10 vs x   / convert to base 10
                           in           / left list in right list, returns boolean list
                   til[10]              / range 0..9
               min                      / return the minimum of the list, 0 or 1
           2 1                          / list (2;1) indexed into with 0 or 1
         x*                             / return x multiplied by either 2 or 1
      1_                                / 1 drop, drop one element from front of list
count                                   / count the length of the list

Ghi chú:

Nếu chúng ta thả xuống kdấu nhắc thì chúng ta có thể có một giải pháp 25 byte. Chuyển đổi số thành danh sách các ký tự:

q)\
  #1_{x*2 1@&/($!10)in$$x}\[100]
51