Die heiligen Zahlen


44

In vielen Schriften (insbesondere in der Consolas-Schrift ) weisen 5 der 10 Dezimalstellen "Löcher" auf. Wir werden diese heiligen Ziffern nennen:

46890

Die 5 unheiligen Ziffern sind also:

12357

Eine Ganzzahl kann daher als "heilig" klassifiziert werden, wenn sie nur heilige Ziffern enthält, und ansonsten als "unheilig". Weil -es unheilig ist, können keine negativen ganzen Zahlen heilig sein.

Heilige ganze Zahlen können basierend auf der Anzahl ihrer Löcher weiter klassifiziert werden. Beispielsweise haben die folgenden Ziffern eine Heiligkeit von 1:

469

Und diese Ziffern haben eine Heiligkeit von 2:

80

Wir sagen, dass die Gesamtheiligkeit einer ganzen Zahl die Summe der Heiligkeit ihrer Ziffern ist. Daher 80hätte eine Heiligkeit von 4 und 99eine Heiligkeit von 2.

Die Herausforderung

Geben Sie bei zwei Ganzzahlen n > 0und h > 0die nth heilige Ganzzahl aus, deren Heiligkeit mindestens ist h. Sie können davon ausgehen, dass die Ein- und Ausgänge nicht größer sind als die maximal darstellbare Ganzzahl in Ihrer Sprache oder 2^64 - 1, je nachdem, welcher Wert kleiner ist.

Hier ist eine Liste der ersten 25 heiligen ganzen Zahlen mit Heiligkeit h >= 1als Referenz:

0, 4, 6, 8, 9, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99

Die ersten 25 Ganzzahlen mit Heiligkeit h >= 2sind:

0, 8, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99, 400, 404, 406

Related - 1 2
Mego

26
Ich saß hier für etwa 30 Sekunden und dachte "Wie zum Teufel hat 0eine Heiligkeit von zwei", bevor ich schließlich auf den Wikipedia-Link zu Consolas
undergroundmonorail

Ist die fünfte 1-heilige Zahl 9 oder 40?
Conor O'Brien

3
Ist es nur ein Zufall, dass die 8. 8+ -Holzzahl 8888 ist? (Ja, es ist wahrscheinlich, aber es hat mich trotzdem amüsiert ...)
Toby Speight

5
In der Tat, da Sie eine beliebige Anzahl führender Nullen vor einer Zahl haben können, könnte man den Fall annehmen, dass 0 unendlich heilig ist. Obwohl ∞ anscheinend genauso heilig ist. Aber seltsamerweise ist 666 noch heiliger ...
Darrel Hoffman

Antworten:


6

Pyth, 32 Bytes

e.fg*g.{`46890J`Z++lJ/J`8/J`0QE0

Erläuterung

                                 - autoassign Q = eval(input())
 .f                           E0 -  first eval(input()) terms of func V starting Z=0

     g.{`46890J`Z                -    Are all the digits in Z in "46890"?
               `Z                -      str(Z)
              J                  -     autoassign J = ^
     g                           -    is_subset(V,^)
      .{`46890                   -     set("46890")

    *                            -   ^*V (Only return non-zero if only contains holy numbers)

                 ++lJ/J`8/J`0    -    Get the holiness of the number
                   lJ            -      len(J)
                  +              -     ^+V
                     /J`8        -      J.count("8") 
                 +               -    ^+V
                         /J`0    -     J.count("0")
   g                         Q   -  ^>=Q (Is the holiness great enough)
e                                - ^[-1]

Probieren Sie es hier aus

Nimmt Eingaben in das Formular auf h \n n


12

Ruby, 109 105 95 82 Bytes

->n,h{(?0..?9*99).select{|x|x.count('469')+2*x.count('80')>=h&&/[12357]/!~x}[n-1]}

Dies ist der schreckliche Ansatz "Berechne von 0 bis 99999999999 ...", der 13 Byte kürzer ist als sein fauler Gegenüber. Es ist jedoch unwahrscheinlich, dass diese Version vor dem Hitzetod des Universums fertig wird. Trotzdem 13 Bytes wert. \ _ (ツ) _ /

Sie können es auf kleinere Werte testen, indem Sie beispielsweise ?9*99auf '99999'.

Hier ist die alte Version (95 Bytes, mit verzögerter Auswertung, die fast sofort und nicht so gut wie nie ausgeführt wird):

->n,h{(?0..?9*99).lazy.select{|x|x.count('469')+2*x.count('80')>=h&&/[12357]/!~x}.first(n)[-1]}
->n,h{
(?0..?9*99)  # range '0' (string) to '9' repeated 99 times, way more than 2**64
.lazy        # make the range lazy, so we can call `select' on it
.select{|x|  # choose only elements such that...
 x.count('469')+2*x.count('80')  # naive holiness calculation
 >=h         # is at least h
 &&/[12357]/!~x                  # naive "is holy" calculation
}
.first(n)    # take the first n elements that satisfy the condition
[-1]         # choose the last one from this array
}


Warum nicht takestatt first?
Nicht dass Charles

@NotthatCharles takegibt einen Wert zurück Lazy, der nicht indiziert werden kann.
Türknauf

6

Python 3, 103

lambda n,h,l='4698080':[y for y in range(2**64-1)if(sum(l.count(x)-(x not in l)for x in str(y))>=h)][n]

Hier ist eine Lösung, die einen speichereffizienten Ansatz verwendet, aber ansonsten denselben Algorithmus verwendet, wenn Sie ihn testen möchten.

l='4689080'
def f(n,h):
 c=i=0
 while i<n:
  if sum(l.count(x)-(x not in l)for x in str(c))>=h:u=c;i+=1
  c+=1
 return u

Testfälle:

assert f(3, 1) == 6
assert f(4, 2) == 44

@ Mego Cool. Es scheint statisch viel Speicher zu belegen, sodass nicht die Gefahr besteht, dass der Speicher knapp wird. Ich war mir nur nicht sicher, da es schon seit einer halben Stunde auf meiner Maschine läuft.
Morgan Thrapp

Es dauert tatsächlich ein gutes Stück Zeit, nur um zu berechnen 2**64-1; Siehe stackoverflow.com/questions/34113609/…
Mego

@Mego Oh, darüber habe ich nicht einmal nachgedacht. Ja, wenn ich die vorberechnete Konstante in den Code stecke, beginnt sie, ein bisschen RAM zu durchkauen.
Morgan Thrapp

6

PowerShell, 163 150 141 101 98 96 Byte

param($n,$h)for(--$i;$n){if(++$i-notmatch"[12357]"-and($i-replace"8|0",11).Length-ge$h){$n--}}$i

Übernimmt die Eingabe und schleift dann, bis $nNull ist. Wir setzen zunächst $i=-1mit Hilfe eines Pre-Processing-Tricks, der funktioniert, weil $i, nachdem zuvor nicht deklariert, ist $null. Dann wir --es, was PowerShell veranlasst, es als zu bewerten $i = $null - 1, was ist $i=-1.

Jede Schleife wird inkrementiert $iund anschließend eine ausführliche ifAnweisung ausgeführt. Im ersten Teil der Bedingung wird mithilfe des Operators überprüft, ob $inoch etwas 12357davon enthalten ist, um die unheiligen Zahlen herauszufiltern.-notmatch

Der zweite Teil der Bedingung prüft die Anzahl der Löcher in $i. Es verwendet den -replaceOperator, um jedes 8oder 0durch zu ersetzen 11, und vergleicht dann, ob die Länge> = ist $h. Wir müssen uns nicht darum kümmern, die unheiligen Zahlen zu entfernen, da dies im ersten Teil der Bedingung steht und die einlochigen Zahlen die gleiche Länge wie 1ohnehin haben, sodass wir sie auch nicht ersetzen müssen.

Wenn das immer noch wahr ist, verringern wir $n(das heißt, wir haben eine andere Zahl gefunden, die die Eingabeanforderungen erfüllt). Wenn also die forBedingung neu berechnet wird, um zu überprüfen, ob $nNull ist, bedeutet dies, dass wir die n-te gefunden haben , also verlassen wir die forSchleife, geben sie aus $iund beenden sie.

Bearbeiten - 13 Bytes mit einem Array anstelle eines Strings speichern $lund ändern, wie $ndekrementiert / markiert wird.
Bearbeiten 2 - 9 Bytes zusätzlich speichern, indem $ndie forBedingung geprüft und die Ausgabe aus der Schleife
verschoben wird. Bearbeiten 3 - Satte Ergebnisse gespeichert 40 weitere Bytes durch radikale Änderung der Berechnung von Löchern
Edit 4 - 3 zusätzliche Bytes durch Verschieben ++von als Vorinkrement für den ersten Teil des bedingten
Edit 5 gespart - weitere 2 Bytes dank TessellatingHeckler gespart


Ordentlich. Sparen Sie noch ein paar Bytes, indem Sie auf for(--$i;$n)und -replace"8|0"?
TessellatingHeckler

@TessellatingHeckler Ja, danke. Das hat $i=-1mich total verrückt gemacht. Ich versuche immer noch, einen Weg zu finden, damit wir nicht erst initialisieren müssen $i, aber die Dinge, die ich bisher ausprobiert habe, sind länger (und werden diesbezüglich wahrscheinlich noch länger sein).
AdmBorkBork


4

Bash + GNU-Dienstprogramme, 67

  • 20 Bytes gespart dank @TobySpeight!
seq 0 NaN|sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"|sed $2!d\;q
  • seqgeneriert einfach ganze Zahlen ab 0aufwärts
  • sed -r:
    • h Kopieren Sie die Eingabezeile in den Hold-Bereich
    • /12357/d unheilige zahlen löschen
    • s/8|0/&&/gErsetzen Sie doppelt heilige Ziffern durch doppelt selbst. Somit werden einfach heilige Ziffern einmal und doppelt heilige Ziffern zweimal gezählt.
    • /^.{$1}/!dWenn mindestens die $1Löcher nicht übereinstimmen , löschen Sie und fahren Sie mit der nächsten Zeile fort
    • x Bringen Sie die ursprüngliche Nummer wieder in den Musterbereich
    • impliziter Druck
  • sed
    • $2!d$2Löschen Sie alle Zeilen vor der Zeile und fahren Sie mit der nächsten Zeile fort
    • qmuss sich am Zeilenende befinden $2(und impliziter Druck)

Ideone.


1
Shave 9: sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x". Und noch ein 4: sed $2!d\;q. Und wenn Sie mit einer Obergrenze von nur 4611686018427387904 zufrieden sind, könnten Sie mitseq 0 $[1<<62]
Toby Speight

1
Oh, ich seqakzeptiere NaNals Wert: Ich habe jetzt seq 0 NaN|sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"|sed $2!d\;q67.
Toby Speight

@TobySpeight Wow, das ist unglaublich!
Digitales Trauma

@TobySpeight: Fehlt ein \ vor dem!, Sonst:-sh: !d\: event not found
Olivier Dulac

1
@OlivierDulac ` before ! ` Wird in einem Skript nicht benötigt . Es wird nur benötigt, wenn dies direkt auf der Kommandozeile ausgeführt wird, was ich nicht für erforderlich halte.
Digitales Trauma

3

MATL , 39 bis 40 Bytes

x~q`QtV4688900V!=stA*s2G<?T}N1G=?F1$}tT

Inpunts sind nund hin dieser Reihenfolge.

Probieren Sie es online!

Wir müssen zwei Zahlen im Auge behalten: die aktuelle Kandidatennummer (um ihre Heiligkeit zu überprüfen) und die Anzahl der gefundenen Zahlen, die heilig genug sind. Das erste ist die Oberseite des Stapels, und das letztere wird als Anzahl der Elemente im Stapel beibehalten. Wenn das Programm beendet ist, muss nur die Oberseite angezeigt werden.

x~q          % implicitly take two inputs. Delete one and transform the other into -1
`            % do...while loop
  Q          %   add 1 to current candidate number
  tV         %   duplicate and convert to string
  4688900V!  %   column char array of '4', '6' etc. Note '8' and '0' are repeated 
  =          %   compare all combinations. Gives 2D array
  s          %   sum of each column: holiness of each digit of candidate number
  tA*        %   are all digits holy? Multiply by that
  s          %   sum of holiness of all digits, provided they are all holy
  2G<        %   is that less than second input (h)?
  ?          %   if so: current candidate not valid. We'll try the next
    T        %     push true to be used as loop condition: next iteration
  }          %   else: current candidate valid
    N1G=     %     does stack size equal first input (n)?
    ?        %     if so: we're done
      F1$    %       push false to exit loop. Spec 1 input, to display only top
    }        %     else: make a copy of this number
      tT     %       duplicate number. Push true to continue with next iteration
             %     implicit end if 
             %   implicit end if 
             % implicit end do...while. If top of stack is truthy: next iteration
             % implicit display

3

R 109 107 Bytes

f=function(n,h){m=-1;while(n){m=m+1;if(!grepl("[12357]",m))if(nchar(gsub("([08])","\\1\\1",m))>=h)n=n-1};m}

Mit neuen Zeilen und Einrückungen:

f=function(n,h){
    m=-1
    while(n){
        m=m+1
        if(!grepl("[12357]",m))
            if(nchar(gsub("([08])","\\1\\1",m))>=h)
                n=n-1
    }
    m
}

Verwendungszweck:

> f(4,3)
[1] 68
> f(4,2)
[1] 44
> f(6,2)
[1] 48
> f(10,2)
[1] 66

3

JavaScript (ES6), 110 Byte

f=(n,h,r=[],i=0)=>r.length<n?f(n,h,/[12357]/.test(i)|[...''+i].reduce((t,c)=>t+1+!(c%8),0)<h?r:[...r,i],i+1):r

Schwanzrekursive Lösung, die heilige Zahlen in einem Array ansammelt.

Aus Gründen des Interesses wird die Heiligkeit ungünstiger, wenn die Zahl nicht vollständig (!) Heilig sein muss. Insgesamt werden jedoch 10% gespart:

f=(n,h,r=[],i=0)=>r.length<n?f(n,h,[...''+i].reduce((t,c)=>+"2000101021"[c]+t,0)<h?r:[...r,i],i+1):r

@ edc65 Hoppla, ich habe an einer Stelle die Parameter iund vertauscht rund konnte die Änderung nicht richtig bearbeiten.
Neil

1

JavaScript ES6, 191 Bytes

Sicher, das ist nicht der effizienteste Weg. Aber du kennst mich, ich liebe Generatoren <3

H=(x,o=x+"")=>(F=/^[46890]+$/).test(o)&&[...o].map(y=>d+=(F.test(y)+/8|0/.test(y)),d=0)&&d;(n,h)=>(a=(function*(h){q=0;while(1){if(H(q)>=h)yield q;q++}})(h),eval("a.next().value;".repeat(n)))

Leicht ungolfed:

H = (x, o = x + "") => (F = /^[46890]+$/).test(o) && [...o].map(y => d += (F.test(y) + /8|0/.test(y)), d = 0) && d;
Q = (n, h) => (a = (function*(h) {
    q = 0;
    while (1) {
        if (H(q) >= h) yield q;
        q++
    }
})(h), eval("a.next().value;".repeat(n)))

1

C # 6, 168 Bytes

(n,h)=>{for(int i=0;i<=int.MaxValue;i++){string d=$"{i}";if(d.Any(y=>"12357".Contains(y)))continue;n-=d.Sum(y=>y=='0'||y=='8'?2:1)>=h?1:0;if(n==0)return i;}return -1;}

Dies ist ein Lambda-Ausdruck vom Typ Func <int, int, int>. Dieser Code ist für die Mindestgröße optimiert (nicht performatisch).

Unten der verschönerte Code in der Methodendeklaration (mit mehr Leistung):

    int GetHolyNumber(int n, int h)
    {
        for (int i = 0; i <= int.MaxValue; i++)
        {
            string d = $"{i}";
            char[] cs = "12357".ToArray();
            if (d.Any(y => cs.Contains(y))) continue;

            n -= d.Sum(y => y == '0' || y == '8' ? 2 : 1) >= h ? 1 : 0;

            if (n == 0)
                return i;
        }
        return -1;
    }

Hallo Bobson, tut mir leid, wenn ich falsch verstanden habe, aber keine Fehler feststelle, auf die Sie in meinem Code hingewiesen haben? Es gibt das n-te Element zurück, das erforderlich ist, und nur er, und null, wenn es gültig ist, vorausgesetzt, die Eingaben sind n = 1 und h <= 2. Wenn ich die Herausforderung verstehe, muss nur dieses eine Element und nicht alle an ihn zurückgegeben werden . Aber ich habe mich falsch verstanden und auf Englisch verloren: D Danke
Paulo César B. Sincos

Nein, du hast vollkommen recht. Die Referenzlisten haben mich in die Irre geführt, und ich habe die Tatsache übersehen, dass nur die n-te Ziffer abgefragt wurde. Mach weiter!
Bobson

1

JavaScript (ES6), 87

(n,h)=>eval("for(i=0;[...i+''].map(d=>r-=~!(d%8),r=0),/[12357]/.test(i)|r<h||--n;)++i")

Weniger golfen

f=(n,h)=>{
  for (i=0;
    // this is the loop condition
    /[12357]/.test(i) // go on if not holy
    ||([...i+''].map(d=>r-=~!(d%8),r=0),r<h) // go on if not holy enough
    ||--n; // ok, found one! go on if we need to find more
  )
    ++i; // loop body - using eval this is the returned value
  return i; // not using eval, an explicit return is needed
}  

Prüfung

f=(n,h)=>eval("for(i=0;[...i+''].map(d=>r-=~!(d%8),r=0),/[12357]/.test(i)|r<h||--n;)++i")

function test() {
  var a,b
  [a,b]=I.value.match(/\d+/g)
  R.textContent = f(a,b)
}

test()
N, H: <input id=I value="25 2" oninput="test()"> >>
<span id=R></span>


1

Lua, 169 Bytes

function a(n,h)H=0N=0I=-1while N<n do I=I+'1'H=0 if not I:find('[12357]') then _,b=I:gsub('[469]',1)_,c=I:gsub('[08]',1)H=b+2*c end N=H>=h and N+1 or N end print(I) end

Ungolfed:

function a(n,h) -- nth term, holiness
    H=0N=0I=-1 -- Really ugly, but hey, it works. Set up 3 vars
    while N<n do -- While nth term is lower than desired term
        I=''..I+1 -- Convert number to string (can't coerce since it will become a float)
        if not I:find('[12357]') then -- If the number doesn't have those numbers
            _,b=I:gsub('[469]',1) -- _ is the new string, b is the number of changes
            _,c=I:gsub('[08]',1) -- Same as above. Use 1 to replace to save chars
            H=b+2*c -- Increase holiness appropriately
        end
        N=H>=h and N+1 or N -- If current holiness >= desired holiness, increment N
    end 
    print(I) -- Once the loop ends, print the current term
end

1

Lua, 155 141 140 Bytes

Übernimmt beide Eingaben per Kommandozeilenargument (erstes Argument ist n, dann h)

Edit: Danke an @DavisDude, der mir geholfen hat, 14 Bytes zu sparen und mich daran erinnert hat, dass ich nicht alle heiligen Zahlen bis n drucken musste, sondern nur die n-te.

a={}x=0while(#a<arg[1])do b,c=(x..""):gsub("[08]","")e,d=b:gsub("[469]","")a[#a+1],x=c*2+d>=arg[2]and #e<1 and x or nil,x+1 end print(a[#a])

Ungolfed und Erklärungen

x,a=0,{}                      -- initialise a counter, and the array which 
                              -- contains the holy numbers found
while(#a<arg[1])              -- iterate while we found less holy numbers than n
do
  b,c=(x..""):gsub("[08]","") -- replace [08] by "", b=the new string
                              -- c=the number of subsitution
  e,d=b:gsub("[469]","")      -- same thing for [469]
  a[#a+1]=c*2+d>=arg[2]       -- insert the number into a if:nb[08]*2+nb[469]>h
             and #e<1         -- and e is empty (no unholy numbers)
             and x or nil
      x=x+1                   -- increment x
end
print(a[#a])                  -- print the last element of a

Sie könnten ein paar Zeichen print(a[arg[1]])
entfernen,

@DavisDude Ich war dumm, als ich das schrieb, musste ich mir allerdings die gesamte Liste der unheiligen Zahlen bis ausdrucken n. Spart eigentlich print(a[#a])noch mehr Bytes. Danke für den Kommentar !
Katenkyo

Sie schreiben. Aus irgendeinem Grund ist mir das gar nicht eingefallen.
DavisDude

Sie können abschreiben ein Zeichen nehmen x=0a={}statt x,a=0,{}.
Undichte Nonne

1
@KennyLau Eigentlich kann man 0ada keine hexadezimale Zahl interpretieren, aber ich kann a={}x=0whileohne Probleme
auskommen

0

Oracle SQL 11.2, 229 Byte

WITH v(c,p,i,j,n)AS(SELECT 0,-1,0,0,0 FROM DUAL UNION ALL SELECT c+1,c,REGEXP_COUNT(c||'','[4,6,9]'),REGEXP_COUNT(c,'[8,0]'),n+DECODE(LENGTH(p),i+j,DECODE(SIGN(i+j*2-:h),-1,0,1),0)FROM v WHERE p<c AND n<:n)SELECT MAX(p)-1 FROM v;

Nicht golfen

:h -> required min holy value
:n -> nth number 

curv   -> current number
precv  -> previous number
prech1 -> number of holy 1 letters in previous number 
prech2 -> number of holy 2 letters in previous number
n      -> how many numbers with at least the required holy value 

WITH v(curv,precv,prech1,prech2,n)AS 
(
  SELECT 0 curv, -1 precv, 0 prech1, 0 prech2, 0 n FROM DUAL     -- Start with 0
  UNION ALL
  SELECT curv+1,   -- Next number
         curv,     -- Current Number 
         REGEXP_COUNT(curv||'','[4,6,9]'),  -- number of holy 1 letters
         REGEXP_COUNT(curv,'[8,0]'),        -- number of holy 2 letters
         n+DECODE(LENGTH(precv),prech1+prech2,DECODE(SIGN(prech1+prech2*2-:h),-1,0,1),0) -- Is the previous number holy enough ?
  FROM   v 
  WHERE  precv<curv   -- Needed to trick oracle cycle detection 
         AND n<:n     -- Until clause
)
SELECT MAX(precv)-1 FROM v 

0

Python 2, 96 Bytes

f=lambda n,h,k=0,s="0046889":-0**n or-~f(n-(sum(map(s.count,`k`))>=h<set(str(k))<=set(s)),h,k+1)

Der Heiligkeitszustand an kwird durch geprüft

  • sum(map(s.count,`k`))>=h, der die Anzahl der Löcher zählt, indem er die Anzahl für jedes Zeichen in summiert s="0046889", wobei 0und 8zweimal erscheint.
  • set(str(k))<=set(s)), die überprüft, dass die Zahlen alle heilig sind. strwird anstelle von Backticks verwendet, um das Suffix Lfür Longs zu vermeiden .

Diese werden unter Verwendung der Python 2-Tatsache, dass Zahlen kleiner als Mengen sind, zu einer einzelnen Gleichheit verkettet.

Die Funktion wird rekursiv definiert, um Zahlen khochzuzählen und den Zähler njedes Mal zu verringern, wenn eine heilige Anzahl von Treffern erzielt wird, es sei denn, sie trifft 0. Es könnte dann den zurückgeben k, der dies ausgelöst hat, aber es ist kürzer, die Zählung rekursiv zu halten, indem 1jedes Mal addiert wird, obwohl ein Off-by-One-Wert eine Basiszählung von -1zum Reparieren erfordert .


0

Haskell, 94 Bytes

cIst die Heiligkeit einer Ziffer, vdie Heiligkeit einer Zahl, n!herledigt den Rest.

c=([2,0,0,0,1,0,1,0,2,1]!!)
v n|n>9=c(mod n 10)+v(div n 10)|1<2=c n
n!h=[i|i<-[0..],v i<=h]!!n

Hinweis: Ich denke, dies ist die einzige Antwort ohne die Zeichen 4,6,8.


0

Schnell

func f(n: Int, h: Int) {
    var m = 0
    let a = [1,2,3,5,7]
    for j in 0..<Int.max {
        var c = 0
        for i in (j.description.characters.map{(String($0) as NSString).integerValue}) {
            c += (a.contains(i)) ? 0 : (i == 8 || i == 0) ? 2 :1
        }
        if c >= h { m += 1; if m >= n {print(j); break}}
    }
}
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.