数字增加而字母减少


23

受此堆栈溢出问题的启发:对列表进行排序:数字以升序排列,字母以降序排列。您的任务是解决以下问题,并且由于这是,因此应尽可能减少字节。

你应该采取的对象为包含字母输入的列表(任何合理形式:stringchar,等)和数字。然后,您应该将数字按升序排序,并将字母按降序排序。但是,应将字母保持在字母位置,将数字保持在数字位置。例如,如果列表为:

[L, D, L, L, D, L]

输出列表应采用以下形式:

[L, D, L, L, D, L]

遍历

输入: ['a', 2, 'b', 1, 'c', 3]

  • 将数字按升序排序: [1, 2, 3]
  • 将字母按降序排列: ['c', 'b', 'a']
  • 重新加入他们,但顺序保持不变: ['c', 1', 'b', 2, 'a', 3]

规则

  • 该列表将仅包含字母和数字。
  • 该列表可能为空。
  • 该列表只能包含字母或数字。
  • 如果您的语言不支持混合类型数组,则可以使用数字字符而不是数字。请注意,如果您的语言支持,则必须使用混合类型。
  • 字母只会是[a-z][A-Z],您可以选择其中一个。
  • 字母被排序为a最低,z最高,即a = 1, z = 26
  • 禁止出现标准漏洞
  • I / O可以通过任何标准方式包括字符串形式。

测试用例

[5, 'a', 'x', 3, 6, 'b'] -> [3, 'x', 'b', 5, 6, 'a']

[ 3, 2, 1] -> [ 1, 2, 3 ]

[ 'a', 'b', 'c' ] -> [ 'c', 'b', 'a' ]

[] -> []

[ 2, 3, 2, 1 ] -> [1, 2, 2, 3]

因为这是所以最短的答案以字节为单位!


评论不作进一步讨论;此对话已转移至聊天
Martin Ender

Answers:


7

视网膜,10字节

O`\d
O^`\D

在线尝试!

O视网膜中的舞台可以直接执行此挑战所需的那种选择性排序。

在此,第一行对数字进行排序,而第二行对非数字进行反向排序。


13

Python 2中53 52个字节

g.rocket -2个
字节,Jonathan Frech -1个字节

def F(x):n=sorted(x);print[n.pop((e<x)-1)for e in x]

在线尝试!

sorted名单将有编号,然后再像字符[3, 5, 6, 'a', 'b', 'x'],然后使用e<x到过滤器是什么号码,什么是char,在蟒蛇任何数目小于列表(输入)和一个列表小于一个字符串。


版本失败IndexError: pop index out of range。前一种解决方案确实有效。
Xcoder先生17年

但是,它也可以使用55个字节。1-(e<'`')应该是(e<'`')-1。您只是以错误的顺序放置它们。顺便说一句,你忍者要我:/我有这个
Xcoder先生,17年

@ Mr.Xcoder感谢您的帮助c:
Rod

2
保存两次与e>x
g.rocket

1
@RootTwo这与预期的行为相反。
LyricLy

9

APL(Dyalog)27 26字节

期望字符为大写

(⍋⊃¨⊂)@(~e)(⍒⊃¨⊂)@(e←∊∘⎕A)

在线尝试!

这只是表格的两个应用程序f@g,将功能f应用于所指示的项目g

对于第一个应用程序,我们使用:
f:  ⍒⊃¨⊂ 降等级的()的每一个选择(⊃¨)从整个参数()。
g:  (e←∊∘⎕A) 部件((株))的 lphabet( ⎕A),以及存储()该函数作为e

对于第二个应用程序,我们使用:
f:  ⍋⊃¨⊂ 升等级()的每一个选择(⊃¨)从整个参数()。
g:  (~e) 不是(~)个字母的成员(e;我们之前存储的函数)


我认为这需要覆盖所有整数,因此请将第二个过滤器替换为83=⎕DR¨⍵
Uriel

@Uriel实际上似乎不是必需的,但是确实节省了一个字节。同样,⎕DR对于数字而言并非普遍为83,仅对于小整数而言。
2015年

总是3=10|⎕DR整数吗?
Uriel's

@Uriel是:0 = UnicodeChar,1 = Boolean,2 = ClassicChar,3 = int,5 = float,6 = pointer,7 = decimal,9 = complex。⌊0.1×⎕DR为您提供用于表示每个标量的位数,除了指针,指针取决于体系结构,但始终为326。因此,所有数字均为2|⎕DR
2015年

8

JavaScript(ES6),71 51 47字节

sort()通过@JustinMariner的建议,仅使用即可节省20个字节多亏了@CraigAyre
节省了4个字节

使用与Rod的Python答案类似的方法:

a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']())

测试用例


我是否缺少某些东西,或者您不能删除整个sort功能并仅使用sort()它吗?似乎没有功能就以相同的方式排序(在Chrome / FF / Edge中)。
贾斯汀·马里纳

@JustinMariner起初,我以为数字值可以是数字-在这种情况下,简单的操作sort()将失败。但是由于我们仅限于数字,所以您是对的:这确实有效。谢谢!
Arnauld

1
不错的解决方案,您能在a.sort()每个循环上移动/弹出而不是分配给x吗?:.map(n=>a.sort()[1/n?'shift':'pop']())
Craig Ayre

@CraigAyre好收获!
Arnauld

我很确定+n可以代替1/n
Conor O'Brien

5

R83 76字节

-7个字节,感谢Miff

function(n){u=unlist
d=n%in%0:9
n[d]=sort(u(n[d]))
n[!d]=sort(u(n[!d]),T)
n}

这与下面的相同,但是它允许使用混合类型输入list而不是atomic向量(它将把所有类型都转换为具有混合类型的字符)。

在线尝试!

R68 61字节

-7个字节,感谢Miff

function(n){d=n%in%0:9
n[d]=sort(n[d])
n[!d]=sort(n[!d],T)
n}

匿名函数。在这种情况下,所有数字都强制转换为字符。n[-d]是没有数字的数组。NULL空输入时返回(空列表)。

在线尝试!


您可以使用d=n%in%0:9
Miff 17'Aug

4

Japt18 15字节

感谢@Shaggy提供-3个字节,并帮助修复带有0s的数组。


c ñc
®¤?Vv :Vo

第一行故意留为空白。

在线尝试!使用-Q以查看格式化阵列。

说明

第一行为空白,以避免覆盖输入数组。
[5, 'a', 'x', 3, 6, 'b']

c ñc

通过展平(c)输入数组,然后ñ使用其字符代码(c)表示的字符串对()进行排序来进行复制。这存储在中V
[3, 5, 6, 'a', 'b', 'x']

£

然后通过函数映射输入数组...

¤?Vv :Vo

将数字转换为二进制字符串(真实)或将字符串转换为""(伪)(¤)。如果是,请从Vv)开头删除,否则从(o)结尾删除。



@Shaggy Nice,这真的很聪明。谢谢!
贾斯汀·马里纳

你忘了开关VoVv周围。我坚信,没有三进制,必须有更短的方法。
毛茸茸的

@粗野的哦,哎呀。是的,就算是o从一开始就可以消除负值之类的东西……
Justin Mariner

4

JavaScript 164 162 158 142字节

编辑1:删除v的多余分配后,少2个字节。

编辑2:多亏了TheLethalCoder,减少了4个字节。

编辑3:少了16个字节,这要归功于Justin Mariner的精彩提示

x=>eval("n=v=>typeof(v)=='number';l=x.length;for(i=0;i<l;x[i++]=x[m],x[m]=w){for(v=w=x[j=m=i];++j<l;)n(e=x[j])==n(w)&&e<v==n(w)&&(m=j,v=e)}x")

这是我第一次接触代码高尔夫球,因此可以肯定地加以改进。但是,仍然值得一试。

该程序执行选择排序的变体,它仅考虑与当前类型相同的值(仅交换一个数字和一个数字,或交换一个字母和一个字母)

可读形式:

x=>eval("
    n=v=>typeof(v)=='number';
    l=x.length;
    for(i=0;i<l;x[i++]=x[m],x[m]=w){
        for(v=w=x[j=m=i];++j<l;) 
            n(e=x[j])==n(w) && e<v==n(w) && (m=j,v=e)
    }
    x
")

for(j=i+1;j<l;j++)-> for(j=i++;++j<l;)并删除外循环中的增量。
TheLethalCoder

也欢迎PPCG!
TheLethalCoder

@TheLethalCoder如果我们这么早就增加计数器,我们还需要更改使用i和j的行...但是这个想法确实很聪明,无论如何我都会考虑如何使用它。
mackoo13 '17

你可以增加j我的建议,我没有看到你使用i进一步下跌只是改变x[i]=x[m]x[i++]=x[m]
TheLethalCoder

啊,当然...我为什么没想到x[i++]=x[m]...谢谢!
mackoo13年

3

C ++ 17(gcc),219字节

#include <variant>
#include <set>
using V=std::variant<char,int>;void f(V*a,V*b){std::set<V>S[2];for(V*c=a;c<b;++c)S[c->index()].insert(*c);auto
C=S->rbegin();auto N=S[1].begin();for(;a<b;++a)*a=(a->index()?*N++:*C++);}

在线尝试!

几乎没有竞争力。但是我必须支持混合类型的数组吗?精细。

接受一系列范围样式的变体,并对其进行修改。将输入复制到两个排序集中,然后重新输入到输入/输出数组。


这是有趣的。我不会以这种方式解释“支持混合类型的数组”。否则,我将不得不使用void *in C 的数组;)但是,是的,很有趣地看到一个解决方案跳过了这样的困境。
菲利克斯·帕尔姆

您可以通过删除#includes中的空格来节省两个字节
Conor O'Brien

2

Mathematica,203个字节

(K=Reverse;B=Complement;L=Length;S=Position[#,_Integer];T=Sort@Cases[#,_Integer];G=K@B[#,T];V=B[Range@L@#,Flatten@S];R=K@Sort@#;Table[R[[Min@S[[i]]]]=T[[i]],{i,L@T}];Table[R[[V[[i]]]]=G[[i]],{i,L@G}];R)&


在线尝试!



2

Pyth12 11字节

KSQm.(Kt>\@

在线尝试!尝试测试套件。


说明

KSQm.(Kt<d\@  - Full program with implicit input.

KSQ           - Assign a variable K to the lexicographically sorted input.
   m          - Map over the input (with a variable d).
    .(K       - Pop the sorted list at this location:
       >\@    - If d is lexicographically lower than '@', at 0 (the first element). Else, at -1 (the last element).

等一下,您不需要订购整个数组,只需将其分成两个均质的数组即可,每个数组都应易于​​排序。APL不能对混合数组进行排序(还),但是我分别对每种类型进行排序。
2015年

@Adám 将两个均等的数组拆分成两个均应易于排序的数组是什么意思?
Xcoder先生17年

如OP的“演练”中所述:1.记下哪些元素是数字元素,哪些是字符。2.将所有数字提取到一个单独的数组中并进行排序。对字符执行相同的操作。3.将排序后的号码放回号码槽。对字符执行相同的操作。
亚当

@Adám如果OP认为这是无效的,我会按照您所说的去做(这将导致更长,更久的方法)
Xcoder先生17年

2

Python,第145个 139 130字节

@officialaimm节省了6个字节

@Chris_Rands节省了9个字节

g=lambda s,a:sorted(x for x in s if(type(x)==str)==a)
def f(s):l,n=g(s,1),g(s,0)[::-1];return[[n,l][type(x)==str].pop()for x in s]

在线尝试!



type(x)==str使用isinstance(...)我认为会节省一些字节
Chris_Rands

@Chris_Rands谢谢!
Uriel's

2

05AB1E,17个字节

SaJ¹á{R¹þ{«vyay.;

在线尝试!


SaJ               # Push 1 if letter 0 else, for all letters in string.
   ¹á{R           # Reverse sort letters from input.
       ¹þ{        # Regular sort digits from input.
          «       # Concatenate those two things.
           v      # For each letter in the sorted string...
            ya    # 0 if digit, 1 if letter.
              y.; # Replace first instance of 0/1 with digit/letter.

使用排序方式闭包实际上更糟: Σ©Ç®ai0<*}}¹SaJsvyay.;


2

Python 3,77个字节

该答案基于这样的注释:如果字符和数字在语言上不具有可比性,则可以使用“ 1”,“ 2”等。'a'和1在Python 3中不具有可比性。

def f(s):x=sorted(s,key=lambda c:ord(c)-95);return[x.pop(-(c>'.'))for c in s]

2

q / kdb +,54 53字节

解:

{x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}

例子:

q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}(5;"a";"x";3;6;"b") / mixed list
3
"x"
"b"
5
6
"a"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}3 2 1   / simple list
1 2 3
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}"abc"   / simple list
"cba"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}2 3 2 1 / simple list
1 2 2 3

说明:

在列表中找到字符,对字符进行降序排序,在列表中找到longs,对它们进行升序排序,加入以获取例如的列表("x";"b";"a";3;5;6),然后将排序后的值分配回它们在列表中的原始位置,例如0 3 4 1 2 5

高尔夫只是开关按Q关键字(eachwhere以及not)他们k当量(这需要他们在括号中被包裹)。

{x[w,q]:asc[x w:where d],desc x q:where not d:-7=type each x;x} / ungolfed
{                                                           ; } / lambda function with 2 statements
                                                 type each x    / return types of elements in mixed list
                                              -7=               / true where item is a long
                                            d:                  / save this bool array in d
                                        not                     / invert
                                  where                         / indices where true (we have chars)
                                q:                              / save these indices in q
                              x                                 / values of x at these indices
                         desc                                   / sort them descending
                        ,                                       / join/contatenate
                where d                                         / indices where we have digits
              w:                                                / save this in w
            x                                                   / values of x at these indices
        asc[           ]                                        / sort them ascending
 x[w,q]:                                                        / assign this list to x at indices w,q
                                                             x  / return x

编辑

  • -1字节,因为不需要方括号 desc

2

C(GCC) 125个 113 110字节

main(i){char*b,*c,s[99];for(gets(c=b=s);*++c||*(c=++b);)i=*b&64,i^*c&64||*c>*b^!i&&(i=*c,*c=*b,*b=i);puts(s);}

在线尝试!

解释:

main(i)
{
    char*b,*c,s[99];

    // slightly modified stupid bubblesort, this line in fact
    // does nested looping with a single for statement
    for(gets(c=b=s);*++c||*(c=++b);)
    // (undefined behavior here, there's no sequence point between accesses to c,
    // so this could go wrong. Works with the gcc version on tio.)

        // determine whether the current b is a letter:
        i=*b&64,

        // for doing anything, b and c must be the same "type":
        i^*c&64

            // when c > b for letter or c <= b for digit
            || *c>*b^!i

            // then swap
            && (i=*c,*c=*b,*b=i);

    puts(s);
}

字母应大写。


2

PHP,66个字节:

for($a=$argv,sort($a);a&$c=$argv[++$i];)echo$a[$c<A?++$k:--$argc];

从命令行参数获取输入,输出字符串。运行-nr在线尝试

在PHP 7.1中产生警告;替换a&""<要修复。


1

Mathematica,107个字节

(s=#;s[[p]]=Sort[s[[p=#&@@@s~($=Position)~_String]],#2~Order~#>0&];s[[c]]=Sort@s[[c=#&@@@s~$~_Integer]];s)&

1

C#(.NET Core),171字节

a=>{var b=a.Where(x=>x is int).ToList();b.Sort();int i=0,j=0;return a.Select(x=>b.Contains(x)?b[i++]:a.Except(b).OrderByDescending(y=>y).ToList()[j++]);}

字节数还包括:

using System.Linq;

在线尝试!

说明:

a =>
{
    var b = a.Where(x => x is int).ToList(); // Filter to only ints and transform to list
    b.Sort();                                // Sort the list
    int i = 0, j = 0;                        // Create index counters
    return a.Select(x =>                     // Replace each input element with
                    b.Contains(x) ?          // If it is in list b:
                    b[i++] :                 // Get the next element from b
                    a.Except(b)              // Otherwise take input and filter out those in b
                     .OrderByDescending(x=>x)// Order them z to a
                     .ToList()[j++]);        // Get the next element

1

Perl 5,107 +1(-n)= 108字节

y/][//d;@a=split/, /;@l=sort grep/\D/,@a;@d=sort grep/\d/,@a;@r=map{/\d/?pop@d:shift@l}@a;$"=", ";say"[@r]"

在线尝试!


1

红宝石,265字节

x.sort_by(&:to_s).select{|a| a.is_a?(String)}.zip(x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact).each{|a,i| x[i] = a}
x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}.zip(x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact).each{|a,i| x[i] = a}

在线尝试!

第一次来,我的解决方案绝对不是最好的。但是,由于这是我的第一个答案,因此我认为发布只是出于乐趣。

期待看到更好的Ruby答案,看看什么是最好的方法。我希望以后的答案会有所改善=)

可读的

x = ["c", 1, "a", 3, "b", 2]

b = x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact
s = x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact

o = x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}
d = x.sort_by(&:to_s).select{|a| a.is_a?(String)}

d.zip s
d.zip(s).each {|a, i| x[i] = a}

o.zip b
o.zip(b).each {|a, i| x[i] = a }

p x

1

Haskell,108个字节

可能有更短的方法,但是我只需要在Lens库中尝试一下。

import Control.Lens
import Data.List
i(!)f=partsOf(traverse.filtered(!'='))%~f.sort
f x=x&i(<)id&i(>)reverse

我可以将其定义f为两个i调用的组合,但仍必须将x其应用于避免单态性限制引起的类型错误。请注意,类型为fTraversable t => t Char -> t Char因此它可以与作为Strings列表的Chars以及的数组一起使用Char s。

这是测试用例:

*Main> map f ["5ax36b","321","abc","","2321"]
["3xb56a","123","cba","","1223"]

1

Python 3,91个字节

def f(s):x=sorted(s,key=lambda c:(type(c)==str,c));return[x.pop(-(type(c)==str))for c in s]

1

Clojure,151个字节

#(map(fn[t c](nth((if(=(type 1)t)vec reverse)(sort((group-by type %)t)))(-(c t)1)))(map type %)(reductions(partial merge-with +)(for[i %]{(type i)1})))

例:

(def f #( ... ))
(f [5 \a \x 3 6 \b])
; (3 \x \b 5 6 \a)

这将计算整数和字符的累加总数,并使用它从对应类型元素的排序列表中查找正确的元素。


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.