Pour neutraliser les données, remplacez récursivement tous les nombres (pas les chiffres!) Par des zéros et tous les caractères (pas les chaînes!) Par des espaces.

Vous devez accepter n'importe quel nombre, caractère ou chaîne unique, ou éventuellement un tableau récursif * de données numériques / caractères mixtes que votre langue peut gérer. Par exemple, vous devez accepter des chaînes réelles (et ne pas restreindre votre saisie à des listes de caractères uniques) si votre langue peut gérer de telles chaînes.

Si votre langue contient une fonction intégrée qui effectue tout ou la plupart de cette tâche, j'apprécierais une version alternative supplémentaire sans elle.

La soumission la plus courte dans chaque langue est gagnante et recevra un vote positif de ma part.

Exemples de cas

1. "" → ""

2. 7 → 0

3. 123.456 → 0

4. "X" → " "

5. " " → " "

6. "Yo!" → " "

7. [] → []

8. [-1.2E3] → [0]

9. ["Hey"] → [" "]

10. ["H","e","y"] → [" "," "," "]

11. ["R",2,"D",2] → [" ",0," ",0]

12. ["C","3","P",0] → [" "," "," ",0]

13. ["THX",[1138]] → [" ",[0]]

14. ["T","H","X",[1138]] → [" "," "," ",[0]]

15. [[["H"],"e",1,1,0],[[-3],"arth"]] → [[[" "]," ",0,0,0],[[0]," "]]

* Si votre langue a plusieurs types qui peuvent tout aussi bien représenter des tableaux comme les exemples ci-dessus, vous pouvez choisir d'en prendre en charge un seul. Deux entrées peuvent gagner toutes les deux, même si elles utilisent la même langue, en utilisant chacune un type de données différent.

JavaScript (ES6), 53 47 octets

f=o=>o.big?o.replace(/./g,' '):o.map?o.map(f):0

Cas de test

f=o=>o.big?o.replace(/./g,' '):o.map?o.map(f):0

test = [
  "",
  7,
  123.456,
  "X",
  "  ",
  "Yo!",
  [],
  [-1.2E3],
  ["Hey"],
  ["H","e","y"],
  ["R",2,"D",2],
  ["C","3","P",0],
  ["THX",[1138]],
  ["T","H","X",[1138]],
  [[["H"],"e",1,1,0],[[-3],"arth"]]
];

test.map(o => {
  console.log(JSON.stringify(o), '=>', JSON.stringify(f(o)));
});

Python 2 , 52 octets

f=lambda x:1-(x<{})and map(f,x)if x<''else' '*len(x)

Essayez-le en ligne!

Comment ça marche

Python vous permet de comparer différents types. Les types numériques sont toujours plus petits que les itérables, et les itérables sont triés par leur nom de type, donc

0 < {} < [] < '' < ()

De cette façon, f fait ce qui suit.

• Si x est numérique, x<{}renvoie True et 1-(x<{})renvoie 0 . Le code suivant andn'est pas exécuté.

• Si x est itérable, 1-(x<{})renvoie 1 (véridique), donc le code après andest exécuté.

  • Si x est une liste, x<''est vrai et f est mappé sur ses éléments.

  • Si x est une chaîne, x<''est faux et x est remplacé par une chaîne d'espaces de même longueur.

Rubis, 54 53 49 octets

f=->a{a*0==0?0:a*0==[]?a.map{|x|f[x]}:" "*a.size}

Il y a peut-être une meilleure façon, mais:

• x * 0 == 0 pour les entiers
• x * 0 == "" pour les chaînes
• x * 0 == [] pour les tableaux

Mathematica, 51 octets

J'ai actuellement deux solutions pour ce nombre d'octets:

#/._?NumberQ->0/.x_String:>StringReplace[x,_->" "]&
StringReplace[#,_->" "]~Check~#&//@#/._?NumberQ->0&

Le second lance un tas d'avertissements qui peuvent être ignorés.

Explication

Dans les deux cas, nous commençons par transformer les nombres en zéros avec

#/._?NumberQ->0

Ensuite, pour traiter la chaîne, il y a deux options. Soit, nous utilisons une autre substitution qui ne s'applique qu'aux chaînes:

.../.x_String:>StringReplace[x,_->" "]

Ou, nous utilisons l' MapAllopérateur //@qui mappe une fonction sur chaque élément unique d'une liste imbriquée. Le hic ici est que nous allons essayer d'utiliser des StringReplacezéros ainsi que le symbole List(car //@il passe également par les têtes d'expressions), nous devons donc utiliser Check(un peu comme une catchdéclaration dans d'autres langues) pour éviter de faire des ravages avec ces valeurs:

StringReplace[#,_->" "]~Check~#&//@...

Gelée , 4 octets

nOa⁶

Ceci est un lien monadique. L'impression implicite de Jelly fait beaucoup d'éclaboussures; pour vérifier que la sortie est ce qu'elle devrait être, vous pouvez afficher la représentation interne avec ŒṘ. Notez que cela expose les chaînes sous forme de listes de caractères, c'est ainsi que l'interpréteur Jelly les implémente.

Essayez-le en ligne!

Comment ça marche

nOa⁶  Monadic link. Argument: z

 O    Ordinal; replace all characters with the code points.
      This does not affect numbers.
n     Vectorizing not-equal; compare z with the result to the right, replacing
      characters with 1 and numbers with 0.
  a⁶  Logical AND space; replace all 1's with spaces.

Perl 6, 34 48 octets

{.deepmap:{$_~~Str??" "x.comb!!0}}

{$_~~List??$_».&?BLOCK!!$_~~Str??" "x .comb!!0}

Étendu:

{                          # block-based lambda
    $_ ~~ List             # if argument is a list/array
        ?? $_».&?BLOCK     # then recurse for each element (&?BLOCK is a compile-time var)
        !! $_ ~~ Str       # else if argument is a string
            ?? " "x .comb  # then use space repeated by the string's length,
            !! 0           # else use the number 0
}

GAP , 91 octets

GAP a une méthode Zeroqui renvoie l'élément additif neutre correspondant à un élément d'une structure additive. Cela gère les nombres et même les listes de nombres qui sont considérés comme des vecteurs, mais pas des listes arbitraires. Ajoutons donc ceux-ci et les caractères et utilisons que les chaînes sont des listes de caractères:

InstallOtherMethod(Zero,[IsChar],c->' ');
InstallOtherMethod(Zero,[IsList],l->List(l,Zero));

(Je ne compte pas la nouvelle ligne car elle n'est pas nécessaire.) Bien sûr, cela est loin de l'utilisation prévue de Zero, et GAP se plaindrait si je n'avais pas utilisé InstallAutreMethod . Maintenant je peux faire:

gap> Zero([[["H"],"e",1,1,0],[[-3],"arth"]]);
[ [ [ " " ], " ", 0, 0, 0 ], [ [ 0 ], "    " ] ]

Je ne dirais pas que le builtin fait la plupart du travail, on pourrait plutôt penser que l'écriture d'une fonction normale devrait être plus courte, mais mon meilleur essai était de 92 octets:

f:=function(x)if IsInt(x)then return 0;elif IsList(x)then return List(x,f);fi;return' ';end;

Haskell, 115 octets

Ma langue ne peut gérer aucun mélange de nombres et de chaînes dans les listes (mais bien sûr, vous pouvez définir un type de somme et le mettre dans une liste), et ses listes standard ne peuvent pas gérer différemment les listes imbriquées. Je fais donc juste ce qu'il peut gérer. Je pense que ce n'est pas injuste car il est encore long, et je le fais principalement pour montrer les caractéristiques de haskell qui sont rarement vues dans les solutions de golf de haskell. Notez que les chaînes sont des listes de caractères.

class N a where n::a->a
instance N Double where n _=0
instance N Char where n _=' '
instance N a=>N[a]where n=map n

Cela gère tout nombre comme Double:

*Main> n 42
0.0
*Main> n 123.456
0.0
*Main> n "hi"
"  "
*Main> n [[1,2],[3,4,5]]
[[0.0,0.0],[0.0,0.0,0.0]]
*Main> n ["hello","world!"]
["     ","      "]

PHP, 91 octets

function f($a){return!is_array($a)?is_string($a)?str_pad("",strlen($a)):0:array_map(f,$a);}

si le paramètre est un tableau: recurse en utilisant array_map.
sinon si le paramètre est une chaîne: générez une chaîne d'espaces de même longueur.
sinon 0.

is_stringenregistre un octet de plus is_numeric; la négation is_array()rend les parenthèses obsolètes. Au total, il est de 17 octets plus court if()recursion-loop;else x?string:numberqu'avec un appel par référence.

Python 2, 59 octets

g=lambda d:0if d*0==0else " "*len(d)if d*0==""else map(g,d)

utilise la méthode de GB pour déterminer les types

 Lisp commun, 87

(defun c(e)(typecase e(list(mapcar'c e))(number 0)(string(map'string(lambda(u)#\ )e))))

Non golfé

(defun c(e)
  (typecase e
    (list (mapcar #'c e))
    (number 0)
    (string (map 'string (lambda(u) #\space) e))))

Exemple

> (c '((("H") "e" 1 1 0) ((-3) "arth")))
(((" ") " " 0 0 0) ((0) "    "))

Groovy, 53 octets

{[it].collectNested{it in String?" "*it.size():0}[0]}

Il s'agit d'une fermeture sans nom. Essayez-le ici!

Explication :

Groovy a cette méthode .collectNestedqui aide à parcourir une liste comme si elle était aplatie.

Pour gérer des cas particuliers où seul un entier ou une chaîne est passé sans liste, il suffit d'encapsuler chaque entrée dans une liste et de sortir le premier élément.

Pyke, 8 octets (ancienne version)

.FZ*0+d&

Explication:

.FZ*0+d& - for i in deep_for(input):
  Z*     -    i*0
    0+   -   ^ + 0
      d& -  ^ and " "

Cela ne fonctionne plus car une mise à jour a fait en sorte que les faux d'autres types où il y a des vérités se convertissent automatiquement en falsey du type véridique.

C #, 197 195 octets

a=>{if(a is string||a is char)return new string(' ',(a as string)?.Length??1);try{System.Convert.ToDecimal(a);return 0;}catch{}var b=(object[])a;for(int i=0;i<b.Length;)b[i]=n(b[i++]);return b;};

Cette poignée de fonction char, stringtout type de nombre de tableaux et builtin récursives.

Programme complet, assistant de sortie non golfé:

using System.Linq;    
class Class
{
    public static void Main()
    {
        System.Func<object, object> n = null;
        n = a => 
        {
            if (a is string || a is char)
                return new string(' ', (a as string)?.Length ?? 1);
            try
            {
                System.Convert.ToDecimal(a);
                return 0;
            }
            catch { }

            var b = (object[])a;
            for (int i = 0; i < b.Length;)
                b[i] = n(b[i++]);
            return b;
        };

        var result = n(new object[] { new object[] { new object[] { "H" }, 'e', 1.5, 1, 0 }, new object[] { new object[] { -3 }, "arth" } });
        System.Console.WriteLine(Output(result));
        System.Console.Read();
    }

    static string Output(object x)
    {
        var arr = x as object[];
        if (arr != null)
            return "[" + string.Join(",", arr.Select(Output)) + "]";
        else
            return x.ToString();
    }
};

L' usinginstruction n'est nécessaire que pour l'assistant de sortie, pas pour la fonction réelle.

Essayez en ligne

APL (Dyalog) 13.2 et versions antérieures, 1 octet

Jusqu'à et y compris la version 13.2, monadic ∊faisait exactement cela. L'ancien comportement peut être activé par le réglage ⎕ML( M igration L Evel) à zéro.

∊

Essayez-le en ligne!

Sans utiliser l'ancien comportement, il s'agit de 4 octets:

⊃0⍴⊂

Essayez-le en ligne!

⊂ joindre

0⍴ faire une liste de longueur nulle des copies de l'entrée entière (ne conserve que la structure et les informations de type)

⊃ contraindre un élément à partir de cela (crée un tableau prototypique)

Javascript ES6, 81 caractères

f=(x,t)=>(t=g=>eval(`try{x.${g}}catch(e){}`))`replace(/./g,' ')`||t`map(f)`||x&&0

Tester:

f=(x,t)=>(t=g=>eval(`try{x.${g}}catch(e){}`))`replace(/./g,' ')`||t`map(f)`||x&&0

console.log(
`"" → ""
7 → 0
123.456 → 0
"X" → " "
"  " → "  "
"Yo!" → "   "
[] → []
[-1.2E3] → [0]
["Hey"] → ["   "]
["H","e","y"] → [" "," "," "]
["R",2,"D",2] → [" ",0," ",0]
["C","3","P",0] → [" "," "," ",0]
["THX",[1138]] → ["   ",[0]]
["T","H","X",[1138]] → [" "," "," ",[0]]
[[["H"],"e",1,1,0],[[-3],"arth"]] → [[[" "]," ",0,0,0],[[0],"    "]]`
.split`
`.map(s => s.split` → `.map(eval))
.every(([s,k]) => JSON.stringify(f(s))==JSON.stringify(k)))

Java 7, 262 (268) octets

import java.util.*;Object c(Object o){if(o instanceof List){List r=new ArrayList();for(Object x:(List)o)r.add(c(x));return r;}if(o instanceof String){String r="\"";for(int i=((String)o).length();i-->0;r+=" ");return r+"\"";}return o instanceof Number?0:o instanceof Character?"' '":"";}

282 + 6 pour l'ajout \"et 'pour imprimer la chaîne et les caractères.

Explication:

import java.util.*;            // Required import for List and ArrayList
Object c(Object o){            // Method with Object parameter and Object return-type
  if(o instanceof List){       //  If the input is a List
    List r=new ArrayList();    //   Create a result-list
    for(Object x:(List)o)      //   Loop over the items of the input-list
      r.add(c(x));             //    And add all items with a recursive-call to this method
                               //   End of loop (implicit / single-line body)
    return r;                  //   Return result-list
  }if(o instanceof String){    //  If the input is a String instead
    String r="\"";             //   Create a result-String (starting with `"`
    for(int i=((String)o).length();i-->0;r+=" ");
                               //   Replace all characters in the String with a space
    return r+"\"";             //   Return the result within double-quotes
  }
  return o instanceof Number?  //  If the input is an integer or decimal instead:
    0                          //   Return 0
   :o instanceof Character?    //  If the input is a character instead:
    "' '"                      //   Return ' '
   :                           //  Else:
    "";                        //   Return an empty String
}                              // End of method

Code de test:

Essayez-le ici.

import java.util.*;
class M{
  static Object c(Object o){if(o instanceof List){List r=new ArrayList();for(Object x:(List)o)r.add(c(x));return r;}if(o instanceof String){String r="\"";for(int i=((String)o).length();i-->0;r+=" ");return r+"\"";}return o instanceof Number?0:o instanceof Character?"' '":"";}

  public static void main(String[] a){
    System.out.println(c(""));
    System.out.println(c(7));
    System.out.println(c(123.456));
    System.out.println(c('X'));
    System.out.println(c("  "));
    System.out.println(c("Yo!"));
    System.out.println(c(new ArrayList()));
    System.out.println(c(new ArrayList(){{add(-1.2e3);}}));
    System.out.println(c(new ArrayList(){{add("Hey");}}));
    System.out.println(c(new ArrayList(){{add('H');add('e');add('y');}}));
    System.out.println(c(new ArrayList(){{add('R');add(2);add('D');add(2);}}));
    System.out.println(c(new ArrayList(){{add("THX");add(new ArrayList(){{add(1138);}});}}));
    System.out.println(c(new ArrayList(){{add('T');add('H');add('X');add(new ArrayList(){{add(1138);}});}}));
    System.out.println(c(new ArrayList(){{add(new ArrayList(){{add(new ArrayList(){{add('H');}});add('e');add(1);add(1);add(0);}});add(new ArrayList(){{add(new ArrayList(){{add(-3);}});add("arth");}});}}));
  }
}

Sortie:

""
0
0
' '
"  "
"   "
[]
[0]
["   "]
[' ', ' ', ' ']
[' ', 0, ' ', 0]
["   ", [0]]
[' ', ' ', ' ', [0]]
[[[' '], ' ', 0, 0, 0], [[0], "    "]]