Multiplizieren und teilen

10

Wenn ein Wert x gegeben ist, finden Sie den kleinsten numerischen Wert größer als y , der multipliziert und mit x geteilt werden kann, während alle ursprünglichen Ziffern beibehalten werden.

  • Die neuen Nummern verlieren keine Ziffern.
  • Die neuen Nummern erhalten keine Ziffern.

Zum Beispiel:

Eingabe: x = 2, y = 250000

  • Original: 285714
    • Abteilung: 142857
    • Multiplikation: 571428

Dies ist wahr, weil 285714 größer als y ist ; dann , wenn sie durch unterteilt x Ergebnisse in 142857 und wenn multipliziert mit x führt zu 571.428 . In beiden Tests sind alle Originalziffern von 285714 vorhanden und es wurden keine zusätzlichen Ziffern hinzugefügt.

Die Regeln

  • X sollte 2 oder 3 sein, da die Berechnung zu hoch ist.
  • Y muss eine ganze Zahl größer als Null sein .
  • Der kürzeste Code gewinnt.

Testfälle

Dies sind meine häufigsten Testfälle, da sie am schnellsten zu testen sind.

  • x = 2, y = 250000 = 285714
  • x = 2, y = 290000 = 2589714
  • x = 2, y = 3000000 = 20978514
  • x = 3, y = 31000000 = 31046895
  • x = 3, y = 290000000 = 301046895

Klarstellungen

  • Die Art der Aufteilung spielt keine Rolle. Wenn Sie irgendwie 2,05, 0,25 und 5,20 bekommen können, dann fühlen Sie sich frei.

Viel glück, euch allen!

code-golf  number 
— Emma - PerpetualJ
quelle
4
" X muss ein Wert zwischen 2 und 5 sein ." - Wenn X> = 4, wird die mit X multiplizierte Zahl mindestens 16-mal größer sein als die durch X geteilte Zahl, so dass sie sicherlich mehr Ziffern haben wird
— ngn
2
x kann nichts anderes als 2 oder 3 sein, da das Produkt das x ^ 2-fache des Quotienten ist und beide die gleiche Anzahl von Ziffern haben sollten. x = 1 ist ein trivialer Fall. IMO, es gibt keine Lösung für x = 3 für irgendein y, obwohl ich falsch liegen könnte.
— Jatin Sanghvi
2
Ist Division Float oder Integer Division?
— Erik der Outgolfer
3
Testfälle wären toll
— Stephen
3
Ich vermute , ich bin nicht die einzige Person , die bei der Abstimmung wird Verzicht wieder zu öffnen , da die Klärung tatsächlich die Herausforderung macht mehr zweideutig, denn die richtige Antwort in Abhängigkeit von ändern könnte , ob Gleitkomma - Ausgabe betrachtet wird oder nicht. Ich vermute , @EriktheOutgolfer ‚s Frage nicht fragt nach Floating - Point - Ausgang ermöglicht, sondern darüber , ob es erlaubt zu verwenden Kürzen Integer - Division. (Und es tut mir leid, wenn meine Kommentare zur Verwirrung
— Ørjan Johansen

Antworten:

4

Schale , 14 Bytes

ḟ§¤=OoDd§¤+d*/

Probieren Sie es online aus!

Erläuterung

ḟ§¤=O(Dd)§¤+d*/  -- example inputs: x=2  y=1
ḟ                -- find first value greater than y where the following is true (example on 285714)
 §               -- | fork
         §       -- | | fork
              /  -- | | | divide by x: 142857
                 -- | | and
             *   -- | | | multiply by y: 571428
                 -- | | then do the following with 142857 and 571428
                 -- | | | concatenate but first take
           +     -- | | | | digits: [1,4,2,8,5,7] [5,7,1,4,2,8]
          ¤ d    -- | | | : [1,4,2,8,5,7,5,7,1,4,2,8]
                 -- | and
       d         -- | | digits: [2,8,5,7,1,4]
      D          -- | | double: [2,8,5,7,1,4,2,8,5,7,1,4]
                 -- | then do the following with [2,8,5,7,1,4,2,8,5,7,1,4] and [1,4,2,8,5,7,5,7,1,4,2,8]
   =             -- | | are they equal
  ¤ O            -- | | | when sorted: [1,1,2,2,4,4,5,5,7,7,8,8] [1,1,2,2,4,4,5,5,7,7,8,8]
                 -- | : truthy
                 -- : 285714
— ბიმო
quelle
Ich habe den Wert für y angepasst , um einen genaueren Ausgangspunkt zu erhalten, und das Ergebnis war für x = 3, y = 25000000 falsch .
— Emma - PerpetualJ
@PerpetualJ: Wenn Sie das Ergebnis kennen, können Sie einfach y anpassen , und diese Version sollte etwas schneller sein (nur die Typprüfung).
— 27.
Ich habe es nach einigem Überlegen angepasst und meinen ersten Kommentar bearbeitet.
— Emma - PerpetualJ
@PerpetualJ: Ich habe es behoben: eine Annahme gemacht, -was falsch war.
— 27.
1
@PerpetualJ: Ich habe das Programm geschrieben;) Ich habe eine Erklärung hinzugefügt, jetzt sollte jeder verstehen, was los ist.
— 27.
5

Brachylog v2, 15 Bytes

t<.g,?kA/p.∧A×p

Probieren Sie es online aus!

Nimmt Eingaben in das Formular vor [x,y].

Erläuterung

t<.g,?kA/p.∧A×p
t                  Tail (extract y from the input)
 <                 Brute-force search for a number > y, such that:
  .                  it's the output to the user (called ".");
   g                 forming it into a list,
    ,?               appending both inputs (to form [.,x,y]),
      k              and removing the last (to form [.,x])
       A             gives a value called A, such that:
        /              first ÷ second element of {A}
         p             is a permutation of
          .            .
           ∧         and
            A×         first × second element of {A}
              p        is a permutation of {.}

Kommentar

Hier zeigt sich die Schwäche von Brachylog, mehrere Werte mehrmals wiederzuverwenden. Dieses Programm ist fast alles Sanitär und sehr wenig Algorithmus.

Daher erscheint es möglicherweise bequemer, den Wert von y einfach fest zu codieren (es gibt einen Kommentar zu dieser Frage, in dem angenommen wird, dass 2 der einzig mögliche Wert ist). Es gibt jedoch tatsächlich Lösungen für y = 3, was bedeutet, dass die Installation leider auch den Wert von y verarbeiten muss . Das kleinste, das mir bekannt ist, ist das Folgende:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Die Technik, mit der ich diese Zahl gefunden habe, ist nicht ganz allgemein, daher ist es möglich, dass es eine kleinere Lösung mit einem anderen Ansatz gibt.)

Es ist jedoch unwahrscheinlich, dass Sie dies mit diesem Programm überprüfen . Brachylog's pist sehr allgemein geschrieben und enthält keine Optimierungen für Sonderfälle (z. B. für den Fall, dass sowohl die Eingabe als auch die Ausgabe bereits bekannt sind). Dies bedeutet, dass Sie die Überprüfung in O ( n log n ) eher durch Sortieren durchführen können als das O ( n !) für den Brute-Force-Ansatz, von dem ich vermute, dass er verwendet wird). Infolgedessen dauert es sehr lange, bis überprüft wird, ob 105263157894736842 eine Permutation von 315789473684210526 ist (ich habe es jetzt einige Minuten lang ohne offensichtlichen Fortschritt laufen lassen).

(BEARBEITEN: Ich habe die Brachylog-Quelle aus diesem Grund überprüft. Wenn Sie pzwei bekannte Ganzzahlen verwenden, generiert der verwendete Algorithmus alle möglichen Permutationen der betreffenden Ganzzahl, bis eine gefunden wird, die der Ausgabe-Ganzzahl als Algorithmus entspricht ist „Eingang → indigits, permute indigits → outdigits, outdigits → Ausgang“. Ein effizienter Algorithmus wäre, die outdigits / Ausgangs - Beziehung einzurichten zuerst , so dass die Rückverfolgung innerhalb der Permutation berücksichtigen könnte , die Ziffern zur Verfügung stehen.)

— ais523
quelle
Die Verwendung einer Gabel kann Ihren Code um 1 Byte verringern. Probieren Sie es online aus!
— Kroppeb
Laut den Dokumenten scheint es auch zu überprüfen, ob zwei bekannte Listen eine Permutation sind. O (n²) swi-prolog.org/pldoc/man?predicate=permutation/2
— Kroppeb
@Kroppeb: Das Problem ist, dass Brachylog's pnicht permutation/2mit zwei bekannten Listen ausgeführt wird, selbst wenn zwei bekannte Ganzzahlen als Argumente angegeben werden. es erzeugt alle Permutationen der ersten ganzen Zahl (unter Verwendung von permutation/2mit einer bekannten Liste) und vergleicht sie dann gegen die zweite ganze Zahl ist .
— Ais523
3

q 65 Bytes

{f:{asc 10 vs x};while[not((f y)~f y*x)&(f y*x)~f"i"$y%x;y+:1];y}

Teilen Sie die Zahl auf Basis 10, sortieren Sie jede aufsteigende Zahl und prüfen Sie, ob sie gleich ist. Wenn nicht, erhöhen Sie y und gehen Sie erneut

— Thaufeki
quelle
3

JavaScript (ES6), 76 73 69 Byte

3 Bytes wurden mithilfe eval()von gespeichert, wie von @ShieruAsakoto vorgeschlagen

Nimmt Eingabe als (x)(y).

x=>y=>eval("for(;(g=x=>r=[...x+''].sort())(y*x)+g(y/x)!=g(y)+r;)++y")

Probieren Sie es online aus!

Eine rekursive Version wäre 62 Byte , aber hier ist sie wegen der hohen Anzahl erforderlicher Iterationen nicht gut geeignet.

Wie?

G

Beispiel:

g(285714) = [ '1', '2', '4', '5', '7', '8' ]

y×xy/.xyG(y×x)G(y/.x)G(y)

Wenn Sie zwei Arrays zusammenfügen, wird jedes davon implizit zu einer durch Kommas getrennten Zeichenfolge gezwungen. Die letzte Ziffer des ersten Arrays wird direkt mit der ersten Ziffer des zweiten Arrays ohne Komma verkettet, wodurch dieses Format eindeutig ist.

Beispiel:

g(123) + g(456) = [ '1', '2', '3' ] + [ '4', '5', '6' ] = '1,2,34,5,6'

Aber:

g(1234) + g(56) = [ '1', '2', '3', '4' ] + [ '5', '6' ] = '1,2,3,45,6'

Kommentiert

x => y =>                   // given x and y
  eval(                     // evaluate as JS code:
    "for(;" +               //   loop:
      "(g = x =>" +         //     g = helper function taking x
        "r =" +             //       the result will be eventually saved in r
          "[...x + '']" +   //       coerce x to a string and split it
          ".sort() + ''" +  //       sort the digits and coerce them back to a string
      ")(y * x) +" +        //     compute g(y * x)
      "g(y / x) !=" +       //     concatenate it with g(y / x)
      "g(y) + r;" +         //     loop while it's not equal to g(y) concatenated with
    ")" +                   //     itself
    "++y"                   //   increment y after each iteration
  )                         // end of eval(); return y
— Arnauld
quelle
66: x=>F=y=>(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x)?F(y+1):yKann einen Stapelüberlauf verursachen, wenn y weit von der Lösung entfernt ist.
— Shieru Asakoto
oder 75 mit eval:x=>y=>eval("for(;(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x);y++);y")
— Shieru Asakoto
@ ShieruAsakoto Danke für die eval()Idee. Mein erster Versuch war zwar rekursiv, aber ich gab wegen der hohen Anzahl erforderlicher Iterationen auf.
— Arnauld
3

Haskell, 76 74 Bytes

Dank Lynns Kommentar wurden zwei Bytes rasiert

import Data.List
s=sort.show
x#y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0
— umnikos
quelle
1
Für die gleiche Anzahl von Bytes fkönnen Sie sein, f x y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0aber wenn Sie Ihre Antwort als Operator definieren, werden zwei Bytes gespeichert: x!y=…und dann lautet Ihre Antwort (!):)
— Lynn
Ich habe nicht daran gedacht, Listenverständnisse zu verwenden! Vielen Dank für den Vorschlag: D
— umnikos
2

Japt, 24 Bytes

Ziemlich naive Lösung bei ein paar Bieren; Ich bin sicher, es gibt einen besseren Weg.

@[X*UX/U]®ì nÃeeXì n}a°V

Versuch es

— Zottelig
quelle
Leider führt dies zu einem falschen Ergebnis, wenn x = 3 und y = 25000 .
— Emma - PerpetualJ
@PerpetualJ Angenommen, es 315789473684210526ist die erste Lösung für x=3, Javascript oder Japt können es nicht richtig berechnen, da es nicht mit doppelter Genauigkeit passt.
— Bubbler
@PerpetualJ, das früher behoben. Dieser Testfall wird jedoch aus dem oben genannten Grund Bubbler niemals abgeschlossen.
— Shaggy
@Shaggy Dies führt nun zu einem korrekten Ergebnis und die Lösung, auf die Bubbler zeigte, ist nicht das erste richtige Ergebnis über 25000 . Sehen Sie sich meine Testfälle an, wenn Sie daran interessiert sind. +1
— Emma - PerpetualJ
1

Python 2 , 69 Bytes

S=sorted
x,y=input()
while(S(`y`)==S(`y*x`)==S(`y/x`))<1:y+=1
print y

Probieren Sie es online aus!

— Chas Brown
quelle
f=lambda x,y,S=sorted:y*(S(`y`)==S(`y*x`)==S(`y/x`))or f(x,y+1)sollte funktionieren, aber es erreicht das Rekursionslimit ziemlich schnell, und ich weiß nicht, was die PPCG-Regeln dazu zu sagen haben.
— Lynn
1

Gelee ,  14  13 Bytes

-1 danke an Erik den Outgolfer (`` verwendet make_digits, Dwar also nicht erforderlich)
+2 behebt einen Fehler (nochmals danke an Erik den Outgolfer für den Hinweis auf das Off-by-One-Problem)

×;÷;⁸Ṣ€E
‘ç1#

Ein vollständiges Programm, das das Ergebnis druckt (als dyadischer Link wird eine Liste der Länge 1 erhalten).

Probieren Sie es online aus!

Wie?

×;÷;⁸Ṣ€E - Link 1, checkValidity: n, x               e.g. n=285714,  x=2
×        -     multiply -> n×x                       571428
  ÷      -     divide -> n÷x                         142857
 ;       -     concatenate -> [n×x,n÷x]              [571428,142857]
    ⁸    -     chain's left argument = n             285714
   ;     -     concatenate -> [n×x,n÷x,n]            [571428,142857,285714]
     Ṣ€  -     sort €ach (implicitly make decimals)  [[1,2,4,5,7,8],[1,2,4,5,7,8],[1,2,4,5,7,8]]
        E    -     all equal?                        1

‘ç1# - Main link: y, x
‘    - increment -> y+1
   # - count up from n=y+1 finding the first...
  1  - ...1 match of:
 ç   -   the last link (1) as a dyad i.e. f(n, x)

Beachten Sie, dass, wenn die Division nicht genau ist, die implizite Dezimalanweisung (äquivalent zu a D), die vor der Sortierung angewendet wird, einen Bruchteil ergibt,
z. B.: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

— Jonathan Allan
quelle
Ich bin mir nicht sicher, ob diese Antwort gültig ist. Die Herausforderung erfordert, dass das Ergebnis "größer als y " ist, was ich als "streng größer als Y " interpretiere . Auch brauchst du nicht D.
— Erik der Outgolfer
Ah, genau das habe >=ich total verpasst! Hatte keine Ahnung, Ṣdass make_digits darauf gesetzt war - danke. Muss aber später repariert und aktualisiert werden ...
— Jonathan Allan
1

Mathematica, 82 74 Bytes

x=Sort@*IntegerDigits;Do[If[x[i#]==x@Floor[i/#]==x@i,Break@i],{i,#2,∞}]&

-8 Bytes dank tsh

Funktion, die Argumente als akzeptiert [x,y]. Effektiv eine Brute - Force, die überprüft , ob die sortierten Liste von Ziffern suchen y, y/xund xyist gleich.

Probieren Sie es online aus!

— Zahlmaniac
quelle
Ich bin nicht mit Mathematica vertraut. Es könnte jedoch bewiesen werden, dass die Antwort immer noch richtig wäre, wenn Sie den Bruchteil der Division fallen lassen: Alle ans, ans / x, ans * x sollten durch 9 teilbar sein. Und dies kann Ihre Lösung kürzer machen.
— tsh
@tsh Das funktioniert für x=3, aber ich bin nicht sicher, ob es wahr ist x=2.
— Ørjan Johansen
@ ØrjanJohansen Let v = a[1]*10^p[1] + a[2]*10^p[2] + ... + a[n]*10^p[n], u = a[1] * 10^q[1] + ... + a[n] * 10^q[n]. Und u-v = a[1]*(10^p[1]-10^q[1]) + ... + a[n]*(10^p[n]-10^q[n])da gilt 10^x-10^y=0 (mod 9)immer. u-v=0 (mod 9)hält immer. Wenn es eine falsche Antwort gibt w, seit w*x-w=0 (mod 9)und w-floor(w/x)=0 (mod 9): haben wir floor(w/x)=0 (mod 9). wenn floor(w/x)*x <> w, w-floor(w/x)*x>=9aber dieser Konflikt mit der Tatsache, dass w-floor(w/x)*x<xwährend x 2 oder 3 sein könnte.
— tsh
@tsh Danke! Für andere, die viel zu lange brauchen, um diesen Punkt zu erreichen, w=0 (mod 9)folgt daraus, w*x-w=0 (mod 9)dass x-1es nicht durch 3 teilbar ist.
— Ørjan Johansen
Wenn ich den IntegerQTest ausschließe, erzeugt er einige Fehler, wenn er versucht, IntegerDigitsBrüche zu bearbeiten, aber Mathematica geht immer noch an ihnen vorbei und liefert die richtige Antwort. Ich bin mir nicht sicher, ob Fehler bei der Berechnung zulässig sind, auch wenn die endgültige Antwort korrekt ist.
— Numbermaniac
0

APL (NARS), 490 Zeichen, 980 Byte

T←{v←⍴⍴⍵⋄v>2:7⋄v=2:6⋄(v=1)∧''≡0↑⍵:4⋄''≡0↑⍵:3⋄v=1:5⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
D←{x←{⍵≥1e40:,¯1⋄(40⍴10)⊤⍵}⍵⋄{r←(⍵≠0)⍳1⋄k←⍴⍵⋄r>k:,0⋄(r-1)↓⍵}x}
r←c f w;k;i;z;v;x;y;t;u;o ⍝   w  cxr
   r←¯1⋄→0×⍳(2≠T c)∨2≠T w⋄→0×⍳(c≤1)∨w<0⋄→0×⍳c>3
   r←⌊w÷c⋄→Q×⍳w≤c×r⋄r←r+c
Q: u←D r⋄x←1⊃u⋄y←c×x⋄t←c×y⋄o←↑⍴u⋄→0×⍳o>10⋄→A×⍳∼t>9
M:                     r←10*o⋄⍞←r⋄→Q
A: u←D r⋄→M×⍳x≠1⊃u⋄→B×⍳∼(t∊u)∧y∊u⋄z←r×c⋄v←D z⋄→C×⍳(⍳0)≡v∼⍦u
B: r←r+1⋄→A
C: k←z×c⋄⍞←'x'⋄→B×⍳(⍳0)≢v∼⍦D k
   ⎕←' '⋄r←z

Prüfung

  2 f¨250000 290000 3000000
xxxx 
1000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
10000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
285714 2589714 20978514 
 3 f¨ 31000000 290000000 
xxxxxxxxx 
100000000xxxxxxxxxxxxxxxxxxxxxxxxxx 
31046895 301046895

Ich dachte, das Problem sei eine bequeme Zahl, die variieren kann, so dass man die 3 Zahlen r, r * x, r * x * x so hat, wie r zu einem Wert beginnt, dass r * x in der Nähe von y liegt (wobei x und y Eingaben sind des Problems mit den gleichen Buchstaben wie der Hauptbeitrag). Ich habe die Beobachtung verwendet, dass, wenn die erste Ziffer von r d ist als in r, auch die Ziffern d * x und d * x * x erscheinen müssen, um r (oder besser r * x) zu einer Lösung zu machen.

— RosLuP
quelle
0

05AB1E , 16 Bytes

[>©Ð²÷s²*)€{Ë®s#

Probieren Sie es online aus. (HINWEIS: Sehr ineffiziente Lösung. Verwenden Sie daher Eingaben in der Nähe des Ergebnisses. Dies funktioniert auch lokal für größere Eingaben, bei TIO tritt jedoch nach 60 Sekunden eine Zeitüberschreitung auf.)

Erläuterung:

[                   # Start an infinite loop
 >                  #  Increase by 1 (in the first iteration the implicit input is used)
  ©                 #  Store it in the register (without popping)
   Ð                #  Triplicate it
    ²÷              #  Divide it by the second input
      s             #  Swap so the value is at the top of the stack again
       ²*           #  Multiply it by the second input
         )          #  Wrap all the entire stack (all three values) to a list
          €{        #  Sort the digits for each of those lists
             ®s     #  Push the value from the register onto the stack again
            Ë       #  If all three lists are equal:
               #    #   Stop the infinite loop
— Kevin Cruijssen
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.