Wenn Sie nicht verstehen, was dieser Typ sagt, überspringen Sie es
Natürlich ist es oft einfacher, mit einer C ++ - spezifischen Grammatik zu zeichnen, aber ich schreibe mit einer Grammatik, die auch in C geschrieben werden kann.
#include <stdio.h>
void loop(int n);
void fizzbuzz(int x);
#define N 100
#define TWO(i) fizzbuzz(i); fizzbuzz(i + 1);
#define FOUR(i) TWO(i) TWO(i + 2)
#define EIGHT(i) FOUR(i) FOUR(i + 4)
#define SIXTEEN(i) EIGHT(i) EIGHT(i + 8)
#define THIRTY_TWO(i) SIXTEEN(i) SIXTEEN(i + 16)
#define SIXTY_FOUR(i) THIRTY_TWO(i) THIRTY_TWO(i + 32)
#define HUNDRED(i) SIXTY_FOUR(i) THIRTY_TWO(i + 64) FOUR(i + 96)
int main(){
int array[100];
//FizzBuzz mit einer normalen for-Anweisung
for(int i = 0; i < 100; i++)
fizzbuzz(i);
printf("\n");
//FizzBuzz durch Subtrahieren des Zeigers
for(int *i = &array[0]; i != &array[N]; i++)
fizzbuzz((int)(i - &array[0]) + 1);
//Makro
HUNDRED(1)
//Rekursiv
loop(100);
printf("\n");
//while-Anweisung
int j = 0;
while(++j < 100)
fizzbuzz(j);
printf("\n");
return 0;
}
void fizzbuzz(int x){
if(x % 15 == 0){
printf("fizzbuzz");
}else if(x % 3 == 0){
printf("fizz");
}else if(x % 5 == 0){
printf("buzz");
}else{
printf("%d", x);
}
printf(" ");
}
void loop(int n){
if(n <= 0)
return;
loop(n - 1);
fizzbuzz(n);
}
Durch die Subtraktion des zweiten Zeigers nutzt FizzBuzz die Tatsache, dass das Array eine kontinuierliche Datenstruktur ist. Mit einer verketteten Liste können Sie also nicht dasselbe tun. FizzBuzz, das das dritte Makro verwendet, hatte eine etwas umständliche Definition des Makros. Sie können sehen, was Sie tun, wenn Sie normalerweise das Rep-Makro verwenden. FizzBuzz verwendet das 4. Rekursiv, aber theoretisch können alle Schleifen, mit denen für Anweisungen geschrieben werden kann, und während Anweisungen mit Rekursiv geschrieben werden können, so dass es unvermeidlich möglich ist, mit Rekursiv zu schreiben. In der Realität sind Schleifen, die rekursiv verwenden, jedoch schwerer als for und while und verbrauchen Speicher. Daher ist es besser, diese zu verwenden, wenn Sie mit for und while schreiben können. Wenn Sie mit for schreiben können, können Sie auch mit while schreiben. So können Sie FizzBuzz mit while schreiben. In Wirklichkeit ist es einfacher zu lesen, wenn Sie es für schreiben, für das so viele Leute es verwenden.
#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <numeric>
using namespace std;
#define N 100
string fizzbuzz(int x);
int main(){
vector<int> vec_int(N);
// for_In jedem implementiert
for(vector<int>::iterator i = vec_int.begin(); i < vec_int.end(); i++){
*i = distance(vec_int.begin(), i) + 1;
}
for_each(vec_int.begin(), vec_int.end(), [](intelement){cout<<fizzbuzz(element)<<"";});
cout << endl;
//Implementiert mit akkumulieren
fill(vec_int.begin(), vec_int.end(), 1);
accumulate(vec_int.begin(), vec_int.end(), 0, [](intx,inty){cout<<fizzbuzz(x)<<"";returnx+y;});
cout << endl;
//Implementiert mit Transformation
vector<string> output_string(N);
for(vector<int>::iterator i = vec_int.begin(); i < vec_int.end(); i++){
*i = distance(vec_int.begin(), i) + 1;
}
transform(vec_int.begin(), vec_int.end(), output_string.begin(), [](intinput){returnfizzbuzz(input);});
for_each(output_string.begin(), output_string.end(), [](strings){cout<<s<<"";});
return 0;
}
string fizzbuzz(int x){
if(x % 15 == 0){
return "fizzbuzz";
}else if(x % 3 == 0){
return "fizz";
}else if(x % 5 == 0){
return "buzz";
}else{
return to_string(x);
}
}
Viele Schleifen können mit dem Algorithmuspaket neu geschrieben werden. Manchmal mache ich AC, ohne für oder während der Wettbewerbsprogrammierung zu verwenden. Der Grund, warum dies nur wenige Menschen tun, ist jedoch, dass die Lesbarkeit verringert ist. Wenn mehrere Prozesse in einen Lambda-Ausdruck geschrieben werden, wird die Lesbarkeit sofort verringert. Der zweite FizzBuzz ist eine Operation zum Schreiben in die Standardausgabe, während die Summe der Elemente des Arrays mit akkumuliert berechnet wird. Funktionen, die Lambda-Ausdrücke im Algorithmuspaket verwenden, können etwas Ähnliches tun. Es ist eine Funktion namens Transformation, die im dritten FizzBuzz verwendet wird, aber in Ruby und Lisp wird sie als Kartenfunktion bezeichnet. Hier wird es verwendet, um einen Vektor vom Typ int in einen Vektor vom Typ String zu konvertieren. Ich werde es hier weglassen, aber Sie können es auch mit list and set implementieren.
import java.util.ArrayList;
import java.util.List;
class Main {
public static void main(String[] args){
for(int i = 0; i < 100; i++)
FizzBuzz(i);
System.out.println();
int n = 0;
while(n++ < 100)
FizzBuzz(n);
System.out.println();
Loop(100);
System.out.println();
int length = 100;
List<Integer> numbers = new ArrayList<Integer>(length);
for(int i = 0; i < length; i++){
numbers.add(i);
}
numbers.stream()
.forEach((i) -> { FizzBuzz(i); });
System.out.println();
numbers.stream()
.map((i) -> { return toString(i); })
.forEach((i) -> { System.out.print(i); });
System.out.println();
for(int i = 0; i < length; i++){
numbers.set(i, 1);
}
numbers.stream()
.reduce((i, j) -> { FizzBuzz(i); return i + j; });
System.out.println();
}
static void FizzBuzz(int n){
if(n % 15 == 0)
System.out.print("FizzBuzz");
else if(n % 3 == 0)
System.out.print("Fizz");
else if(n % 5 == 0)
System.out.print("Buzz");
else
System.out.print(n);
System.out.print(" ");
}
static void Loop(int n){
if(n <= 0)
return;
Loop(n - 1);
FizzBuzz(n);
}
static String toString(int n){
if(n % 15 == 0)
return "FizzBuzz ";
else if(n % 3 == 0)
return "Fizz ";
else if(n % 5 == 0)
return "Buzz ";
else
return Integer.toString(n) + " ";
}
}
Die erste, zweite und dritte sind für Anweisungen, während Anweisungen und rekursive Implementierungen, die ebenfalls in C implementiert wurden. Es ist in der vierten ArrayList implementiert, aber Sie sollten es auch in der LinkedList implementieren können. ~~ Ich habe jedoch LinkedList verwendet, weil es nicht sehr komfortabel zu bedienen war. Bei ~~ ArrayList müssen Sie vorsichtig sein: Wenn Sie die Anzahl der Elemente zum Zeitpunkt der ersten Variablendeklaration nicht angeben, wird das Array jedes Mal neu erstellt, wenn Sie ein Element hinzufügen, sodass die Länge des Arrays einige Zeit in Anspruch nimmt. nicht wahr. Die 5., 6. und 7. Funktion sind Stream-Funktionen, die mit Linq in C # identisch sind. Der Unterschied zu Linq besteht darin, dass Sie keine SQL-ähnliche Syntax verwenden können. Ich habe "akkumulieren" in C ++ verwendet, weil es eine Funktion namens Reduzieren in Java war. ~~ Ich liebe Faltungsfunktionen. ~~ In ähnlicher Weise war die Funktion transform in C ++ eine Funktion namens map in Java. Wie Sie im Vergleich sehen können, ist das Lesen mit Javas Stream einfacher als mit den Funktionen des C ++ - Algorithmuspakets.