车道上的数字

32

输入：

整数列表

输出：

将每个数字（和减号）按顺序放在自己的通道中-0123456789，忽略任何重复的数字。

例：

输入： [1,729,4728510,-3832,748129321,89842,-938744,0,11111]

输出：

-0123456789  <- Added as clarification only, it's not part of the output

  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1

挑战规则：

  • 数字中的任何重复数字都将被忽略。
  • I / O可以采用任何合理的格式。输入可以是字符串或字符数组的列表/数组。输出可以是字符串，字符，字符矩阵等的列表。
  • 尾随空格是可选的。
  • 任意数量的前导或尾随新行都是可选的（但在行之间不可以）。
  • 输入将始终包含至少一个整数
  • 你必须至少支持一个整数的范围-2,147,483,648，虽然2,147,483,647（32位）。
  • 输入列表将永远不会包含-0，00（或两个以上的零）或带有前导零的整数（即012）。
  • 如果您的语言对负数使用其他符号（例如upper ¯），则只要它是一致的，也可以使用它。
  • 允许您在数字之间使用空格定界符（因此，没有5或8的行可以- 0 1 2 3 4 6 7 9代替-01234 67 9），只要它是一致的（因此-and 之间也应该有一个空格0）。

一般规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
  • 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。你的来电。
  • 默认漏洞是禁止的。
  • 如果可能，请为您的代码添加一个带有测试的链接。
  • 另外，如有必要，请添加说明。

测试用例：

Input: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]
Output:
  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1        

Input: [4,534,4,4,53,26,71,835044,-3559534,-1027849356,-9,-99,-3459,-3459,-94593,-10234567859]
Output:
      4     
     345    
      4     
      4     
     3 5    
    2   6   
   1     7  
  0  345  8 
 -   345   9
 -0123456789
 -         9
 -         9
 -   345   9
 -   345   9
 -   345   9
 -0123456789

Input: [112,379,-3,409817,239087123,-96,0,895127308,-97140,923,-748]
Output:
  12       
   3    7 9
-  3       
 01 4   789
 0123   789
-      6  9
 0         
  123 5 789
-01  4  7 9
   23     9
-    4  78 

Input: [-15,-14,-13,-12,-11,10,-9,-8,-7,-5,-4,-3,-1,0,9,100,101,102,1103,104,105,106,116,-12345690]
Output:
- 1   5    
- 1  4     
- 1 3      
- 12       
- 1        
-01        
-         9
-        8 
-       7  
-     5    
-    4     
-   3      
- 1        
 0         
          9
 01        
 01        
 012       
 01 3      
 01  4     
 01   5    
 01    6   
  1    6   
-0123456  9

Input: [99,88,77,66,55,44,33,22,11,10,0,0,0,-941]
Output:
          9
         8 
        7  
       6   
      5    
     4     
    3      
   2       
  1        
 01        
 0         
 0         
 0         
- 1  4    9
code-golf  ascii-art  number  integer 
— 凯文·克鲁伊森
source
输出中的数字之间是否允许空格？
— 毛茸茸的
我们可以使用高减号¯代替-吗？
— Uriel '18
丢失的数字仍将替换为空格，因此，在您的示例中，在4＆6和7＆9之间将存在3个空格：（"-0 1 2 3 4 <space> 6 7 <space> 9"由于某些原因，注释中的多个空格被折叠了）
— Shaggy
1
我希望偷偷溜走你！：D井井有条！
— 毛茸茸的
1
— streetster

Answers:

4

Stax，8 个字节

║V≡u╝─é╢

运行并调试

标准输入每行需要一个数字。它通过找到每个字符的目标索引并将其分配给结果的索引来工作。如果索引超出范围，则将数组扩展为零，直到适合为止。在输出期间，0变成一个空格。其余为字符代码。

开箱即用，没有包装，没有评论，这就是它的样子。

m       for each line of input, execute the rest of the program and print the result
 zs     put an empty array under the line of input
 F      for each character code in the line of input, run the rest of the program
  Vd    "0123456789"
  I^    get the index of the character in this string and increment
  _&    assign this character to that index in the original string

运行这个

— 递归的
source
如何输入一个长度为1的列表？（如果只是值或值和换行，则行不通。）
— Jonathan Allan
1
哦，是的，很好。也适用于单个值的另一种输入形式是["7"]。此格式还可以处理多个值，例如["34", "43"]。
— 递归
6

05AB1E，13个字节

码：

v'-žh«DyмSð:,

使用05AB1E编码。在线尝试！

说明：

v               # For each element in the input..
 '-žh«          #   Push -0123456789
      D         #   Duplicate this string
       yм       #   String subtraction with the current element
                    e.g. "-0123456789" "456" м  →  "-0123789"
         Sð:    #   Replace all remaining elements with spaces
                    e.g. "-0123456789" "-0123789" Sð:  →  "     456   "
            ,   #   Pop and print with a newline
— 阿德南
source
1
真好！去替换路线比插入路线要短：)
— Emigna
2
@Emigna插入路由也是一种非常有趣的方法。实际上，我认为您可以使用vðTúyvyÐd+ǝ},;）保存4个字节。
— 阿德南'18
1
辉煌！我不知道ǝ这样会起作用-0。但是，现在我开始使用它了，它实际上是一个数字，而不是一个字符串，因为我第一次读为：P
— Emigna
糟糕...我当时只有23bytes。05AB1E（关于人类的双关语）。
— 魔术章鱼缸
4

JavaScript，59 58字节

输入和输出为字符串数组。

a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))

试试吧

o.innerText=(g=s=>(f=
a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))
)(s.split`,`).join`\n`)(i.value="1,729,4728510,-3832,748129321,89842,-938744,0,11111");oninput=_=>o.innerText=g(i.value)
input{width:100%;}
<input id=i><pre id=o></pre>
展开摘要

原版的

将输入作为字符串数组并输出字符数组数组

a=>a.map(x=>[...`-0123456789`].map(y=>-~x.search(y)?y:` `))

显示代码段

— 毛茸茸
source
1
如此优雅的解决方案，我真的很喜欢。
— Brian H.
3

05AB1E，17 13字节

感谢Adnan，节省了4个字节

vðTúyvyÐd+ǝ},

在线尝试！

说明

v               # loop over elements y in input
 ðTú            # push a space prepended by 10 spaces
    yv          # for each element y in the outer y
      y         # push y
       Ðd+      # push y+isdigit(y)
          ǝ     # insert y at this position in the space-string
           }    # end inner loop
            ,   # print
— 艾米尼亚
source
3

Ruby，42个字节

匿名lambda处理数字数组：

->a{a.map{|n|"-0123456789".tr"^#{n}",?\s}}

在线尝试！

另外，完全类似于Perl的完整程序要短得多。我想说-pl在这种情况下，开关看起来很有趣：

Ruby -pl，29个字节

$_="-0123456789".tr"^#$_"," "

在线尝试！

最后，如果可以引用输出字符串，则可以执行以下操作：

红宝石 -n，27个字节

p"-0123456789".tr ?^+$_,?\s

在线尝试！

— 基里尔
source
3

JavaScript（Node.js），60字节

  • 感谢@Andrew Taylor减少了加入（8个字符）
  • 感谢@Yair Rand X.match（8个字符）
a=>a.map(X=>"-0123456789".replace(/./g,x=>X.match(x)?x:" "))

在线尝试！

— 丹尼尔·印度
source
哦，那join把戏很可爱-但问题看起来像是字符串数组，可以正常输出，所以也许您可以通过删除它来剃掉8个字节？
— 安德鲁·泰勒
敢肯定你可以通过更换再节省(X+"").includes(x)用RegExp(x).test(X)
— 安德鲁·泰勒
(X+"").match(x)会更短。该问题还允许输入为字符串数组，因此甚至可以为X.match(x)。
— Yair Rand
2

Japt，16字节

输入和输出为字符串数组。

£Ao ¬i- ®iS gXøZ

试试吧

说明

£                    :Map over each element X
 Ao                  :  Range [0,10)
    ¬                :  Join to a string
     i-              :  Prepend "-"
        ®            :  Map over each character Z
         iS          :    Prepend a space
            g        :    Get the character at index
             XøZ     :      X contains Z? (true=1, false=0)
— 毛茸茸
source
2

Python 3中，77 64个字节

-12个字节感谢@Rod

lambda x:[[[" ",z][z in str(y)]for z in"-0123456789"]for y in x]

在线尝试！

我第一次尝试用Python打高尔夫球。欢迎指教！

返回二维字符数组。

— 乔·金
source
1
您可以使用'-0123456789'，而不是range(10)拖放第一模块和交换str(z)用z，你也可以切换到python2和使用`y`，而不是str(y)（``是+ -相当于repr）
— 罗德
多余的空间in "-。
— 乔纳森·弗雷希
2

Haskell，47个字节

map(\s->do d<-"-0123456789";max" "[d|elem d s])

在线尝试！

用于max插入不存在任何元素的空格，因为空格小于任何数字或减号。

如果末尾的空格数可以接受，则可以保存两个字节：

45字节

map(\s->do d<-'-':['0'..];max" "[d|elem d s])

在线尝试！

— 异或
source
2

MATL，13字节

"45KY2ht@gm*c

输入是字符串的单元格数组。在线尝试！或验证所有测试用例。

说明

         % Implicit input: cell array of strings, for example {'1','729',...,'11111'}
"        % For each cell
  45     %   Push 45 (ASCII code of '-')
  KY2    %   Push predefined literal '0123456789'
  h      %   Concatenate horizontally: gives '-0123456789'
  t      %   Duplicate
  @      %   Push current cell, for example {'729'}
  g      %   Convert cell to matrix. This effectively gives the cell's contents, '729'
  m      %   Ismember: gives an array of zeros and ones indicating membership of each
         %   char from '-0123456789' in '729'. The result in the example is
         %   [0 0 0 1 0 0 0 0 1 0 1]
  *      %   Multiply, element-wise. Chars are implicity converted to ASCII 
         %   Gives the array [0 0 0 50 0 0 0 0 55 0 57] 
  c      %   Convert ASCII codes to chars. 0 is displayed as space. Gives the string
         %   '   2    7 9'
         % Implicit end
         % Implicilly display each string on a different line
— 路易斯·门多
source
2

Google表格，124个字节

=Transpose(ArrayFormula(If(IsError(Find(Mid("-0123456789",Row($1:$11),1),Split(A1,",")))," ",Mid("-0123456789",Row($1:$11),1

输入是cell中以逗号分隔的列表A1。输出在该范围内B1:L?，其中?被然而许多条目被输入。（B1为方便起见，您可以将公式放在任意位置，我只是为了方便而选择。）请注意，Sheets会自动在公式末尾添加四个右括号，为我们节省了这四个字节。

屏幕截图

另一个测试用例和另一个测试用例

说明：

  • Mid("-0123456789",Row($1:$11),1) 依次选择11个字符中的每个字符。
  • Find(Mid(~),Split(A1,","))在每个输入元素中查找那些字符。这将返回一个数值，或者，如果找不到，将返回一个错误。
  • If(IsError(Find(~)," ",Mid(~))如果找不到该字符，则返回一个空格，如果找到则返回一个空格。（我希望有一种避免重复的Mid(~)部分的方法，但我不知道该部分。）
  • ArrayFormula(If(~))是什么使得在多单元格引用Mid(~)和Find(~)工作。这也是使一个单元格中的公式在多个单元格中返回值的原因。
  • Transpose(ArrayFormula(~)) 转置返回的数组，因为它从侧面开始。
— 工程师吐司
source
2

果冻，12字节

ØD”-;¹⁶e?€Ʋ€

在线尝试！

-2感谢Jonathan Allan读了我没有的规则。

请注意，TIO链接中使用的I / O格式不是实际的I / O格式，它是作为字符串表示形式的列表输入并作为行的列表输出的。

— 暴民埃里克
source
1

Perl 6、35个字节

{.map:{map {m/$^a/||' '},'-',|^10}}

在线尝试！

输出是一个包含正则表达式匹配项或空格字符的字符矩阵。

— 恩韦恩霍夫
source
如果“输入可以是任何合理的格式”可以是标准输入，那么想必-pe会让你与初始.MAP，括号和交换免除$^a了$_
— 菲尔^ h
@PhilH -p和-n不知何故似乎越野车，至少在TIO。由于某种原因$_未传递给块。参见示例1，示例2。
— nwellnhof
1

Java 8，53字节

a->a.map(i->"-0123456789".replaceAll("[^"+i+"]"," "))

我自己的挑战比我挑战时想象的要容易。

输入和输出均为java.util.stream.Stream<String>。

说明：

在线尝试。

a->                              // Method with String-Stream as both input and return-type
  a.map(i->                      //  For every String in the input:
    "-0123456789"                //   Replace it with "-0123456789",
    .replaceAll("[^"+i+"]"," ")) //   with every character not in `i` replaced with a space
— 凯文·克鲁伊森
source
1

R，96 75字节

for(i in scan())cat(paste(gsub(paste0("[^",i,"]")," ","-0123456789"),"\n"))

在线尝试！

感谢Kevin Cruijssen建议使用这种正则表达式方法！

将来自stdin的输入作为空格分隔的整数，并将ascii-art打印到stdout。

— 朱塞佩
source
我不太了解R，因此我确定它可以进一步打高尔夫球，但是这种不同的方法要短12个字节：function(N)for(i in N)cat(paste(gsub(paste("[^","]",sep=i)," ","-0123456789"),"\n"))。（输入为字符串数组而不是整数数组。）在线尝试。
— 凯文·克鲁伊森
@KevinCruijssen啊，很好，是的，我也可以打高尔夫球。
— 朱塞佩
1

SOGL V0.12，14 13 个字节

{ø,{²²⁴WI1ž}P

在这里尝试！

说明：

{ø,{²²⁴WI1ž}P

{            repeat input times
 ø,            push an empty string and the next input above that
   {       }   for each character in the input
    ²²           push "0123456789"
      ⁴          copy the character on top
       W         and get it's index in that string (1-indexed, 0 for the non-existent "-")
        I        increment that (SOGL is 1-indexed, so this is required)
         1ž      at coordinates (index; 1) in the string pushed earlier, insert that original copy of the character
            P  print the current line
— 宰马
source
1

SNOBOL4（CSNOBOL4），85字节

I	X =INPUT	:F(END)
	S ='-0123456789'
R	S NOTANY(X ' ') =' '	:S(R)
	OUTPUT =S	:(I)
END

在线尝试！

I	X =INPUT	:F(END)		;* read input, if none, goto end
	S ='-0123456789'		;* set the string
R	S NOTANY(X ' ') =' '	:S(R)	;* replace characters of S not in X + space with space
	OUTPUT =S	:(I)		;* print S, goto I
END
— 朱塞佩
source
1

Pyth，14个字节

VQm*d}dNs+\-UT

将输入作为字符串列表，并输出每行的字符串列表。
在这里尝试

说明

VQm*d}dNs+\-UT
VQ                For each string in the input...
  m     s+\-UT    ... and each character in "-0123456789"...
     }dN          ... check if the character is in the string...
   *d             ... and get that character or an empty string.
1

视网膜，26字节

%"-0123456789"~`.+
[^$&]¶

在线尝试！注意：尾随空格。说明：每行输入都%执行~一次其子阶段。~首先执行其子阶段，该子阶段将行包装在[^和中]<CR><SP>，从而生成一个程序，该程序用空格替换不在行中的字符。在"-0123456789"指定的输入到该程序是给定的字符串（$替换是允许的，但我并不需要它们）。

— 尼尔
source
1

C（gcc），95 94字节

c,d;f(l,n)char**l;{for(;n--;l++)for(c=0;c<12;)putchar(strchr(*l,d=c++?c+46:45)?d:d^58?32:10);}

在线尝试！

以字符串列表的形式输入。输出到STDOUT。

— 腹肌
source
您可以删除c++，然后更改d=c?c+47:为来打高尔夫球d=c++?c+46:。
— 凯文·克鲁伊森
1

K4，30 27个字节

解：

{?[a in$x;a:"-",.Q.n;" "]}'

例：

q)k){?[a in$x;a:"-",.Q.n;" "]}'1 729 4728510 -3832 748129321 89842 -938744 0 11111
"  1        "
"   2    7 9"
" 012 45 78 "
"-  23    8 "
"  1234  789"
"   2 4   89"
"-   34  789"
" 0         "
"  1        "

说明：

根据输入返回“ -0123 ...”或“”。从右到左解释。APL的答案没有竞争：(

{?[a in$x;a:"-",.Q.n;" "]}' / the solution
{                        }' / lambda for each
 ?[      ;          ;   ]   / if[cond;true;false]
                .Q.n        / string "0123456789"
            "-",            / join with "-"
          a:                / save as a
       $x                   / convert input to string
   a in                     / return boolean list where each a in x
                     " "    / whitespace (return when false)
— 街头小贩
source
0

APL + WIN，33个字节

提示屏幕输入为字符串

n←11⍴' '⋄n['-0123456789'⍳s]←s←⎕⋄n
— 格雷厄姆
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.