笔试题求解……
今天第一次笔试，两道算法题，跟考官说第二题真不会了，就直接被Pass掉了，说不用面试了，你不适合开发……郁闷到现在
第一题：两个Int数组，都是从小到大的排列，需要合并成一个新的数组，也是从小到大排列，请写出性能比较好的代码。
Fun(int a[m],int b[n])
{
}
第二题：已经有一个包括了多行文本的字符串。请写一个函数，能够输出字符串中最长的行和最短的行。如果最长和最短的不止一行，请输出最长和最短的多行。请写出性能比较好的代码。
Fun(string lines){
1、拆分成多行；
2、循环为每行计算长度，记录最大和最小行的位置；
3、打印输出
}
[最优解释]
static void Main(string[] args)
{
string str = @"aaaa
bbbbb
cccccccccc
dd
dd
eeee";
string[] s = str.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("行数：" + s.Length);
//if(s.Length==0)return;
List<string> mins = new List<string>();
mins.Add(s[0]);
List<string> maxs = new List<string>();
maxs.Add(s[0]);
for (int i = 1; i < s.Length; i++)
{
if (s[i].Length <= mins[0].Length)
{
if (s[i].Length < mins[0].Length)
mins.Clear();
mins.Add(s[i]);
}
if (s[i].Length >= maxs[0].Length)
{
if (s[i].Length > maxs[0].Length)
maxs.Clear();
maxs.Add(s[i]);
}
}
Console.WriteLine("较小值：");
mins.ForEach(item => Console.WriteLine(item));
Console.WriteLine("较大值：");
maxs.ForEach(item => Console.WriteLine(item));
}
int[] Fun1(int[] a, int b[])
{
return a.Concat(b).OrderBy(x => x).ToArray();
}
Tuple<string[], string[]> Fun2(string[] lines)
{
var query = lines.GroupBy(x => x.Length).OrderBy(x => x.Key);
return new Tuple<string[], string[]>()
{
Item1 = query.First().ToArray(), //min
Item2 = query.Last().ToArray() //max
};
}
//
// main.cpp
// acm
//
// Created by BossJue on 12-11-30.
// Copyright (c) 2012年 __MyCompanyName__. All rights reserved.
//
#include <iostream>
using std::endl;
using std::cout;
using std::cin;
int* Merge(int* ArrayA, int iLenA, int* ArrayB, int iLenB);
int main(int argc, const char * argv[])
{
// insert code here...
int A[]= {1,3,5,7};
int B[]= {0,2,4,6,8,10};
int* result = Merge(A, 4, B, 6);
for(int i= 0; i< 10; ++i){
cout<<result[i]<<" ";
}
cout<<endl;
return 0;
}
//ArrayA, ArrayB分别是你要合并的数组,iLenA,iLenB是长度,返回值指向合并之后的数组
int* Merge(int* ArrayA, int iLenA, int* ArrayB, int iLenB){
int* Result= new int[iLenA+ iLenB];
int iItA, iItB, iItAns;
for (iItA= 0, iItB= 0, iItAns= 0; iItA< iLenA && iItB< iLenB;) {
if(ArrayA[iItA]< ArrayB[iItB]){
Result[iItAns++] = ArrayA[iItA++];
}else {
Result[iItAns++] = ArrayB[iItB++];
}
}
while(iItA< iLenA){
Result[iItAns++] = ArrayA[iItA++];
}
while(iItB< iLenB){
Result[iItAns++] = ArrayB[iItB++];
}
return Result;
}
[其他解释]
数组合并,合并之后排序可以使用冒泡法等,关于排序我资源里面有常用的八种排序法及代码,可以去免费下载,下面是合并的代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ArrayH
{
class Program
{
static void Main(string[] args)
{
int[] intArray = new int[10] { 10, 2, 30, 400, 501 ,6,70,80,9,10};
int[] intArrayOne = new int[] { 1, 2, 3, 4, 5 };
int[] intArrayTwo = new int[] { 6, 7, 8, 9, 10 };
int n = intArrayOne.Length + intArrayTwo.Length;
int[] intArrayThree = new int[n];
int i = 0;
int j = 0;
for (i = 0; i < intArrayThree.Length; i++)
{
if (i < intArrayOne.Length)
{
intArrayThree[i] = intArrayOne[i];
}
else
{
intArrayThree[i] = intArrayTwo[i - intArrayOne.Length];
}
}
Console.WriteLine("合并后的一维数组: ");
foreach (int k in intArrayThree)
Console.Write("{0} ",intArrayThree[k-1].ToString());
int[,] intArrayFour = new int[2, 5];
for (i = 0; i < intArrayFour.GetLength(0); i++)
{
switch (i)
{
case 0:
{
for (j = 0; j < intArrayFour.GetLength(1); j++)
{
intArrayFour[i, j] = intArrayOne[j];
}
}
break;
case 1:
{
for (j = 0; j < intArrayTwo.Length; j++)
{
intArrayFour[i, j] = intArrayTwo[j];
}
}
break;
default:
break;
}
}
Console.WriteLine("合并后的二维数组: ");
for(i = 0;i<intArrayFour.GetLength(0)-2;i++)
{
for (j = 0; j < intArrayFour.GetLength(1)-2; i++)
{
Console.Write(intArrayFour[i, j] + " ");
}
Console.WriteLine();
}
Array.Sort(intArray);
Console.WriteLine();
for (i = 0; i < intArray.Length; i++)
{
Console.Write("{0} ", intArray[i]);
}
Console.WriteLine();
Array.Reverse(intArray);
for (j = 0; j < intArray.Length; j++)
{
Console.Write("{0} ", intArray[j]);
}
Console.ReadKey();
}
}
}
[其他解释]
第一题，我倒是做出来了，已经测试通过。 估计人家也不会要我这么算的。楼主看看吧
int a[4]= {1,3,5,7}; int b[6]= {0,2,4,6,8,10};
int x=0,y=0,z,i,m=4,n=6;
int c[10];
for (z=0;z<m+n;z++)
{
if(a[x]<=b[y])
{
c[z]=a[x];
x++;
if(x>=m)
{
for(i=z+1;i<m+n;i++)
{
c[i]=b[y++];
}
break;
}
}
else
{
c[z]=b[y];
y++;
if(y>=n)
{
for(i=z+1;i<m+n;i++)
{
c[i]=a[x++];
}
break;
}
}
}
[其他解释]
第一题
int[] Fun(int[] a,int[] b)
{
return a.Concat(b).OrderBy(t => t).ToArray();
}
第二题
List<string> Fun(string lines)
{
var ary = Regex.Matches(lines, @"(?m).+").Cast<Match>().Select(t => t.Value).OrderByDescending(t => t.Length);
return ary.Count()<1 ? null : ary.Where(t => t.Length == ary.First().Length).ToList();
}
[其他解释]
第一题就是简单排序 基本都会吧
[其他解释]
/*
* 第二题：已经有一个包括了多行文本的字符串。
* 请写一个函数，能够输出字符串中最长的行和最短的行。
* 如果最长和最短的不止一行，请输出最长和最短的多行。
* 请写出性能比较好的代码。
* Fun(string lines)
* {
* 1、拆分成多行；
* 2、循环为每行计算长度，记录最大和最小行的位置；
* 3、打印输出
* }
* */
private static void Function8()
{
//包括了多行文本的字符串 应该是string[] ，而不是string
string[] lines ={ "第二题：已经有一个包括了多行文本的字符串。",
"请写一个函数，能够输出字符串中最长的行和最短的行。",
"如果最长和最短的不止一行，请输出最长和最短的多行。",
"请写出性能比较好的代码。"};
Fun2(lines);
}
private static void Fun2(string[] lines)
{
int maxIndex = int.MinValue;//长度最长的行的长度
int minIndex = int.MaxValue;//长度最短的行的长度
//第一次循环，找出最大的长度和最小的长度
for (int i = 0; i < lines.Length;i++ )
{
int len=lines[i].Length;
if (len>maxIndex)
{
maxIndex = len;
}
if (len<minIndex)
{
minIndex = len;
}
}
//第二次循环，打印符合要求的字符串
for (int i = 0; i < lines.Length; i++)
{
string s=lines[i];
int len = s.Length;
if (len == maxIndex)
{
Console.WriteLine("最长的行：{0}",s);
}
if (len == minIndex)
{
Console.WriteLine("最短的行：{0}", s);
}
}
}
index_max.Add(0);
index_min.Add(0);
//
// main.cpp
// acm
//
// Created by BossJue on 12-11-30.
// Copyright (c) 2012年 __MyCompanyName__. All rights reserved.
//
#include <iostream>
using std::endl;
using std::cout;
using std::cin;
int* Merge(int* ArrayA, int iLenA, int* ArrayB, int iLenB);
int main(int argc, const char * argv[])
{
// insert code here...
int A[]= {1,3,5,7};
int B[]= {0,2,4,6,8,10};
int* result = Merge(A, 4, B, 6);
for(int i= 0; i< 10; ++i){
cout<<result[i]<<" ";
}
cout<<endl;
return 0;
}
//ArrayA, ArrayB分别是你要合并的数组,iLenA,iLenB是长度,返回值指向合并之后的数组
int* Merge(int* ArrayA, int iLenA, int* ArrayB, int iLenB){
int* Result= new int[iLenA+ iLenB];
int iItA, iItB, iItAns;
for (iItA= 0, iItB= 0, iItAns= 0; iItA< iLenA && iItB< iLenB;) {
if(ArrayA[iItA]< ArrayB[iItB]){
Result[iItAns++] = ArrayA[iItA++];
}else {
Result[iItAns++] = ArrayB[iItB++];
}
}
while(iItA< iLenA){
Result[iItAns++] = ArrayA[iItA++];
}
while(iItB< iLenB){
Result[iItAns++] = ArrayB[iItB++];
}
return Result;
}
public static void findMinAndMaxLines(String[] lines
, ArrayList<Integer> min_lines, ArrayList<Integer> max_lines) {
int min_len = Integer.MAX_VALUE;
int max_len = Integer.MIN_VALUE;
for (int i=0; i<lines.length; i++) {
if (lines[i].length() < min_len) {
min_len = lines[i].length();
min_lines.clear();
min_lines.add(i);
} else if (lines[i].length() == min_len) {
min_lines.add(i);
}
if (lines[i].length() > max_len) {
max_len = lines[i].length();
max_lines.clear();
max_lines.add(i);
} else if (lines[i].length() == max_len) {
max_lines.add(i);
}
}
}
static void Main(string[] args)
{
string str = @"aaaa
bbbbb
cccccccccc
dd
dd
eeee";
string[] s = str.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("行数：" + s.Length);
List<string> mins = new List<string>();
List<string> maxs = new List<string>() { "" };
for (int i = 0; i < s.Length; i++)
{
if (mins.Count == 0)
{
mins.Add(s[i]);
}
else if (s[i].Length < mins[0].Length)
{
mins.Clear();
mins.Add(s[i]);
}
else if (s[i].Length == mins[0].Length)
{
mins.Add(s[i]);
}
if (s[i].Length > maxs[0].Length)
{
maxs.Clear();
maxs.Add(s[i]);
}
else if (s[i].Length == maxs[0].Length)
{
maxs.Add(s[i]);
}
}
Console.WriteLine("较小值：");
mins.ForEach(item => Console.WriteLine(item));
Console.WriteLine("较大值：");
maxs.ForEach(item => Console.WriteLine(item));
}
/*
* 第一题：两个Int数组，都是从小到大的排列，需要合并成一个新的数组，也是从小到大排列，请写出性能比较好的代码。 Fun(int a[m],int
* b[n]) { }
*/
public int[] fun(int[] a, int[] b) {
int[] c = new int[a.length + b.length];
int ai = 0, bi = 0;//数组下标
while (ai < a.length && bi < b.length)
c[ai + bi] = (a[ai] < b[bi]) ? a[ai++] : b[bi++];
while (ai < a.length)
c[ai + bi] = a[ai++];
while (bi < b.length)
c[ai + bi] = b[bi++];
return c;
}
/* 第一题：两个Int数组，都是从小到大的排列，需要合并成一个新的数组，也是从小到大排列，
* 请写出性能比较好的代码。
* Fun(int a[m],int b[n])
* {
* }
*
*/
private static void Function7()
{
int[] a={1,3,5,9,34,90};
int[] b={2,4,6};
int[] c=Fun(a,b);
//数组c即为要计算的结果
}
private static int[] Fun(int[] a, int[] b)
{
int []c=new int [a.Length+b.Length];
int i=0;//c的下标
int j=0;//a的下标
int k=0;//b的下标
do
{
if (a[j]<=b[k])
{
c[i]=a[j];
j++;
i++;
}
else
{
c[i]=b[k];
k++;
i++;
}
} while (j < a.Length && k < b.Length) ;
if (j>=a.Length)//a已空b有剩余
{
while (k < b.Length)
{
c[i] = b[k];
i++;
k++;
}
}
else if (k>=b.Length)//b已空a有剩余
{
while (j < a.Length)
{
c[i] = a[j];
i++;
j++;
}
}
else//a和b同时为空
{
}
return c;
}
movl-64(%ebp), %eax
addl-60(%ebp), %eax
sall$2, %eax
pushl%eax
.LCFI5:
call_Znaj
addl$16, %esp
movl%eax, -72(%ebp)
pushl-64(%ebp)
pushl-60(%ebp)
leal-56(%ebp), %eax
pushl%eax
leal-24(%ebp), %eax
pushl%eax
call_Z9sortArrayPiS_ii
addl$16, %esp
cmpl$0, -72(%ebp)
je.L3
subl$12, %esp
pushl-72(%ebp)
call_ZdaPv
addl$16, %esp
.L3:
movl$0, %eax
leal-8(%ebp), %esp
popl%esi
popl%edi
leave
ret
.LFE1479:
.Lfe1:
.sizemain,.Lfe1-main
.section.rodata
.LC1:
.string" "
.text
.align 2
.globl _Z9sortArrayPiS_ii
.type_Z9sortArrayPiS_ii,@function
_Z9sortArrayPiS_ii:
.LFB1481:
pushl%ebp
.LCFI6:
movl%esp, %ebp
.LCFI7:
pushl%ebx
.LCFI8:
subl$36, %esp
.LCFI9:
movl16(%ebp), %eax
movl%eax, -8(%ebp)
movl20(%ebp), %eax
movl%eax, -12(%ebp)
subl$12, %esp
movl20(%ebp), %eax
addl16(%ebp), %eax
sall$2, %eax
pushl%eax
.LCFI10:
call_Znaj
addl$16, %esp
movl%eax, -16(%ebp)
movl$0, -20(%ebp)
.L5:
movl-20(%ebp), %eax
cmpl-8(%ebp), %eax
jl.L8
jmp.L6
.L8:
movl-20(%ebp), %eax
leal0(,%eax,4), %ebx
movl-16(%ebp), %ecx
movl-20(%ebp), %eax
leal0(,%eax,4), %edx
movl8(%ebp), %eax
movl(%eax,%edx), %eax
movl%eax, (%ecx,%ebx)
leal-20(%ebp), %eax
incl(%eax)
jmp.L5
.L6:
movl$0, -20(%ebp)
.L9:
movl-20(%ebp), %eax
cmpl-12(%ebp), %eax
jl.L12
jmp.L10
.L12:
movl-20(%ebp), %eax
addl-8(%ebp), %eax
leal0(,%eax,4), %ebx
movl-16(%ebp), %ecx
movl-20(%ebp), %eax
leal0(,%eax,4), %edx
movl12(%ebp), %eax
movl(%eax,%edx), %eax
movl%eax, (%ecx,%ebx)
leal-20(%ebp), %eax
incl(%eax)
jmp.L9
.L10:
movl$0, -20(%ebp)
.L13:
movl-12(%ebp), %eax
addl-8(%ebp), %eax
cmpl%eax, -20(%ebp)
jle.L16
jmp.L14
.L16:
movl$1, -24(%ebp)
.L17:
movl-12(%ebp), %eax
addl-8(%ebp), %eax
decl%eax
cmpl%eax, -24(%ebp)
jl.L20
jmp.L15
.L20:
movl-24(%ebp), %eax
leal0(,%eax,4), %ebx
movl-16(%ebp), %ecx
movl-24(%ebp), %eax
sall$2, %eax
addl-16(%ebp), %eax
leal4(%eax), %edx
movl(%ecx,%ebx), %eax
cmpl(%edx), %eax
jle.L19
movl-24(%ebp), %eax
leal0(,%eax,4), %edx
movl-16(%ebp), %eax
movl(%eax,%edx), %eax
movl%eax, -28(%ebp)
movl-24(%ebp), %eax
leal0(,%eax,4), %edx
movl-16(%ebp), %ecx
movl-24(%ebp), %eax
sall$2, %eax
addl-16(%ebp), %eax
addl$4, %eax
movl(%eax), %eax
movl%eax, (%ecx,%edx)
movl-24(%ebp), %eax
sall$2, %eax
addl-16(%ebp), %eax
leal4(%eax), %edx
movl-28(%ebp), %eax
movl%eax, (%edx)
.L19:
leal-24(%ebp), %eax
incl(%eax)
jmp.L17
.L15:
leal-20(%ebp), %eax
incl(%eax)
jmp.L13
.L14:
movl$0, -20(%ebp)
.L22:
movl-12(%ebp), %eax
addl-8(%ebp), %eax
decl%eax
cmpl%eax, -20(%ebp)
jle.L25
jmp.L23
.L25:
subl$8, %esp
pushl$.LC1
subl$12, %esp
movl-20(%ebp), %eax
leal0(,%eax,4), %edx
movl-16(%ebp), %eax
pushl(%eax,%edx)
pushl$_ZSt4cout
.LCFI11:
call_ZNSolsEi
addl$20, %esp
pushl%eax
.LCFI12:
call_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
addl$16, %esp
leal-20(%ebp), %eax
incl(%eax)
jmp.L22
.L23:
movl$0, %eax
movl-4(%ebp), %ebx
leave
ret
.LFE1481:
.Lfe2:
.size_Z9sortArrayPiS_ii,.Lfe2-_Z9sortArrayPiS_ii
.align 2
.type_Z41__static_initialization_and_destruction_0ii,@function
_Z41__static_initialization_and_destruction_0ii:
.LFB1493:
pushl%ebp
.LCFI13:
movl%esp, %ebp
.LCFI14:
subl$8, %esp
.LCFI15:
cmpl$65535, 12(%ebp)
jne.L26
cmpl$1, 8(%ebp)
jne.L26
subl$12, %esp
pushl$_ZSt8__ioinit
.LCFI16:
call_ZNSt8ios_base4InitC1Ev
addl$16, %esp
subl$4, %esp
pushl$__dso_handle
pushl$0
pushl$__tcf_0
call__cxa_atexit
addl$16, %esp
.L26:
leave
ret
.LFE1493:
.Lfe3:
.size_Z41__static_initialization_and_destruction_0ii,.Lfe3-_Z41__static_initialization_and_destruction_0ii
.align 2
.type__tcf_0,@function
__tcf_0:
.LFB1494:
pushl%ebp
.LCFI17:
movl%esp, %ebp
.LCFI18:
subl$8, %esp
.LCFI19:
subl$12, %esp
pushl$_ZSt8__ioinit
.LCFI20:
call_ZNSt8ios_base4InitD1Ev
addl$16, %esp
leave
ret
.LFE1494:
.Lfe4:
.size__tcf_0,.Lfe4-__tcf_0
.align 2
.type_GLOBAL__I_main,@function
_GLOBAL__I_main:
.LFB1496:
pushl%ebp
.LCFI21:
movl%esp, %ebp
.LCFI22:
subl$8, %esp
.LCFI23:
subl$8, %esp
pushl$65535
pushl$1
.LCFI24:
call_Z41__static_initialization_and_destruction_0ii
addl$16, %esp
leave
ret
.LFE1496:
.Lfe5:
.size_GLOBAL__I_main,.Lfe5-_GLOBAL__I_main
.section.ctors,"aw",@progbits
.align 4
.long_GLOBAL__I_main
.weakpthread_mutex_unlock
.weakpthread_mutex_trylock
.weakpthread_mutex_lock
.weakpthread_create
.weakpthread_setspecific
.weakpthread_getspecific
.weakpthread_key_delete
.weakpthread_key_create
.weakpthread_once
.section.eh_frame,"a",@progbits
.Lframe1:
.long.LECIE1-.LSCIE1
.LSCIE1:
.long0x0
.byte0x1
.string"zP"
.uleb128 0x1
.sleb128 -4
.byte0x8
.uleb128 0x5
.byte0x0
.long__gxx_personality_v0
.byte0xc
.uleb128 0x4
.uleb128 0x4
.byte0x88
.uleb128 0x1
.align 4
.LECIE1:
.LSFDE1:
.long.LEFDE1-.LASFDE1
.LASFDE1:
.long.LASFDE1-.Lframe1
.long.LFB1479
.long.LFE1479-.LFB1479
.uleb128 0x0
.byte0x4
.long.LCFI0-.LFB1479
.byte0xe
.uleb128 0x8
.byte0x85
.uleb128 0x2
.byte0x4
.long.LCFI1-.LCFI0
.byte0xd
.uleb128 0x5
.byte0x4
.long.LCFI4-.LCFI1
.byte0x86
.uleb128 0x4
.byte0x87
.uleb128 0x3
.byte0x4
.long.LCFI5-.LCFI4
.byte0x2e
.uleb128 0x10
.align 4
.LEFDE1:
.LSFDE3:
.long.LEFDE3-.LASFDE3
.LASFDE3:
.long.LASFDE3-.Lframe1
.long.LFB1481
.long.LFE1481-.LFB1481
.uleb128 0x0
.byte0x4
.long.LCFI6-.LFB1481
.byte0xe
.uleb128 0x8
.byte0x85
.uleb128 0x2
.byte0x4
.long.LCFI7-.LCFI6
.byte0xd
.uleb128 0x5
.byte0x4
.long.LCFI9-.LCFI7
.byte0x83
.uleb128 0x3
.byte0x4
.long.LCFI10-.LCFI9
.byte0x2e
.uleb128 0x10
.byte0x4
.long.LCFI11-.LCFI10
.byte0x2e
.uleb128 0x14
.byte0x4
.long.LCFI12-.LCFI11
.byte0x2e
.uleb128 0x10
.align 4
.LEFDE3:
.LSFDE5:
.long.LEFDE5-.LASFDE5
.LASFDE5:
.long.LASFDE5-.Lframe1
.long.LFB1493
.long.LFE1493-.LFB1493
.uleb128 0x0
.byte0x4
.long.LCFI13-.LFB1493
.byte0xe
.uleb128 0x8
.byte0x85
.uleb128 0x2
.byte0x4
.long.LCFI14-.LCFI13
.byte0xd
.uleb128 0x5
.byte0x4
.long.LCFI16-.LCFI14
.byte0x2e
.uleb128 0x10
.align 4
.LEFDE5:
.LSFDE7:
.long.LEFDE7-.LASFDE7
.LASFDE7:
.long.LASFDE7-.Lframe1
.long.LFB1494
.long.LFE1494-.LFB1494
.uleb128 0x0
.byte0x4
.long.LCFI17-.LFB1494
.byte0xe
.uleb128 0x8
.byte0x85
.uleb128 0x2
.byte0x4
.long.LCFI18-.LCFI17
.byte0xd
.uleb128 0x5
.byte0x4
.long.LCFI20-.LCFI18
.byte0x2e
.uleb128 0x10
.align 4
.LEFDE7:
.LSFDE9:
.long.LEFDE9-.LASFDE9
.LASFDE9:
.long.LASFDE9-.Lframe1
.long.LFB1496
.long.LFE1496-.LFB1496
.uleb128 0x0
.byte0x4
.long.LCFI21-.LFB1496
.byte0xe
.uleb128 0x8
.byte0x85
.uleb128 0x2
.byte0x4
.long.LCFI22-.LCFI21
.byte0xd
.uleb128 0x5
.byte0x4
.long.LCFI24-.LCFI22
.byte0x2e
.uleb128 0x10
.align 4
.LEFDE9:
.ident"GCC: (GNU) 3.2.2 20030222 (Red Hat Linux 3.2.2-5)"
private static void SplitString(string lines) {
// string lines = System.IO.File.ReadAllText("c:\\b.txt",Encoding.UTF8);
string[] strBox = lines.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
SortString(ref strBox, 0, strBox.Length - 1);//先排序
//输出最短字符串
for (int i = 0; i < strBox.Length; i++) {
Console.WriteLine("最短字符串:" + strBox[i]);
if (strBox[i].Length < strBox[i + 1].Length) break;
}
for (int i = strBox.Length - 1; i >= 0; i--)
{
Console.WriteLine("最长字符串:" + strBox[i]);
if (strBox[i].Length > strBox[i-1].Length) break;
}
}
static void SortString(ref string[] strBox, int s, int e)
{
if (s < e) {
int mid = (s + e) / 2;
SortString(ref strBox, s, mid);
SortString(ref strBox, mid + 1, e);
ComboString(ref strBox, s, e, mid);
}
}
static void ComboString(ref string[] strBox, int s, int e, int mid)
{
int i = s, n = e, m = mid, j = mid + 1, k = 0;
string[] temp = new string[e - s + 1];
while (i <= m && j <= n)
{
if (strBox[i].Length > strBox[j].Length)
{
temp[k++] = strBox[j++];
}
else
{
temp[k++] = strBox[i++];
}
}
while (i <= m)
{
temp[k++] = strBox[i++];
}
while (j <= n)
{
temp[k++] = strBox[j++];
}
for (i = 0; i < k; i++)
{
strBox[s + i] = temp[i];
}
}
foreach (var item in query)
{
Console.WriteLine(item);
}
foreach (var item in query2)
{
Console.WriteLine(item.ToString());
}
#endregion
var query3 = strs.OrderByDescending(a => a.Length).Select(a => a);
var max = query3.GroupBy(p => p).First().Select(p => p);
var min = query3.GroupBy(p => p).Last().Select(p => p);
Console.WriteLine("最大数组:");
foreach (var item in max)
{
Console.WriteLine(item);
}
Console.WriteLine("最小数组");
foreach (var item in min)
{
Console.WriteLine(item);
}
Console.Read();
[其他解释]
public static int[] combine2SortedArray(int[] a, int[] b) {
int[] c = new int[a.length+b.length];
int i,j,k;
i=j=k=0;
while (i<a.length && j<b.length) {
if (a[i] <= b[j]) {
c[k++] = a[i++];
} else {
c[k++] = b[j++];
}
}
while (i<a.length) {
c[k++] = a[i++];
}
while (j<b.length) {
c[k++] = b[j++];
}
return c;
}
//按题意a,b已经是从小打到的排列
public int[] function1(int[] a, int[] b)
{
int[] ret = new int[a.Length + b.Length];
int a_index = 0, b_index = 0;
for (int i = 0; i < ret.Length; i++)
{
if (a_index >= a.Length)
{
ret[i] = b[b_index++];
continue;
}
if (b_index >= b.Length)
{
ret[i] = a[a_index++];
continue;
}
if (a[a_index] < b[b_index])
ret[i] = a[a_index++];
else
ret[i] = b[b_index++];
}
return ret;
}
public void function2(string lines)
{
List<int> index_max = new List<int>();
List<int> index_min = new List<int>();
string[] ret = lines.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
int max = ret[0].Length, min = max;
for (int i = 1; i < ret.Length; i++)
{
if (ret[i].Length >= max)
{
if (ret[i].Length != max)
{
max = ret[i].Length;
index_max.Clear();
}
index_max.Add(i);
}
if (ret[i].Length <= min)
{
if (ret[i].Length != min)
{
min = ret[i].Length;
index_min.Clear();
}
index_min.Add(i);
}
}
}
我表示楼上的大神们，我已经彻底膜拜了，我只学C#，虽然说汇编，C++，Java都学过，但基本上属于零基础，勉强知道是什么，但看懂还是挺费劲的，呵呵
大神们，你们继续比较着角逐着，我就观望着吧
[其他解释]
class Program
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 7 };
int[] b = { 2, 4, 5, 6, 8, 9, 10 };
var result = Fun(a, b);
foreach (int i in result)
{
Console.WriteLine(i);
}
Console.Read();
}
static int[] Fun(int[] a, int[] b)
{
int count = a.Length + b.Length;
int[] newArray = new int[count];
int aIndex = 0;
int bIndex = 0;
for (int i = 0; i < count; i++)
{
if (aIndex < a.Length && a[aIndex] <= b[bIndex])
{
newArray[i] = a[aIndex];
aIndex++;
}
else
{
newArray[i] = b[bIndex];
bIndex++;
}
}
return newArray;
}
}