Per neutralizzare i dati, sostituisci ricorsivamente tutti i numeri (non cifre!) Con zeri e tutti i caratteri (non stringhe!) Con spazi.

Devi accettare qualsiasi singolo numero, carattere o stringa, o eventualmente array ricorsivo * di dati misti numerici / di carattere che la tua lingua può gestire. Ad esempio, è necessario accettare stringhe effettive (e non limitare l'input a elenchi di singoli caratteri) se la lingua è in grado di gestirle.

Se la tua lingua contiene un built-in che svolge tutto o la maggior parte di questa attività, apprezzerei una versione alternativa aggiuntiva senza di essa.

Il contributo più breve in ciascuna lingua è un vincitore e riceverà un mio voto.

Casi di esempio

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]," "]]

* Se la tua lingua ha diversi tipi che possono ugualmente rappresentare array come gli esempi sopra, puoi scegliere di supportarne solo uno. Possono vincere entrambe le voci, anche se usano la stessa lingua, ognuna con un diverso tipo di dati.

JavaScript (ES6), 53 47 byte

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

Casi 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 byte

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

Provalo online!

Come funziona

Python ti consente di confrontare diversi tipi. I tipi numerici sono sempre più piccoli degli iterabili e gli iterabili sono ordinati in base al nome del tipo, quindi

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

In questo modo, f fa quanto segue.

• Se x è numerico x<{}restituisce True e 1-(x<{})restituisce 0 . Il codice dopo andnon viene eseguito.

• Se x è iterabile, 1-(x<{})restituisce 1 (verità), quindi il codice dopo andviene eseguito.

  • Se x è un elenco, x<''è vero e f viene mappato sui suoi elementi.

  • Se x è una stringa, x<''è falso e x viene sostituito con una stringa di spazi della stessa lunghezza.

Rubino, 54 53 49 byte

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

Forse c'è un modo migliore, ma:

• x * 0 == 0 per numeri interi
• x * 0 == "" per le stringhe
• x * 0 == [] per array

Mathematica, 51 byte

Al momento ho due soluzioni con questo numero di byte:

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

Il secondo lancia un mucchio di avvertimenti che possono essere ignorati.

Spiegazione

In entrambi i casi, iniziamo trasformando i numeri in zeri con

#/._?NumberQ->0

Quindi per elaborare la stringa, ci sono due opzioni. O usiamo un'altra sostituzione che si applica solo alle stringhe:

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

In alternativa, utilizziamo l' MapAlloperatore //@che mappa una funzione su ogni singolo elemento in un elenco nidificato. Il trucco qui è che proveremo a usare gli StringReplacezeri e il simbolo List(dato che //@passa anche attraverso le teste delle espressioni), quindi dobbiamo usare Check(una specie di catchaffermazione simile in altre lingue) per evitare di creare caos con quei valori:

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

Gelatina , 4 byte

nOa⁶

Questo è un collegamento monadico. La stampa implicita di Jelly fa molto schizzi; per verificare che l'output sia quello che dovrebbe essere, è possibile visualizzare la rappresentazione interna con ŒṘ. Nota che questo espone le stringhe come liste di caratteri, ed è così che l'interprete Jelly le implementa.

Provalo online!

Come funziona

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 byte

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

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

Allargato:

{                          # 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 byte

GAP ha un metodo Zeroche restituisce l'elemento additivo neutro corrispondente a un elemento di una struttura additiva. Gestisce numeri e persino elenchi di numeri considerati vettori, ma non elenchi arbitrari. Quindi aggiungiamo questi e caratteri e usiamo che le stringhe sono elenchi di caratteri:

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

(Non conto il newline in quanto non è necessario.) Naturalmente questo è molto lontano dall'uso previsto di Zero, e GAP si lamenterebbe se non avessi usatoInstall AltroMethod . Ora posso fare:

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

Non direi che il builtin svolge la maggior parte del lavoro, si potrebbe piuttosto sospettare che scrivere una funzione normale dovrebbe essere più breve, ma il mio tentativo migliore di farlo è lungo 92 byte:

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

Haskell, 115 byte

La mia lingua non è in grado di gestire alcuna combinazione di numeri e stringhe negli elenchi (ma ovviamente è possibile definire un tipo di somma e inserirlo in un elenco) e i suoi elenchi standard non possono gestire elenchi nidificati in modo diverso. Quindi sto solo facendo quello che può gestire. Penso che non sia ingiusto perché è ancora lungo, e lo faccio principalmente per mostrare le caratteristiche di haskell che raramente si vedono nelle soluzioni di golf haskell. Nota che le stringhe sono elenchi di caratteri.

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

Questo gestisce qualsiasi numero come doppio:

*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 byte

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

se il parametro è array: recurse using array_map.
altrimenti se il parametro è stringa: genera una stringa di spazi con la stessa lunghezza.
altro 0.

is_stringsalva un byte is_numeric; la negazione is_array()rende le parentesi obsolete. Complessivamente è più breve di 17 byte rispetto if()recursion-loop;else x?string:numbera una chiamata per riferimento.

Python 2, 59 byte

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

usa il modo di GB per determinare i tipi

 Lisp comune, 87

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

Ungolfed

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

Esempio

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

Groovy, 53 byte

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

Questa è una chiusura senza nome. Provalo qui!

Spiegazione :

Groovy ha questo metodo .collectNestedche aiuta a scorrere un elenco come se fosse stato appiattito.

Per gestire casi speciali in cui viene passato solo un numero intero o una stringa senza un elenco, è sufficiente avvolgere ogni input in un elenco e generare il primo elemento.

Pyke, 8 byte (Vecchia versione)

.FZ*0+d&

Spiegazione:

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

Questo non funziona più come un aggiornamento reso così falsi di altri tipi dove ci sono verità convertite automaticamente nella falsità del tipo di verità.

C #, 197 195 byte

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;};

Questa funzione gestisce char, string, qualsiasi tipo di numero incorporato e gli array ricorsive.

Programma completo non supportato con supporto dell'output:

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();
    }
};

Il using istruzione è necessaria solo per l'helper di output, non per la funzione effettiva.

Prova online

APL (Dyalog) 13.2 e precedenti, 1 byte

Fino alla versione 13.2 inclusa, monadic ha ∊fatto esattamente questo. Il vecchio comportamento può essere attivata impostando ⎕ML( M igration L evel) a zero.

∊

Provalo online!

Senza usare il vecchio comportamento è di 4 byte:

⊃0⍴⊂

Provalo online!

⊂ accludere

0⍴ crea un elenco lunghezza zero di copie dell'intero input (conserva solo la struttura e le informazioni sul tipo)

⊃ forzare un elemento da quello (crea un array prototipico)

Javascript ES6, 81 caratteri

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

Test:

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) byte

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 per l'aggiunta \"e' per stampare graziosamente la stringa e i caratteri.

Spiegazione:

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

Codice di prova:

Provalo qui.

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");}});}}));
  }
}

Produzione:

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