wake-up-neo.com

Von 1 bis 100 drucken Sie "ping" bei einem Vielfachen von 3, "Pong" bei einem Vielfachen von 5 oder drucken Sie die Zahl

Ich kam gerade von einem Vorstellungsgespräch nach Hause und der Interviewer bat mich, ein Programm zu schreiben:

Es sollte von 1 bis 100 zählen und drucken ...

Wenn es ein Vielfaches von 3 war, "Ping"
Wenn es ein Vielfaches von 5 war, "pong"
Andernfalls drucken Sie die Nummer.

Wenn es ein Vielfaches von 3 UND 5 (wie 15) war, sollten "ping" und "pong" gedruckt werden.

Ich wählte Javascript und kam dazu:

for (x=1; x <= 100; x++){
    if( x % 3 == 0 ){
        write("ping")
    }
    if( x % 5 == 0 ){
        write("pong")
    }
    if( ( x % 3 != 0 ) && ( x % 5 != 0 ) ){
        write(x)
    }
}

Eigentlich bin ich mit meiner Lösung sehr unzufrieden, aber ich kann keine bessere Lösung finden.

Weiß jemand einen besseren Weg, um das zu tun? Es wird zweimal überprüft, es hat mir nicht gefallen. Ich habe hier zu Hause einige Tests durchgeführt, ohne Erfolg, dies ist der einzige, der das Ergebnis liefert korrekte Antwort...

10
BernaMariano

Ihre Lösung ist meiner Meinung nach ziemlich zufriedenstellend. Da halbe Zahlen kein Vielfaches von 3 oder 5 sind, würde ich andersherum beginnen:

for (var x=1; x <= 100; x++){
    if( x % 3 && x % 5 ) {
        document.write(x);
    } else {
        if( x % 3 == 0 ) {
            document.write("ping");
        }
        if( x % 5 == 0 ) {
            document.write("pong");
        }
    }
    document.write('<br>'); //line breaks to enhance output readability
}​

Fiddle

Beachten Sie auch, dass jede andere Zahl als 0 und NaN wahrheitsgemäße Werte sind. Daher habe ich den unnötigen != 0 und einige Klammerpaare entfernt.


Hier ist eine andere Version, sie führt nicht zweimal den gleichen Modul-Vorgang aus, sondern muss eine Variable speichern:

for (var x=1; x <= 100; x++) {
    var skip = 0;
    if (x % 3 == 0) {
        document.write('ping');
        skip = 1;
    }
    if (x % 5 == 0) {
        document.write('pong');
        skip = 1;
    }
    if (!skip) {
        document.write(x);
    }
    document.write('<br>'); //line breaks to enhance output readability
}

Fiddle

20

Hier ist mein Einzeiler: 

for(var x=1;x<101;x++)document.write((((x%3?'':'ping')+(x%5?'':'pong'))||x)+'<br>');

Ich verwende ternäre Operatoren, um entweder einen leeren String oder 'ping'/'pong' zurückzugeben, das Ergebnis dieser Operatoren zu verketten und dann ein OR auszuführen (wenn die Zahl weder durch 3 noch durch 5 teilbar ist. Das Ergebnis der Verkettung ist '', was in Javascript FALSEY ist. Wenn beide Fälle zutreffen, ist das Ergebnis der Verkettung 'pingpong'

Im Grunde kommt es darauf an 

'' || x         // returns x
'ping' || x     // returns 'ping'
'pong' || x     // returns 'pong'
'pingpong' || x // returns 'pingpong'
7
Shmiddty

Hier ist eine Lösung, die eine dynamische Liste von Vielfachen ermöglicht, ohne weitere Bedingungen hinzuzufügen.

// List of outputs
var outputs = [
    {mult: 3, str: 'ping'},
    {mult: 5, str: 'pong'}
    // {mult: 10, str: 'play'} ex: [30] => 'pingpongplay'
];

// Loop 100 times
for (var i = 1, j = 100; i <= j; i += 1) {

    // Set empty vars
    var result, string = '';

    // Loop through the listed output objects
    outputs.forEach(function (output) {

        // If listed multiple, concat string
        if (i % output.mult === 0) {
            string += output.str;
        }

    });

    // Set result
    if (string.length) {
        result = string;
    } else {
        result = i;
    }

    // print result
    document.body.innerHTML += result + '<br>';
}

Und als Funktion, die jslint übergibt:

/*jslint browser: true */
var printOutputs = function (array, iterations) {
    'use strict';
    var i = 1;
    var outputResults = function (arr, idx) {
        var result;
        var str = '';
        arr.forEach(function (item) {
            if (idx % item.mult === 0) {
                str += item.str;
            }
        });
        if (str.length) {
            result = str;
        } else {
            result = idx;
        }
        return result;
    };
    while (i < iterations) {
        document.body.innerHTML += outputResults(array, i) + '<br>';
        i += 1;
    }
};
var outputs = [
    {mult: 3, str: 'ping'},
    {mult: 5, str: 'pong'}
];
printOutputs(outputs, 100);

Und zum Spaß eine verminderte ES6-Version:

const pO=(arr,itr)=>{let i=1,o=(a,idx)=>{let r,s='';a.map(v=>{if(idx%v.mult===0)s+=v.str});s.length?r=s:r=idx;return r};while(i<itr){document.body.innerHTML+=`${o(arr,i)}<br>`;i++}};
pO([{mult:3,str:'ping'},{mult:5,str:'pong'}], 100);
1
SomeGuy

Die beste Lösung, die ich gefunden habe, ist diese:

for (var i = 1; i <= 100; i++) {
  var message = '';
  if (i%3 === 0) message += 'ping';
  if (i%5 === 0) message += 'pong';
  console.log(message || i);
}
0
TheSETJ

//create a for loop to count from 0 to 100
       for (let num = 0; num <= 100; num++){
        /**As the count increments, if the number is divisible by 3 and divisible by 5
        print FizzBuzz, I have concatenated the number with FizzBuzz for clarity. 
        Use % instead of \ to ensure it returns an int instead of float.**/
         if ((0 == num % 3) && (0 == num % 5)){
           console.log ("FizzBuzz" + " " + num); 
//otherwise, if the number is divisible by 5 print Buzz
         } else if (0 == num % 5) {
          console.log("Buzz" + " " + num);
//Also, if the number is divisible by 3 print Fizz
         } else if (0 == num % 3){
           console.log("fizz" + " " + num);
         } else {
//meanwhile, still print all the numbers that don't satisfy the conditions above
           console.log (num);
         }
      }

0
Sambydev

Ich habe ein paar Variationen dazu geschrieben (mit fizz und buzz) als Benchmark, um verschiedene Wege der Iteration über bedingter Logik zu betrachten.

while wieder gewonnen:

// Iterate using a recursive function
// firing a callback once per iteration

function f(s,n) {
    if(++n >= 102) return;
    s === '' ? console.log(n-1) : console.log(s);
    !!(n % 3)
        ? !!(n % 5)
            ? f('',n) : f('Buzz',n)
        : !!(n % 5)
            ? f('Fizz',n) : f('FizzBuzz',n);
}

// Iterate using a `while` loop
// firing a callback after satisfying a condition

function b(n) {
    var i = n;
    $:
        while(++i) {
            if(i % 3)
                if(i % 5) 
                    console.log(i);
                else 
                    console.log('Buzz');
            else if(i % 5) 
                console.log('Fizz');
            else 
                console.log('FizzBuzz');
            if(i >= 100) 
                break $;
        }
    return;
}

// Iterate using a `for` loop
// firing a callback once per iteration

function F(n) {
    var i = n, f = 'Fizz', b = 'Buzz', o = '';
    for (; i <= 100; i++) { 
        o = !(i % 3) 
            ? !(i % 5) 
                ? f + b : f 
            : !(i % 5) 
                ? b : i; 
        console.log(o);
    }
    return;
}

// Iterate using a `for` loop
// firing a callback after satisfying a condition

function B(n) {
    var i = n;
    var fiz = 'Fizz';
    var buz = 'Buzz';
    for(; i <= 100; i++)
        if(!(i % 3))
            if(!(i % 5))
                console.log(fiz + buz);
            else
                console.log(fiz);
        else if(!(i % 5))
            console.log(buz);
        else
            console.log(i);
    return;     
}


f('', 1); // recursive
b(0);     // `while`
F(1);     // `for`
B(1);     // `for

Benchmark: http://jsperf.com/fizzbuzz-mod

0
Benny