Si vous ne comprenez pas ce que dit ce gars, sautez-le
Bien sûr, il est souvent plus facile de dessiner en utilisant une grammaire spécifique à C ++, mais j'écris avec une grammaire qui peut aussi être écrite en C.
#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 avec une instruction for normale
for(int i = 0; i < 100; i++)
fizzbuzz(i);
printf("\n");
//FizzBuzz en soustrayant le pointeur
for(int *i = &array[0]; i != &array[N]; i++)
fizzbuzz((int)(i - &array[0]) + 1);
//macro
HUNDRED(1)
//Récursif
loop(100);
printf("\n");
//déclaration while
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);
}
En utilisant la soustraction du deuxième pointeur, FizzBuzz tire parti du fait que le tableau est une structure de données continue. Vous ne pouvez donc pas faire la même chose avec une liste concaténée. FizzBuzz, qui utilise la troisième macro, avait une définition un peu maladroite de la macro. Vous pouvez voir ce que vous faites si vous utilisez généralement la macro rep. FizzBuzz utilise la 4ème récursive, mais en théorie toutes les boucles qui peuvent être écrites avec les instructions for et while peuvent être écrites avec récursif, il est donc inévitablement possible d'écrire avec récursif. Cependant, en réalité, les boucles qui utilisent la récursive sont plus lourdes que l'utilisation de for et while et consomment de la mémoire, il est donc préférable de l'utiliser lorsque vous pouvez écrire avec for et while. Si vous pouvez écrire avec for, vous pouvez également écrire avec while. Vous pouvez donc écrire FizzBuzz avec while. Eh bien, en réalité, c'est plus facile à lire si vous l'écrivez pour, tant de gens l'utilisent.
#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_Mis en œuvre dans chaque
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;
//Mis en œuvre avec accumulate
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;
//Mis en œuvre avec transform
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);
}
}
Un certain nombre de boucles peuvent être réécrites à l'aide du package algorithm. Parfois, je fais de la climatisation sans utiliser pour ou pendant la programmation de compétition. Cependant, la raison pour laquelle peu de gens le font est que la lisibilité est réduite. Si plusieurs processus sont écrits dans une expression lambda, la lisibilité diminuera immédiatement. Le second FizzBuzz est une opération d'écriture sur la sortie standard tout en calculant la somme des éléments du tableau avec accumulate. Les fonctions qui utilisent des expressions lambda dans le package d'algorithme peuvent faire quelque chose de similaire. C'est une fonction appelée transform utilisée dans le troisième FizzBuzz, mais en ruby et Lisp, elle s'appelle une fonction de carte. Ici, il est utilisé pour convertir un vecteur de type int en vecteur de type chaîne. Je vais l'omettre ici, mais vous pouvez également l'implémenter en utilisant list and set.
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) + " ";
}
}
Les premier, deuxième et troisième sont l'instruction for, l'instruction while et l'implémentation récursive qui ont également été implémentées dans C. Il est implémenté dans le quatrième ArrayList, mais vous devriez également pouvoir l'implémenter dans LinkedList. ~~ Cependant, j'ai utilisé LinkedList car ce n'était pas très confortable à utiliser. Ce que vous devez faire attention avec ~~ ArrayList est que si vous ne spécifiez pas le nombre d'éléments au moment de la première déclaration de variable, le tableau sera recréé chaque fois que vous ajoutez un élément, donc cela prendra du temps pour la longueur du tableau. n'est-ce pas. Les 5ème, 6ème et 7ème fonctions sont stream, ce qui est identique à Linq en C #. La différence avec Linq est que vous ne pouvez pas utiliser de syntaxe de type SQL. J'ai utilisé "accumulate" en C ++ car c'était une fonction appelée réduire en Java. ~~ J'adore les fonctions de convolution. ~~ De même, la fonction appelée transform en C ++ était une fonction appelée map en Java. Comme vous pouvez le voir par comparaison, il est plus facile à lire en utilisant le flux de Java qu'en utilisant les fonctions du package d'algorithmes C ++.