Finden Sie die kleinste positive ganze Zahl, die auf n endet, durch n teilbar ist und deren Ziffern sich zu n addieren

33

Auf den Titel kommt es an ...

Nehmen Sie als Eingabe eine positive Ganzzahl n>=12und ... tun Sie, was der Titel sagt.

Ja, dies ist in OEIS A187924 .

Einige Testfälle 

12 -> 912  
13 -> 11713  
14 -> 6314  
15 -> 915  
16 -> 3616  
17 -> 15317  
18 -> 918  
19 -> 17119 
20 -> 9920  
40 -> 1999840   
100-> 99999999999100

Das ist Code-Golf . Kürzester Code in Bytes gewinnt!

code-golf  integer 
— user202729
quelle
Kommentare sind nicht für eine längere Diskussion gedacht. Diese Unterhaltung wurde in den Chat verschoben .
— Martin Ender
Um einen Teil von dem, was zum Chatten bewegt wurde, zu schließen: Meine Änderung am OEIS, die beweist, dass 11 die einzige Nummer ohne eine Lösung ist, wurde gerade genehmigt.
— Ørjan Johansen

Antworten:

19

Befunge, 81 Bytes

&>00p0v<!%g0<
v%"d":_>1+:0^
>00g->#^_:0v
0g10g-#^_.@1>
>0p:55+/\:v>
^1+g01%+55_$^

Probieren Sie es online!

Kann mindestens bis zu n = 70 verarbeiten. Danach überschreiten einige Werte bei den meisten Implementierungen die Stack-Zellengröße, und bei anderen dauert es so lange, dass es sich nicht lohnt, darauf zu warten.

Diese Einschränkungen gegeben, wir nicht einmal die Mühe versucht , Werte zu handhaben n größer als 99, was bedeutet , wir können leichter testen , ob der Wert Enden in n mit , indem Sie einfach den Wert Modulo 100 mit Vergleichen n .

Nachfolgend finden Sie eine detailliertere Aufschlüsselung des Codes.

Quellcode mit hervorgehobenen Ausführungspfaden

*Lies n von stdin und speichere im Speicher.
*Initialisieren Sie den Testwert v auf 0 und starten Sie die Hauptschleife, indem Sie v nach vorne erhöhen .
*Testen Sie, ob v%n == 0und kehren Sie an den Anfang der Hauptschleife zurück.
*Testen Sie, ob v%100 == nund kehren Sie an den Anfang der Hauptschleife zurück. Addieren Sie
*die Ziffern in v, indem Sie wiederholt v modulo 10 addieren und v durch 10 dividieren .
*Prüfen Sie, ob die Summe gleich n ist , und kehren Sie an den Anfang der Hauptschleife zurück.
*Ansonsten gib v aus und beende.

— James Holderness
quelle
12

05AB1E , 14 Bytes

[NI«ÐIÖsSOIQ*#

Probieren Sie es online!

Erläuterung

Bei Lösungen, für die große Präfixe erforderlich sind, tritt bei TIO ein Timeout auf

[                # start a loop
 NI«             # append input to current iteration number
    Ð            # triplicate
     IÖ          # is the first copy evenly divisible by input?
       sSOIQ     # is the digit sum of the second copy equal to the input?
            *    # multiply
             #   # if true, break loop
                 # output the third copy
— Emigna
quelle
Ich habe das Gefühl, 05AB1E betrügt, weil es so gut ist. Der einzige Weg, dies um eine Meile zu übertreffen, wäre, eine Programmiersprache zu erstellen, die sich auf vergangene Sprachen bezieht. Ich übermittle ans = dic [1] lol
— Pathfinder
@Pathfinder: Es gibt ein paar Sprachen, die 05AB1E konstant schlagen können, also können wir immer noch hoffen, etwas noch kürzeres zu sehen :)
— Emigna
12

JavaScript (ES6), 55 54 Byte

f=(s,p=0,a=p+s)=>a%s|eval([...a].join`+`)-s?f(s,p+1):a
<input type=number min=12 oninput=o.textContent=f(this.value)><pre id=o>
Erweitern Sie das Snippet

Übernimmt die Eingabe als Zeichenfolge. Benötigt einen Browser mit Schwanzrekursionsunterstützung für die größeren Ergebnisse. Bearbeiten: 1 Byte dank @Arnauld gespeichert.

— Neil
quelle
eval([s,...a].join`-`)?würde auch funktionieren, obwohl es nicht kürzer ist ...
— ETHproductions
@Arnauld Nein, ich habe nur vergessen, dass ich das mit machen kann ||.
— Neil
8

Brachylog v2, 12 10 Bytes

a₁.;A×?≜ẹ+

Probieren Sie es online!

Dies ist eine Funktionsübergabe, die Eingabe über .und Ausgabe über erzeugt ?(im Gegensatz zur normalen Konvention: Alle Brachylog-Funktionen haben genau zwei Argumente, die Eingabe- oder Ausgabeargumente sein können, aber die Sprache erzwingt keine bestimmte Argumentverwendung). Normalerweise halten wir Konventionen für die Verwendung von Argumenten bei PPCG nicht für relevant .

Erläuterung

Eine frühere Version dieser Lösung hatte einen Sonderfall ( Ḋ|dh "Ziffern buchstäblich zurückgeben") für einzelne Ziffern, aber die Frage besagt anscheinend, dass Sie das nicht überprüfen müssen (danke @DLosc, dass Sie dies abgefangen haben), also habe ich es entfernt es. (Die geschriebene Lösung funktioniert nicht mit einzelnen Ziffern, da Brachylog 1 nicht als Möglichkeit für ein Unbekanntes in einer Multiplikation betrachtet, um Endlosschleifen zu verhindern. Die Multiplikationen sind willkürlich.)

Diese Antwort bezieht sich nun auf eine ziemlich direkte Übersetzung der Spezifikation. Beginnend mit ?(der Ausgabe / Zahl, die wir suchen; ein Brachylog-Prädikat beginnt implizit immer mit ?) wird a₁.behauptet, dass es .(die Eingabe) als Suffix hat. Das ;A×?bedeutet dann , dass wir ×das Ergebnis mit etwas multiplizieren können, um es ;Azu produzieren ?. Schließlich ẹ+summiert ( +) die Ziffern ( ẹ) von ?und am Ende jedes Brachylog-Programms, das das Endergebnis erzeugt, steht standardmäßig eine implizite Zusicherung .. Mit anderen Worten, dieses Programm ist " .ist ein Suffix von ?, .multipliziert mit etwas ?, .ist die Ziffernsumme von?", was einer wörtlichen Übersetzung des ursprünglichen Programms sehr nahe kommt.

Dies ≜ist erforderlich, damit die Ziffernsummenanforderung durchgesetzt wird. Ich nehme an, dass etwas ẹUnbekanntes nicht mag, und so fordert das ≜Brachylog dazu auf, einen Brute-Force-Ansatz für diesen Teil des Programms anstelle von Algebra zu verwenden.

— Gemeinschaft
quelle
6

Haskell , 72 Bytes

f n=[x|x<-[n,n+lcm n(10^length(show n))..],sum[read[j]|j<-show x]==n]!!0

Probieren Sie es online!

Beachten Sie, dass die gefundene Zahl minus n ein Vielfaches von n und 10 ^ Länge (n) sein muss.

Inspiriert von Laikoni und total menschlich

— Fischinear
quelle
Willkommen auf der Seite!
— DJMcMayhem
3
Änderung lcm n(10^length(show n))auf lcm(10^length(show n))n1 Byte
— H.PWiz
6

Alice , 35 Bytes

/o
\i@/!w?+.?~\ & /-$K..?\ L z $ /K

Probieren Sie es online!

Erläuterung

Dieses Programm bietet eine sehr gute Mischung und Interaktion zwischen dem Cardinal-Modus (Integer-Verarbeitung) und dem Ordinal-Modus (String-Verarbeitung).

Das übliche Framework für Herausforderungen mit dezimaler E / A, die hauptsächlich im Kardinalmodus ausgeführt werden:

/o 
\i@/...

Und das eigentliche Programm:

!     Store the input N on the tape.
      We'll use an implicit zero on top of the stack as our iterator variable X,
      which searches for the first valid result.
w     Store the current IP position on the return address stack. This marks
      the beginning of the main search loop. We can avoid the divisibility
      test by going up in increments of N. To check the other two 
      conditions, we'll use individual conditional loop ends that skip to 
      the next iteration. Only if both checks pass and all loop ends are 
      skipped will the search terminate.

  ?+    Increment the iterator X by N.
  .     Duplicate X.
  ?~    Put a copy of N underneath.
  \     Switch to Ordinal mode.
  &     Implicitly convert X to a string, then fold the next command over its
        characters, i.e. its digits. Here, "fold" means that each character
        is pushed to the stack in turn, followed by one execution of that
        next command.
  /     Switch back to Cardinal mode (this is not a command).
  -     Fold subtraction over the digits. This implicitly converts each 
        digit back to its numerical value and subtracts it from N. If the
        digit sum of X is equal to N, this will result in 0.
  $K    Jump back to the w if the digit sum of X isn't N.
  ..    Duplicate X twice.
  ?     Get a copy of N.
  \     Switch to Ordinal mode.
  L     Shortest common superstring. Implicitly converts X and N to strings
        and gives the shortest string that starts with X and ends with N. 
        This will be equal to X iff X already ends with N. Call this Y.
  z     Drop. If X contains Y, this deletes everything up to and including
        Y from X. This can only happen if they are equal, i.e. if X ended
        with N. Otherwise X remains unchanged.
  $     Skip the next command if the string is empty, i.e. if X ended with N.
  /     Switch back to Cardinal mode.
  K     Jump back to w if X didn't end with N.
— Martin Ender
quelle
5

Java (OpenJDK 8) , 136 110 103 92 Bytes

-26 danke an JollyJoker

-7 Nochmals vielen Dank an JollyJoker

-11 danke an Oliver Grégoire

a->{for(int i=a;!(""+a).endsWith(""+i)|i!=(""+a).chars().map(x->x-48).sum();a+=i);return a;}

Probieren Sie es online!

Muss Java lieben! Es könnte gut sein, dass ich einen ineffizienten Ansatz verwende, aber keine eingebaute Prüfsummenfunktion und die doppelte Konvertierung in String, um nach dem Ende der Zahl zu suchen, Bytes kostet ...

Ungolfed:

  a->{                                                       //input n (as integer)
      for (int i = a;                                        //initiate loop
           !("" + a).endsWith("" + i)                        //check if the calculated number ends with the input
           | i != ("" + a).chars().map(x -> x - 48).sum();   //check if the checksum is equal to the input
           a += i)                                           //for every iteration, increase i by the input to save checking for divisibility
        ;                                                    //empty loop body, as everything is calculated in the header
    return a;                                                //return number
}
— Luca H
quelle
1
(""+i).endsWith(""+a)sollte arbeiten.
— JollyJoker
@ JollyJoker brillant, danke, dass ich mich dumm gefühlt habe: P
— Luca H
1
Heh. n/=10statt n=n/10auch. Außerdem können Sie i+=ain der for-Schleife die Teilbarkeitsprüfung überspringen.
— JollyJoker
@ JollyJoker wow, ich habe es für die Summe getan, aber nicht für die Division ... Danke, ich werde es in Kürze hinzufügen
— Luca H
1
92 Bytes sind mit der API kürzer als Sie selbst. Außerdem ist das Semikolon nicht Teil des bytecount, da beispielsweise ein gültiges Lambda als Methodenargument angegeben werden kann und Sie dieses Semikolon dann nicht benötigen.
— Olivier Grégoire
4

Mathematica, 72 Bytes

(t=#;While[Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#,t+=#];t)&

-18 Bytes von @MartinEnder

Probieren Sie es online!

Hier ist eine andere Version von Martin Ender.
Dieser Ansatz kann bis zu n=40(41 überschreitet das Standard-Iterationslimit) gehen.

Mathematica, 65 Bytes

#//.t_/;Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#:>t+#&

Probieren Sie es online!

— J42161217
quelle
3

Python 2 , 74 Bytes

Diese Lösung geht davon aus n <= sys.maxint.

n=x=input()
while sum(map(int,str(x)))-n*str(x).endswith(`n`):x+=n
print x

Probieren Sie es online!

— FlipTack
quelle
Ersetzen Sie str(x)mit xin Back-Ticks zweimal, um 6 Byte zu sparen (wie können Sie Back-Ticks in Back-Ticks umgehen?).
— Chas Brown
@ChasBrown `Backslash in Backticks ankreuzen.
— wvxvw
@ChasBrown nein, wie bei langen ganzen Zahlen, die eine hinzufügen würden, Ldie den Algorithmus durcheinander bringen könnte.
— FlipTack
3

C (gcc) 71 69 Bytes, schlägt bei 100 fehl

Ich habe es mit long und% 1000 aber mal ausprobiert

-2 Bytes dank Steadybox

s,i,j;f(n){for(j=0;s^n|j%100!=n;)for(s=0,i=j+=n;i;i/=10)s+=i%10;j=j;}

Probieren Sie es online aus

— PrincePolka
quelle
Habe heute einen neuen Trick gelernt mit diesem j * = 1 == return j Trick. Netter Code.
— Michael Dorgan
stackoverflow.com/questions/2598084/… (letzte Rechnung wird zurückgegeben.)
— Michael Dorgan
— PrincePolka
@Steadybox danke, ich werde das tun
— PrincePolka
2

C # (.NET Core) , 90 84 83 + 18 = 101 Bytes

using System.Linq;
n=>{for(int i=n;!(""+n).EndsWith(""+i)|n%i>0|(""+n).Sum(c=>c-48)!=i;n++);return n;}

Probieren Sie es online!

  • 6 Bytes gespart dank Emigna und meiner unheimlichen Fähigkeit, (""+n)an einigen Stellen und n.ToString()an anderen zu schreiben .
— Charlie
quelle
n=>{for(int i=n;n%100!=i|n%i>0|(""+n).Sum(c=>c-'0')!=i;n++);return n;}spart 20 Bytes.
— Emigna
@Emigna warum n%100? Was wäre , wenn n>100?
— Charlie
Oh ja, ignoriere diesen Teil. Das war aus Tests mit zweistelliger Eingabe. Der Mod müsste 10 ^ len (Eingang) sein. Dann lohnt es sich wahrscheinlich nicht.
— Emigna
1

Pip , 18 Bytes

T!y%a&$+y=aY++i.ay

Algorithmus inspiriert von Emignas Antwort . Probieren Sie es online!

Wie es funktioniert

                    a is 1st cmdline arg, i is 0, y is "" (implicit)
T                   Loop until
 !y%a&              y%a is 0 and
      $+y=a         sum of y is a:
            ++i      Increment i
           Y   .a    and yank (i concat a) into y
                 y  After the loop exits, autoprint y
— DLosc
quelle
1

JavaScript REPL (ES5), 60 59 Bytes

for(n=prompt(i=0);eval([].join.call(t=++i+n,'+'))-n|t%n;);t
— l4m2
quelle
@totallyhuman Behoben
— l4m2
In der Konsole wird es ohne alert ()
— ausgegeben,
0

Haskell , 75 Bytes

f n=[x|x<-[0,n..],sum[read[d]|d<-show x]==n,mod x(10^length(show n))==n]!!0

Probieren Sie es online!

Erläuterung:

f n=[x|                                      ]!!0 -- Given input n, take the first x
       x<-[0,n..],                                -- which is a multiple of n,
                  sum[read[d]|d<-show x]==n,      -- has a digital sum of n
                  mod x(10^length(show n))==n     -- and ends in n.

Ich frage mich, ob der Teil "endet in n" verkürzt werden kann. Ich habe es auch versucht show n`elem`scanr(:)""(show x), aber es ist länger.

— Laikoni
quelle
0

PowerShell , 84 Byte

for($n=$i=$args[0];$i%$n-or$i-notmatch"$n$"-or([char[]]"$i"-join'+'|iex)-$n){$i++}$i

Probieren Sie es online!

Einfacher Aufbau, aber langwierige Befehle. Timeout bei TIO für n=100, aber wenn wir explizit iauf close setzen, wird es korrekt ausgegeben.

Dies ist nur eine einfache forSchleife, die so lange fortgesetzt wird, wie eine der Bedingungen erfüllt ist. Die drei Bedingungen sind 1) $i%$n, dh wir haben einen Rest; 2) $i-notmatch"$n$", dh es stimmt nicht mit den letzten Ziffern überein; und 3) ([char[]]"$i"-join'+'|iex)-$n, dh die $nSumme der Ziffern ist ungleich (hier durch einfache Subtraktion überprüft, da Werte ungleich Null wahr sind). Innerhalb der Schleife werden wir einfach erhöht $i.

Wenn wir also keinen Rest haben, stimmt der reguläre Ausdruck überein und die Zahlen sind gleich. Alle drei Bedingungen sind erfüllt $falseund wir verlassen die Schleife. Infolgedessen können wir einfach $iin der Pipeline verbleiben und die Ausgabe ist implizit.

— AdmBorkBork
quelle
0

PHP, 73 + 1 Bytes

while(array_sum(str_split($i+=$n=$argn))-$n|$i%10**strlen($n)-$n);echo$i;

Als Rohr mit laufen lassen -R.

Schleifen $idurch ein Vielfaches von <input>bis zu sum_of_digits-<input>und tail_of_i-$nsind falsy; dann druckt i.

— Titus
quelle
0

m4, 210 Bytes

define(d,define)d(i,ifelse)d(s,`i($1,,0,`eval(substr($1,0,1)+s(substr($1,1)))')')d(k,`r($1,eval($2+1))')d(r,`i(s($2),$1,i(regexp($2,$1$),-1,`k($1,$2)',i(eval($2%$1),0,$2,`k($1,$2)')),`k($1,$2)')')d(f,`r($1,1)')

Definiert ein Makro f, das die Antwort berechnet. Es ist ein bisschen langsam - ungewöhnlich - aber ich verspreche, dass es funktioniert.

Ich dachte, m4 wäre schön, weil es Ganzzahlen standardmäßig als Zeichenfolgen behandelt, aber das ist ziemlich schlecht.

— Programm Mann
quelle
0

Scala, 120 Bytes

def a(n:Int)={val b=math.pow(10,math.ceil(math.log10(n))).##;var c=b+n;while(c%n!=0||(0/:c.toString)(_+_-'0')!=n)c+=b;c}

Dies funktioniert bis zum n = 70Überlauf von ganzen Zahlen. Für ein zusätzliches Zeichen Intkann das in a geändert werden, Longund es können Werte n > 100berechnet werden.

Hier ist die etwas längere ungolfed Version:

def golfSourceLong(n: Long): Long = {
  val delta = math.pow(10, math.ceil(math.log10(n))).toInt
  var current = delta + n
  while (current % n != 0 || current.toString.foldLeft(0)(_ + _ - '0') != n) {
    current += delta
  }
  current
}
— Martin Tuskevicius
quelle
0

R , 115 Bytes

function(n,d=nchar(n):1){while(sum(D<-F%/%10^((k=nchar(F)):1-1)%%10)-n|any(D[k-d+1]-n%/%10^(d-1)%%10)|F%%n)F=F+n
F}

Probieren Sie es online!

Schreckliche R-Funktion. Inkrementiert F(beginnt um 0), nbis ein Wert gefunden wird, der die erforderlichen Eigenschaften erfüllt, und gibt ihn dann zurück. Die Verwendung von anyon für einen doubleAusdruck gibt für jede Iteration der Schleife eine Warnung aus, hat jedoch keinen Einfluss auf die Korrektheit.

Zeitüberschreitung bei TIO für ausreichend große Eingaben (n = 55 oder höher), sollte aber die Lösung bei genügend Zeit / Raum korrekt berechnen.

— Giuseppe
quelle
0

Jelly , 22 21 Bytes

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#

Probieren Sie es online!

Bearbeiten: Auf eine einzelne Zeile komprimiert

Erläuterung

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#
                  ø1#  Evaluate the condition before this and increment a counter until it is met then output the counter                     
D                      Digits of incremented variable as a list
 S                     Sum
  =³                   Equals argument of program?
    a                  Logical and
     ³ḍ                Does arg divide incremented variable?
       a               Logical and
        Dṫ     Ḍ       Last n digits of inc. var. where n is number of digits in program input
          ³DLC         1 - (number of digits of program input)
              ¤        Book ends above nilad
                =³     Equals program input?

Ich habe viele Stunden gebraucht, um zu schreiben, weil ich Jelly gelernt habe, aber jetzt, wo ich fertig bin, bin ich so zufrieden. Lange wusste ich nicht, dass ich das brauchte ¤und ich konnte es einfach nicht zum Laufen bringen. Ein Blick auf [diesen] [1] gut erklärten Code hat mir geholfen, den Deal zu besiegeln. Viele andere Jelly-Antworten in PPCG haben mich auch angeleitet.

— dylnan
quelle
0

Javascript, 224 Bytes function getNumber(x){if(x<12){return!1};const sumDigits=(x)=>x.toString().split('').map(Number).reduce((a,b)=>a+b,0);for(let i=2;i<9999;i++){if((x*i-x)%(Math.pow(10,x.toString().length))==0&&sumDigits(x*i)==x){return x*i}}} Un-Golf:

function getNumber(x){
	if (x<12) {return false};
	const sumDigits = (x) => x.toString().split('').map(Number).reduce((a,b)=>a+b, 0);
	for (let i=2; i<9999; i++){
		if((x*i-x)%(Math.pow(10, x.toString().length))==0 && sumDigits(x*i)==x){
			return x*i;
}
}
}
Erweitern Sie das Snippet

Verwendung: 1. getNumber (12) 2. getNumber (13) 3. ....

— NTCG
quelle
Ich weiß nicht viel über Javascript Golf, aber ich bin mir ziemlich sicher, dass Sie die Namen getNumberoder verkürzen sollten sumDigits.
— Ørjan Johansen
Vielen Dank, ich werde hier nicht gewinnen, ich möchte mich nur dieser Herausforderung stellen: smile:
— NTCG
0

J , 37-33 Bytes

+^:(((=1#."."0)*:(e.".\.))":)^:_~

Probieren Sie es online!

                                ~    A = N
+^:                          ^:_     while(...)A+=N; return A
   (                      ":)        A to string
   (((    "."0)          )  )        digits of A
   ((( 1#.    )          )  )        sum
   (((=       )          )  )        equals N
   ((            (e.".\.))  )        N is one of the suffixes of A-string
   ((          *:        )  )        not AND

Das Voranstellen des Iterationszählers ist ~ 5-mal schneller, aber 5 Byte länger:

(]+[((=1#.,.&.":)<:|),~&.":)^:_&1,&":]

Probieren Sie es online!

Inkrementierung um 100, 27 Bytes :

(]+100*(=1#.,.&.":)<:|)^:_~

Probieren Sie es online!

— FrownyFrog
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.