Inspiriert von diesem CMC

Führen Sie bei einer positiven Ganzzahl größer als 0 die folgende Operation aus:

• Wenn alle zehn einzelnen Ziffern ( 1234567890) mindestens einmal in der Nummer enthalten sind, geben Sie den Zähler aus und beenden Sie das Programm
• Andernfalls verdoppeln Sie die Zahl und wiederholen Sie den Vorgang, indem Sie die Anzahl erhöhen.

Die Zählung beginnt bei 0 und gibt an, wie oft die Eingabe verdoppelt wurde. Wenn die Eingabe beispielsweise 617283945 wäre, müsste sie einmal verdoppelt werden, da 1234567890 alle 10 Ziffern enthält.

Dies ist ein Code-Golf, also gewinnt der kürzeste Code. Die Eingabe kann nach Belieben als Zeichenfolge erfolgen.

Testfälle

input => output

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

Python 3 , 39 Bytes

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

Probieren Sie es online!

Ausgänge False für 0.

J , 24 23 Bytes

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

Probieren Sie es online!

Erläuterung

(]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 Bytes

-1 byte dank scottinet

[D9ÝåË#·]N

Probieren Sie es online! oder als Test Suite

[          // 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 Bytes (27 Zeichen)

-3 Bytes dank @Joshua

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

Probieren Sie es online!

Erläuterung: Immer noch dasselbe Konstrukt zum rekursiven Generieren von Listen. Das erste Element ist die angegebene Zahl ( $_), jedes nächste Element ist das 2-fache der vorherigen ( 2×*- wir verwenden ×, da es, obwohl 2-Byte-Zeichen, immer noch 1 Byte billiger ist als 2 * *), und wir tun dies, bis die Endbedingung von *.comb.unique>9erfüllt ist dh wenn die Nummer mehr als 9 eindeutige Zeichen enthält. (Technisch gesehen zerlegen wir die Zeichenfolge in eine Liste mit Zeichen .comb, erzwingen sie in eine Menge mit .Set(natürlich enthalten Mengen jedes Element nur einmal) und vergleichen sie mit 9, wodurch die Menge in einen numerischen Kontext versetzt wird, was wiederum ergibt die Anzahl der Elemente.)

Schließlich subtrahieren wir 1 von dieser Liste. Die Liste wird wiederum in einen numerischen Kontext gezwungen, sodass 1 weniger als die Länge dieser Liste zurückgegeben wird.

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

Vielen Dank an @ ConorO'Brien für das Speichern von 10 Byte, indem big.js anstelle von bignumber.js vorgeschlagen wird. Vielen
Dank an @Rick Hitchcock für -1 Byte.
Vielen Dank an @Shaggy für -3 Byte

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

Übernimmt die Eingabe als String; unterstützt bis zu 2 ^69, da die automatische Konvertierung der wissenschaftlichen Notation über diesen Punkt hinaus erfolgt.

Testschnipsel

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>

Unendlicher Bereich, 106 88 87 84 Bytes

Wenn Sie die Option config verwenden, um die wissenschaftliche Notation bei der Konvertierung von Zahlen in Zeichenfolgen effektiv zu deaktivieren, können Sie einen nahezu unendlichen Bereich festlegen.

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>

Jelly , 12 , 11 Bytes

QLn⁵
ḤÇпL’

Probieren Sie es online!

Muss schnell los!

Erläuterung:

        # 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 Bytes

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

Probieren Sie es online!

J, 43 bytes

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

Try it online!

Defines an anonymous function. Collects results quite suboptimally. Check out miles's superior answer here!

Haskell, 44 bytes

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

Clojure, 115 89 82 bytes

-26 bytes by just using a string to represent the list of characters (duh, in retrospect), and changing from using recursion to loop, which allowed me to make a couple of optimizations.

-7 bytes by getting rid of the call to bigint. Apparently we only need to handle input that won't cause an overflow.

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

Pregolfed:

(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)))))

Netzhaut , 85 Bytes

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

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

Probieren Sie es online! Link enthält Testfälle. Leicht laufzeitoptimiert. Erläuterung:

^\d*
$&¶$&

Duplizieren Sie die eingegebene Nummer.

D`.(?=.*¶)

Deduplizieren Sie die Ziffern in der ersten Kopie.

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

Wenn noch 10 Stellen übrig sind, löschen Sie beide Nummern, andernfalls löschen Sie einfach die erste Kopie. Beachten Sie, dass das Löschen beider Nummern dazu führt, dass der Rest der Schleife nicht mehr ausgeführt wird.

[5-9]
#$&

#Stellen Sie eine vor große Ziffern.

T`d`EE

Verdoppeln Sie jede Ziffer.

T`_d#`d_`\d#

Fügen Sie in die Trage.

#
1

Deal mit einem führenden Carry.

}`\d\b
$&@

Hänge eine @und Schleife an, bis alle 10 Ziffern gefunden sind.

@

Gibt die Anzahl der @hinzugefügten s aus.

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

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

Probieren Sie es online!

Dies ist ein dyadischer Dfn( d irect f unctio n ), 0 als sein linkes Argument nimmt und die ganze Zahl als rechts. Da die Eingabe nur die Ganzzahl sein soll, habe ich der Byteanzahl 2 Bytes für das Argument hinzugefügt 0∘.

f←ist nicht in der Byteanzahl enthalten, da dies nicht erforderlich ist . Es macht es einfach einfacher, die Testfälle zu erstellen.

Wie es funktioniert:

Die Überschriften: Ich habe diese nach einigem Chatten im APL-Raum aus der Byteanzahl entfernt, da die Funktion das tut, was sie tun soll, und die Ergebnisse nur aufgrund der Standardeinstellungen von APLs REPL falsch sind.

⎕FR←1287Stellt die F loat R ePresentation bis 128-Bit - Dezimalzahl (7 wird der Code für dezimale in APL REPL). ⎕PP←34Stellt die P RINT P recision bis 34 Ziffern. Beide werden benötigt, da die Standarddarstellung von APL für große Zahlen sie in eine wissenschaftliche Notation (z. B. 3.14159265359E15) umwandelt, die den Code erheblich durcheinander bringt.

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 Bytes

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

-57 Bytes dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es hier aus. (Hinweis: Der Testfall für 2ist deaktiviert, da er bei 2 ^{68 enden} sollte, die Größe von longist jedoch auf 2 ⁶³ -1 begrenzt.)

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

Alte 132 Bytes antworten mit StringEingabe und 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);}

Probieren Sie es hier aus. (Hinweis: Testfall für 2ist deaktiviert, da er aufgrund einer leicht zu hohen Rekursion eine StackOverflowException verursacht.)

Der gesamte reguläre Ausdruck, der überprüft werden soll, ob der String alle 9 Ziffern enthält ^(?=.*0)(?=.*1)(?=.*2)(?=.*3)(?=.*4)(?=.*5)(?=.*6)(?=.*7)(?=.*8)(?=.*9).*$, verwendet eine positive Vorausschau für den gesamten String.

Schale , 10 Bytes

←Vö>9Lud¡D

Probieren Sie es online!

Erläuterung

        ¡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)

Mathematica, 59 48 47 46 38 Bytes

-9 Bytes dank Jenny_mathy.

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

Probieren Sie es online mit Mathematik!

R 74 Bytes

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

Probieren Sie es online! Beachten Sie, dass R die falsche Antwort auf gibtf(2) da in der Sprache nur begrenzte Ganzzahlen gespeichert werden.

Erläuterung: Für den Test der Pandigitalität wird die Eingabe durch Verknüpfen mit einer leeren Zeichenfolge in einen Zeichenvektor gezwungen und dann in einzelne Ziffern aufgeteilt. Wir prüfen dann, ob alle 0: 9 im resultierenden Vektor vorhanden sind; Wenn nicht, erhöhen wir den Zähler, verdoppeln die Eingabe und wiederholen.

Der Zähler verwendet F, das als FALSE initialisiert wird. Um sicherzustellen, dass es in numerisch umgewandelt wird, multiplizieren wir es vor der Rückkehr mit eins.

PowerShell , 70 bis 69 Byte

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

Probieren Sie es online!

(Fast doppelt so lange wie die Python-Antwort: - \)

Nimmt Eingaben auf $args[0], wandelt sie in eine um [bigint]und speichert sie in $n. Gibt eine forSchleife ein. Bei jeder Iteration wird geprüft, ob die $nUmber in einen String konvertiert wurde und dann in ein char-array, wenn Group-Objectzusammengenommen, ein .count -less than oder equal to hat 9. Dies bedeutet, dass es nur dann gleich 10 ist, wenn mindestens eine Ziffer jeder Zahl 1234567890vorhanden ist. Wenn ja, verlassen wir die Schleife. Wenn nicht, fahren wir $n*=2fort. Bei jeder Iteration innerhalb der Schleife erhöhen wir sie einfach $i. Wenn wir die Schleife verlassen, geben wir einfach aus $i.

Beachten Sie, dass bei Eingaben, bei 1234567890denen beispielsweise jede Ziffer bereits berücksichtigt ist, nichts ausgegeben wird. Dies ist ein falscher Wert in PowerShell und entspricht der Umwandlung 0als [int]. Wenn das nicht in Ordnung ist, können wir +der Ausgabe einfach ein voranstellen, $ium sie explizit als Ganzzahl zu setzen.

Dank Roland Heath ein Byte gespart.

Pyth , 11 Bytes

f>l{`.<QT9Z

Testsuite .

Erste natürliche Zahl, Tbei input << Tder die Anforderung erfüllt ist.

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

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

Probieren Sie es online!

Perl, 43 + 1 Bytes

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

Unter Verwendung der -pFlagge. Dies baut auf der oben von Xcali bereitgestellten Lösung auf.

Schnelle 4 , 111 Bytes

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

Hinweis: Funktioniert wegen Überlauf nicht für x = 2.

Erläuterung - Eingabe x wird zuerst in Zeichenfolge typisiert. Dann entfernt Set () die sich wiederholenden Zeichen. Dann wird es sortiert, um das Ergebnis abzugleichen. Wenn es nicht übereinstimmt, ist x doppelt und der Zähler wird erhöht.

Rubin, 46 45 39 38 Bytes

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

Probieren Sie es online!

Aktualisierung:

1. -1 mit def f n;anstelle von def f(n);.
2. -6 mit …[9]anstelle von….size==10
3. -1 durch Entfernen eines Semikolons

Japt , 15 Bytes

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

Versuch es

Erläuterung

Implizite Eingabe einer Ganzzahl U.

LÆ    Ã

Erstellen Sie ein Array von Ganzzahlen von 0bis 99und durchlaufen Sie jeweils eine Funktion, bei der Xes sich um das aktuelle Element handelt.

*2pX

Umultipliziert mit 2 erhöht auf die Potenz von X.

b

Holen Sie sich den Index des ersten Elements und geben Sie dann true zurück, wenn Sie die folgende Funktion durchlaufen.

ì_â

Teilen Sie in eine Reihe von Ziffern und entfernen Sie die Duplikate.

Ê¥A

Holen Sie sich die Länge des Arrays und überprüfen Sie auf Gleichheit mit 10.

Alternative, 15 Bytes

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

Versuch es

Erläuterung

Implizite Eingabe einer Ganzzahl U.

@            }a

Beginnen Sie mit 0, und geben Sie die erste Zahl zurück, die true zurückgibt, wenn die folgende Funktion ausgeführt wird. Dabei handelt Xes sich um die aktuelle Zahl.

*2pX)

Wie oben, multiplizieren Sie Umit 2, um die Potenz von X.

ìâ

In ein Array von Ziffern aufteilen, Duplikate entfernen und wieder zu einer Ganzzahl zusammenfügen.

sÊ

Konvertieren Sie in einen String, ermitteln Sie die Länge und konvertieren Sie zurück in eine Ganzzahl.

¥A

Prüfen Sie auf Gleichheit mit 10.

QBIC , 48 Bytes, nc

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

Dies sollte theoretisch funktionieren. In der Praxis schlägt dies jedoch fehl, da QBasic zehnstellige Zahlen (die mindestens erforderlich sind, um alle Ziffern zu erhalten) in wissenschaftlicher Notation umsetzt. Ich habe sie aus diesem Grund als nicht konkurrierend markiert.

Erläuterung

{             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 Bytes

Die Eingabe wird vom oberen Ende des Stapels kopiert (der ansonsten leer sein muss). Die Ausgabe wird nach oben geschoben.

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

Erläuterung

Wir verwenden die Array-Variable a, speichern eine 1 in, a[d]wenn eine Ziffer dvorhanden ist, andernfalls fallen wir dort auf 0 zurück. Wir verwenden die GNU-Erweiterung ~, um Quotienten und Rest in einem einzigen Befehl zu erhalten.

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

Als Bonus funktioniert dies in beliebigen Zahlenbasen (nicht nur in Dezimalzahlen): Stellen Sie einfach den gewünschten Eingaberadix ein (die Konstante 11in der Definition von fwird anhand dieser Zahlenbasis gelesen, ist also automatisch korrekt).

Prüfung

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 Bytes

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

q / kdb + 33 Bytes

Lösung:

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

Beispiele:

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

Erläuterung:

Alle Bytes sind gleich, möglicherweise können Sie dieses ein wenig weiter nach unten spielen. Verwendet das scanAdverb von 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

Anmerkungen:

Wenn wir auf die sinken k Eingabeaufforderung gehen, können wir eine 25-Byte-Lösung haben. Konvertiert die Zahl in eine Liste von Zeichen:

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