两道嵌入式面试题

davycu

感觉是靠应届生的题目，楼主偶猜的对吗？

dongchenghuozi

回复 1# moonwhite999


    至于第一个问题，先不考虑编译器的原因，在这种情况下前一种方式相对优化，至于原因就是对if（·····）的判断次数。

如果考虑到编译器，就无话可说了。每个编译器都不一样，以后发展了说不定在头上插两个电线。电脑就能编程呢。

第二个问题，可以设置一个1维数组，具体要看字符种类有多少。如果是26个字母的话，就设置A[26]够了。初始化数据A[]=27
从字符串末尾扫描，遇到一个字符串如果它在数组中对应数值不是27话，说明该字符已经多次出现不用理会，否则就在数组多对应位置填入该字符在字符串中的位置数字。

一轮扫描结束后，每个字符具体在字符串中的位置信息已经记录在数组中了。只要判断数组特征就可以知道答案。

wangfei775

哈哈，很早的东西了，

松饼熊

说到嵌入式我以为我会看到
编码规则
变量对齐
端口映射地址读取方法
任务优先级与中断引起的内存锁
之类的题目。

可是我却还是看到了这些计算机竞赛初级班的题目。

linuxIsPerfect

回复 48# 专操五毛

学习学习，继续学习。。。

zhouweiz

个人认为，面试官最好多问解决问题的思路上的东西，比如从什么地方入手，思想方法。不要扣住一些知识细节问到底。所有的实现都是由应用引发的。比如 一般情况下创建子进程回拷贝父进程页面，但是在没有MMU的uClinux下为了节省时间，父子进程是共享页面的。只要解决问题思路对，就行了。

lyscsu

第一道题
1、业务逻辑：看i是否影响condition的计算，同时看分支是否改变i的值
2、性能和空间要求
第二道题
使用glibc函数
char find_first_once_char(char * s)
{
        if(!s)
        {
                return 0;
        }

        while(*s)
        {
                if(!strchr(s+1, *s))
                {
                        break;
                }

                s++;
        }

        return *s
}

不使用glibc函数
char find_first_once_char(char * s)
{
        if(!s)
        {
                return 0;
        }
       
        while(*s)
        {
                char * p = s+1;

                while(*p && (*p!=*s))
                {
                        p++;
                }

                if(*p)
                {
                        s++;
                }
                else
                {
                        break;
                }
        }

        return *s
}

kris_fei

学习了

system888net

int condition;

void DoSomeThing()
{
   return;
}

void DoOtherThing()
{
   return;
}

int fun1(int N)
{
   int i;
   for(i=1;i<N;i++)
    {
           if(condition)
              DoSomeThing();
           else
              DoOtherThing();
    }
    return(i);
}
int fun2(int N)
{
    int i;
    if(condition)
    {
          for(i=1;i<N;i++)
               DoSomeThing();
    }
    else
    {
          for(i=1;i<N;i++)
              DoOtherThing();
    }
   return(i);
}

int main()
{
   
   fun1(100);
   fun2(100);
   return(0);
}

system888net

output: arm asm


        .file        "test_arm.c"
        .text
        .align        2
        .global        DoSomeThing
        .type        DoSomeThing, %function
DoSomeThing:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 1, uses_anonymous_args = 0
        mov        ip, sp
        stmfd        sp!, {fp, ip, lr, pc}
        sub        fp, ip, #4
        ldmfd        sp, {fp, sp, pc}
        .size        DoSomeThing, .-DoSomeThing
        .align        2
        .global        DoOtherThing
        .type        DoOtherThing, %function
DoOtherThing:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 1, uses_anonymous_args = 0
        mov        ip, sp
        stmfd        sp!, {fp, ip, lr, pc}
        sub        fp, ip, #4
        ldmfd        sp, {fp, sp, pc}
        .size        DoOtherThing, .-DoOtherThing
        .align        2
        .global        fun1
        .type        fun1, %function
fun1:
        @ args = 0, pretend = 0, frame = 8
        @ frame_needed = 1, uses_anonymous_args = 0
        mov        ip, sp
        stmfd        sp!, {fp, ip, lr, pc}
        sub        fp, ip, #4
        sub        sp, sp, #8
        str        r0, [fp, #-16]
        mov        r3, #1
        str        r3, [fp, #-20]
.L4:
        ldr        r2, [fp, #-20]
        ldr        r3, [fp, #-16]
        cmp        r2, r3
        bge        .L5
        ldr        r3, .L9
        ldr        r3, [r3, #0]
        cmp        r3, #0
        beq        .L7
        bl        DoSomeThing
        b        .L6
.L7:
        bl        DoOtherThing
.L6:
        ldr        r3, [fp, #-20]
        add        r3, r3, #1
        str        r3, [fp, #-20]
        b        .L4
.L5:
        ldr        r3, [fp, #-20]
        mov        r0, r3
        sub        sp, fp, #12
        ldmfd        sp, {fp, sp, pc}
.L10:
        .align        2
.L9:
        .word        condition
        .size        fun1, .-fun1
        .align        2
        .global        fun2
        .type        fun2, %function
fun2:
        @ args = 0, pretend = 0, frame = 8
        @ frame_needed = 1, uses_anonymous_args = 0
        mov        ip, sp
        stmfd        sp!, {fp, ip, lr, pc}
        sub        fp, ip, #4
        sub        sp, sp, #8
        str        r0, [fp, #-16]
        ldr        r3, .L20
        ldr        r3, [r3, #0]
        cmp        r3, #0
        beq        .L12
        mov        r3, #1
        str        r3, [fp, #-20]
.L13:
        ldr        r2, [fp, #-20]
        ldr        r3, [fp, #-16]
        cmp        r2, r3
        bge        .L16
        bl        DoSomeThing
        ldr        r3, [fp, #-20]
        add        r3, r3, #1
        str        r3, [fp, #-20]
        b        .L13
.L12:
        mov        r3, #1
        str        r3, [fp, #-20]
.L17:
        ldr        r2, [fp, #-20]
        ldr        r3, [fp, #-16]
        cmp        r2, r3
        bge        .L16
        bl        DoOtherThing
        ldr        r3, [fp, #-20]
        add        r3, r3, #1
        str        r3, [fp, #-20]
        b        .L17
.L16:
        ldr        r3, [fp, #-20]
        mov        r0, r3
        sub        sp, fp, #12
        ldmfd        sp, {fp, sp, pc}
.L21:
        .align        2
.L20:
        .word        condition
        .size        fun2, .-fun2
        .align        2
        .global        main
        .type        main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 1, uses_anonymous_args = 0
        mov        ip, sp
        stmfd        sp!, {fp, ip, lr, pc}
        sub        fp, ip, #4
        mov        r0, #100
        bl        fun1
        mov        r0, #100
        bl        fun2
        mov        r3, #0
        mov        r0, r3
        ldmfd        sp, {fp, sp, pc}
        .size        main, .-main
        .comm        condition,4,4
        .ident        "GCC: (GNU) 3.4.4"