Чтобы нейтрализовать данные, рекурсивно замените все числа (не цифры!) Нулями, а все символы (не строки!) Пробелами.

Вы должны принять любое одиночное число, символ или строку, или, возможно, рекурсивный массив * смешанных числовых / символьных данных, которые может обработать ваш язык. Например, вы должны принять фактические строки (и не ограничивать свой ввод списками одиночных символов), если ваш язык может обрабатывать такие.

Если ваш язык содержит встроенный, который выполняет все или большую часть этой задачи, я был бы признателен за дополнительную альтернативную версию без него.

Самая короткая заявка на каждом языке является победителем и получит от меня ответ.

Примеры случаев

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

* Если ваш язык имеет несколько типов, которые могут одинаково хорошо представлять массивы, как в приведенных выше примерах, вы можете выбрать поддержку только одного. Две записи могут выиграть, даже если они используют один и тот же язык, каждая из которых имеет свой тип данных.

JavaScript (ES6), 53 47 байт

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

Контрольные примеры

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 байта

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

Попробуйте онлайн!

Как это работает

Python позволяет сравнивать разные типы. Числовые типы всегда меньше, чем итерации, а итерации сортируются по именам типов, поэтому

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

Таким образом, f делает следующее.

• Если x является числовым, x<{}возвращает True и 1-(x<{})возвращает 0 . Код после andне выполняется.

• Если x является итеративным, 1-(x<{})возвращает 1 (правда), поэтому код после andвыполняется.

  • Если x - это список, он x<''имеет значение true и f отображается на его элементы.

  • Если x является строкой, x<''ложно и x заменяется строкой пробелов одинаковой длины.

Рубин, 54 53 49 байтов

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

Может быть, есть лучший способ, но:

• x * 0 == 0 для целых чисел
• x * 0 == "" для строк
• x * 0 == [] для массивов

Mathematica, 51 байт

В настоящее время у меня есть два решения на этот счет байтов:

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

Второй бросает кучу предупреждений, которые можно игнорировать.

объяснение

В любом случае, мы начинаем с превращения чисел в нули с

#/._?NumberQ->0

Затем для обработки строки есть два варианта. Либо мы используем другую замену, которая применяется только к строкам:

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

Или мы используем MapAllоператор, //@который отображает функцию на каждый отдельный элемент во вложенном списке. Подвох в том, что мы будем пытаться использовать StringReplaceкак нули, так и символы List(так как //@также проходит через главы выражений), поэтому нам нужно использовать Check(вроде как catchвыражение в других языках), чтобы избежать хаоса с эти значения:

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

Желе , 4 байта

nOa⁶

Это монадическая ссылка. Неявная печать Jelly делает много брызг; чтобы убедиться в том, что выходные данные соответствуют требованиям, вы можете просмотреть внутреннее представление с помощьюŒṘ . Обратите внимание, что это представляет строки в виде списков символов, как их реализует интерпретатор Jelly.

Попробуйте онлайн!

Как это работает

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 байт

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

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

Expanded:

{                          # 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 байт

GAP имеет метод, Zeroкоторый возвращает нейтральный аддитивный элемент, соответствующий элементу аддитивной структуры. Это обрабатывает числа и даже списки чисел, которые считаются векторами, но не произвольными списками. Итак, давайте добавим эти и символы и используем эти строки как списки символов:

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

(Я не считаю символ новой строки, поскольку он не нужен.) Конечно, это далеко от предполагаемого использования Zero, и GAP будет жаловаться, если бы я не использовал InstallOtherMethod . Теперь я могу сделать:

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

Я бы не сказал, что встроенная функция выполняет большую часть работы, можно было бы предположить, что написание нормальной функции должно быть короче, но моя лучшая попытка сделать это была бы длиной 92 байта:

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

Haskell, 115 байт

Мой язык не может обрабатывать любое сочетание чисел и строк в списках (но, конечно, вы можете определить тип суммы и поместить его в список), а его стандартные списки не могут обрабатывать по-разному вложенные списки. Так что я просто делаю то, что он может справиться. Я думаю, что это не несправедливо, потому что это все еще долго, и я в основном делаю это, чтобы показать особенности haskell, которые редко встречаются в решениях для игры в гольф haskell. Обратите внимание, что строки являются списками символов.

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

Это обрабатывает любое число как 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 байт

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

если параметр является массивом: recurse, используя array_map.
иначе, если параметр является строкой: генерировать строки пробелов одинаковой длины.
остальное 0.

is_stringсохраняет один байт is_numeric; отрицание is_array()делает скобки устаревшими. В целом это на 17 байт короче, чем if()recursion-loop;else x?string:numberпри вызове по ссылке.

Python 2, 59 байт

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

использует способ GB для определения типов

 Common Lisp, 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))))

пример

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

Groovy, 53 байта

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

Это безымянное закрытие. Попробуй это здесь!

Пояснение :

Groovy имеет этот метод, .collectNestedкоторый помогает перебирать список, как если бы он был сплющен.

Для обработки особых случаев, когда без списка передается только целое число или строка, просто оберните каждый вход в список и выведите первый элемент.

Пайк, 8 байт (Старая версия)

.FZ*0+d&

Объяснение:

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

Это больше не работает, поскольку обновление сделало его таким, что союзники других типов, где есть истины, автоматически преобразуются в ложь типа правдивых.

C #, 197 195 байт

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

Эта функция обрабатывает char, stringлюбой тип номера и встроенный рекурсивные массивы.

Полная программа, вспомогательная программа вывода:

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

usingЗаявление требуется только для вывода помощника, а не для реальной функции.

Попробуйте онлайн

APL (Dyalog) 13,2 и ранее, 1 байт

До и включая версию 13.2, monadic ∊делал именно это. Старое поведение может быть активирована путем установки ⎕ML( M igration L Evel) к нулю.

∊

Попробуйте онлайн!

Без использования старого поведения это 4 байта:

⊃0⍴⊂

Попробуйте онлайн!

⊂ Вложите

0⍴ составить список копий всего ввода с нулевой длиной (сохраняет только информацию о структуре и типе)

⊃ вынудить один элемент из этого (создает прототипный массив)

Javascript ES6, 81 символ

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

Тест:

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) байтов

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 для добавленных \"и' красивой печати строки и символов.

Объяснение:

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

Тестовый код:

Попробуй это здесь.

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

Выход:

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